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 870 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
524 870 : swig_cast_info *cast = ti->cast;
525 : /* if (ti->clientdata == clientdata) return; */
526 870 : ti->clientdata = clientdata;
527 :
528 1740 : while (cast) {
529 870 : if (!cast->converter) {
530 870 : swig_type_info *tc = cast->type;
531 870 : if (!tc->clientdata) {
532 0 : SWIG_TypeClientData(tc, clientdata);
533 : }
534 : }
535 870 : cast = cast->next;
536 : }
537 870 : }
538 : SWIGRUNTIME void
539 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
540 870 : SWIG_TypeClientData(ti, clientdata);
541 870 : 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 0 : 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 0 : str = PyUnicode_AsUTF8String(str);
787 0 : PyBytes_AsStringAndSize(str, &cstr, &len);
788 0 : newstr = (char *) malloc(len+1);
789 0 : memcpy(newstr, cstr, len+1);
790 0 : Py_XDECREF(str);
791 0 : return newstr;
792 : #else
793 : return PyString_AsString(str);
794 : #endif
795 : }
796 :
797 : #if PY_VERSION_HEX >= 0x03000000
798 : # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
799 : #else
800 : # define SWIG_Python_str_DelForPy3(x)
801 : #endif
802 :
803 :
804 : SWIGINTERN PyObject*
805 : SWIG_Python_str_FromChar(const char *c)
806 : {
807 : #if PY_VERSION_HEX >= 0x03000000
808 29 : return PyUnicode_FromString(c);
809 : #else
810 : return PyString_FromString(c);
811 : #endif
812 : }
813 :
814 : /* Add PyOS_snprintf for old Pythons */
815 : #if PY_VERSION_HEX < 0x02020000
816 : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
817 : # define PyOS_snprintf _snprintf
818 : # else
819 : # define PyOS_snprintf snprintf
820 : # endif
821 : #endif
822 :
823 : /* A crude PyString_FromFormat implementation for old Pythons */
824 : #if PY_VERSION_HEX < 0x02020000
825 :
826 : #ifndef SWIG_PYBUFFER_SIZE
827 : # define SWIG_PYBUFFER_SIZE 1024
828 : #endif
829 :
830 : static PyObject *
831 : PyString_FromFormat(const char *fmt, ...) {
832 : va_list ap;
833 : char buf[SWIG_PYBUFFER_SIZE * 2];
834 : int res;
835 : va_start(ap, fmt);
836 : res = vsnprintf(buf, sizeof(buf), fmt, ap);
837 : va_end(ap);
838 : return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
839 : }
840 : #endif
841 :
842 : #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 0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1129 : {
1130 0 : return PyInstanceMethod_New(func);
1131 : }
1132 : #else
1133 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1134 : {
1135 : 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 27492 : 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 27492 : PyDict_SetItemString(d, name, obj);
1254 : #endif
1255 27492 : Py_DECREF(obj);
1256 27492 : }
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 2571 : PyObject *none = Py_None;
1422 2571 : 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 870 : SwigPyClientData_New(PyObject* obj)
1455 : {
1456 870 : if (!obj) {
1457 : return 0;
1458 : } else {
1459 870 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1460 : /* the klass element */
1461 870 : data->klass = obj;
1462 870 : Py_INCREF(data->klass);
1463 : /* the newraw method and newargs arguments used to create a new raw instance */
1464 870 : if (PyClass_Check(obj)) {
1465 870 : data->newraw = 0;
1466 870 : data->newargs = obj;
1467 870 : Py_INCREF(obj);
1468 : } else {
1469 : #if (PY_VERSION_HEX < 0x02020000)
1470 : data->newraw = 0;
1471 : #else
1472 0 : data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1473 : #endif
1474 0 : if (data->newraw) {
1475 0 : Py_INCREF(data->newraw);
1476 0 : data->newargs = PyTuple_New(1);
1477 0 : PyTuple_SetItem(data->newargs, 0, obj);
1478 : } else {
1479 0 : data->newargs = obj;
1480 : }
1481 0 : Py_INCREF(data->newargs);
1482 : }
1483 : /* the destroy method, aka as the C++ delete method */
1484 870 : data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1485 870 : if (PyErr_Occurred()) {
1486 0 : PyErr_Clear();
1487 0 : data->destroy = 0;
1488 : }
1489 870 : if (data->destroy) {
1490 : int flags;
1491 870 : Py_INCREF(data->destroy);
1492 870 : flags = PyCFunction_GET_FLAGS(data->destroy);
1493 : #ifdef METH_O
1494 870 : data->delargs = !(flags & (METH_O));
1495 : #else
1496 : data->delargs = 0;
1497 : #endif
1498 : } else {
1499 0 : data->delargs = 0;
1500 : }
1501 870 : data->implicitconv = 0;
1502 870 : data->pytype = 0;
1503 870 : return data;
1504 : }
1505 : }
1506 :
1507 : SWIGRUNTIME void
1508 870 : SwigPyClientData_Del(SwigPyClientData *data) {
1509 870 : Py_XDECREF(data->newraw);
1510 870 : Py_XDECREF(data->newargs);
1511 870 : Py_XDECREF(data->destroy);
1512 870 : }
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 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
1552 : {
1553 : PyObject *res = NULL;
1554 : PyObject *args = PyTuple_New(1);
1555 : if (args) {
1556 : if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1557 : PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1558 : if (ofmt) {
1559 : #if PY_VERSION_HEX >= 0x03000000
1560 : res = PyUnicode_Format(ofmt,args);
1561 : #else
1562 : res = PyString_Format(ofmt,args);
1563 : #endif
1564 : Py_DECREF(ofmt);
1565 : }
1566 : Py_DECREF(args);
1567 : }
1568 : }
1569 : return res;
1570 : }
1571 :
1572 : SWIGRUNTIME PyObject *
1573 : SwigPyObject_oct(SwigPyObject *v)
1574 : {
1575 : return SwigPyObject_format("%o",v);
1576 : }
1577 :
1578 : SWIGRUNTIME PyObject *
1579 : SwigPyObject_hex(SwigPyObject *v)
1580 : {
1581 : 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 0 : PyObject *joined = PyUnicode_Concat(repr, nrep);
1601 0 : Py_DecRef(repr);
1602 0 : Py_DecRef(nrep);
1603 0 : repr = joined;
1604 : # else
1605 : PyString_ConcatAndDel(&repr,nrep);
1606 : # endif
1607 : }
1608 0 : return repr;
1609 : }
1610 :
1611 : SWIGRUNTIME int
1612 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1613 : {
1614 0 : void *i = v->ptr;
1615 0 : void *j = w->ptr;
1616 0 : 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 0 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1622 : {
1623 : PyObject* res;
1624 0 : if( op != Py_EQ && op != Py_NE ) {
1625 0 : Py_INCREF(Py_NotImplemented);
1626 0 : return Py_NotImplemented;
1627 : }
1628 0 : res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1629 0 : 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 23999 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1650 23999 : return type;
1651 : }
1652 : #endif
1653 :
1654 : SWIGRUNTIMEINLINE int
1655 18703 : 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 18703 : return (Py_TYPE(op) == SwigPyObject_type())
1663 18703 : || (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 2635 : SwigPyObject_dealloc(PyObject *v)
1672 : {
1673 2635 : SwigPyObject *sobj = (SwigPyObject *) v;
1674 2635 : PyObject *next = sobj->next;
1675 2635 : 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 2635 : Py_XDECREF(next);
1718 2635 : PyObject_DEL(v);
1719 2635 : }
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 29 : 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 29 : 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 29 : swigpyobject_type = tmp;
1985 29 : type_init = 1;
1986 : #if PY_VERSION_HEX < 0x02020000
1987 : swigpyobject_type.ob_type = &PyType_Type;
1988 : #else
1989 29 : if (PyType_Ready(&swigpyobject_type) < 0)
1990 : return NULL;
1991 : #endif
1992 : }
1993 : return &swigpyobject_type;
1994 : }
1995 :
1996 : SWIGRUNTIME PyObject *
1997 2648 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1998 : {
1999 2648 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2000 2648 : if (sobj) {
2001 2648 : sobj->ptr = ptr;
2002 2648 : sobj->ty = ty;
2003 2648 : sobj->own = own;
2004 2648 : sobj->next = 0;
2005 : }
2006 2648 : 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 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2058 : {
2059 : size_t i = v->size;
2060 : size_t j = w->size;
2061 : int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2062 : 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 29 : return SWIG_Python_str_FromChar("this");
2224 : }
2225 :
2226 : static PyObject *swig_this = NULL;
2227 :
2228 : SWIGRUNTIME PyObject *
2229 : SWIG_This(void)
2230 : {
2231 9551 : if (swig_this == NULL)
2232 29 : swig_this = _SWIG_This();
2233 9551 : 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 11134 : SWIG_Python_GetSwigThis(PyObject *pyobj)
2245 : {
2246 : PyObject *obj;
2247 :
2248 11134 : 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 7569 : obj = 0;
2264 :
2265 : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2266 : if (PyInstance_Check(pyobj)) {
2267 : obj = _PyInstance_Lookup(pyobj, SWIG_This());
2268 : } else {
2269 : PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2270 : if (dictptr != NULL) {
2271 : PyObject *dict = *dictptr;
2272 : obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2273 : } else {
2274 : #ifdef PyWeakref_CheckProxy
2275 : if (PyWeakref_CheckProxy(pyobj)) {
2276 : PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2277 : return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2278 : }
2279 : #endif
2280 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2281 : if (obj) {
2282 : Py_DECREF(obj);
2283 : } else {
2284 : if (PyErr_Occurred()) PyErr_Clear();
2285 : return 0;
2286 : }
2287 : }
2288 : }
2289 : #else
2290 7569 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2291 7569 : if (obj) {
2292 7569 : Py_DECREF(obj);
2293 : } else {
2294 0 : if (PyErr_Occurred()) PyErr_Clear();
2295 : return 0;
2296 : }
2297 : #endif
2298 7569 : 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 11330 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2326 : int res;
2327 : SwigPyObject *sobj;
2328 11330 : int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2329 :
2330 11330 : if (!obj)
2331 : return SWIG_ERROR;
2332 11330 : if (obj == Py_None && !implicit_conv) {
2333 196 : if (ptr)
2334 196 : *ptr = 0;
2335 : return SWIG_OK;
2336 : }
2337 :
2338 11134 : res = SWIG_ERROR;
2339 :
2340 11134 : sobj = SWIG_Python_GetSwigThis(obj);
2341 11134 : if (own)
2342 0 : *own = 0;
2343 11134 : while (sobj) {
2344 11134 : void *vptr = sobj->ptr;
2345 11134 : if (ty) {
2346 11134 : swig_type_info *to = sobj->ty;
2347 11134 : if (to == ty) {
2348 : /* no type cast needed */
2349 11134 : 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 11134 : if (sobj) {
2374 11134 : if (own)
2375 0 : *own = *own | sobj->own;
2376 11134 : 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 1953 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2486 : {
2487 : #if (PY_VERSION_HEX >= 0x02020000)
2488 1953 : PyObject *inst = 0;
2489 1953 : PyObject *newraw = data->newraw;
2490 1953 : if (newraw) {
2491 0 : inst = PyObject_Call(newraw, data->newargs, NULL);
2492 0 : if (inst) {
2493 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2494 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2495 : if (dictptr != NULL) {
2496 : PyObject *dict = *dictptr;
2497 : if (dict == NULL) {
2498 : dict = PyDict_New();
2499 : *dictptr = dict;
2500 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2501 : }
2502 : }
2503 : #else
2504 0 : PyObject *key = SWIG_This();
2505 0 : PyObject_SetAttr(inst, key, swig_this);
2506 : #endif
2507 : }
2508 : } else {
2509 : #if PY_VERSION_HEX >= 0x03000000
2510 1953 : inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2511 1953 : if (inst) {
2512 1953 : PyObject_SetAttr(inst, SWIG_This(), swig_this);
2513 1953 : Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2514 : }
2515 : #else
2516 : PyObject *dict = PyDict_New();
2517 : if (dict) {
2518 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2519 : inst = PyInstance_NewRaw(data->newargs, dict);
2520 : Py_DECREF(dict);
2521 : }
2522 : #endif
2523 : }
2524 1953 : 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 2738 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2601 : SwigPyClientData *clientdata;
2602 : PyObject * robj;
2603 : int own;
2604 :
2605 2738 : if (!ptr)
2606 90 : return SWIG_Py_Void();
2607 :
2608 2648 : clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2609 2648 : own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2610 2648 : 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 2648 : robj = SwigPyObject_New(ptr, type, own);
2643 2648 : if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2644 1953 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2645 1953 : 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 29 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2668 : static void *type_pointer = (void *)0;
2669 : /* first check if module already created */
2670 29 : if (!type_pointer) {
2671 : #ifdef SWIG_LINK_RUNTIME
2672 : type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2673 : #else
2674 : # ifdef SWIGPY_USE_CAPSULE
2675 29 : 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 29 : if (PyErr_Occurred()) {
2681 29 : PyErr_Clear();
2682 29 : type_pointer = (void *)0;
2683 : }
2684 : #endif
2685 : }
2686 29 : 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 29 : SWIG_Python_DestroyModule(PyObject *obj)
2722 : #else
2723 : SWIG_Python_DestroyModule(void *vptr)
2724 : #endif
2725 : {
2726 : #ifdef SWIGPY_USE_CAPSULE
2727 29 : 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 29 : swig_type_info **types = swig_module->types;
2732 : size_t i;
2733 3190 : for (i =0; i < swig_module->size; ++i) {
2734 3161 : swig_type_info *ty = types[i];
2735 3161 : if (ty->owndata) {
2736 870 : SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2737 870 : if (data) SwigPyClientData_Del(data);
2738 : }
2739 : }
2740 29 : Py_DECREF(SWIG_This());
2741 29 : swig_this = NULL;
2742 29 : }
2743 :
2744 : SWIGRUNTIME void
2745 29 : SWIG_Python_SetModule(swig_module_info *swig_module) {
2746 : #if PY_VERSION_HEX >= 0x03000000
2747 : /* Add a dummy module object into sys.modules */
2748 29 : 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 : PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2752 : #endif
2753 : #ifdef SWIGPY_USE_CAPSULE
2754 29 : PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2755 29 : if (pointer && module) {
2756 29 : 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 29 : }
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_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t swig_types[30]
3015 : #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[31]
3016 : #define SWIGTYPE_p_f_p_void_off_t_int__off_t swig_types[32]
3017 : #define SWIGTYPE_p_f_p_void_p_char_size_t_p_size_t__int swig_types[33]
3018 : #define SWIGTYPE_p_f_p_void_p_q_const__char_int_int_int__void swig_types[34]
3019 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t swig_types[35]
3020 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t swig_types[36]
3021 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t swig_types[37]
3022 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t swig_types[38]
3023 : #define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__gpg_error_t swig_types[39]
3024 : #define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t swig_types[40]
3025 : #define SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t swig_types[41]
3026 : #define SWIGTYPE_p_gpg_err_code_t swig_types[42]
3027 : #define SWIGTYPE_p_gpg_err_source_t swig_types[43]
3028 : #define SWIGTYPE_p_gpg_error_t swig_types[44]
3029 : #define SWIGTYPE_p_gpgme_conf_arg swig_types[45]
3030 : #define SWIGTYPE_p_gpgme_conf_arg_value swig_types[46]
3031 : #define SWIGTYPE_p_gpgme_conf_comp swig_types[47]
3032 : #define SWIGTYPE_p_gpgme_conf_level_t swig_types[48]
3033 : #define SWIGTYPE_p_gpgme_conf_opt swig_types[49]
3034 : #define SWIGTYPE_p_gpgme_conf_type_t swig_types[50]
3035 : #define SWIGTYPE_p_gpgme_context swig_types[51]
3036 : #define SWIGTYPE_p_gpgme_data swig_types[52]
3037 : #define SWIGTYPE_p_gpgme_data_cbs swig_types[53]
3038 : #define SWIGTYPE_p_gpgme_data_encoding_t swig_types[54]
3039 : #define SWIGTYPE_p_gpgme_data_type_t swig_types[55]
3040 : #define SWIGTYPE_p_gpgme_decrypt_flags_t swig_types[56]
3041 : #define SWIGTYPE_p_gpgme_encrypt_flags_t swig_types[57]
3042 : #define SWIGTYPE_p_gpgme_event_io_t swig_types[58]
3043 : #define SWIGTYPE_p_gpgme_hash_algo_t swig_types[59]
3044 : #define SWIGTYPE_p_gpgme_io_cbs swig_types[60]
3045 : #define SWIGTYPE_p_gpgme_io_event_done_data swig_types[61]
3046 : #define SWIGTYPE_p_gpgme_keyorg_t swig_types[62]
3047 : #define SWIGTYPE_p_gpgme_pinentry_mode_t swig_types[63]
3048 : #define SWIGTYPE_p_gpgme_protocol_t swig_types[64]
3049 : #define SWIGTYPE_p_gpgme_pubkey_algo_t swig_types[65]
3050 : #define SWIGTYPE_p_gpgme_sig_mode_t swig_types[66]
3051 : #define SWIGTYPE_p_gpgme_sigsum_t swig_types[67]
3052 : #define SWIGTYPE_p_gpgme_status_code_t swig_types[68]
3053 : #define SWIGTYPE_p_gpgme_tofu_policy_t swig_types[69]
3054 : #define SWIGTYPE_p_gpgme_validity_t swig_types[70]
3055 : #define SWIGTYPE_p_gpgrt_stream_t swig_types[71]
3056 : #define SWIGTYPE_p_int swig_types[72]
3057 : #define SWIGTYPE_p_off_t swig_types[73]
3058 : #define SWIGTYPE_p_p__gpgme_engine_info swig_types[74]
3059 : #define SWIGTYPE_p_p__gpgme_import_status swig_types[75]
3060 : #define SWIGTYPE_p_p__gpgme_key swig_types[76]
3061 : #define SWIGTYPE_p_p__gpgme_key_sig swig_types[77]
3062 : #define SWIGTYPE_p_p__gpgme_op_encrypt_result swig_types[78]
3063 : #define SWIGTYPE_p_p__gpgme_op_genkey_result swig_types[79]
3064 : #define SWIGTYPE_p_p__gpgme_op_import_result swig_types[80]
3065 : #define SWIGTYPE_p_p__gpgme_op_verify_result swig_types[81]
3066 : #define SWIGTYPE_p_p__gpgme_sig_notation swig_types[82]
3067 : #define SWIGTYPE_p_p__gpgme_signature swig_types[83]
3068 : #define SWIGTYPE_p_p__gpgme_subkey swig_types[84]
3069 : #define SWIGTYPE_p_p__gpgme_trust_item swig_types[85]
3070 : #define SWIGTYPE_p_p__gpgme_user_id swig_types[86]
3071 : #define SWIGTYPE_p_p_char swig_types[87]
3072 : #define SWIGTYPE_p_p_f_p_void__void swig_types[88]
3073 : #define SWIGTYPE_p_p_f_p_void_enum_gpgme_event_io_t_p_void__void swig_types[89]
3074 : #define SWIGTYPE_p_p_f_p_void_int__gpg_error_t swig_types[90]
3075 : #define SWIGTYPE_p_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t swig_types[91]
3076 : #define SWIGTYPE_p_p_f_p_void_off_t_int__off_t swig_types[92]
3077 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_int_int_int__void swig_types[93]
3078 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t swig_types[94]
3079 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t swig_types[95]
3080 : #define SWIGTYPE_p_p_f_p_void_p_q_const__void_size_t__ssize_t swig_types[96]
3081 : #define SWIGTYPE_p_p_f_p_void_p_void_size_t__ssize_t swig_types[97]
3082 : #define SWIGTYPE_p_p_gpgme_conf_arg swig_types[98]
3083 : #define SWIGTYPE_p_p_gpgme_conf_comp swig_types[99]
3084 : #define SWIGTYPE_p_p_gpgme_conf_opt swig_types[100]
3085 : #define SWIGTYPE_p_p_gpgme_context swig_types[101]
3086 : #define SWIGTYPE_p_p_gpgme_data swig_types[102]
3087 : #define SWIGTYPE_p_p_void swig_types[103]
3088 : #define SWIGTYPE_p_size_t swig_types[104]
3089 : #define SWIGTYPE_p_ssize_t swig_types[105]
3090 : #define SWIGTYPE_p_time_t swig_types[106]
3091 : #define SWIGTYPE_p_unsigned_int swig_types[107]
3092 : #define SWIGTYPE_p_void swig_types[108]
3093 : static swig_type_info *swig_types[110];
3094 : static swig_module_info swig_module = {swig_types, 109, 0, 0, 0, 0};
3095 : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3096 : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3097 :
3098 : /* -------- TYPES TABLE (END) -------- */
3099 :
3100 : #if (PY_VERSION_HEX <= 0x02000000)
3101 : # if !defined(SWIG_PYTHON_CLASSIC)
3102 : # error "This python version requires swig to be run with the '-classic' option"
3103 : # endif
3104 : #endif
3105 :
3106 : /*-----------------------------------------------
3107 : @(target):= _gpgme.so
3108 : ------------------------------------------------*/
3109 : #if PY_VERSION_HEX >= 0x03000000
3110 : # define SWIG_init PyInit__gpgme
3111 :
3112 : #else
3113 : # define SWIG_init init_gpgme
3114 :
3115 : #endif
3116 : #define SWIG_name "_gpgme"
3117 :
3118 : #define SWIGVERSION 0x030010
3119 : #define SWIG_VERSION SWIGVERSION
3120 :
3121 :
3122 : #define SWIG_as_voidptr(a) (void *)((const void *)(a))
3123 : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3124 :
3125 :
3126 : /* We use public symbols (eg. "_obsolete_class") which are marked as
3127 : * deprecated but we need to keep them. Silence the warning. */
3128 : #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
3129 :
3130 :
3131 : #include "data.h" /* For struct gpgme_data. */
3132 :
3133 :
3134 : #include <limits.h>
3135 : #if !defined(SWIG_NO_LLONG_MAX)
3136 : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3137 : # define LLONG_MAX __LONG_LONG_MAX__
3138 : # define LLONG_MIN (-LLONG_MAX - 1LL)
3139 : # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3140 : # endif
3141 : #endif
3142 :
3143 :
3144 : SWIGINTERN int
3145 : SWIG_AsVal_double (PyObject *obj, double *val)
3146 : {
3147 : int res = SWIG_TypeError;
3148 : if (PyFloat_Check(obj)) {
3149 : if (val) *val = PyFloat_AsDouble(obj);
3150 : return SWIG_OK;
3151 : #if PY_VERSION_HEX < 0x03000000
3152 : } else if (PyInt_Check(obj)) {
3153 : if (val) *val = PyInt_AsLong(obj);
3154 : return SWIG_OK;
3155 : #endif
3156 : } else if (PyLong_Check(obj)) {
3157 : double v = PyLong_AsDouble(obj);
3158 : if (!PyErr_Occurred()) {
3159 : if (val) *val = v;
3160 : return SWIG_OK;
3161 : } else {
3162 : PyErr_Clear();
3163 : }
3164 : }
3165 : #ifdef SWIG_PYTHON_CAST_MODE
3166 : {
3167 : int dispatch = 0;
3168 : double d = PyFloat_AsDouble(obj);
3169 : if (!PyErr_Occurred()) {
3170 : if (val) *val = d;
3171 : return SWIG_AddCast(SWIG_OK);
3172 : } else {
3173 : PyErr_Clear();
3174 : }
3175 : if (!dispatch) {
3176 : long v = PyLong_AsLong(obj);
3177 : if (!PyErr_Occurred()) {
3178 : if (val) *val = v;
3179 : return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3180 : } else {
3181 : PyErr_Clear();
3182 : }
3183 : }
3184 : }
3185 : #endif
3186 : return res;
3187 : }
3188 :
3189 :
3190 : #include <float.h>
3191 :
3192 :
3193 : #include <math.h>
3194 :
3195 :
3196 : SWIGINTERNINLINE int
3197 : SWIG_CanCastAsInteger(double *d, double min, double max) {
3198 : double x = *d;
3199 : if ((min <= x && x <= max)) {
3200 : double fx = floor(x);
3201 : double cx = ceil(x);
3202 : double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3203 : if ((errno == EDOM) || (errno == ERANGE)) {
3204 : errno = 0;
3205 : } else {
3206 : double summ, reps, diff;
3207 : if (rd < x) {
3208 : diff = x - rd;
3209 : } else if (rd > x) {
3210 : diff = rd - x;
3211 : } else {
3212 : return 1;
3213 : }
3214 : summ = rd + x;
3215 : reps = diff/summ;
3216 : if (reps < 8*DBL_EPSILON) {
3217 : *d = rd;
3218 : return 1;
3219 : }
3220 : }
3221 : }
3222 : return 0;
3223 : }
3224 :
3225 :
3226 : SWIGINTERN int
3227 885 : SWIG_AsVal_long (PyObject *obj, long* val)
3228 : {
3229 : #if PY_VERSION_HEX < 0x03000000
3230 : if (PyInt_Check(obj)) {
3231 : if (val) *val = PyInt_AsLong(obj);
3232 : return SWIG_OK;
3233 : } else
3234 : #endif
3235 885 : if (PyLong_Check(obj)) {
3236 885 : long v = PyLong_AsLong(obj);
3237 885 : if (!PyErr_Occurred()) {
3238 885 : if (val) *val = v;
3239 : return SWIG_OK;
3240 : } else {
3241 0 : PyErr_Clear();
3242 0 : return SWIG_OverflowError;
3243 : }
3244 : }
3245 : #ifdef SWIG_PYTHON_CAST_MODE
3246 : {
3247 : int dispatch = 0;
3248 : long v = PyInt_AsLong(obj);
3249 : if (!PyErr_Occurred()) {
3250 : if (val) *val = v;
3251 : return SWIG_AddCast(SWIG_OK);
3252 : } else {
3253 : PyErr_Clear();
3254 : }
3255 : if (!dispatch) {
3256 : double d;
3257 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3258 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3259 : if (val) *val = (long)(d);
3260 : return res;
3261 : }
3262 : }
3263 : }
3264 : #endif
3265 : return SWIG_TypeError;
3266 : }
3267 :
3268 :
3269 : SWIGINTERN int
3270 : SWIG_AsVal_int (PyObject * obj, int *val)
3271 : {
3272 : long v;
3273 885 : int res = SWIG_AsVal_long (obj, &v);
3274 885 : if (SWIG_IsOK(res)) {
3275 885 : if ((v < INT_MIN || v > INT_MAX)) {
3276 : return SWIG_OverflowError;
3277 : } else {
3278 885 : if (val) *val = (int)(v);
3279 : }
3280 : }
3281 : return res;
3282 : }
3283 :
3284 :
3285 : SWIGINTERN swig_type_info*
3286 0 : SWIG_pchar_descriptor(void)
3287 : {
3288 : static int init = 0;
3289 : static swig_type_info* info = 0;
3290 0 : if (!init) {
3291 0 : info = SWIG_TypeQuery("_p_char");
3292 0 : init = 1;
3293 : }
3294 0 : return info;
3295 : }
3296 :
3297 :
3298 : SWIGINTERN int
3299 0 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3300 : {
3301 : #if PY_VERSION_HEX>=0x03000000
3302 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3303 : if (PyBytes_Check(obj))
3304 : #else
3305 0 : if (PyUnicode_Check(obj))
3306 : #endif
3307 : #else
3308 : if (PyString_Check(obj))
3309 : #endif
3310 : {
3311 : char *cstr; Py_ssize_t len;
3312 : #if PY_VERSION_HEX>=0x03000000
3313 : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3314 0 : if (!alloc && cptr) {
3315 : /* We can't allow converting without allocation, since the internal
3316 : representation of string in Python 3 is UCS-2/UCS-4 but we require
3317 : a UTF-8 representation.
3318 : TODO(bhy) More detailed explanation */
3319 : return SWIG_RuntimeError;
3320 : }
3321 0 : obj = PyUnicode_AsUTF8String(obj);
3322 0 : if(alloc) *alloc = SWIG_NEWOBJ;
3323 : #endif
3324 0 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3325 : #else
3326 : PyString_AsStringAndSize(obj, &cstr, &len);
3327 : #endif
3328 0 : if (cptr) {
3329 0 : if (alloc) {
3330 : /*
3331 : In python the user should not be able to modify the inner
3332 : string representation. To warranty that, if you define
3333 : SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3334 : buffer is always returned.
3335 :
3336 : The default behavior is just to return the pointer value,
3337 : so, be careful.
3338 : */
3339 : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3340 : if (*alloc != SWIG_OLDOBJ)
3341 : #else
3342 0 : if (*alloc == SWIG_NEWOBJ)
3343 : #endif
3344 : {
3345 0 : *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3346 0 : *alloc = SWIG_NEWOBJ;
3347 : } else {
3348 0 : *cptr = cstr;
3349 0 : *alloc = SWIG_OLDOBJ;
3350 : }
3351 : } else {
3352 : #if PY_VERSION_HEX>=0x03000000
3353 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3354 : *cptr = PyBytes_AsString(obj);
3355 : #else
3356 : assert(0); /* Should never reach here with Unicode strings in Python 3 */
3357 : #endif
3358 : #else
3359 : *cptr = SWIG_Python_str_AsChar(obj);
3360 : #endif
3361 : }
3362 : }
3363 0 : if (psize) *psize = len + 1;
3364 : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3365 0 : Py_XDECREF(obj);
3366 : #endif
3367 : return SWIG_OK;
3368 : } else {
3369 : #if defined(SWIG_PYTHON_2_UNICODE)
3370 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3371 : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3372 : #endif
3373 : #if PY_VERSION_HEX<0x03000000
3374 : if (PyUnicode_Check(obj)) {
3375 : char *cstr; Py_ssize_t len;
3376 : if (!alloc && cptr) {
3377 : return SWIG_RuntimeError;
3378 : }
3379 : obj = PyUnicode_AsUTF8String(obj);
3380 : if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3381 : if (cptr) {
3382 : if (alloc) *alloc = SWIG_NEWOBJ;
3383 : *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3384 : }
3385 : if (psize) *psize = len + 1;
3386 :
3387 : Py_XDECREF(obj);
3388 : return SWIG_OK;
3389 : } else {
3390 : Py_XDECREF(obj);
3391 : }
3392 : }
3393 : #endif
3394 : #endif
3395 :
3396 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3397 0 : if (pchar_descriptor) {
3398 0 : void* vptr = 0;
3399 0 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3400 0 : if (cptr) *cptr = (char *) vptr;
3401 0 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3402 0 : if (alloc) *alloc = SWIG_OLDOBJ;
3403 0 : return SWIG_OK;
3404 : }
3405 : }
3406 : }
3407 : return SWIG_TypeError;
3408 : }
3409 :
3410 :
3411 :
3412 :
3413 :
3414 : #ifdef HAVE_CONFIG_H
3415 : #include "config.h"
3416 : #endif
3417 :
3418 : #include <gpgme.h>
3419 :
3420 :
3421 : SWIGINTERNINLINE PyObject *
3422 2805 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3423 : {
3424 2805 : if (carray) {
3425 2178 : if (size > INT_MAX) {
3426 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3427 : return pchar_descriptor ?
3428 0 : SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3429 : } else {
3430 : #if PY_VERSION_HEX >= 0x03000000
3431 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3432 : return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3433 : #else
3434 : #if PY_VERSION_HEX >= 0x03010000
3435 2236 : return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3436 : #else
3437 : return PyUnicode_FromStringAndSize(carray, (Py_ssize_t)(size));
3438 : #endif
3439 : #endif
3440 : #else
3441 : return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3442 : #endif
3443 : }
3444 : } else {
3445 627 : return SWIG_Py_Void();
3446 : }
3447 : }
3448 :
3449 :
3450 : SWIGINTERNINLINE PyObject *
3451 2370 : SWIG_FromCharPtr(const char *cptr)
3452 : {
3453 2805 : return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3454 : }
3455 :
3456 :
3457 : SWIGINTERN int
3458 185 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3459 : {
3460 : #if PY_VERSION_HEX < 0x03000000
3461 : if (PyInt_Check(obj)) {
3462 : long v = PyInt_AsLong(obj);
3463 : if (v >= 0) {
3464 : if (val) *val = v;
3465 : return SWIG_OK;
3466 : } else {
3467 : return SWIG_OverflowError;
3468 : }
3469 : } else
3470 : #endif
3471 185 : if (PyLong_Check(obj)) {
3472 185 : unsigned long v = PyLong_AsUnsignedLong(obj);
3473 185 : if (!PyErr_Occurred()) {
3474 185 : if (val) *val = v;
3475 : return SWIG_OK;
3476 : } else {
3477 0 : PyErr_Clear();
3478 0 : return SWIG_OverflowError;
3479 : }
3480 : }
3481 : #ifdef SWIG_PYTHON_CAST_MODE
3482 : {
3483 : int dispatch = 0;
3484 : unsigned long v = PyLong_AsUnsignedLong(obj);
3485 : if (!PyErr_Occurred()) {
3486 : if (val) *val = v;
3487 : return SWIG_AddCast(SWIG_OK);
3488 : } else {
3489 : PyErr_Clear();
3490 : }
3491 : if (!dispatch) {
3492 : double d;
3493 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3494 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3495 : if (val) *val = (unsigned long)(d);
3496 : return res;
3497 : }
3498 : }
3499 : }
3500 : #endif
3501 : return SWIG_TypeError;
3502 : }
3503 :
3504 :
3505 : SWIGINTERN int
3506 : SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3507 : {
3508 : unsigned long v;
3509 81 : int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3510 81 : if (SWIG_IsOK(res)) {
3511 81 : if ((v > UINT_MAX)) {
3512 : return SWIG_OverflowError;
3513 : } else {
3514 81 : if (val) *val = (unsigned int)(v);
3515 : }
3516 : }
3517 : return res;
3518 : }
3519 :
3520 :
3521 : SWIGINTERNINLINE PyObject*
3522 : SWIG_From_unsigned_SS_int (unsigned int value)
3523 : {
3524 2943 : return PyInt_FromSize_t((size_t) value);
3525 : }
3526 :
3527 :
3528 : SWIGINTERNINLINE PyObject*
3529 : SWIG_From_int (int value)
3530 : {
3531 11565 : return PyInt_FromLong((long) value);
3532 : }
3533 :
3534 :
3535 : SWIGINTERNINLINE PyObject *
3536 : SWIG_From_char (char c)
3537 : {
3538 58 : return SWIG_FromCharPtrAndSize(&c,1);
3539 : }
3540 :
3541 :
3542 : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
3543 : # define SWIG_LONG_LONG_AVAILABLE
3544 : #endif
3545 :
3546 :
3547 : #ifdef SWIG_LONG_LONG_AVAILABLE
3548 : SWIGINTERN int
3549 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
3550 : {
3551 : int res = SWIG_TypeError;
3552 : if (PyLong_Check(obj)) {
3553 : unsigned long long v = PyLong_AsUnsignedLongLong(obj);
3554 : if (!PyErr_Occurred()) {
3555 : if (val) *val = v;
3556 : return SWIG_OK;
3557 : } else {
3558 : PyErr_Clear();
3559 : res = SWIG_OverflowError;
3560 : }
3561 : } else {
3562 : unsigned long v;
3563 : res = SWIG_AsVal_unsigned_SS_long (obj,&v);
3564 : if (SWIG_IsOK(res)) {
3565 : if (val) *val = v;
3566 : return res;
3567 : }
3568 : }
3569 : #ifdef SWIG_PYTHON_CAST_MODE
3570 : {
3571 : const double mant_max = 1LL << DBL_MANT_DIG;
3572 : double d;
3573 : res = SWIG_AsVal_double (obj,&d);
3574 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
3575 : if (val) *val = (unsigned long long)(d);
3576 : return SWIG_AddCast(res);
3577 : }
3578 : res = SWIG_TypeError;
3579 : }
3580 : #endif
3581 : return res;
3582 : }
3583 : #endif
3584 :
3585 :
3586 : SWIGINTERNINLINE int
3587 : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3588 : {
3589 26 : int res = SWIG_TypeError;
3590 : #ifdef SWIG_LONG_LONG_AVAILABLE
3591 : if (sizeof(size_t) <= sizeof(unsigned long)) {
3592 : #endif
3593 : unsigned long v;
3594 26 : res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3595 26 : if (SWIG_IsOK(res) && val) *val = (size_t)(v);
3596 : #ifdef SWIG_LONG_LONG_AVAILABLE
3597 : } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
3598 : unsigned long long v;
3599 : res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
3600 : if (SWIG_IsOK(res) && val) *val = (size_t)(v);
3601 : }
3602 : #endif
3603 : return res;
3604 : }
3605 :
3606 :
3607 : SWIGINTERN int
3608 : SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
3609 : {
3610 : unsigned long v;
3611 0 : int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3612 0 : if (SWIG_IsOK(res)) {
3613 0 : if ((v > USHRT_MAX)) {
3614 : return SWIG_OverflowError;
3615 : } else {
3616 0 : if (val) *val = (unsigned short)(v);
3617 : }
3618 : }
3619 : return res;
3620 : }
3621 :
3622 :
3623 : #define SWIG_From_long PyInt_FromLong
3624 :
3625 :
3626 : SWIGINTERNINLINE PyObject*
3627 32 : SWIG_From_unsigned_SS_long (unsigned long value)
3628 : {
3629 32 : return (value > LONG_MAX) ?
3630 32 : PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
3631 : }
3632 :
3633 :
3634 : SWIGINTERNINLINE PyObject *
3635 : SWIG_From_unsigned_SS_short (unsigned short value)
3636 : {
3637 0 : return SWIG_From_unsigned_SS_long (value);
3638 : }
3639 :
3640 :
3641 : SWIGINTERN int
3642 0 : SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3643 : {
3644 0 : char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3645 0 : int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3646 0 : if (SWIG_IsOK(res)) {
3647 : /* special case of single char conversion when we don't need space for NUL */
3648 0 : if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3649 0 : if (csize <= size) {
3650 0 : if (val) {
3651 0 : if (csize) memcpy(val, cptr, csize*sizeof(char));
3652 0 : if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3653 : }
3654 0 : if (alloc == SWIG_NEWOBJ) {
3655 0 : free((char*)cptr);
3656 0 : res = SWIG_DelNewMask(res);
3657 : }
3658 : return res;
3659 : }
3660 0 : if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3661 : }
3662 : return SWIG_TypeError;
3663 : }
3664 :
3665 :
3666 : size_t
3667 0 : SWIG_strnlen(const char* s, size_t maxlen)
3668 : {
3669 : const char *p;
3670 0 : for (p = s; maxlen-- && *p; p++)
3671 : ;
3672 0 : return p - s;
3673 : }
3674 :
3675 : typedef union {
3676 : unsigned int count;
3677 : unsigned int uint32;
3678 : int int32;
3679 : char *string;
3680 : } gpgme_conf_arg_value;
3681 :
3682 :
3683 : static gpgme_ctx_t *new_gpgme_ctx_t_p() {
3684 84 : return (gpgme_ctx_t *)malloc(sizeof(gpgme_ctx_t));
3685 : }
3686 :
3687 0 : static gpgme_ctx_t *copy_gpgme_ctx_t_p(gpgme_ctx_t value) {
3688 0 : return (gpgme_ctx_t *)memcpy((gpgme_ctx_t *)malloc(sizeof(gpgme_ctx_t)),&value,sizeof(gpgme_ctx_t));
3689 : }
3690 :
3691 : static void delete_gpgme_ctx_t_p(gpgme_ctx_t *obj) {
3692 84 : if (obj) free((char*)obj);
3693 : }
3694 :
3695 : static void gpgme_ctx_t_p_assign(gpgme_ctx_t *obj, gpgme_ctx_t value) {
3696 0 : *obj = value;
3697 : }
3698 :
3699 : static gpgme_ctx_t gpgme_ctx_t_p_value(gpgme_ctx_t *obj) {
3700 : return *obj;
3701 : }
3702 :
3703 :
3704 : static gpgme_data_t *new_gpgme_data_t_p() {
3705 109 : return (gpgme_data_t *)malloc(sizeof(gpgme_data_t));
3706 : }
3707 :
3708 0 : static gpgme_data_t *copy_gpgme_data_t_p(gpgme_data_t value) {
3709 0 : return (gpgme_data_t *)memcpy((gpgme_data_t *)malloc(sizeof(gpgme_data_t)),&value,sizeof(gpgme_data_t));
3710 : }
3711 :
3712 : static void delete_gpgme_data_t_p(gpgme_data_t *obj) {
3713 109 : if (obj) free((char*)obj);
3714 : }
3715 :
3716 : static void gpgme_data_t_p_assign(gpgme_data_t *obj, gpgme_data_t value) {
3717 0 : *obj = value;
3718 : }
3719 :
3720 : static gpgme_data_t gpgme_data_t_p_value(gpgme_data_t *obj) {
3721 : return *obj;
3722 : }
3723 :
3724 :
3725 : static gpgme_key_t *new_gpgme_key_t_p() {
3726 241 : return (gpgme_key_t *)malloc(sizeof(gpgme_key_t));
3727 : }
3728 :
3729 0 : static gpgme_key_t *copy_gpgme_key_t_p(gpgme_key_t value) {
3730 0 : return (gpgme_key_t *)memcpy((gpgme_key_t *)malloc(sizeof(gpgme_key_t)),&value,sizeof(gpgme_key_t));
3731 : }
3732 :
3733 : static void delete_gpgme_key_t_p(gpgme_key_t *obj) {
3734 239 : if (obj) free((char*)obj);
3735 : }
3736 :
3737 : static void gpgme_key_t_p_assign(gpgme_key_t *obj, gpgme_key_t value) {
3738 0 : *obj = value;
3739 : }
3740 :
3741 : static gpgme_key_t gpgme_key_t_p_value(gpgme_key_t *obj) {
3742 : return *obj;
3743 : }
3744 :
3745 :
3746 : static gpgme_error_t *new_gpgme_error_t_p() {
3747 17 : return (gpgme_error_t *)malloc(sizeof(gpgme_error_t));
3748 : }
3749 :
3750 0 : static gpgme_error_t *copy_gpgme_error_t_p(gpgme_error_t value) {
3751 0 : return (gpgme_error_t *)memcpy((gpgme_error_t *)malloc(sizeof(gpgme_error_t)),&value,sizeof(gpgme_error_t));
3752 : }
3753 :
3754 : static void delete_gpgme_error_t_p(gpgme_error_t *obj) {
3755 11 : if (obj) free((char*)obj);
3756 : }
3757 :
3758 : static void gpgme_error_t_p_assign(gpgme_error_t *obj, gpgme_error_t value) {
3759 0 : *obj = value;
3760 : }
3761 :
3762 : static gpgme_error_t gpgme_error_t_p_value(gpgme_error_t *obj) {
3763 : return *obj;
3764 : }
3765 :
3766 :
3767 : static gpgme_trust_item_t *new_gpgme_trust_item_t_p() {
3768 2 : return (gpgme_trust_item_t *)malloc(sizeof(gpgme_trust_item_t));
3769 : }
3770 :
3771 0 : static gpgme_trust_item_t *copy_gpgme_trust_item_t_p(gpgme_trust_item_t value) {
3772 0 : return (gpgme_trust_item_t *)memcpy((gpgme_trust_item_t *)malloc(sizeof(gpgme_trust_item_t)),&value,sizeof(gpgme_trust_item_t));
3773 : }
3774 :
3775 : static void delete_gpgme_trust_item_t_p(gpgme_trust_item_t *obj) {
3776 2 : if (obj) free((char*)obj);
3777 : }
3778 :
3779 : static void gpgme_trust_item_t_p_assign(gpgme_trust_item_t *obj, gpgme_trust_item_t value) {
3780 0 : *obj = value;
3781 : }
3782 :
3783 : static gpgme_trust_item_t gpgme_trust_item_t_p_value(gpgme_trust_item_t *obj) {
3784 : return *obj;
3785 : }
3786 :
3787 :
3788 : static gpgme_engine_info_t *new_gpgme_engine_info_t_p() {
3789 0 : return (gpgme_engine_info_t *)malloc(sizeof(gpgme_engine_info_t));
3790 : }
3791 :
3792 0 : static gpgme_engine_info_t *copy_gpgme_engine_info_t_p(gpgme_engine_info_t value) {
3793 0 : return (gpgme_engine_info_t *)memcpy((gpgme_engine_info_t *)malloc(sizeof(gpgme_engine_info_t)),&value,sizeof(gpgme_engine_info_t));
3794 : }
3795 :
3796 : static void delete_gpgme_engine_info_t_p(gpgme_engine_info_t *obj) {
3797 0 : if (obj) free((char*)obj);
3798 : }
3799 :
3800 : static void gpgme_engine_info_t_p_assign(gpgme_engine_info_t *obj, gpgme_engine_info_t value) {
3801 0 : *obj = value;
3802 : }
3803 :
3804 : static gpgme_engine_info_t gpgme_engine_info_t_p_value(gpgme_engine_info_t *obj) {
3805 : return *obj;
3806 : }
3807 :
3808 :
3809 : #include <stdio.h>
3810 :
3811 :
3812 : #include "helpers.h"
3813 : #include "private.h"
3814 :
3815 : /* SWIG runtime support for helpers.c */
3816 : PyObject *
3817 47 : _gpg_wrap_gpgme_data_t(gpgme_data_t data)
3818 : {
3819 : /*
3820 : * If SWIG is invoked without -builtin, the macro SWIG_NewPointerObj
3821 : * expects a variable named "self".
3822 : *
3823 : * XXX: It is not quite clear why passing NULL as self is okay, but
3824 : * it works with -builtin, and it seems to work just fine without
3825 : * it too.
3826 : */
3827 47 : PyObject* self = NULL;
3828 : (void) self;
3829 47 : return SWIG_NewPointerObj(data, SWIGTYPE_p_gpgme_data, 0);
3830 : }
3831 :
3832 : gpgme_ctx_t
3833 441 : _gpg_unwrap_gpgme_ctx_t(PyObject *wrapped)
3834 : {
3835 : gpgme_ctx_t result;
3836 441 : if (SWIG_ConvertPtr(wrapped,
3837 : (void **) &result,
3838 : SWIGTYPE_p_gpgme_context,
3839 : SWIG_POINTER_EXCEPTION) == -1)
3840 : return NULL;
3841 441 : return result;
3842 : }
3843 :
3844 : #ifdef __cplusplus
3845 : extern "C" {
3846 : #endif
3847 20 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3848 20 : PyObject *resultobj = 0;
3849 20 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
3850 20 : char *arg2 = (char *) "" ;
3851 20 : int arg3 = (int) 0 ;
3852 20 : void *argp1 = 0 ;
3853 20 : int res1 = 0 ;
3854 20 : PyObject *encodedInput2 = NULL ;
3855 : int val3 ;
3856 20 : int ecode3 = 0 ;
3857 20 : PyObject * obj0 = 0 ;
3858 20 : PyObject * obj1 = 0 ;
3859 20 : PyObject * obj2 = 0 ;
3860 : gpgme_error_t result;
3861 :
3862 20 : if (!PyArg_ParseTuple(args,(char *)"O|OO:gpgme_op_keylist_start",&obj0,&obj1,&obj2)) SWIG_fail;
3863 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
3864 20 : if (!SWIG_IsOK(res1)) {
3865 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
3866 : }
3867 20 : arg1 = (gpgme_ctx_t)(argp1);
3868 20 : if (obj1) {
3869 : {
3870 19 : if (obj1 == Py_None)
3871 : arg2 = NULL;
3872 14 : else if (PyUnicode_Check(obj1))
3873 : {
3874 13 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
3875 13 : if (encodedInput2 == NULL)
3876 : return NULL;
3877 13 : arg2 = PyBytes_AsString(encodedInput2);
3878 : }
3879 1 : else if (PyBytes_Check(obj1))
3880 1 : arg2 = PyBytes_AsString(obj1);
3881 : else {
3882 0 : PyErr_Format(PyExc_TypeError,
3883 : "arg %d: expected str, bytes, or None, got %s",
3884 : 2, obj1->ob_type->tp_name);
3885 0 : return NULL;
3886 : }
3887 : }
3888 : }
3889 20 : if (obj2) {
3890 36 : ecode3 = SWIG_AsVal_int(obj2, &val3);
3891 18 : if (!SWIG_IsOK(ecode3)) {
3892 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_keylist_start" "', argument " "3"" of type '" "int""'");
3893 : }
3894 : arg3 = (int)(val3);
3895 : }
3896 : {
3897 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
3898 20 : result = gpgme_op_keylist_start(arg1,(char const *)arg2,arg3);
3899 20 : SWIG_PYTHON_THREAD_END_ALLOW;
3900 : }
3901 : {
3902 20 : resultobj = PyLong_FromLong(result);
3903 : }
3904 : {
3905 20 : Py_XDECREF(encodedInput2);
3906 : }
3907 : return resultobj;
3908 : fail:
3909 : {
3910 0 : Py_XDECREF(encodedInput2);
3911 : }
3912 : return NULL;
3913 : }
3914 :
3915 :
3916 46 : SWIGINTERN PyObject *_wrap_gpgme_data_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3917 46 : PyObject *resultobj = 0;
3918 46 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
3919 : off_t arg2 ;
3920 46 : int arg3 = (int) SEEK_SET ;
3921 46 : void *argp1 = 0 ;
3922 46 : int res1 = 0 ;
3923 : int val3 ;
3924 46 : int ecode3 = 0 ;
3925 46 : PyObject * obj0 = 0 ;
3926 46 : PyObject * obj1 = 0 ;
3927 46 : PyObject * obj2 = 0 ;
3928 : off_t result;
3929 :
3930 46 : if (!PyArg_ParseTuple(args,(char *)"OO|O:gpgme_data_seek",&obj0,&obj1,&obj2)) SWIG_fail;
3931 46 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
3932 46 : if (!SWIG_IsOK(res1)) {
3933 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_seek" "', argument " "1"" of type '" "gpgme_data_t""'");
3934 : }
3935 46 : arg1 = (gpgme_data_t)(argp1);
3936 : {
3937 46 : if (PyLong_Check(obj1))
3938 :
3939 :
3940 :
3941 46 : arg2 = PyLong_AsLong(obj1);
3942 :
3943 :
3944 : else if (PyInt_Check(obj1))
3945 : arg2 = PyInt_AsLong(obj1);
3946 :
3947 : else
3948 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
3949 : }
3950 46 : if (obj2) {
3951 90 : ecode3 = SWIG_AsVal_int(obj2, &val3);
3952 45 : if (!SWIG_IsOK(ecode3)) {
3953 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_seek" "', argument " "3"" of type '" "int""'");
3954 : }
3955 : arg3 = (int)(val3);
3956 : }
3957 : {
3958 46 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
3959 46 : result = gpgme_data_seek(arg1,arg2,arg3);
3960 46 : SWIG_PYTHON_THREAD_END_ALLOW;
3961 : }
3962 : {
3963 46 : resultobj = PyLong_FromLong(result);
3964 :
3965 : }
3966 46 : return resultobj;
3967 : fail:
3968 : return NULL;
3969 : }
3970 :
3971 :
3972 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3973 0 : PyObject *resultobj = 0;
3974 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
3975 0 : char *arg2 = (char *) 0 ;
3976 0 : void *argp1 = 0 ;
3977 0 : int res1 = 0 ;
3978 : int res2 ;
3979 0 : char *buf2 = 0 ;
3980 0 : int alloc2 = 0 ;
3981 0 : PyObject * obj0 = 0 ;
3982 0 : PyObject * obj1 = 0 ;
3983 :
3984 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_name_set",&obj0,&obj1)) SWIG_fail;
3985 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
3986 0 : if (!SWIG_IsOK(res1)) {
3987 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_name_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
3988 : }
3989 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
3990 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3991 0 : if (!SWIG_IsOK(res2)) {
3992 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_sig_notation_name_set" "', argument " "2"" of type '" "char *""'");
3993 : }
3994 0 : arg2 = (char *)(buf2);
3995 : {
3996 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
3997 0 : if (arg1->name) free((char*)arg1->name);
3998 0 : if (arg2) {
3999 0 : size_t size = strlen((const char *)(arg2)) + 1;
4000 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4001 : } else {
4002 0 : arg1->name = 0;
4003 : }
4004 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4005 : }
4006 0 : resultobj = SWIG_Py_Void();
4007 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4008 : return resultobj;
4009 : fail:
4010 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4011 : return NULL;
4012 : }
4013 :
4014 :
4015 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4016 15 : PyObject *resultobj = 0;
4017 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4018 15 : void *argp1 = 0 ;
4019 15 : int res1 = 0 ;
4020 15 : PyObject * obj0 = 0 ;
4021 15 : char *result = 0 ;
4022 :
4023 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_name_get",&obj0)) SWIG_fail;
4024 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4025 15 : if (!SWIG_IsOK(res1)) {
4026 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_name_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4027 : }
4028 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4029 : {
4030 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4031 15 : result = (char *) ((arg1)->name);
4032 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4033 : }
4034 15 : resultobj = SWIG_FromCharPtr((const char *)result);
4035 15 : return resultobj;
4036 : fail:
4037 : return NULL;
4038 : }
4039 :
4040 :
4041 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4042 0 : PyObject *resultobj = 0;
4043 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4044 0 : char *arg2 = (char *) 0 ;
4045 0 : void *argp1 = 0 ;
4046 0 : int res1 = 0 ;
4047 : int res2 ;
4048 0 : char *buf2 = 0 ;
4049 0 : int alloc2 = 0 ;
4050 0 : PyObject * obj0 = 0 ;
4051 0 : PyObject * obj1 = 0 ;
4052 :
4053 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_value_set",&obj0,&obj1)) SWIG_fail;
4054 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4055 0 : if (!SWIG_IsOK(res1)) {
4056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_value_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4057 : }
4058 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4059 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4060 0 : if (!SWIG_IsOK(res2)) {
4061 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_sig_notation_value_set" "', argument " "2"" of type '" "char *""'");
4062 : }
4063 0 : arg2 = (char *)(buf2);
4064 : {
4065 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4066 0 : if (arg1->value) free((char*)arg1->value);
4067 0 : if (arg2) {
4068 0 : size_t size = strlen((const char *)(arg2)) + 1;
4069 0 : arg1->value = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4070 : } else {
4071 0 : arg1->value = 0;
4072 : }
4073 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4074 : }
4075 0 : resultobj = SWIG_Py_Void();
4076 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4077 : return resultobj;
4078 : fail:
4079 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4080 : return NULL;
4081 : }
4082 :
4083 :
4084 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4085 15 : PyObject *resultobj = 0;
4086 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4087 15 : void *argp1 = 0 ;
4088 15 : int res1 = 0 ;
4089 15 : PyObject * obj0 = 0 ;
4090 15 : char *result = 0 ;
4091 :
4092 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_value_get",&obj0)) SWIG_fail;
4093 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4094 15 : if (!SWIG_IsOK(res1)) {
4095 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_value_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4096 : }
4097 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4098 : {
4099 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4100 15 : result = (char *) ((arg1)->value);
4101 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4102 : }
4103 15 : resultobj = SWIG_FromCharPtr((const char *)result);
4104 15 : return resultobj;
4105 : fail:
4106 : return NULL;
4107 : }
4108 :
4109 :
4110 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4111 0 : PyObject *resultobj = 0;
4112 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4113 : gpgme_sig_notation_flags_t arg2 ;
4114 0 : void *argp1 = 0 ;
4115 0 : int res1 = 0 ;
4116 : unsigned int val2 ;
4117 0 : int ecode2 = 0 ;
4118 0 : PyObject * obj0 = 0 ;
4119 0 : PyObject * obj1 = 0 ;
4120 :
4121 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_flags_set",&obj0,&obj1)) SWIG_fail;
4122 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4123 0 : if (!SWIG_IsOK(res1)) {
4124 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_flags_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4125 : }
4126 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4127 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4128 0 : if (!SWIG_IsOK(ecode2)) {
4129 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_flags_set" "', argument " "2"" of type '" "gpgme_sig_notation_flags_t""'");
4130 : }
4131 0 : arg2 = (gpgme_sig_notation_flags_t)(val2);
4132 : {
4133 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4134 0 : if (arg1) (arg1)->flags = arg2;
4135 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4136 : }
4137 0 : resultobj = SWIG_Py_Void();
4138 0 : return resultobj;
4139 : fail:
4140 : return NULL;
4141 : }
4142 :
4143 :
4144 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4145 15 : PyObject *resultobj = 0;
4146 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4147 15 : void *argp1 = 0 ;
4148 15 : int res1 = 0 ;
4149 15 : PyObject * obj0 = 0 ;
4150 : gpgme_sig_notation_flags_t result;
4151 :
4152 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_flags_get",&obj0)) SWIG_fail;
4153 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4154 15 : if (!SWIG_IsOK(res1)) {
4155 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_flags_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4156 : }
4157 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4158 : {
4159 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4160 15 : result = (gpgme_sig_notation_flags_t) ((arg1)->flags);
4161 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4162 : }
4163 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4164 15 : return resultobj;
4165 : fail:
4166 : return NULL;
4167 : }
4168 :
4169 :
4170 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_human_readable_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4171 0 : PyObject *resultobj = 0;
4172 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4173 : unsigned int arg2 ;
4174 0 : void *argp1 = 0 ;
4175 0 : int res1 = 0 ;
4176 : unsigned int val2 ;
4177 0 : int ecode2 = 0 ;
4178 0 : PyObject * obj0 = 0 ;
4179 0 : PyObject * obj1 = 0 ;
4180 :
4181 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_human_readable_set",&obj0,&obj1)) SWIG_fail;
4182 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4183 0 : if (!SWIG_IsOK(res1)) {
4184 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_human_readable_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4185 : }
4186 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4187 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4188 0 : if (!SWIG_IsOK(ecode2)) {
4189 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_human_readable_set" "', argument " "2"" of type '" "unsigned int""'");
4190 : }
4191 0 : arg2 = (unsigned int)(val2);
4192 : {
4193 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4194 0 : if (arg1) (arg1)->human_readable = arg2;
4195 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4196 : }
4197 0 : resultobj = SWIG_Py_Void();
4198 0 : return resultobj;
4199 : fail:
4200 : return NULL;
4201 : }
4202 :
4203 :
4204 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_human_readable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4205 15 : PyObject *resultobj = 0;
4206 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4207 15 : void *argp1 = 0 ;
4208 15 : int res1 = 0 ;
4209 15 : PyObject * obj0 = 0 ;
4210 : unsigned int result;
4211 :
4212 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_human_readable_get",&obj0)) SWIG_fail;
4213 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4214 15 : if (!SWIG_IsOK(res1)) {
4215 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_human_readable_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4216 : }
4217 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4218 : {
4219 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4220 15 : result = (unsigned int) ((arg1)->human_readable);
4221 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4222 : }
4223 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4224 15 : return resultobj;
4225 : fail:
4226 : return NULL;
4227 : }
4228 :
4229 :
4230 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_critical_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4231 0 : PyObject *resultobj = 0;
4232 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4233 : unsigned int arg2 ;
4234 0 : void *argp1 = 0 ;
4235 0 : int res1 = 0 ;
4236 : unsigned int val2 ;
4237 0 : int ecode2 = 0 ;
4238 0 : PyObject * obj0 = 0 ;
4239 0 : PyObject * obj1 = 0 ;
4240 :
4241 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_critical_set",&obj0,&obj1)) SWIG_fail;
4242 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4243 0 : if (!SWIG_IsOK(res1)) {
4244 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_critical_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4245 : }
4246 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4247 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4248 0 : if (!SWIG_IsOK(ecode2)) {
4249 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_critical_set" "', argument " "2"" of type '" "unsigned int""'");
4250 : }
4251 0 : arg2 = (unsigned int)(val2);
4252 : {
4253 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4254 0 : if (arg1) (arg1)->critical = arg2;
4255 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4256 : }
4257 0 : resultobj = SWIG_Py_Void();
4258 0 : return resultobj;
4259 : fail:
4260 : return NULL;
4261 : }
4262 :
4263 :
4264 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_critical_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4265 15 : PyObject *resultobj = 0;
4266 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4267 15 : void *argp1 = 0 ;
4268 15 : int res1 = 0 ;
4269 15 : PyObject * obj0 = 0 ;
4270 : unsigned int result;
4271 :
4272 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_critical_get",&obj0)) SWIG_fail;
4273 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4274 15 : if (!SWIG_IsOK(res1)) {
4275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_critical_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4276 : }
4277 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4278 : {
4279 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4280 15 : result = (unsigned int) ((arg1)->critical);
4281 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4282 : }
4283 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4284 15 : return resultobj;
4285 : fail:
4286 : return NULL;
4287 : }
4288 :
4289 :
4290 0 : SWIGINTERN PyObject *_wrap_new__gpgme_sig_notation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4291 0 : PyObject *resultobj = 0;
4292 0 : struct _gpgme_sig_notation *result = 0 ;
4293 :
4294 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_sig_notation")) SWIG_fail;
4295 : {
4296 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4297 0 : result = (struct _gpgme_sig_notation *)calloc(1, sizeof(struct _gpgme_sig_notation));
4298 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4299 : }
4300 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_NEW | 0 );
4301 0 : return resultobj;
4302 : fail:
4303 : return NULL;
4304 : }
4305 :
4306 :
4307 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_sig_notation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 0 : PyObject *resultobj = 0;
4309 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4310 0 : void *argp1 = 0 ;
4311 0 : int res1 = 0 ;
4312 0 : PyObject * obj0 = 0 ;
4313 :
4314 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_sig_notation",&obj0)) SWIG_fail;
4315 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
4316 0 : if (!SWIG_IsOK(res1)) {
4317 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_sig_notation" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4318 : }
4319 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4320 : {
4321 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4322 0 : free((char *) arg1);
4323 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4324 : }
4325 0 : resultobj = SWIG_Py_Void();
4326 0 : return resultobj;
4327 : fail:
4328 : return NULL;
4329 : }
4330 :
4331 :
4332 29 : SWIGINTERN PyObject *_gpgme_sig_notation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4333 : PyObject *obj;
4334 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4335 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_sig_notation, SWIG_NewClientData(obj));
4336 29 : return SWIG_Py_Void();
4337 : }
4338 :
4339 0 : SWIGINTERN PyObject *_wrap_gpgme_err_make(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4340 0 : PyObject *resultobj = 0;
4341 : gpgme_err_source_t arg1 ;
4342 : gpgme_err_code_t arg2 ;
4343 0 : PyObject * obj0 = 0 ;
4344 0 : PyObject * obj1 = 0 ;
4345 : gpgme_error_t result;
4346 :
4347 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_err_make",&obj0,&obj1)) SWIG_fail;
4348 : {
4349 0 : if (PyLong_Check(obj0))
4350 0 : arg1 = PyLong_AsLong(obj0);
4351 :
4352 : else if (PyInt_Check(obj0))
4353 : arg1 = PyInt_AsLong(obj0);
4354 :
4355 : else
4356 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4357 : }
4358 : {
4359 0 : if (PyLong_Check(obj1))
4360 0 : arg2 = PyLong_AsLong(obj1);
4361 :
4362 : else if (PyInt_Check(obj1))
4363 : arg2 = PyInt_AsLong(obj1);
4364 :
4365 : else
4366 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4367 : }
4368 : {
4369 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4370 0 : result = gpgme_err_make(arg1,arg2);
4371 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4372 : }
4373 : {
4374 0 : resultobj = PyLong_FromLong(result);
4375 : }
4376 0 : return resultobj;
4377 : fail:
4378 : return NULL;
4379 : }
4380 :
4381 :
4382 0 : SWIGINTERN PyObject *_wrap_gpgme_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4383 0 : PyObject *resultobj = 0;
4384 : gpgme_err_code_t arg1 ;
4385 0 : PyObject * obj0 = 0 ;
4386 : gpgme_error_t result;
4387 :
4388 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error",&obj0)) SWIG_fail;
4389 : {
4390 0 : if (PyLong_Check(obj0))
4391 0 : arg1 = PyLong_AsLong(obj0);
4392 :
4393 : else if (PyInt_Check(obj0))
4394 : arg1 = PyInt_AsLong(obj0);
4395 :
4396 : else
4397 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4398 : }
4399 : {
4400 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4401 0 : result = gpgme_error(arg1);
4402 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4403 : }
4404 : {
4405 0 : resultobj = PyLong_FromLong(result);
4406 : }
4407 0 : return resultobj;
4408 : fail:
4409 : return NULL;
4410 : }
4411 :
4412 :
4413 54 : SWIGINTERN PyObject *_wrap_gpgme_err_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 54 : PyObject *resultobj = 0;
4415 : gpgme_error_t arg1 ;
4416 54 : PyObject * obj0 = 0 ;
4417 : gpgme_err_code_t result;
4418 :
4419 54 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code",&obj0)) SWIG_fail;
4420 : {
4421 54 : if (PyLong_Check(obj0))
4422 54 : arg1 = PyLong_AsLong(obj0);
4423 :
4424 : else if (PyInt_Check(obj0))
4425 : arg1 = PyInt_AsLong(obj0);
4426 :
4427 : else
4428 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4429 : }
4430 : {
4431 54 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4432 54 : result = gpgme_err_code(arg1);
4433 54 : SWIG_PYTHON_THREAD_END_ALLOW;
4434 : }
4435 : {
4436 54 : resultobj = PyLong_FromLong(result);
4437 : }
4438 54 : return resultobj;
4439 : fail:
4440 : return NULL;
4441 : }
4442 :
4443 :
4444 1 : SWIGINTERN PyObject *_wrap_gpgme_err_source(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4445 1 : PyObject *resultobj = 0;
4446 : gpgme_error_t arg1 ;
4447 1 : PyObject * obj0 = 0 ;
4448 : gpgme_err_source_t result;
4449 :
4450 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_source",&obj0)) SWIG_fail;
4451 : {
4452 1 : if (PyLong_Check(obj0))
4453 1 : arg1 = PyLong_AsLong(obj0);
4454 :
4455 : else if (PyInt_Check(obj0))
4456 : arg1 = PyInt_AsLong(obj0);
4457 :
4458 : else
4459 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4460 : }
4461 : {
4462 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4463 1 : result = gpgme_err_source(arg1);
4464 1 : SWIG_PYTHON_THREAD_END_ALLOW;
4465 : }
4466 : {
4467 1 : resultobj = PyLong_FromLong(result);
4468 : }
4469 1 : return resultobj;
4470 : fail:
4471 : return NULL;
4472 : }
4473 :
4474 :
4475 0 : SWIGINTERN PyObject *_wrap_gpgme_strerror(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 0 : PyObject *resultobj = 0;
4477 : gpgme_error_t arg1 ;
4478 0 : PyObject * obj0 = 0 ;
4479 0 : char *result = 0 ;
4480 :
4481 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_strerror",&obj0)) SWIG_fail;
4482 : {
4483 0 : if (PyLong_Check(obj0))
4484 0 : arg1 = PyLong_AsLong(obj0);
4485 :
4486 : else if (PyInt_Check(obj0))
4487 : arg1 = PyInt_AsLong(obj0);
4488 :
4489 : else
4490 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4491 : }
4492 : {
4493 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4494 0 : result = (char *)gpgme_strerror(arg1);
4495 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4496 : }
4497 0 : resultobj = SWIG_FromCharPtr((const char *)result);
4498 0 : return resultobj;
4499 : fail:
4500 : return NULL;
4501 : }
4502 :
4503 :
4504 0 : SWIGINTERN PyObject *_wrap_gpgme_strerror_r(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4505 0 : PyObject *resultobj = 0;
4506 : gpg_error_t arg1 ;
4507 0 : char *arg2 = (char *) 0 ;
4508 : size_t arg3 ;
4509 0 : PyObject * obj0 = 0 ;
4510 0 : PyObject * obj1 = 0 ;
4511 : int result;
4512 :
4513 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_strerror_r",&obj0,&obj1)) SWIG_fail;
4514 : {
4515 0 : if (PyLong_Check(obj0))
4516 0 : arg1 = PyLong_AsLong(obj0);
4517 :
4518 : else if (PyInt_Check(obj0))
4519 : arg1 = PyInt_AsLong(obj0);
4520 :
4521 : else
4522 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4523 : }
4524 : {
4525 : {
4526 : long tmp2;
4527 0 : if (PyLong_Check(obj1))
4528 0 : tmp2 = PyLong_AsLong(obj1);
4529 :
4530 : else if (PyInt_Check(obj1))
4531 : tmp2 = PyInt_AsLong(obj1);
4532 :
4533 : else
4534 : {
4535 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4536 0 : return NULL;
4537 : }
4538 :
4539 0 : if (tmp2 < 0) {
4540 0 : PyErr_SetString(PyExc_ValueError, "Positive integer expected");
4541 0 : return NULL;
4542 : }
4543 0 : arg3 = (size_t) tmp2;
4544 0 : arg2 = (char *) malloc(arg3+1);
4545 : }
4546 : }
4547 : {
4548 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4549 0 : result = (int)gpgme_strerror_r(arg1,arg2,arg3);
4550 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4551 : }
4552 0 : resultobj = SWIG_From_int((int)(result));
4553 : {
4554 0 : Py_XDECREF(resultobj); /* Blow away any previous result */
4555 0 : if (result < 0) {
4556 : /* Check for I/O error */
4557 0 : free(arg2);
4558 0 : return PyErr_SetFromErrno(PyExc_RuntimeError);
4559 : }
4560 0 : resultobj = PyBytes_FromStringAndSize(arg2,result);
4561 0 : free(arg2);
4562 : }
4563 0 : return resultobj;
4564 : fail:
4565 : return NULL;
4566 : }
4567 :
4568 :
4569 0 : SWIGINTERN PyObject *_wrap_gpgme_strsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4570 0 : PyObject *resultobj = 0;
4571 : gpgme_error_t arg1 ;
4572 0 : PyObject * obj0 = 0 ;
4573 0 : char *result = 0 ;
4574 :
4575 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_strsource",&obj0)) SWIG_fail;
4576 : {
4577 0 : if (PyLong_Check(obj0))
4578 0 : arg1 = PyLong_AsLong(obj0);
4579 :
4580 : else if (PyInt_Check(obj0))
4581 : arg1 = PyInt_AsLong(obj0);
4582 :
4583 : else
4584 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4585 : }
4586 : {
4587 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4588 0 : result = (char *)gpgme_strsource(arg1);
4589 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4590 : }
4591 0 : resultobj = SWIG_FromCharPtr((const char *)result);
4592 0 : return resultobj;
4593 : fail:
4594 : return NULL;
4595 : }
4596 :
4597 :
4598 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_from_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4599 0 : PyObject *resultobj = 0;
4600 : int arg1 ;
4601 : int val1 ;
4602 0 : int ecode1 = 0 ;
4603 0 : PyObject * obj0 = 0 ;
4604 : gpgme_err_code_t result;
4605 :
4606 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code_from_errno",&obj0)) SWIG_fail;
4607 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4608 0 : if (!SWIG_IsOK(ecode1)) {
4609 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_err_code_from_errno" "', argument " "1"" of type '" "int""'");
4610 : }
4611 0 : arg1 = (int)(val1);
4612 : {
4613 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4614 0 : result = gpgme_err_code_from_errno(arg1);
4615 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4616 : }
4617 : {
4618 0 : resultobj = PyLong_FromLong(result);
4619 : }
4620 0 : return resultobj;
4621 : fail:
4622 : return NULL;
4623 : }
4624 :
4625 :
4626 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_to_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4627 0 : PyObject *resultobj = 0;
4628 : gpgme_err_code_t arg1 ;
4629 0 : PyObject * obj0 = 0 ;
4630 : int result;
4631 :
4632 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code_to_errno",&obj0)) SWIG_fail;
4633 : {
4634 0 : if (PyLong_Check(obj0))
4635 0 : arg1 = PyLong_AsLong(obj0);
4636 :
4637 : else if (PyInt_Check(obj0))
4638 : arg1 = PyInt_AsLong(obj0);
4639 :
4640 : else
4641 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4642 : }
4643 : {
4644 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4645 0 : result = (int)gpgme_err_code_to_errno(arg1);
4646 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4647 : }
4648 0 : resultobj = SWIG_From_int((int)(result));
4649 0 : return resultobj;
4650 : fail:
4651 : return NULL;
4652 : }
4653 :
4654 :
4655 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_from_syserror(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4656 0 : PyObject *resultobj = 0;
4657 : gpgme_err_code_t result;
4658 :
4659 0 : if (!PyArg_ParseTuple(args,(char *)":gpgme_err_code_from_syserror")) SWIG_fail;
4660 : {
4661 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4662 0 : result = gpgme_err_code_from_syserror();
4663 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4664 : }
4665 : {
4666 0 : resultobj = PyLong_FromLong(result);
4667 : }
4668 0 : return resultobj;
4669 : fail:
4670 : return NULL;
4671 : }
4672 :
4673 :
4674 0 : SWIGINTERN PyObject *_wrap_gpgme_err_set_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4675 0 : PyObject *resultobj = 0;
4676 : int arg1 ;
4677 : int val1 ;
4678 0 : int ecode1 = 0 ;
4679 0 : PyObject * obj0 = 0 ;
4680 :
4681 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_set_errno",&obj0)) SWIG_fail;
4682 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4683 0 : if (!SWIG_IsOK(ecode1)) {
4684 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_err_set_errno" "', argument " "1"" of type '" "int""'");
4685 : }
4686 0 : arg1 = (int)(val1);
4687 : {
4688 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4689 0 : gpgme_err_set_errno(arg1);
4690 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4691 : }
4692 0 : resultobj = SWIG_Py_Void();
4693 0 : return resultobj;
4694 : fail:
4695 : return NULL;
4696 : }
4697 :
4698 :
4699 0 : SWIGINTERN PyObject *_wrap_gpgme_err_make_from_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4700 0 : PyObject *resultobj = 0;
4701 : gpgme_err_source_t arg1 ;
4702 : int arg2 ;
4703 : int val2 ;
4704 0 : int ecode2 = 0 ;
4705 0 : PyObject * obj0 = 0 ;
4706 0 : PyObject * obj1 = 0 ;
4707 : gpgme_error_t result;
4708 :
4709 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_err_make_from_errno",&obj0,&obj1)) SWIG_fail;
4710 : {
4711 0 : if (PyLong_Check(obj0))
4712 0 : arg1 = PyLong_AsLong(obj0);
4713 :
4714 : else if (PyInt_Check(obj0))
4715 : arg1 = PyInt_AsLong(obj0);
4716 :
4717 : else
4718 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4719 : }
4720 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
4721 0 : if (!SWIG_IsOK(ecode2)) {
4722 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_err_make_from_errno" "', argument " "2"" of type '" "int""'");
4723 : }
4724 0 : arg2 = (int)(val2);
4725 : {
4726 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4727 0 : result = gpgme_err_make_from_errno(arg1,arg2);
4728 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4729 : }
4730 : {
4731 0 : resultobj = PyLong_FromLong(result);
4732 : }
4733 0 : return resultobj;
4734 : fail:
4735 : return NULL;
4736 : }
4737 :
4738 :
4739 0 : SWIGINTERN PyObject *_wrap_gpgme_error_from_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4740 0 : PyObject *resultobj = 0;
4741 : int arg1 ;
4742 : int val1 ;
4743 0 : int ecode1 = 0 ;
4744 0 : PyObject * obj0 = 0 ;
4745 : gpgme_error_t result;
4746 :
4747 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error_from_errno",&obj0)) SWIG_fail;
4748 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4749 0 : if (!SWIG_IsOK(ecode1)) {
4750 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_error_from_errno" "', argument " "1"" of type '" "int""'");
4751 : }
4752 0 : arg1 = (int)(val1);
4753 : {
4754 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4755 0 : result = gpgme_error_from_errno(arg1);
4756 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4757 : }
4758 : {
4759 0 : resultobj = PyLong_FromLong(result);
4760 : }
4761 0 : return resultobj;
4762 : fail:
4763 : return NULL;
4764 : }
4765 :
4766 :
4767 0 : SWIGINTERN PyObject *_wrap_gpgme_error_from_syserror(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4768 0 : PyObject *resultobj = 0;
4769 : gpgme_error_t result;
4770 :
4771 0 : if (!PyArg_ParseTuple(args,(char *)":gpgme_error_from_syserror")) SWIG_fail;
4772 : {
4773 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4774 0 : result = gpgme_error_from_syserror();
4775 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4776 : }
4777 : {
4778 0 : resultobj = PyLong_FromLong(result);
4779 : }
4780 0 : return resultobj;
4781 : fail:
4782 : return NULL;
4783 : }
4784 :
4785 :
4786 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_protocol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4787 0 : PyObject *resultobj = 0;
4788 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4789 : gpgme_protocol_t arg2 ;
4790 0 : void *argp1 = 0 ;
4791 0 : int res1 = 0 ;
4792 : int val2 ;
4793 0 : int ecode2 = 0 ;
4794 0 : PyObject * obj0 = 0 ;
4795 0 : PyObject * obj1 = 0 ;
4796 :
4797 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_protocol_set",&obj0,&obj1)) SWIG_fail;
4798 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4799 0 : if (!SWIG_IsOK(res1)) {
4800 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_protocol_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4801 : }
4802 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4803 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
4804 0 : if (!SWIG_IsOK(ecode2)) {
4805 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_engine_info_protocol_set" "', argument " "2"" of type '" "gpgme_protocol_t""'");
4806 : }
4807 0 : arg2 = (gpgme_protocol_t)(val2);
4808 : {
4809 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4810 0 : if (arg1) (arg1)->protocol = arg2;
4811 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4812 : }
4813 0 : resultobj = SWIG_Py_Void();
4814 0 : return resultobj;
4815 : fail:
4816 : return NULL;
4817 : }
4818 :
4819 :
4820 216 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_protocol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4821 216 : PyObject *resultobj = 0;
4822 216 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4823 216 : void *argp1 = 0 ;
4824 216 : int res1 = 0 ;
4825 216 : PyObject * obj0 = 0 ;
4826 : gpgme_protocol_t result;
4827 :
4828 216 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_protocol_get",&obj0)) SWIG_fail;
4829 216 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4830 216 : if (!SWIG_IsOK(res1)) {
4831 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_protocol_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4832 : }
4833 216 : arg1 = (struct _gpgme_engine_info *)(argp1);
4834 : {
4835 216 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4836 216 : result = (gpgme_protocol_t) ((arg1)->protocol);
4837 216 : SWIG_PYTHON_THREAD_END_ALLOW;
4838 : }
4839 432 : resultobj = SWIG_From_int((int)(result));
4840 216 : return resultobj;
4841 : fail:
4842 : return NULL;
4843 : }
4844 :
4845 :
4846 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_file_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4847 0 : PyObject *resultobj = 0;
4848 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4849 0 : char *arg2 = (char *) 0 ;
4850 0 : void *argp1 = 0 ;
4851 0 : int res1 = 0 ;
4852 : int res2 ;
4853 0 : char *buf2 = 0 ;
4854 0 : int alloc2 = 0 ;
4855 0 : PyObject * obj0 = 0 ;
4856 0 : PyObject * obj1 = 0 ;
4857 :
4858 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_file_name_set",&obj0,&obj1)) SWIG_fail;
4859 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4860 0 : if (!SWIG_IsOK(res1)) {
4861 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_file_name_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4862 : }
4863 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4864 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4865 0 : if (!SWIG_IsOK(res2)) {
4866 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_file_name_set" "', argument " "2"" of type '" "char *""'");
4867 : }
4868 0 : arg2 = (char *)(buf2);
4869 : {
4870 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4871 0 : if (arg1->file_name) free((char*)arg1->file_name);
4872 0 : if (arg2) {
4873 0 : size_t size = strlen((const char *)(arg2)) + 1;
4874 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4875 : } else {
4876 0 : arg1->file_name = 0;
4877 : }
4878 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4879 : }
4880 0 : resultobj = SWIG_Py_Void();
4881 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4882 : return resultobj;
4883 : fail:
4884 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4885 : return NULL;
4886 : }
4887 :
4888 :
4889 216 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_file_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4890 216 : PyObject *resultobj = 0;
4891 216 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4892 216 : void *argp1 = 0 ;
4893 216 : int res1 = 0 ;
4894 216 : PyObject * obj0 = 0 ;
4895 216 : char *result = 0 ;
4896 :
4897 216 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_file_name_get",&obj0)) SWIG_fail;
4898 216 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4899 216 : if (!SWIG_IsOK(res1)) {
4900 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_file_name_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4901 : }
4902 216 : arg1 = (struct _gpgme_engine_info *)(argp1);
4903 : {
4904 216 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4905 216 : result = (char *) ((arg1)->file_name);
4906 216 : SWIG_PYTHON_THREAD_END_ALLOW;
4907 : }
4908 216 : resultobj = SWIG_FromCharPtr((const char *)result);
4909 216 : return resultobj;
4910 : fail:
4911 : return NULL;
4912 : }
4913 :
4914 :
4915 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4916 0 : PyObject *resultobj = 0;
4917 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4918 0 : char *arg2 = (char *) 0 ;
4919 0 : void *argp1 = 0 ;
4920 0 : int res1 = 0 ;
4921 : int res2 ;
4922 0 : char *buf2 = 0 ;
4923 0 : int alloc2 = 0 ;
4924 0 : PyObject * obj0 = 0 ;
4925 0 : PyObject * obj1 = 0 ;
4926 :
4927 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_version_set",&obj0,&obj1)) SWIG_fail;
4928 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4929 0 : if (!SWIG_IsOK(res1)) {
4930 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_version_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4931 : }
4932 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4933 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4934 0 : if (!SWIG_IsOK(res2)) {
4935 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_version_set" "', argument " "2"" of type '" "char *""'");
4936 : }
4937 0 : arg2 = (char *)(buf2);
4938 : {
4939 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4940 0 : if (arg1->version) free((char*)arg1->version);
4941 0 : if (arg2) {
4942 0 : size_t size = strlen((const char *)(arg2)) + 1;
4943 0 : arg1->version = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4944 : } else {
4945 0 : arg1->version = 0;
4946 : }
4947 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4948 : }
4949 0 : resultobj = SWIG_Py_Void();
4950 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4951 : return resultobj;
4952 : fail:
4953 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4954 : return NULL;
4955 : }
4956 :
4957 :
4958 216 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4959 216 : PyObject *resultobj = 0;
4960 216 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4961 216 : void *argp1 = 0 ;
4962 216 : int res1 = 0 ;
4963 216 : PyObject * obj0 = 0 ;
4964 216 : char *result = 0 ;
4965 :
4966 216 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_version_get",&obj0)) SWIG_fail;
4967 216 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4968 216 : if (!SWIG_IsOK(res1)) {
4969 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_version_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4970 : }
4971 216 : arg1 = (struct _gpgme_engine_info *)(argp1);
4972 : {
4973 216 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4974 216 : result = (char *) ((arg1)->version);
4975 216 : SWIG_PYTHON_THREAD_END_ALLOW;
4976 : }
4977 216 : resultobj = SWIG_FromCharPtr((const char *)result);
4978 216 : return resultobj;
4979 : fail:
4980 : return NULL;
4981 : }
4982 :
4983 :
4984 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_req_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4985 0 : PyObject *resultobj = 0;
4986 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4987 0 : char *arg2 = (char *) 0 ;
4988 0 : void *argp1 = 0 ;
4989 0 : int res1 = 0 ;
4990 0 : PyObject *encodedInput2 = NULL ;
4991 0 : PyObject * obj0 = 0 ;
4992 0 : PyObject * obj1 = 0 ;
4993 :
4994 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_req_version_set",&obj0,&obj1)) SWIG_fail;
4995 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4996 0 : if (!SWIG_IsOK(res1)) {
4997 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_req_version_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4998 : }
4999 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
5000 : {
5001 0 : if (obj1 == Py_None)
5002 : arg2 = NULL;
5003 0 : else if (PyUnicode_Check(obj1))
5004 : {
5005 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
5006 0 : if (encodedInput2 == NULL)
5007 : return NULL;
5008 0 : arg2 = PyBytes_AsString(encodedInput2);
5009 : }
5010 0 : else if (PyBytes_Check(obj1))
5011 0 : arg2 = PyBytes_AsString(obj1);
5012 : else {
5013 0 : PyErr_Format(PyExc_TypeError,
5014 : "arg %d: expected str, bytes, or None, got %s",
5015 : 2, obj1->ob_type->tp_name);
5016 0 : return NULL;
5017 : }
5018 : }
5019 : {
5020 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5021 0 : if (arg2) {
5022 0 : size_t size = strlen((const char *)((const char *)(arg2))) + 1;
5023 0 : arg1->req_version = (char const *)(char *)memcpy((char *)malloc((size)*sizeof(char)), arg2, sizeof(char)*(size));
5024 : } else {
5025 0 : arg1->req_version = 0;
5026 : }
5027 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5028 : }
5029 0 : resultobj = SWIG_Py_Void();
5030 : {
5031 0 : Py_XDECREF(encodedInput2);
5032 : }
5033 : return resultobj;
5034 : fail:
5035 : {
5036 : Py_XDECREF(encodedInput2);
5037 : }
5038 : return NULL;
5039 : }
5040 :
5041 :
5042 216 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_req_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5043 216 : PyObject *resultobj = 0;
5044 216 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
5045 216 : void *argp1 = 0 ;
5046 216 : int res1 = 0 ;
5047 216 : PyObject * obj0 = 0 ;
5048 216 : char *result = 0 ;
5049 :
5050 216 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_req_version_get",&obj0)) SWIG_fail;
5051 216 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
5052 216 : if (!SWIG_IsOK(res1)) {
5053 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_req_version_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
5054 : }
5055 216 : arg1 = (struct _gpgme_engine_info *)(argp1);
5056 : {
5057 216 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5058 216 : result = (char *) ((arg1)->req_version);
5059 216 : SWIG_PYTHON_THREAD_END_ALLOW;
5060 : }
5061 216 : resultobj = SWIG_FromCharPtr((const char *)result);
5062 216 : return resultobj;
5063 : fail:
5064 : return NULL;
5065 : }
5066 :
5067 :
5068 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_home_dir_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 0 : PyObject *resultobj = 0;
5070 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
5071 0 : char *arg2 = (char *) 0 ;
5072 0 : void *argp1 = 0 ;
5073 0 : int res1 = 0 ;
5074 : int res2 ;
5075 0 : char *buf2 = 0 ;
5076 0 : int alloc2 = 0 ;
5077 0 : PyObject * obj0 = 0 ;
5078 0 : PyObject * obj1 = 0 ;
5079 :
5080 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_home_dir_set",&obj0,&obj1)) SWIG_fail;
5081 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
5082 0 : if (!SWIG_IsOK(res1)) {
5083 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_home_dir_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
5084 : }
5085 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
5086 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5087 0 : if (!SWIG_IsOK(res2)) {
5088 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_home_dir_set" "', argument " "2"" of type '" "char *""'");
5089 : }
5090 0 : arg2 = (char *)(buf2);
5091 : {
5092 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5093 0 : if (arg1->home_dir) free((char*)arg1->home_dir);
5094 0 : if (arg2) {
5095 0 : size_t size = strlen((const char *)(arg2)) + 1;
5096 0 : arg1->home_dir = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5097 : } else {
5098 0 : arg1->home_dir = 0;
5099 : }
5100 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5101 : }
5102 0 : resultobj = SWIG_Py_Void();
5103 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5104 : return resultobj;
5105 : fail:
5106 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5107 : return NULL;
5108 : }
5109 :
5110 :
5111 216 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_home_dir_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5112 216 : PyObject *resultobj = 0;
5113 216 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
5114 216 : void *argp1 = 0 ;
5115 216 : int res1 = 0 ;
5116 216 : PyObject * obj0 = 0 ;
5117 216 : char *result = 0 ;
5118 :
5119 216 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_home_dir_get",&obj0)) SWIG_fail;
5120 216 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
5121 216 : if (!SWIG_IsOK(res1)) {
5122 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_home_dir_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
5123 : }
5124 216 : arg1 = (struct _gpgme_engine_info *)(argp1);
5125 : {
5126 216 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5127 216 : result = (char *) ((arg1)->home_dir);
5128 216 : SWIG_PYTHON_THREAD_END_ALLOW;
5129 : }
5130 216 : resultobj = SWIG_FromCharPtr((const char *)result);
5131 216 : return resultobj;
5132 : fail:
5133 : return NULL;
5134 : }
5135 :
5136 :
5137 0 : SWIGINTERN PyObject *_wrap_new__gpgme_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5138 0 : PyObject *resultobj = 0;
5139 0 : struct _gpgme_engine_info *result = 0 ;
5140 :
5141 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_engine_info")) SWIG_fail;
5142 : {
5143 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5144 0 : result = (struct _gpgme_engine_info *)calloc(1, sizeof(struct _gpgme_engine_info));
5145 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5146 : }
5147 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_engine_info, SWIG_POINTER_NEW | 0 );
5148 0 : return resultobj;
5149 : fail:
5150 : return NULL;
5151 : }
5152 :
5153 :
5154 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5155 0 : PyObject *resultobj = 0;
5156 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
5157 0 : void *argp1 = 0 ;
5158 0 : int res1 = 0 ;
5159 0 : PyObject * obj0 = 0 ;
5160 :
5161 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_engine_info",&obj0)) SWIG_fail;
5162 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, SWIG_POINTER_DISOWN | 0 );
5163 0 : if (!SWIG_IsOK(res1)) {
5164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_engine_info" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
5165 : }
5166 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
5167 : {
5168 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5169 0 : free((char *) arg1);
5170 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5171 : }
5172 0 : resultobj = SWIG_Py_Void();
5173 0 : return resultobj;
5174 : fail:
5175 : return NULL;
5176 : }
5177 :
5178 :
5179 29 : SWIGINTERN PyObject *_gpgme_engine_info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5180 : PyObject *obj;
5181 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5182 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_engine_info, SWIG_NewClientData(obj));
5183 29 : return SWIG_Py_Void();
5184 : }
5185 :
5186 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5187 0 : PyObject *resultobj = 0;
5188 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5189 : unsigned int arg2 ;
5190 0 : void *argp1 = 0 ;
5191 0 : int res1 = 0 ;
5192 : unsigned int val2 ;
5193 0 : int ecode2 = 0 ;
5194 0 : PyObject * obj0 = 0 ;
5195 0 : PyObject * obj1 = 0 ;
5196 :
5197 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_validity_set",&obj0,&obj1)) SWIG_fail;
5198 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5199 0 : if (!SWIG_IsOK(res1)) {
5200 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_validity_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5201 : }
5202 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5203 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5204 0 : if (!SWIG_IsOK(ecode2)) {
5205 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_validity_set" "', argument " "2"" of type '" "unsigned int""'");
5206 : }
5207 0 : arg2 = (unsigned int)(val2);
5208 : {
5209 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5210 0 : if (arg1) (arg1)->validity = arg2;
5211 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5212 : }
5213 0 : resultobj = SWIG_Py_Void();
5214 0 : return resultobj;
5215 : fail:
5216 : return NULL;
5217 : }
5218 :
5219 :
5220 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5221 0 : PyObject *resultobj = 0;
5222 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5223 0 : void *argp1 = 0 ;
5224 0 : int res1 = 0 ;
5225 0 : PyObject * obj0 = 0 ;
5226 : unsigned int result;
5227 :
5228 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_validity_get",&obj0)) SWIG_fail;
5229 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5230 0 : if (!SWIG_IsOK(res1)) {
5231 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_validity_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5232 : }
5233 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5234 : {
5235 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5236 0 : result = (unsigned int) ((arg1)->validity);
5237 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5238 : }
5239 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5240 0 : return resultobj;
5241 : fail:
5242 : return NULL;
5243 : }
5244 :
5245 :
5246 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_policy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5247 0 : PyObject *resultobj = 0;
5248 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5249 : unsigned int arg2 ;
5250 0 : void *argp1 = 0 ;
5251 0 : int res1 = 0 ;
5252 : unsigned int val2 ;
5253 0 : int ecode2 = 0 ;
5254 0 : PyObject * obj0 = 0 ;
5255 0 : PyObject * obj1 = 0 ;
5256 :
5257 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_policy_set",&obj0,&obj1)) SWIG_fail;
5258 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5259 0 : if (!SWIG_IsOK(res1)) {
5260 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_policy_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5261 : }
5262 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5263 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5264 0 : if (!SWIG_IsOK(ecode2)) {
5265 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_policy_set" "', argument " "2"" of type '" "unsigned int""'");
5266 : }
5267 0 : arg2 = (unsigned int)(val2);
5268 : {
5269 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5270 0 : if (arg1) (arg1)->policy = arg2;
5271 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5272 : }
5273 0 : resultobj = SWIG_Py_Void();
5274 0 : return resultobj;
5275 : fail:
5276 : return NULL;
5277 : }
5278 :
5279 :
5280 4 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_policy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5281 4 : PyObject *resultobj = 0;
5282 4 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5283 4 : void *argp1 = 0 ;
5284 4 : int res1 = 0 ;
5285 4 : PyObject * obj0 = 0 ;
5286 : unsigned int result;
5287 :
5288 4 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_policy_get",&obj0)) SWIG_fail;
5289 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5290 4 : if (!SWIG_IsOK(res1)) {
5291 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_policy_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5292 : }
5293 4 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5294 : {
5295 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5296 4 : result = (unsigned int) ((arg1)->policy);
5297 4 : SWIG_PYTHON_THREAD_END_ALLOW;
5298 : }
5299 4 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5300 4 : return resultobj;
5301 : fail:
5302 : return NULL;
5303 : }
5304 :
5305 :
5306 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info__rfu_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5307 0 : PyObject *resultobj = 0;
5308 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5309 : unsigned int arg2 ;
5310 0 : void *argp1 = 0 ;
5311 0 : int res1 = 0 ;
5312 : unsigned int val2 ;
5313 0 : int ecode2 = 0 ;
5314 0 : PyObject * obj0 = 0 ;
5315 0 : PyObject * obj1 = 0 ;
5316 :
5317 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info__rfu_set",&obj0,&obj1)) SWIG_fail;
5318 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5319 0 : if (!SWIG_IsOK(res1)) {
5320 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info__rfu_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5321 : }
5322 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5323 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5324 0 : if (!SWIG_IsOK(ecode2)) {
5325 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info__rfu_set" "', argument " "2"" of type '" "unsigned int""'");
5326 : }
5327 0 : arg2 = (unsigned int)(val2);
5328 : {
5329 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5330 0 : if (arg1) (arg1)->_rfu = arg2;
5331 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5332 : }
5333 0 : resultobj = SWIG_Py_Void();
5334 0 : return resultobj;
5335 : fail:
5336 : return NULL;
5337 : }
5338 :
5339 :
5340 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info__rfu_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5341 0 : PyObject *resultobj = 0;
5342 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5343 0 : void *argp1 = 0 ;
5344 0 : int res1 = 0 ;
5345 0 : PyObject * obj0 = 0 ;
5346 : unsigned int result;
5347 :
5348 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info__rfu_get",&obj0)) SWIG_fail;
5349 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5350 0 : if (!SWIG_IsOK(res1)) {
5351 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info__rfu_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5352 : }
5353 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5354 : {
5355 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5356 0 : result = (unsigned int) ((arg1)->_rfu);
5357 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5358 : }
5359 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5360 0 : return resultobj;
5361 : fail:
5362 : return NULL;
5363 : }
5364 :
5365 :
5366 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5367 0 : PyObject *resultobj = 0;
5368 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5369 : unsigned short arg2 ;
5370 0 : void *argp1 = 0 ;
5371 0 : int res1 = 0 ;
5372 : unsigned short val2 ;
5373 0 : int ecode2 = 0 ;
5374 0 : PyObject * obj0 = 0 ;
5375 0 : PyObject * obj1 = 0 ;
5376 :
5377 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_signcount_set",&obj0,&obj1)) SWIG_fail;
5378 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5379 0 : if (!SWIG_IsOK(res1)) {
5380 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signcount_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5381 : }
5382 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5383 0 : ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
5384 0 : if (!SWIG_IsOK(ecode2)) {
5385 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signcount_set" "', argument " "2"" of type '" "unsigned short""'");
5386 : }
5387 0 : arg2 = (unsigned short)(val2);
5388 : {
5389 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5390 0 : if (arg1) (arg1)->signcount = arg2;
5391 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5392 : }
5393 0 : resultobj = SWIG_Py_Void();
5394 0 : return resultobj;
5395 : fail:
5396 : return NULL;
5397 : }
5398 :
5399 :
5400 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5401 0 : PyObject *resultobj = 0;
5402 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5403 0 : void *argp1 = 0 ;
5404 0 : int res1 = 0 ;
5405 0 : PyObject * obj0 = 0 ;
5406 : unsigned short result;
5407 :
5408 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signcount_get",&obj0)) SWIG_fail;
5409 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5410 0 : if (!SWIG_IsOK(res1)) {
5411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signcount_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5412 : }
5413 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5414 : {
5415 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5416 0 : result = (unsigned short) ((arg1)->signcount);
5417 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5418 : }
5419 0 : resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
5420 0 : return resultobj;
5421 : fail:
5422 : return NULL;
5423 : }
5424 :
5425 :
5426 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5427 0 : PyObject *resultobj = 0;
5428 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5429 : unsigned short arg2 ;
5430 0 : void *argp1 = 0 ;
5431 0 : int res1 = 0 ;
5432 : unsigned short val2 ;
5433 0 : int ecode2 = 0 ;
5434 0 : PyObject * obj0 = 0 ;
5435 0 : PyObject * obj1 = 0 ;
5436 :
5437 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_encrcount_set",&obj0,&obj1)) SWIG_fail;
5438 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5439 0 : if (!SWIG_IsOK(res1)) {
5440 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrcount_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5441 : }
5442 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5443 0 : ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
5444 0 : if (!SWIG_IsOK(ecode2)) {
5445 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrcount_set" "', argument " "2"" of type '" "unsigned short""'");
5446 : }
5447 0 : arg2 = (unsigned short)(val2);
5448 : {
5449 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5450 0 : if (arg1) (arg1)->encrcount = arg2;
5451 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5452 : }
5453 0 : resultobj = SWIG_Py_Void();
5454 0 : return resultobj;
5455 : fail:
5456 : return NULL;
5457 : }
5458 :
5459 :
5460 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461 0 : PyObject *resultobj = 0;
5462 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5463 0 : void *argp1 = 0 ;
5464 0 : int res1 = 0 ;
5465 0 : PyObject * obj0 = 0 ;
5466 : unsigned short result;
5467 :
5468 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrcount_get",&obj0)) SWIG_fail;
5469 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5470 0 : if (!SWIG_IsOK(res1)) {
5471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrcount_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5472 : }
5473 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5474 : {
5475 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5476 0 : result = (unsigned short) ((arg1)->encrcount);
5477 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5478 : }
5479 0 : resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
5480 0 : return resultobj;
5481 : fail:
5482 : return NULL;
5483 : }
5484 :
5485 :
5486 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signfirst_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5487 0 : PyObject *resultobj = 0;
5488 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5489 : unsigned long arg2 ;
5490 0 : void *argp1 = 0 ;
5491 0 : int res1 = 0 ;
5492 : unsigned long val2 ;
5493 0 : int ecode2 = 0 ;
5494 0 : PyObject * obj0 = 0 ;
5495 0 : PyObject * obj1 = 0 ;
5496 :
5497 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_signfirst_set",&obj0,&obj1)) SWIG_fail;
5498 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5499 0 : if (!SWIG_IsOK(res1)) {
5500 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signfirst_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5501 : }
5502 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5503 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5504 0 : if (!SWIG_IsOK(ecode2)) {
5505 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signfirst_set" "', argument " "2"" of type '" "unsigned long""'");
5506 : }
5507 0 : arg2 = (unsigned long)(val2);
5508 : {
5509 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5510 0 : if (arg1) (arg1)->signfirst = arg2;
5511 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5512 : }
5513 0 : resultobj = SWIG_Py_Void();
5514 0 : return resultobj;
5515 : fail:
5516 : return NULL;
5517 : }
5518 :
5519 :
5520 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signfirst_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5521 0 : PyObject *resultobj = 0;
5522 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5523 0 : void *argp1 = 0 ;
5524 0 : int res1 = 0 ;
5525 0 : PyObject * obj0 = 0 ;
5526 : unsigned long result;
5527 :
5528 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signfirst_get",&obj0)) SWIG_fail;
5529 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5530 0 : if (!SWIG_IsOK(res1)) {
5531 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signfirst_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5532 : }
5533 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5534 : {
5535 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5536 0 : result = (unsigned long) ((arg1)->signfirst);
5537 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5538 : }
5539 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5540 0 : return resultobj;
5541 : fail:
5542 : return NULL;
5543 : }
5544 :
5545 :
5546 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signlast_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5547 0 : PyObject *resultobj = 0;
5548 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5549 : unsigned long arg2 ;
5550 0 : void *argp1 = 0 ;
5551 0 : int res1 = 0 ;
5552 : unsigned long val2 ;
5553 0 : int ecode2 = 0 ;
5554 0 : PyObject * obj0 = 0 ;
5555 0 : PyObject * obj1 = 0 ;
5556 :
5557 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_signlast_set",&obj0,&obj1)) SWIG_fail;
5558 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5559 0 : if (!SWIG_IsOK(res1)) {
5560 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signlast_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5561 : }
5562 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5563 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5564 0 : if (!SWIG_IsOK(ecode2)) {
5565 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signlast_set" "', argument " "2"" of type '" "unsigned long""'");
5566 : }
5567 0 : arg2 = (unsigned long)(val2);
5568 : {
5569 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5570 0 : if (arg1) (arg1)->signlast = arg2;
5571 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5572 : }
5573 0 : resultobj = SWIG_Py_Void();
5574 0 : return resultobj;
5575 : fail:
5576 : return NULL;
5577 : }
5578 :
5579 :
5580 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signlast_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 0 : PyObject *resultobj = 0;
5582 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5583 0 : void *argp1 = 0 ;
5584 0 : int res1 = 0 ;
5585 0 : PyObject * obj0 = 0 ;
5586 : unsigned long result;
5587 :
5588 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signlast_get",&obj0)) SWIG_fail;
5589 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5590 0 : if (!SWIG_IsOK(res1)) {
5591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signlast_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5592 : }
5593 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5594 : {
5595 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5596 0 : result = (unsigned long) ((arg1)->signlast);
5597 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5598 : }
5599 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5600 0 : return resultobj;
5601 : fail:
5602 : return NULL;
5603 : }
5604 :
5605 :
5606 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrfirst_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5607 0 : PyObject *resultobj = 0;
5608 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5609 : unsigned long arg2 ;
5610 0 : void *argp1 = 0 ;
5611 0 : int res1 = 0 ;
5612 : unsigned long val2 ;
5613 0 : int ecode2 = 0 ;
5614 0 : PyObject * obj0 = 0 ;
5615 0 : PyObject * obj1 = 0 ;
5616 :
5617 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_encrfirst_set",&obj0,&obj1)) SWIG_fail;
5618 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5619 0 : if (!SWIG_IsOK(res1)) {
5620 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrfirst_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5621 : }
5622 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5623 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5624 0 : if (!SWIG_IsOK(ecode2)) {
5625 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrfirst_set" "', argument " "2"" of type '" "unsigned long""'");
5626 : }
5627 0 : arg2 = (unsigned long)(val2);
5628 : {
5629 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5630 0 : if (arg1) (arg1)->encrfirst = arg2;
5631 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5632 : }
5633 0 : resultobj = SWIG_Py_Void();
5634 0 : return resultobj;
5635 : fail:
5636 : return NULL;
5637 : }
5638 :
5639 :
5640 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrfirst_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5641 0 : PyObject *resultobj = 0;
5642 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5643 0 : void *argp1 = 0 ;
5644 0 : int res1 = 0 ;
5645 0 : PyObject * obj0 = 0 ;
5646 : unsigned long result;
5647 :
5648 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrfirst_get",&obj0)) SWIG_fail;
5649 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5650 0 : if (!SWIG_IsOK(res1)) {
5651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrfirst_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5652 : }
5653 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5654 : {
5655 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5656 0 : result = (unsigned long) ((arg1)->encrfirst);
5657 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5658 : }
5659 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5660 0 : return resultobj;
5661 : fail:
5662 : return NULL;
5663 : }
5664 :
5665 :
5666 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrlast_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5667 0 : PyObject *resultobj = 0;
5668 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5669 : unsigned long arg2 ;
5670 0 : void *argp1 = 0 ;
5671 0 : int res1 = 0 ;
5672 : unsigned long val2 ;
5673 0 : int ecode2 = 0 ;
5674 0 : PyObject * obj0 = 0 ;
5675 0 : PyObject * obj1 = 0 ;
5676 :
5677 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_encrlast_set",&obj0,&obj1)) SWIG_fail;
5678 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5679 0 : if (!SWIG_IsOK(res1)) {
5680 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrlast_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5681 : }
5682 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5683 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5684 0 : if (!SWIG_IsOK(ecode2)) {
5685 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrlast_set" "', argument " "2"" of type '" "unsigned long""'");
5686 : }
5687 0 : arg2 = (unsigned long)(val2);
5688 : {
5689 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5690 0 : if (arg1) (arg1)->encrlast = arg2;
5691 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5692 : }
5693 0 : resultobj = SWIG_Py_Void();
5694 0 : return resultobj;
5695 : fail:
5696 : return NULL;
5697 : }
5698 :
5699 :
5700 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrlast_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5701 0 : PyObject *resultobj = 0;
5702 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5703 0 : void *argp1 = 0 ;
5704 0 : int res1 = 0 ;
5705 0 : PyObject * obj0 = 0 ;
5706 : unsigned long result;
5707 :
5708 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrlast_get",&obj0)) SWIG_fail;
5709 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5710 0 : if (!SWIG_IsOK(res1)) {
5711 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrlast_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5712 : }
5713 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5714 : {
5715 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5716 0 : result = (unsigned long) ((arg1)->encrlast);
5717 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5718 : }
5719 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5720 0 : return resultobj;
5721 : fail:
5722 : return NULL;
5723 : }
5724 :
5725 :
5726 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5727 0 : PyObject *resultobj = 0;
5728 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5729 0 : char *arg2 = (char *) 0 ;
5730 0 : void *argp1 = 0 ;
5731 0 : int res1 = 0 ;
5732 : int res2 ;
5733 0 : char *buf2 = 0 ;
5734 0 : int alloc2 = 0 ;
5735 0 : PyObject * obj0 = 0 ;
5736 0 : PyObject * obj1 = 0 ;
5737 :
5738 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_description_set",&obj0,&obj1)) SWIG_fail;
5739 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5740 0 : if (!SWIG_IsOK(res1)) {
5741 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_description_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5742 : }
5743 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5744 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5745 0 : if (!SWIG_IsOK(res2)) {
5746 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_tofu_info_description_set" "', argument " "2"" of type '" "char *""'");
5747 : }
5748 0 : arg2 = (char *)(buf2);
5749 : {
5750 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5751 0 : if (arg1->description) free((char*)arg1->description);
5752 0 : if (arg2) {
5753 0 : size_t size = strlen((const char *)(arg2)) + 1;
5754 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5755 : } else {
5756 0 : arg1->description = 0;
5757 : }
5758 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5759 : }
5760 0 : resultobj = SWIG_Py_Void();
5761 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5762 : return resultobj;
5763 : fail:
5764 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5765 : return NULL;
5766 : }
5767 :
5768 :
5769 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5770 0 : PyObject *resultobj = 0;
5771 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5772 0 : void *argp1 = 0 ;
5773 0 : int res1 = 0 ;
5774 0 : PyObject * obj0 = 0 ;
5775 0 : char *result = 0 ;
5776 :
5777 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_description_get",&obj0)) SWIG_fail;
5778 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5779 0 : if (!SWIG_IsOK(res1)) {
5780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_description_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5781 : }
5782 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5783 : {
5784 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5785 0 : result = (char *) ((arg1)->description);
5786 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5787 : }
5788 0 : resultobj = SWIG_FromCharPtr((const char *)result);
5789 0 : return resultobj;
5790 : fail:
5791 : return NULL;
5792 : }
5793 :
5794 :
5795 0 : SWIGINTERN PyObject *_wrap_new__gpgme_tofu_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5796 0 : PyObject *resultobj = 0;
5797 0 : struct _gpgme_tofu_info *result = 0 ;
5798 :
5799 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_tofu_info")) SWIG_fail;
5800 : {
5801 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5802 0 : result = (struct _gpgme_tofu_info *)calloc(1, sizeof(struct _gpgme_tofu_info));
5803 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5804 : }
5805 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_tofu_info, SWIG_POINTER_NEW | 0 );
5806 0 : return resultobj;
5807 : fail:
5808 : return NULL;
5809 : }
5810 :
5811 :
5812 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_tofu_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5813 0 : PyObject *resultobj = 0;
5814 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5815 0 : void *argp1 = 0 ;
5816 0 : int res1 = 0 ;
5817 0 : PyObject * obj0 = 0 ;
5818 :
5819 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_tofu_info",&obj0)) SWIG_fail;
5820 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, SWIG_POINTER_DISOWN | 0 );
5821 0 : if (!SWIG_IsOK(res1)) {
5822 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_tofu_info" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5823 : }
5824 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5825 : {
5826 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5827 0 : free((char *) arg1);
5828 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5829 : }
5830 0 : resultobj = SWIG_Py_Void();
5831 0 : return resultobj;
5832 : fail:
5833 : return NULL;
5834 : }
5835 :
5836 :
5837 29 : SWIGINTERN PyObject *_gpgme_tofu_info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5838 : PyObject *obj;
5839 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5840 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_tofu_info, SWIG_NewClientData(obj));
5841 29 : return SWIG_Py_Void();
5842 : }
5843 :
5844 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_revoked_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5845 0 : PyObject *resultobj = 0;
5846 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5847 : unsigned int arg2 ;
5848 0 : void *argp1 = 0 ;
5849 0 : int res1 = 0 ;
5850 : unsigned int val2 ;
5851 0 : int ecode2 = 0 ;
5852 0 : PyObject * obj0 = 0 ;
5853 0 : PyObject * obj1 = 0 ;
5854 :
5855 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_revoked_set",&obj0,&obj1)) SWIG_fail;
5856 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5857 0 : if (!SWIG_IsOK(res1)) {
5858 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_revoked_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5859 : }
5860 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5861 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5862 0 : if (!SWIG_IsOK(ecode2)) {
5863 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
5864 : }
5865 0 : arg2 = (unsigned int)(val2);
5866 : {
5867 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5868 0 : if (arg1) (arg1)->revoked = arg2;
5869 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5870 : }
5871 0 : resultobj = SWIG_Py_Void();
5872 0 : return resultobj;
5873 : fail:
5874 : return NULL;
5875 : }
5876 :
5877 :
5878 156 : SWIGINTERN PyObject *_wrap__gpgme_subkey_revoked_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5879 156 : PyObject *resultobj = 0;
5880 156 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5881 156 : void *argp1 = 0 ;
5882 156 : int res1 = 0 ;
5883 156 : PyObject * obj0 = 0 ;
5884 : unsigned int result;
5885 :
5886 156 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_revoked_get",&obj0)) SWIG_fail;
5887 156 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5888 156 : if (!SWIG_IsOK(res1)) {
5889 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_revoked_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5890 : }
5891 156 : arg1 = (struct _gpgme_subkey *)(argp1);
5892 : {
5893 156 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5894 156 : result = (unsigned int) ((arg1)->revoked);
5895 156 : SWIG_PYTHON_THREAD_END_ALLOW;
5896 : }
5897 156 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5898 156 : return resultobj;
5899 : fail:
5900 : return NULL;
5901 : }
5902 :
5903 :
5904 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expired_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5905 0 : PyObject *resultobj = 0;
5906 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5907 : unsigned int arg2 ;
5908 0 : void *argp1 = 0 ;
5909 0 : int res1 = 0 ;
5910 : unsigned int val2 ;
5911 0 : int ecode2 = 0 ;
5912 0 : PyObject * obj0 = 0 ;
5913 0 : PyObject * obj1 = 0 ;
5914 :
5915 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_expired_set",&obj0,&obj1)) SWIG_fail;
5916 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5917 0 : if (!SWIG_IsOK(res1)) {
5918 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expired_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5919 : }
5920 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5921 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5922 0 : if (!SWIG_IsOK(ecode2)) {
5923 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_expired_set" "', argument " "2"" of type '" "unsigned int""'");
5924 : }
5925 0 : arg2 = (unsigned int)(val2);
5926 : {
5927 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5928 0 : if (arg1) (arg1)->expired = arg2;
5929 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5930 : }
5931 0 : resultobj = SWIG_Py_Void();
5932 0 : return resultobj;
5933 : fail:
5934 : return NULL;
5935 : }
5936 :
5937 :
5938 162 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expired_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5939 162 : PyObject *resultobj = 0;
5940 162 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5941 162 : void *argp1 = 0 ;
5942 162 : int res1 = 0 ;
5943 162 : PyObject * obj0 = 0 ;
5944 : unsigned int result;
5945 :
5946 162 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_expired_get",&obj0)) SWIG_fail;
5947 162 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5948 162 : if (!SWIG_IsOK(res1)) {
5949 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expired_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5950 : }
5951 162 : arg1 = (struct _gpgme_subkey *)(argp1);
5952 : {
5953 162 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5954 162 : result = (unsigned int) ((arg1)->expired);
5955 162 : SWIG_PYTHON_THREAD_END_ALLOW;
5956 : }
5957 162 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5958 162 : return resultobj;
5959 : fail:
5960 : return NULL;
5961 : }
5962 :
5963 :
5964 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_disabled_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5965 0 : PyObject *resultobj = 0;
5966 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5967 : unsigned int arg2 ;
5968 0 : void *argp1 = 0 ;
5969 0 : int res1 = 0 ;
5970 : unsigned int val2 ;
5971 0 : int ecode2 = 0 ;
5972 0 : PyObject * obj0 = 0 ;
5973 0 : PyObject * obj1 = 0 ;
5974 :
5975 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_disabled_set",&obj0,&obj1)) SWIG_fail;
5976 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5977 0 : if (!SWIG_IsOK(res1)) {
5978 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_disabled_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5979 : }
5980 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5981 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5982 0 : if (!SWIG_IsOK(ecode2)) {
5983 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_disabled_set" "', argument " "2"" of type '" "unsigned int""'");
5984 : }
5985 0 : arg2 = (unsigned int)(val2);
5986 : {
5987 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5988 0 : if (arg1) (arg1)->disabled = arg2;
5989 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5990 : }
5991 0 : resultobj = SWIG_Py_Void();
5992 0 : return resultobj;
5993 : fail:
5994 : return NULL;
5995 : }
5996 :
5997 :
5998 156 : SWIGINTERN PyObject *_wrap__gpgme_subkey_disabled_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5999 156 : PyObject *resultobj = 0;
6000 156 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6001 156 : void *argp1 = 0 ;
6002 156 : int res1 = 0 ;
6003 156 : PyObject * obj0 = 0 ;
6004 : unsigned int result;
6005 :
6006 156 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_disabled_get",&obj0)) SWIG_fail;
6007 156 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6008 156 : if (!SWIG_IsOK(res1)) {
6009 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_disabled_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6010 : }
6011 156 : arg1 = (struct _gpgme_subkey *)(argp1);
6012 : {
6013 156 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6014 156 : result = (unsigned int) ((arg1)->disabled);
6015 156 : SWIG_PYTHON_THREAD_END_ALLOW;
6016 : }
6017 156 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6018 156 : return resultobj;
6019 : fail:
6020 : return NULL;
6021 : }
6022 :
6023 :
6024 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_invalid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6025 0 : PyObject *resultobj = 0;
6026 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6027 : unsigned int arg2 ;
6028 0 : void *argp1 = 0 ;
6029 0 : int res1 = 0 ;
6030 : unsigned int val2 ;
6031 0 : int ecode2 = 0 ;
6032 0 : PyObject * obj0 = 0 ;
6033 0 : PyObject * obj1 = 0 ;
6034 :
6035 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_invalid_set",&obj0,&obj1)) SWIG_fail;
6036 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6037 0 : if (!SWIG_IsOK(res1)) {
6038 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_invalid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6039 : }
6040 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6041 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6042 0 : if (!SWIG_IsOK(ecode2)) {
6043 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
6044 : }
6045 0 : arg2 = (unsigned int)(val2);
6046 : {
6047 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6048 0 : if (arg1) (arg1)->invalid = arg2;
6049 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6050 : }
6051 0 : resultobj = SWIG_Py_Void();
6052 0 : return resultobj;
6053 : fail:
6054 : return NULL;
6055 : }
6056 :
6057 :
6058 156 : SWIGINTERN PyObject *_wrap__gpgme_subkey_invalid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6059 156 : PyObject *resultobj = 0;
6060 156 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6061 156 : void *argp1 = 0 ;
6062 156 : int res1 = 0 ;
6063 156 : PyObject * obj0 = 0 ;
6064 : unsigned int result;
6065 :
6066 156 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_invalid_get",&obj0)) SWIG_fail;
6067 156 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6068 156 : if (!SWIG_IsOK(res1)) {
6069 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_invalid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6070 : }
6071 156 : arg1 = (struct _gpgme_subkey *)(argp1);
6072 : {
6073 156 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6074 156 : result = (unsigned int) ((arg1)->invalid);
6075 156 : SWIG_PYTHON_THREAD_END_ALLOW;
6076 : }
6077 156 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6078 156 : return resultobj;
6079 : fail:
6080 : return NULL;
6081 : }
6082 :
6083 :
6084 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_encrypt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6085 0 : PyObject *resultobj = 0;
6086 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6087 : unsigned int arg2 ;
6088 0 : void *argp1 = 0 ;
6089 0 : int res1 = 0 ;
6090 : unsigned int val2 ;
6091 0 : int ecode2 = 0 ;
6092 0 : PyObject * obj0 = 0 ;
6093 0 : PyObject * obj1 = 0 ;
6094 :
6095 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_can_encrypt_set",&obj0,&obj1)) SWIG_fail;
6096 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6097 0 : if (!SWIG_IsOK(res1)) {
6098 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_encrypt_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6099 : }
6100 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6101 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6102 0 : if (!SWIG_IsOK(ecode2)) {
6103 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_encrypt_set" "', argument " "2"" of type '" "unsigned int""'");
6104 : }
6105 0 : arg2 = (unsigned int)(val2);
6106 : {
6107 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6108 0 : if (arg1) (arg1)->can_encrypt = arg2;
6109 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6110 : }
6111 0 : resultobj = SWIG_Py_Void();
6112 0 : return resultobj;
6113 : fail:
6114 : return NULL;
6115 : }
6116 :
6117 :
6118 172 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_encrypt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6119 172 : PyObject *resultobj = 0;
6120 172 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6121 172 : void *argp1 = 0 ;
6122 172 : int res1 = 0 ;
6123 172 : PyObject * obj0 = 0 ;
6124 : unsigned int result;
6125 :
6126 172 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_encrypt_get",&obj0)) SWIG_fail;
6127 172 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6128 172 : if (!SWIG_IsOK(res1)) {
6129 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_encrypt_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6130 : }
6131 172 : arg1 = (struct _gpgme_subkey *)(argp1);
6132 : {
6133 172 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6134 172 : result = (unsigned int) ((arg1)->can_encrypt);
6135 172 : SWIG_PYTHON_THREAD_END_ALLOW;
6136 : }
6137 172 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6138 172 : return resultobj;
6139 : fail:
6140 : return NULL;
6141 : }
6142 :
6143 :
6144 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_sign_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6145 0 : PyObject *resultobj = 0;
6146 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6147 : unsigned int arg2 ;
6148 0 : void *argp1 = 0 ;
6149 0 : int res1 = 0 ;
6150 : unsigned int val2 ;
6151 0 : int ecode2 = 0 ;
6152 0 : PyObject * obj0 = 0 ;
6153 0 : PyObject * obj1 = 0 ;
6154 :
6155 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_can_sign_set",&obj0,&obj1)) SWIG_fail;
6156 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6157 0 : if (!SWIG_IsOK(res1)) {
6158 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_sign_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6159 : }
6160 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6161 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6162 0 : if (!SWIG_IsOK(ecode2)) {
6163 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_sign_set" "', argument " "2"" of type '" "unsigned int""'");
6164 : }
6165 0 : arg2 = (unsigned int)(val2);
6166 : {
6167 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6168 0 : if (arg1) (arg1)->can_sign = arg2;
6169 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6170 : }
6171 0 : resultobj = SWIG_Py_Void();
6172 0 : return resultobj;
6173 : fail:
6174 : return NULL;
6175 : }
6176 :
6177 :
6178 179 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_sign_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6179 179 : PyObject *resultobj = 0;
6180 179 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6181 179 : void *argp1 = 0 ;
6182 179 : int res1 = 0 ;
6183 179 : PyObject * obj0 = 0 ;
6184 : unsigned int result;
6185 :
6186 179 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_sign_get",&obj0)) SWIG_fail;
6187 179 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6188 179 : if (!SWIG_IsOK(res1)) {
6189 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_sign_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6190 : }
6191 179 : arg1 = (struct _gpgme_subkey *)(argp1);
6192 : {
6193 179 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6194 179 : result = (unsigned int) ((arg1)->can_sign);
6195 179 : SWIG_PYTHON_THREAD_END_ALLOW;
6196 : }
6197 179 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6198 179 : return resultobj;
6199 : fail:
6200 : return NULL;
6201 : }
6202 :
6203 :
6204 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_certify_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6205 0 : PyObject *resultobj = 0;
6206 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6207 : unsigned int arg2 ;
6208 0 : void *argp1 = 0 ;
6209 0 : int res1 = 0 ;
6210 : unsigned int val2 ;
6211 0 : int ecode2 = 0 ;
6212 0 : PyObject * obj0 = 0 ;
6213 0 : PyObject * obj1 = 0 ;
6214 :
6215 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_can_certify_set",&obj0,&obj1)) SWIG_fail;
6216 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6217 0 : if (!SWIG_IsOK(res1)) {
6218 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_certify_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6219 : }
6220 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6221 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6222 0 : if (!SWIG_IsOK(ecode2)) {
6223 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_certify_set" "', argument " "2"" of type '" "unsigned int""'");
6224 : }
6225 0 : arg2 = (unsigned int)(val2);
6226 : {
6227 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6228 0 : if (arg1) (arg1)->can_certify = arg2;
6229 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6230 : }
6231 0 : resultobj = SWIG_Py_Void();
6232 0 : return resultobj;
6233 : fail:
6234 : return NULL;
6235 : }
6236 :
6237 :
6238 164 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_certify_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6239 164 : PyObject *resultobj = 0;
6240 164 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6241 164 : void *argp1 = 0 ;
6242 164 : int res1 = 0 ;
6243 164 : PyObject * obj0 = 0 ;
6244 : unsigned int result;
6245 :
6246 164 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_certify_get",&obj0)) SWIG_fail;
6247 164 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6248 164 : if (!SWIG_IsOK(res1)) {
6249 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_certify_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6250 : }
6251 164 : arg1 = (struct _gpgme_subkey *)(argp1);
6252 : {
6253 164 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6254 164 : result = (unsigned int) ((arg1)->can_certify);
6255 164 : SWIG_PYTHON_THREAD_END_ALLOW;
6256 : }
6257 164 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6258 164 : return resultobj;
6259 : fail:
6260 : return NULL;
6261 : }
6262 :
6263 :
6264 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_secret_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6265 0 : PyObject *resultobj = 0;
6266 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6267 : unsigned int arg2 ;
6268 0 : void *argp1 = 0 ;
6269 0 : int res1 = 0 ;
6270 : unsigned int val2 ;
6271 0 : int ecode2 = 0 ;
6272 0 : PyObject * obj0 = 0 ;
6273 0 : PyObject * obj1 = 0 ;
6274 :
6275 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_secret_set",&obj0,&obj1)) SWIG_fail;
6276 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6277 0 : if (!SWIG_IsOK(res1)) {
6278 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_secret_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6279 : }
6280 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6281 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6282 0 : if (!SWIG_IsOK(ecode2)) {
6283 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_secret_set" "', argument " "2"" of type '" "unsigned int""'");
6284 : }
6285 0 : arg2 = (unsigned int)(val2);
6286 : {
6287 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6288 0 : if (arg1) (arg1)->secret = arg2;
6289 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6290 : }
6291 0 : resultobj = SWIG_Py_Void();
6292 0 : return resultobj;
6293 : fail:
6294 : return NULL;
6295 : }
6296 :
6297 :
6298 156 : SWIGINTERN PyObject *_wrap__gpgme_subkey_secret_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6299 156 : PyObject *resultobj = 0;
6300 156 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6301 156 : void *argp1 = 0 ;
6302 156 : int res1 = 0 ;
6303 156 : PyObject * obj0 = 0 ;
6304 : unsigned int result;
6305 :
6306 156 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_secret_get",&obj0)) SWIG_fail;
6307 156 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6308 156 : if (!SWIG_IsOK(res1)) {
6309 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_secret_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6310 : }
6311 156 : arg1 = (struct _gpgme_subkey *)(argp1);
6312 : {
6313 156 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6314 156 : result = (unsigned int) ((arg1)->secret);
6315 156 : SWIG_PYTHON_THREAD_END_ALLOW;
6316 : }
6317 156 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6318 156 : return resultobj;
6319 : fail:
6320 : return NULL;
6321 : }
6322 :
6323 :
6324 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_authenticate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6325 0 : PyObject *resultobj = 0;
6326 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6327 : unsigned int arg2 ;
6328 0 : void *argp1 = 0 ;
6329 0 : int res1 = 0 ;
6330 : unsigned int val2 ;
6331 0 : int ecode2 = 0 ;
6332 0 : PyObject * obj0 = 0 ;
6333 0 : PyObject * obj1 = 0 ;
6334 :
6335 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_can_authenticate_set",&obj0,&obj1)) SWIG_fail;
6336 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6337 0 : if (!SWIG_IsOK(res1)) {
6338 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_authenticate_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6339 : }
6340 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6341 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6342 0 : if (!SWIG_IsOK(ecode2)) {
6343 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_authenticate_set" "', argument " "2"" of type '" "unsigned int""'");
6344 : }
6345 0 : arg2 = (unsigned int)(val2);
6346 : {
6347 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6348 0 : if (arg1) (arg1)->can_authenticate = arg2;
6349 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6350 : }
6351 0 : resultobj = SWIG_Py_Void();
6352 0 : return resultobj;
6353 : fail:
6354 : return NULL;
6355 : }
6356 :
6357 :
6358 15 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_authenticate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6359 15 : PyObject *resultobj = 0;
6360 15 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6361 15 : void *argp1 = 0 ;
6362 15 : int res1 = 0 ;
6363 15 : PyObject * obj0 = 0 ;
6364 : unsigned int result;
6365 :
6366 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_authenticate_get",&obj0)) SWIG_fail;
6367 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6368 15 : if (!SWIG_IsOK(res1)) {
6369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_authenticate_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6370 : }
6371 15 : arg1 = (struct _gpgme_subkey *)(argp1);
6372 : {
6373 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6374 15 : result = (unsigned int) ((arg1)->can_authenticate);
6375 15 : SWIG_PYTHON_THREAD_END_ALLOW;
6376 : }
6377 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6378 15 : return resultobj;
6379 : fail:
6380 : return NULL;
6381 : }
6382 :
6383 :
6384 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_qualified_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6385 0 : PyObject *resultobj = 0;
6386 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6387 : unsigned int arg2 ;
6388 0 : void *argp1 = 0 ;
6389 0 : int res1 = 0 ;
6390 : unsigned int val2 ;
6391 0 : int ecode2 = 0 ;
6392 0 : PyObject * obj0 = 0 ;
6393 0 : PyObject * obj1 = 0 ;
6394 :
6395 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_is_qualified_set",&obj0,&obj1)) SWIG_fail;
6396 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6397 0 : if (!SWIG_IsOK(res1)) {
6398 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_qualified_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6399 : }
6400 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6401 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6402 0 : if (!SWIG_IsOK(ecode2)) {
6403 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_is_qualified_set" "', argument " "2"" of type '" "unsigned int""'");
6404 : }
6405 0 : arg2 = (unsigned int)(val2);
6406 : {
6407 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6408 0 : if (arg1) (arg1)->is_qualified = arg2;
6409 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6410 : }
6411 0 : resultobj = SWIG_Py_Void();
6412 0 : return resultobj;
6413 : fail:
6414 : return NULL;
6415 : }
6416 :
6417 :
6418 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_qualified_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6419 0 : PyObject *resultobj = 0;
6420 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6421 0 : void *argp1 = 0 ;
6422 0 : int res1 = 0 ;
6423 0 : PyObject * obj0 = 0 ;
6424 : unsigned int result;
6425 :
6426 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_is_qualified_get",&obj0)) SWIG_fail;
6427 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6428 0 : if (!SWIG_IsOK(res1)) {
6429 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_qualified_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6430 : }
6431 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6432 : {
6433 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6434 0 : result = (unsigned int) ((arg1)->is_qualified);
6435 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6436 : }
6437 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6438 0 : return resultobj;
6439 : fail:
6440 : return NULL;
6441 : }
6442 :
6443 :
6444 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_cardkey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6445 0 : PyObject *resultobj = 0;
6446 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6447 : unsigned int arg2 ;
6448 0 : void *argp1 = 0 ;
6449 0 : int res1 = 0 ;
6450 : unsigned int val2 ;
6451 0 : int ecode2 = 0 ;
6452 0 : PyObject * obj0 = 0 ;
6453 0 : PyObject * obj1 = 0 ;
6454 :
6455 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_is_cardkey_set",&obj0,&obj1)) SWIG_fail;
6456 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6457 0 : if (!SWIG_IsOK(res1)) {
6458 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_cardkey_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6459 : }
6460 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6461 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6462 0 : if (!SWIG_IsOK(ecode2)) {
6463 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_is_cardkey_set" "', argument " "2"" of type '" "unsigned int""'");
6464 : }
6465 0 : arg2 = (unsigned int)(val2);
6466 : {
6467 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6468 0 : if (arg1) (arg1)->is_cardkey = arg2;
6469 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6470 : }
6471 0 : resultobj = SWIG_Py_Void();
6472 0 : return resultobj;
6473 : fail:
6474 : return NULL;
6475 : }
6476 :
6477 :
6478 156 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_cardkey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6479 156 : PyObject *resultobj = 0;
6480 156 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6481 156 : void *argp1 = 0 ;
6482 156 : int res1 = 0 ;
6483 156 : PyObject * obj0 = 0 ;
6484 : unsigned int result;
6485 :
6486 156 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_is_cardkey_get",&obj0)) SWIG_fail;
6487 156 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6488 156 : if (!SWIG_IsOK(res1)) {
6489 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_cardkey_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6490 : }
6491 156 : arg1 = (struct _gpgme_subkey *)(argp1);
6492 : {
6493 156 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6494 156 : result = (unsigned int) ((arg1)->is_cardkey);
6495 156 : SWIG_PYTHON_THREAD_END_ALLOW;
6496 : }
6497 156 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6498 156 : return resultobj;
6499 : fail:
6500 : return NULL;
6501 : }
6502 :
6503 :
6504 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_de_vs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6505 0 : PyObject *resultobj = 0;
6506 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6507 : unsigned int arg2 ;
6508 0 : void *argp1 = 0 ;
6509 0 : int res1 = 0 ;
6510 : unsigned int val2 ;
6511 0 : int ecode2 = 0 ;
6512 0 : PyObject * obj0 = 0 ;
6513 0 : PyObject * obj1 = 0 ;
6514 :
6515 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_is_de_vs_set",&obj0,&obj1)) SWIG_fail;
6516 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6517 0 : if (!SWIG_IsOK(res1)) {
6518 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_de_vs_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6519 : }
6520 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6521 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6522 0 : if (!SWIG_IsOK(ecode2)) {
6523 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_is_de_vs_set" "', argument " "2"" of type '" "unsigned int""'");
6524 : }
6525 0 : arg2 = (unsigned int)(val2);
6526 : {
6527 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6528 0 : if (arg1) (arg1)->is_de_vs = arg2;
6529 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6530 : }
6531 0 : resultobj = SWIG_Py_Void();
6532 0 : return resultobj;
6533 : fail:
6534 : return NULL;
6535 : }
6536 :
6537 :
6538 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_de_vs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6539 0 : PyObject *resultobj = 0;
6540 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6541 0 : void *argp1 = 0 ;
6542 0 : int res1 = 0 ;
6543 0 : PyObject * obj0 = 0 ;
6544 : unsigned int result;
6545 :
6546 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_is_de_vs_get",&obj0)) SWIG_fail;
6547 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6548 0 : if (!SWIG_IsOK(res1)) {
6549 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_de_vs_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6550 : }
6551 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6552 : {
6553 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6554 0 : result = (unsigned int) ((arg1)->is_de_vs);
6555 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6556 : }
6557 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6558 0 : return resultobj;
6559 : fail:
6560 : return NULL;
6561 : }
6562 :
6563 :
6564 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6565 0 : PyObject *resultobj = 0;
6566 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6567 : unsigned int arg2 ;
6568 0 : void *argp1 = 0 ;
6569 0 : int res1 = 0 ;
6570 : unsigned int val2 ;
6571 0 : int ecode2 = 0 ;
6572 0 : PyObject * obj0 = 0 ;
6573 0 : PyObject * obj1 = 0 ;
6574 :
6575 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey__unused_set",&obj0,&obj1)) SWIG_fail;
6576 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6577 0 : if (!SWIG_IsOK(res1)) {
6578 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__unused_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6579 : }
6580 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6581 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6582 0 : if (!SWIG_IsOK(ecode2)) {
6583 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey__unused_set" "', argument " "2"" of type '" "unsigned int""'");
6584 : }
6585 0 : arg2 = (unsigned int)(val2);
6586 : {
6587 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6588 0 : if (arg1) (arg1)->_unused = arg2;
6589 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6590 : }
6591 0 : resultobj = SWIG_Py_Void();
6592 0 : return resultobj;
6593 : fail:
6594 : return NULL;
6595 : }
6596 :
6597 :
6598 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6599 0 : PyObject *resultobj = 0;
6600 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6601 0 : void *argp1 = 0 ;
6602 0 : int res1 = 0 ;
6603 0 : PyObject * obj0 = 0 ;
6604 : unsigned int result;
6605 :
6606 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey__unused_get",&obj0)) SWIG_fail;
6607 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6608 0 : if (!SWIG_IsOK(res1)) {
6609 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__unused_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6610 : }
6611 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6612 : {
6613 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6614 0 : result = (unsigned int) ((arg1)->_unused);
6615 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6616 : }
6617 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6618 0 : return resultobj;
6619 : fail:
6620 : return NULL;
6621 : }
6622 :
6623 :
6624 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6625 0 : PyObject *resultobj = 0;
6626 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6627 : gpgme_pubkey_algo_t arg2 ;
6628 0 : void *argp1 = 0 ;
6629 0 : int res1 = 0 ;
6630 : int val2 ;
6631 0 : int ecode2 = 0 ;
6632 0 : PyObject * obj0 = 0 ;
6633 0 : PyObject * obj1 = 0 ;
6634 :
6635 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
6636 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6637 0 : if (!SWIG_IsOK(res1)) {
6638 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6639 : }
6640 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6641 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
6642 0 : if (!SWIG_IsOK(ecode2)) {
6643 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
6644 : }
6645 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
6646 : {
6647 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6648 0 : if (arg1) (arg1)->pubkey_algo = arg2;
6649 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6650 : }
6651 0 : resultobj = SWIG_Py_Void();
6652 0 : return resultobj;
6653 : fail:
6654 : return NULL;
6655 : }
6656 :
6657 :
6658 160 : SWIGINTERN PyObject *_wrap__gpgme_subkey_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6659 160 : PyObject *resultobj = 0;
6660 160 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6661 160 : void *argp1 = 0 ;
6662 160 : int res1 = 0 ;
6663 160 : PyObject * obj0 = 0 ;
6664 : gpgme_pubkey_algo_t result;
6665 :
6666 160 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_pubkey_algo_get",&obj0)) SWIG_fail;
6667 160 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6668 160 : if (!SWIG_IsOK(res1)) {
6669 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6670 : }
6671 160 : arg1 = (struct _gpgme_subkey *)(argp1);
6672 : {
6673 160 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6674 160 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
6675 160 : SWIG_PYTHON_THREAD_END_ALLOW;
6676 : }
6677 320 : resultobj = SWIG_From_int((int)(result));
6678 160 : return resultobj;
6679 : fail:
6680 : return NULL;
6681 : }
6682 :
6683 :
6684 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_length_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6685 0 : PyObject *resultobj = 0;
6686 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6687 : unsigned int arg2 ;
6688 0 : void *argp1 = 0 ;
6689 0 : int res1 = 0 ;
6690 : unsigned int val2 ;
6691 0 : int ecode2 = 0 ;
6692 0 : PyObject * obj0 = 0 ;
6693 0 : PyObject * obj1 = 0 ;
6694 :
6695 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_length_set",&obj0,&obj1)) SWIG_fail;
6696 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6697 0 : if (!SWIG_IsOK(res1)) {
6698 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_length_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6699 : }
6700 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6701 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6702 0 : if (!SWIG_IsOK(ecode2)) {
6703 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_length_set" "', argument " "2"" of type '" "unsigned int""'");
6704 : }
6705 0 : arg2 = (unsigned int)(val2);
6706 : {
6707 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6708 0 : if (arg1) (arg1)->length = arg2;
6709 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6710 : }
6711 0 : resultobj = SWIG_Py_Void();
6712 0 : return resultobj;
6713 : fail:
6714 : return NULL;
6715 : }
6716 :
6717 :
6718 158 : SWIGINTERN PyObject *_wrap__gpgme_subkey_length_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6719 158 : PyObject *resultobj = 0;
6720 158 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6721 158 : void *argp1 = 0 ;
6722 158 : int res1 = 0 ;
6723 158 : PyObject * obj0 = 0 ;
6724 : unsigned int result;
6725 :
6726 158 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_length_get",&obj0)) SWIG_fail;
6727 158 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6728 158 : if (!SWIG_IsOK(res1)) {
6729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_length_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6730 : }
6731 158 : arg1 = (struct _gpgme_subkey *)(argp1);
6732 : {
6733 158 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6734 158 : result = (unsigned int) ((arg1)->length);
6735 158 : SWIG_PYTHON_THREAD_END_ALLOW;
6736 : }
6737 158 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6738 158 : return resultobj;
6739 : fail:
6740 : return NULL;
6741 : }
6742 :
6743 :
6744 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6745 0 : PyObject *resultobj = 0;
6746 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6747 0 : char *arg2 = (char *) 0 ;
6748 0 : void *argp1 = 0 ;
6749 0 : int res1 = 0 ;
6750 : int res2 ;
6751 0 : char *buf2 = 0 ;
6752 0 : int alloc2 = 0 ;
6753 0 : PyObject * obj0 = 0 ;
6754 0 : PyObject * obj1 = 0 ;
6755 :
6756 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_keyid_set",&obj0,&obj1)) SWIG_fail;
6757 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6758 0 : if (!SWIG_IsOK(res1)) {
6759 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keyid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6760 : }
6761 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6762 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6763 0 : if (!SWIG_IsOK(res2)) {
6764 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_keyid_set" "', argument " "2"" of type '" "char *""'");
6765 : }
6766 0 : arg2 = (char *)(buf2);
6767 : {
6768 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6769 0 : if (arg1->keyid) free((char*)arg1->keyid);
6770 0 : if (arg2) {
6771 0 : size_t size = strlen((const char *)(arg2)) + 1;
6772 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6773 : } else {
6774 0 : arg1->keyid = 0;
6775 : }
6776 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6777 : }
6778 0 : resultobj = SWIG_Py_Void();
6779 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6780 : return resultobj;
6781 : fail:
6782 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6783 : return NULL;
6784 : }
6785 :
6786 :
6787 156 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6788 156 : PyObject *resultobj = 0;
6789 156 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6790 156 : void *argp1 = 0 ;
6791 156 : int res1 = 0 ;
6792 156 : PyObject * obj0 = 0 ;
6793 156 : char *result = 0 ;
6794 :
6795 156 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_keyid_get",&obj0)) SWIG_fail;
6796 156 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6797 156 : if (!SWIG_IsOK(res1)) {
6798 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keyid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6799 : }
6800 156 : arg1 = (struct _gpgme_subkey *)(argp1);
6801 : {
6802 156 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6803 156 : result = (char *) ((arg1)->keyid);
6804 156 : SWIG_PYTHON_THREAD_END_ALLOW;
6805 : }
6806 156 : resultobj = SWIG_FromCharPtr((const char *)result);
6807 156 : return resultobj;
6808 : fail:
6809 : return NULL;
6810 : }
6811 :
6812 :
6813 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6814 0 : PyObject *resultobj = 0;
6815 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6816 : char *arg2 ;
6817 0 : void *argp1 = 0 ;
6818 0 : int res1 = 0 ;
6819 : char temp2[16+1] ;
6820 : int res2 ;
6821 0 : PyObject * obj0 = 0 ;
6822 0 : PyObject * obj1 = 0 ;
6823 :
6824 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey__keyid_set",&obj0,&obj1)) SWIG_fail;
6825 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6826 0 : if (!SWIG_IsOK(res1)) {
6827 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__keyid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6828 : }
6829 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6830 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
6831 0 : if (!SWIG_IsOK(res2)) {
6832 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
6833 : }
6834 0 : arg2 = (char *)(temp2);
6835 : {
6836 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6837 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
6838 : else memset(arg1->_keyid,0,16+1*sizeof(char));
6839 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6840 : }
6841 0 : resultobj = SWIG_Py_Void();
6842 0 : return resultobj;
6843 : fail:
6844 : return NULL;
6845 : }
6846 :
6847 :
6848 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6849 0 : PyObject *resultobj = 0;
6850 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6851 0 : void *argp1 = 0 ;
6852 0 : int res1 = 0 ;
6853 0 : PyObject * obj0 = 0 ;
6854 0 : char *result = 0 ;
6855 :
6856 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey__keyid_get",&obj0)) SWIG_fail;
6857 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6858 0 : if (!SWIG_IsOK(res1)) {
6859 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__keyid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6860 : }
6861 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6862 : {
6863 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6864 0 : result = (char *)(char *) ((arg1)->_keyid);
6865 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6866 : }
6867 : {
6868 0 : size_t size = SWIG_strnlen(result, 16+1);
6869 :
6870 :
6871 :
6872 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
6873 : }
6874 0 : return resultobj;
6875 : fail:
6876 : return NULL;
6877 : }
6878 :
6879 :
6880 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6881 0 : PyObject *resultobj = 0;
6882 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6883 0 : char *arg2 = (char *) 0 ;
6884 0 : void *argp1 = 0 ;
6885 0 : int res1 = 0 ;
6886 : int res2 ;
6887 0 : char *buf2 = 0 ;
6888 0 : int alloc2 = 0 ;
6889 0 : PyObject * obj0 = 0 ;
6890 0 : PyObject * obj1 = 0 ;
6891 :
6892 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_fpr_set",&obj0,&obj1)) SWIG_fail;
6893 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6894 0 : if (!SWIG_IsOK(res1)) {
6895 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_fpr_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6896 : }
6897 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6898 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6899 0 : if (!SWIG_IsOK(res2)) {
6900 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_fpr_set" "', argument " "2"" of type '" "char *""'");
6901 : }
6902 0 : arg2 = (char *)(buf2);
6903 : {
6904 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6905 0 : if (arg1->fpr) free((char*)arg1->fpr);
6906 0 : if (arg2) {
6907 0 : size_t size = strlen((const char *)(arg2)) + 1;
6908 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6909 : } else {
6910 0 : arg1->fpr = 0;
6911 : }
6912 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6913 : }
6914 0 : resultobj = SWIG_Py_Void();
6915 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6916 : return resultobj;
6917 : fail:
6918 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6919 : return NULL;
6920 : }
6921 :
6922 :
6923 161 : SWIGINTERN PyObject *_wrap__gpgme_subkey_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6924 161 : PyObject *resultobj = 0;
6925 161 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6926 161 : void *argp1 = 0 ;
6927 161 : int res1 = 0 ;
6928 161 : PyObject * obj0 = 0 ;
6929 161 : char *result = 0 ;
6930 :
6931 161 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_fpr_get",&obj0)) SWIG_fail;
6932 161 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6933 161 : if (!SWIG_IsOK(res1)) {
6934 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_fpr_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6935 : }
6936 161 : arg1 = (struct _gpgme_subkey *)(argp1);
6937 : {
6938 161 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6939 161 : result = (char *) ((arg1)->fpr);
6940 161 : SWIG_PYTHON_THREAD_END_ALLOW;
6941 : }
6942 161 : resultobj = SWIG_FromCharPtr((const char *)result);
6943 161 : return resultobj;
6944 : fail:
6945 : return NULL;
6946 : }
6947 :
6948 :
6949 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6950 0 : PyObject *resultobj = 0;
6951 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6952 : long arg2 ;
6953 0 : void *argp1 = 0 ;
6954 0 : int res1 = 0 ;
6955 : long val2 ;
6956 0 : int ecode2 = 0 ;
6957 0 : PyObject * obj0 = 0 ;
6958 0 : PyObject * obj1 = 0 ;
6959 :
6960 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_timestamp_set",&obj0,&obj1)) SWIG_fail;
6961 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6962 0 : if (!SWIG_IsOK(res1)) {
6963 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6964 : }
6965 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6966 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
6967 0 : if (!SWIG_IsOK(ecode2)) {
6968 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_timestamp_set" "', argument " "2"" of type '" "long""'");
6969 : }
6970 0 : arg2 = (long)(val2);
6971 : {
6972 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6973 0 : if (arg1) (arg1)->timestamp = arg2;
6974 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6975 : }
6976 0 : resultobj = SWIG_Py_Void();
6977 0 : return resultobj;
6978 : fail:
6979 : return NULL;
6980 : }
6981 :
6982 :
6983 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6984 0 : PyObject *resultobj = 0;
6985 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6986 0 : void *argp1 = 0 ;
6987 0 : int res1 = 0 ;
6988 0 : PyObject * obj0 = 0 ;
6989 : long result;
6990 :
6991 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_timestamp_get",&obj0)) SWIG_fail;
6992 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6993 0 : if (!SWIG_IsOK(res1)) {
6994 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6995 : }
6996 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6997 : {
6998 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6999 0 : result = (long) ((arg1)->timestamp);
7000 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7001 : }
7002 0 : resultobj = SWIG_From_long((long)(result));
7003 0 : return resultobj;
7004 : fail:
7005 : return NULL;
7006 : }
7007 :
7008 :
7009 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expires_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7010 0 : PyObject *resultobj = 0;
7011 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7012 : long arg2 ;
7013 0 : void *argp1 = 0 ;
7014 0 : int res1 = 0 ;
7015 : long val2 ;
7016 0 : int ecode2 = 0 ;
7017 0 : PyObject * obj0 = 0 ;
7018 0 : PyObject * obj1 = 0 ;
7019 :
7020 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_expires_set",&obj0,&obj1)) SWIG_fail;
7021 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7022 0 : if (!SWIG_IsOK(res1)) {
7023 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expires_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7024 : }
7025 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7026 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
7027 0 : if (!SWIG_IsOK(ecode2)) {
7028 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_expires_set" "', argument " "2"" of type '" "long""'");
7029 : }
7030 0 : arg2 = (long)(val2);
7031 : {
7032 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7033 0 : if (arg1) (arg1)->expires = arg2;
7034 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7035 : }
7036 0 : resultobj = SWIG_Py_Void();
7037 0 : return resultobj;
7038 : fail:
7039 : return NULL;
7040 : }
7041 :
7042 :
7043 167 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expires_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7044 167 : PyObject *resultobj = 0;
7045 167 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7046 167 : void *argp1 = 0 ;
7047 167 : int res1 = 0 ;
7048 167 : PyObject * obj0 = 0 ;
7049 : long result;
7050 :
7051 167 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_expires_get",&obj0)) SWIG_fail;
7052 167 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7053 167 : if (!SWIG_IsOK(res1)) {
7054 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expires_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7055 : }
7056 167 : arg1 = (struct _gpgme_subkey *)(argp1);
7057 : {
7058 167 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7059 167 : result = (long) ((arg1)->expires);
7060 167 : SWIG_PYTHON_THREAD_END_ALLOW;
7061 : }
7062 167 : resultobj = SWIG_From_long((long)(result));
7063 167 : return resultobj;
7064 : fail:
7065 : return NULL;
7066 : }
7067 :
7068 :
7069 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_card_number_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7070 0 : PyObject *resultobj = 0;
7071 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7072 0 : char *arg2 = (char *) 0 ;
7073 0 : void *argp1 = 0 ;
7074 0 : int res1 = 0 ;
7075 : int res2 ;
7076 0 : char *buf2 = 0 ;
7077 0 : int alloc2 = 0 ;
7078 0 : PyObject * obj0 = 0 ;
7079 0 : PyObject * obj1 = 0 ;
7080 :
7081 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_card_number_set",&obj0,&obj1)) SWIG_fail;
7082 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7083 0 : if (!SWIG_IsOK(res1)) {
7084 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_card_number_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7085 : }
7086 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7087 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7088 0 : if (!SWIG_IsOK(res2)) {
7089 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_card_number_set" "', argument " "2"" of type '" "char *""'");
7090 : }
7091 0 : arg2 = (char *)(buf2);
7092 : {
7093 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7094 0 : if (arg1->card_number) free((char*)arg1->card_number);
7095 0 : if (arg2) {
7096 0 : size_t size = strlen((const char *)(arg2)) + 1;
7097 0 : arg1->card_number = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7098 : } else {
7099 0 : arg1->card_number = 0;
7100 : }
7101 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7102 : }
7103 0 : resultobj = SWIG_Py_Void();
7104 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7105 : return resultobj;
7106 : fail:
7107 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7108 : return NULL;
7109 : }
7110 :
7111 :
7112 156 : SWIGINTERN PyObject *_wrap__gpgme_subkey_card_number_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7113 156 : PyObject *resultobj = 0;
7114 156 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7115 156 : void *argp1 = 0 ;
7116 156 : int res1 = 0 ;
7117 156 : PyObject * obj0 = 0 ;
7118 156 : char *result = 0 ;
7119 :
7120 156 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_card_number_get",&obj0)) SWIG_fail;
7121 156 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7122 156 : if (!SWIG_IsOK(res1)) {
7123 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_card_number_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7124 : }
7125 156 : arg1 = (struct _gpgme_subkey *)(argp1);
7126 : {
7127 156 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7128 156 : result = (char *) ((arg1)->card_number);
7129 156 : SWIG_PYTHON_THREAD_END_ALLOW;
7130 : }
7131 156 : resultobj = SWIG_FromCharPtr((const char *)result);
7132 156 : return resultobj;
7133 : fail:
7134 : return NULL;
7135 : }
7136 :
7137 :
7138 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_curve_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7139 0 : PyObject *resultobj = 0;
7140 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7141 0 : char *arg2 = (char *) 0 ;
7142 0 : void *argp1 = 0 ;
7143 0 : int res1 = 0 ;
7144 : int res2 ;
7145 0 : char *buf2 = 0 ;
7146 0 : int alloc2 = 0 ;
7147 0 : PyObject * obj0 = 0 ;
7148 0 : PyObject * obj1 = 0 ;
7149 :
7150 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_curve_set",&obj0,&obj1)) SWIG_fail;
7151 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7152 0 : if (!SWIG_IsOK(res1)) {
7153 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_curve_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7154 : }
7155 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7156 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7157 0 : if (!SWIG_IsOK(res2)) {
7158 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_curve_set" "', argument " "2"" of type '" "char *""'");
7159 : }
7160 0 : arg2 = (char *)(buf2);
7161 : {
7162 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7163 0 : if (arg1->curve) free((char*)arg1->curve);
7164 0 : if (arg2) {
7165 0 : size_t size = strlen((const char *)(arg2)) + 1;
7166 0 : arg1->curve = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7167 : } else {
7168 0 : arg1->curve = 0;
7169 : }
7170 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7171 : }
7172 0 : resultobj = SWIG_Py_Void();
7173 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7174 : return resultobj;
7175 : fail:
7176 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7177 : return NULL;
7178 : }
7179 :
7180 :
7181 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_curve_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7182 0 : PyObject *resultobj = 0;
7183 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7184 0 : void *argp1 = 0 ;
7185 0 : int res1 = 0 ;
7186 0 : PyObject * obj0 = 0 ;
7187 0 : char *result = 0 ;
7188 :
7189 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_curve_get",&obj0)) SWIG_fail;
7190 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7191 0 : if (!SWIG_IsOK(res1)) {
7192 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_curve_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7193 : }
7194 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7195 : {
7196 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7197 0 : result = (char *) ((arg1)->curve);
7198 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7199 : }
7200 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7201 0 : return resultobj;
7202 : fail:
7203 : return NULL;
7204 : }
7205 :
7206 :
7207 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keygrip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7208 0 : PyObject *resultobj = 0;
7209 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7210 0 : char *arg2 = (char *) 0 ;
7211 0 : void *argp1 = 0 ;
7212 0 : int res1 = 0 ;
7213 : int res2 ;
7214 0 : char *buf2 = 0 ;
7215 0 : int alloc2 = 0 ;
7216 0 : PyObject * obj0 = 0 ;
7217 0 : PyObject * obj1 = 0 ;
7218 :
7219 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_keygrip_set",&obj0,&obj1)) SWIG_fail;
7220 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7221 0 : if (!SWIG_IsOK(res1)) {
7222 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keygrip_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7223 : }
7224 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7225 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7226 0 : if (!SWIG_IsOK(res2)) {
7227 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_keygrip_set" "', argument " "2"" of type '" "char *""'");
7228 : }
7229 0 : arg2 = (char *)(buf2);
7230 : {
7231 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7232 0 : if (arg1->keygrip) free((char*)arg1->keygrip);
7233 0 : if (arg2) {
7234 0 : size_t size = strlen((const char *)(arg2)) + 1;
7235 0 : arg1->keygrip = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7236 : } else {
7237 0 : arg1->keygrip = 0;
7238 : }
7239 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7240 : }
7241 0 : resultobj = SWIG_Py_Void();
7242 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7243 : return resultobj;
7244 : fail:
7245 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7246 : return NULL;
7247 : }
7248 :
7249 :
7250 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keygrip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7251 0 : PyObject *resultobj = 0;
7252 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7253 0 : void *argp1 = 0 ;
7254 0 : int res1 = 0 ;
7255 0 : PyObject * obj0 = 0 ;
7256 0 : char *result = 0 ;
7257 :
7258 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_keygrip_get",&obj0)) SWIG_fail;
7259 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7260 0 : if (!SWIG_IsOK(res1)) {
7261 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keygrip_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7262 : }
7263 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7264 : {
7265 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7266 0 : result = (char *) ((arg1)->keygrip);
7267 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7268 : }
7269 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7270 0 : return resultobj;
7271 : fail:
7272 : return NULL;
7273 : }
7274 :
7275 :
7276 0 : SWIGINTERN PyObject *_wrap_new__gpgme_subkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7277 0 : PyObject *resultobj = 0;
7278 0 : struct _gpgme_subkey *result = 0 ;
7279 :
7280 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_subkey")) SWIG_fail;
7281 : {
7282 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7283 0 : result = (struct _gpgme_subkey *)calloc(1, sizeof(struct _gpgme_subkey));
7284 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7285 : }
7286 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_NEW | 0 );
7287 0 : return resultobj;
7288 : fail:
7289 : return NULL;
7290 : }
7291 :
7292 :
7293 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_subkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7294 0 : PyObject *resultobj = 0;
7295 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7296 0 : void *argp1 = 0 ;
7297 0 : int res1 = 0 ;
7298 0 : PyObject * obj0 = 0 ;
7299 :
7300 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_subkey",&obj0)) SWIG_fail;
7301 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
7302 0 : if (!SWIG_IsOK(res1)) {
7303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_subkey" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7304 : }
7305 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7306 : {
7307 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7308 0 : free((char *) arg1);
7309 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7310 : }
7311 0 : resultobj = SWIG_Py_Void();
7312 0 : return resultobj;
7313 : fail:
7314 : return NULL;
7315 : }
7316 :
7317 :
7318 29 : SWIGINTERN PyObject *_gpgme_subkey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7319 : PyObject *obj;
7320 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
7321 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_subkey, SWIG_NewClientData(obj));
7322 29 : return SWIG_Py_Void();
7323 : }
7324 :
7325 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_revoked_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7326 0 : PyObject *resultobj = 0;
7327 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7328 : unsigned int arg2 ;
7329 0 : void *argp1 = 0 ;
7330 0 : int res1 = 0 ;
7331 : unsigned int val2 ;
7332 0 : int ecode2 = 0 ;
7333 0 : PyObject * obj0 = 0 ;
7334 0 : PyObject * obj1 = 0 ;
7335 :
7336 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_revoked_set",&obj0,&obj1)) SWIG_fail;
7337 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7338 0 : if (!SWIG_IsOK(res1)) {
7339 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_revoked_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7340 : }
7341 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7342 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7343 0 : if (!SWIG_IsOK(ecode2)) {
7344 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
7345 : }
7346 0 : arg2 = (unsigned int)(val2);
7347 : {
7348 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7349 0 : if (arg1) (arg1)->revoked = arg2;
7350 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7351 : }
7352 0 : resultobj = SWIG_Py_Void();
7353 0 : return resultobj;
7354 : fail:
7355 : return NULL;
7356 : }
7357 :
7358 :
7359 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_revoked_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7360 0 : PyObject *resultobj = 0;
7361 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7362 0 : void *argp1 = 0 ;
7363 0 : int res1 = 0 ;
7364 0 : PyObject * obj0 = 0 ;
7365 : unsigned int result;
7366 :
7367 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_revoked_get",&obj0)) SWIG_fail;
7368 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7369 0 : if (!SWIG_IsOK(res1)) {
7370 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_revoked_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7371 : }
7372 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7373 : {
7374 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7375 0 : result = (unsigned int) ((arg1)->revoked);
7376 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7377 : }
7378 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7379 0 : return resultobj;
7380 : fail:
7381 : return NULL;
7382 : }
7383 :
7384 :
7385 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expired_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7386 0 : PyObject *resultobj = 0;
7387 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7388 : unsigned int arg2 ;
7389 0 : void *argp1 = 0 ;
7390 0 : int res1 = 0 ;
7391 : unsigned int val2 ;
7392 0 : int ecode2 = 0 ;
7393 0 : PyObject * obj0 = 0 ;
7394 0 : PyObject * obj1 = 0 ;
7395 :
7396 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_expired_set",&obj0,&obj1)) SWIG_fail;
7397 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7398 0 : if (!SWIG_IsOK(res1)) {
7399 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expired_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7400 : }
7401 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7402 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7403 0 : if (!SWIG_IsOK(ecode2)) {
7404 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_expired_set" "', argument " "2"" of type '" "unsigned int""'");
7405 : }
7406 0 : arg2 = (unsigned int)(val2);
7407 : {
7408 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7409 0 : if (arg1) (arg1)->expired = arg2;
7410 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7411 : }
7412 0 : resultobj = SWIG_Py_Void();
7413 0 : return resultobj;
7414 : fail:
7415 : return NULL;
7416 : }
7417 :
7418 :
7419 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expired_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7420 0 : PyObject *resultobj = 0;
7421 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7422 0 : void *argp1 = 0 ;
7423 0 : int res1 = 0 ;
7424 0 : PyObject * obj0 = 0 ;
7425 : unsigned int result;
7426 :
7427 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_expired_get",&obj0)) SWIG_fail;
7428 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7429 0 : if (!SWIG_IsOK(res1)) {
7430 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expired_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7431 : }
7432 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7433 : {
7434 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7435 0 : result = (unsigned int) ((arg1)->expired);
7436 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7437 : }
7438 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7439 0 : return resultobj;
7440 : fail:
7441 : return NULL;
7442 : }
7443 :
7444 :
7445 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_invalid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7446 0 : PyObject *resultobj = 0;
7447 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7448 : unsigned int arg2 ;
7449 0 : void *argp1 = 0 ;
7450 0 : int res1 = 0 ;
7451 : unsigned int val2 ;
7452 0 : int ecode2 = 0 ;
7453 0 : PyObject * obj0 = 0 ;
7454 0 : PyObject * obj1 = 0 ;
7455 :
7456 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_invalid_set",&obj0,&obj1)) SWIG_fail;
7457 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7458 0 : if (!SWIG_IsOK(res1)) {
7459 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_invalid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7460 : }
7461 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7462 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7463 0 : if (!SWIG_IsOK(ecode2)) {
7464 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
7465 : }
7466 0 : arg2 = (unsigned int)(val2);
7467 : {
7468 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7469 0 : if (arg1) (arg1)->invalid = arg2;
7470 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7471 : }
7472 0 : resultobj = SWIG_Py_Void();
7473 0 : return resultobj;
7474 : fail:
7475 : return NULL;
7476 : }
7477 :
7478 :
7479 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_invalid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7480 0 : PyObject *resultobj = 0;
7481 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7482 0 : void *argp1 = 0 ;
7483 0 : int res1 = 0 ;
7484 0 : PyObject * obj0 = 0 ;
7485 : unsigned int result;
7486 :
7487 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_invalid_get",&obj0)) SWIG_fail;
7488 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7489 0 : if (!SWIG_IsOK(res1)) {
7490 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_invalid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7491 : }
7492 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7493 : {
7494 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7495 0 : result = (unsigned int) ((arg1)->invalid);
7496 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7497 : }
7498 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7499 0 : return resultobj;
7500 : fail:
7501 : return NULL;
7502 : }
7503 :
7504 :
7505 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_exportable_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7506 0 : PyObject *resultobj = 0;
7507 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7508 : unsigned int arg2 ;
7509 0 : void *argp1 = 0 ;
7510 0 : int res1 = 0 ;
7511 : unsigned int val2 ;
7512 0 : int ecode2 = 0 ;
7513 0 : PyObject * obj0 = 0 ;
7514 0 : PyObject * obj1 = 0 ;
7515 :
7516 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_exportable_set",&obj0,&obj1)) SWIG_fail;
7517 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7518 0 : if (!SWIG_IsOK(res1)) {
7519 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_exportable_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7520 : }
7521 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7522 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7523 0 : if (!SWIG_IsOK(ecode2)) {
7524 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_exportable_set" "', argument " "2"" of type '" "unsigned int""'");
7525 : }
7526 0 : arg2 = (unsigned int)(val2);
7527 : {
7528 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7529 0 : if (arg1) (arg1)->exportable = arg2;
7530 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7531 : }
7532 0 : resultobj = SWIG_Py_Void();
7533 0 : return resultobj;
7534 : fail:
7535 : return NULL;
7536 : }
7537 :
7538 :
7539 27 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_exportable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7540 27 : PyObject *resultobj = 0;
7541 27 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7542 27 : void *argp1 = 0 ;
7543 27 : int res1 = 0 ;
7544 27 : PyObject * obj0 = 0 ;
7545 : unsigned int result;
7546 :
7547 27 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_exportable_get",&obj0)) SWIG_fail;
7548 27 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7549 27 : if (!SWIG_IsOK(res1)) {
7550 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_exportable_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7551 : }
7552 27 : arg1 = (struct _gpgme_key_sig *)(argp1);
7553 : {
7554 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7555 27 : result = (unsigned int) ((arg1)->exportable);
7556 27 : SWIG_PYTHON_THREAD_END_ALLOW;
7557 : }
7558 27 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7559 27 : return resultobj;
7560 : fail:
7561 : return NULL;
7562 : }
7563 :
7564 :
7565 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7566 0 : PyObject *resultobj = 0;
7567 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7568 : unsigned int arg2 ;
7569 0 : void *argp1 = 0 ;
7570 0 : int res1 = 0 ;
7571 : unsigned int val2 ;
7572 0 : int ecode2 = 0 ;
7573 0 : PyObject * obj0 = 0 ;
7574 0 : PyObject * obj1 = 0 ;
7575 :
7576 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig__unused_set",&obj0,&obj1)) SWIG_fail;
7577 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7578 0 : if (!SWIG_IsOK(res1)) {
7579 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__unused_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7580 : }
7581 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7582 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7583 0 : if (!SWIG_IsOK(ecode2)) {
7584 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig__unused_set" "', argument " "2"" of type '" "unsigned int""'");
7585 : }
7586 0 : arg2 = (unsigned int)(val2);
7587 : {
7588 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7589 0 : if (arg1) (arg1)->_unused = arg2;
7590 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7591 : }
7592 0 : resultobj = SWIG_Py_Void();
7593 0 : return resultobj;
7594 : fail:
7595 : return NULL;
7596 : }
7597 :
7598 :
7599 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7600 0 : PyObject *resultobj = 0;
7601 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7602 0 : void *argp1 = 0 ;
7603 0 : int res1 = 0 ;
7604 0 : PyObject * obj0 = 0 ;
7605 : unsigned int result;
7606 :
7607 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__unused_get",&obj0)) SWIG_fail;
7608 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7609 0 : if (!SWIG_IsOK(res1)) {
7610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__unused_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7611 : }
7612 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7613 : {
7614 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7615 0 : result = (unsigned int) ((arg1)->_unused);
7616 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7617 : }
7618 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7619 0 : return resultobj;
7620 : fail:
7621 : return NULL;
7622 : }
7623 :
7624 :
7625 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7626 0 : PyObject *resultobj = 0;
7627 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7628 : gpgme_pubkey_algo_t arg2 ;
7629 0 : void *argp1 = 0 ;
7630 0 : int res1 = 0 ;
7631 : int val2 ;
7632 0 : int ecode2 = 0 ;
7633 0 : PyObject * obj0 = 0 ;
7634 0 : PyObject * obj1 = 0 ;
7635 :
7636 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
7637 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7638 0 : if (!SWIG_IsOK(res1)) {
7639 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7640 : }
7641 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7642 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
7643 0 : if (!SWIG_IsOK(ecode2)) {
7644 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
7645 : }
7646 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
7647 : {
7648 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7649 0 : if (arg1) (arg1)->pubkey_algo = arg2;
7650 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7651 : }
7652 0 : resultobj = SWIG_Py_Void();
7653 0 : return resultobj;
7654 : fail:
7655 : return NULL;
7656 : }
7657 :
7658 :
7659 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7660 0 : PyObject *resultobj = 0;
7661 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7662 0 : void *argp1 = 0 ;
7663 0 : int res1 = 0 ;
7664 0 : PyObject * obj0 = 0 ;
7665 : gpgme_pubkey_algo_t result;
7666 :
7667 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_pubkey_algo_get",&obj0)) SWIG_fail;
7668 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7669 0 : if (!SWIG_IsOK(res1)) {
7670 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7671 : }
7672 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7673 : {
7674 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7675 0 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
7676 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7677 : }
7678 0 : resultobj = SWIG_From_int((int)(result));
7679 0 : return resultobj;
7680 : fail:
7681 : return NULL;
7682 : }
7683 :
7684 :
7685 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7686 0 : PyObject *resultobj = 0;
7687 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7688 0 : char *arg2 = (char *) 0 ;
7689 0 : void *argp1 = 0 ;
7690 0 : int res1 = 0 ;
7691 : int res2 ;
7692 0 : char *buf2 = 0 ;
7693 0 : int alloc2 = 0 ;
7694 0 : PyObject * obj0 = 0 ;
7695 0 : PyObject * obj1 = 0 ;
7696 :
7697 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_keyid_set",&obj0,&obj1)) SWIG_fail;
7698 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7699 0 : if (!SWIG_IsOK(res1)) {
7700 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_keyid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7701 : }
7702 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7703 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7704 0 : if (!SWIG_IsOK(res2)) {
7705 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_keyid_set" "', argument " "2"" of type '" "char *""'");
7706 : }
7707 0 : arg2 = (char *)(buf2);
7708 : {
7709 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7710 0 : if (arg1->keyid) free((char*)arg1->keyid);
7711 0 : if (arg2) {
7712 0 : size_t size = strlen((const char *)(arg2)) + 1;
7713 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7714 : } else {
7715 0 : arg1->keyid = 0;
7716 : }
7717 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7718 : }
7719 0 : resultobj = SWIG_Py_Void();
7720 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7721 : return resultobj;
7722 : fail:
7723 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7724 : return NULL;
7725 : }
7726 :
7727 :
7728 30 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7729 30 : PyObject *resultobj = 0;
7730 30 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7731 30 : void *argp1 = 0 ;
7732 30 : int res1 = 0 ;
7733 30 : PyObject * obj0 = 0 ;
7734 30 : char *result = 0 ;
7735 :
7736 30 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_keyid_get",&obj0)) SWIG_fail;
7737 30 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7738 30 : if (!SWIG_IsOK(res1)) {
7739 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_keyid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7740 : }
7741 30 : arg1 = (struct _gpgme_key_sig *)(argp1);
7742 : {
7743 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7744 30 : result = (char *) ((arg1)->keyid);
7745 30 : SWIG_PYTHON_THREAD_END_ALLOW;
7746 : }
7747 30 : resultobj = SWIG_FromCharPtr((const char *)result);
7748 30 : return resultobj;
7749 : fail:
7750 : return NULL;
7751 : }
7752 :
7753 :
7754 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7755 0 : PyObject *resultobj = 0;
7756 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7757 : char *arg2 ;
7758 0 : void *argp1 = 0 ;
7759 0 : int res1 = 0 ;
7760 : char temp2[16+1] ;
7761 : int res2 ;
7762 0 : PyObject * obj0 = 0 ;
7763 0 : PyObject * obj1 = 0 ;
7764 :
7765 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig__keyid_set",&obj0,&obj1)) SWIG_fail;
7766 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7767 0 : if (!SWIG_IsOK(res1)) {
7768 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__keyid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7769 : }
7770 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7771 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
7772 0 : if (!SWIG_IsOK(res2)) {
7773 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
7774 : }
7775 0 : arg2 = (char *)(temp2);
7776 : {
7777 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7778 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
7779 : else memset(arg1->_keyid,0,16+1*sizeof(char));
7780 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7781 : }
7782 0 : resultobj = SWIG_Py_Void();
7783 0 : return resultobj;
7784 : fail:
7785 : return NULL;
7786 : }
7787 :
7788 :
7789 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7790 0 : PyObject *resultobj = 0;
7791 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7792 0 : void *argp1 = 0 ;
7793 0 : int res1 = 0 ;
7794 0 : PyObject * obj0 = 0 ;
7795 0 : char *result = 0 ;
7796 :
7797 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__keyid_get",&obj0)) SWIG_fail;
7798 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7799 0 : if (!SWIG_IsOK(res1)) {
7800 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__keyid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7801 : }
7802 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7803 : {
7804 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7805 0 : result = (char *)(char *) ((arg1)->_keyid);
7806 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7807 : }
7808 : {
7809 0 : size_t size = SWIG_strnlen(result, 16+1);
7810 :
7811 :
7812 :
7813 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
7814 : }
7815 0 : return resultobj;
7816 : fail:
7817 : return NULL;
7818 : }
7819 :
7820 :
7821 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7822 0 : PyObject *resultobj = 0;
7823 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7824 : long arg2 ;
7825 0 : void *argp1 = 0 ;
7826 0 : int res1 = 0 ;
7827 : long val2 ;
7828 0 : int ecode2 = 0 ;
7829 0 : PyObject * obj0 = 0 ;
7830 0 : PyObject * obj1 = 0 ;
7831 :
7832 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_timestamp_set",&obj0,&obj1)) SWIG_fail;
7833 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7834 0 : if (!SWIG_IsOK(res1)) {
7835 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7836 : }
7837 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7838 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
7839 0 : if (!SWIG_IsOK(ecode2)) {
7840 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_timestamp_set" "', argument " "2"" of type '" "long""'");
7841 : }
7842 0 : arg2 = (long)(val2);
7843 : {
7844 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7845 0 : if (arg1) (arg1)->timestamp = arg2;
7846 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7847 : }
7848 0 : resultobj = SWIG_Py_Void();
7849 0 : return resultobj;
7850 : fail:
7851 : return NULL;
7852 : }
7853 :
7854 :
7855 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7856 0 : PyObject *resultobj = 0;
7857 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7858 0 : void *argp1 = 0 ;
7859 0 : int res1 = 0 ;
7860 0 : PyObject * obj0 = 0 ;
7861 : long result;
7862 :
7863 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_timestamp_get",&obj0)) SWIG_fail;
7864 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7865 0 : if (!SWIG_IsOK(res1)) {
7866 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7867 : }
7868 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7869 : {
7870 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7871 0 : result = (long) ((arg1)->timestamp);
7872 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7873 : }
7874 0 : resultobj = SWIG_From_long((long)(result));
7875 0 : return resultobj;
7876 : fail:
7877 : return NULL;
7878 : }
7879 :
7880 :
7881 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expires_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7882 0 : PyObject *resultobj = 0;
7883 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7884 : long arg2 ;
7885 0 : void *argp1 = 0 ;
7886 0 : int res1 = 0 ;
7887 : long val2 ;
7888 0 : int ecode2 = 0 ;
7889 0 : PyObject * obj0 = 0 ;
7890 0 : PyObject * obj1 = 0 ;
7891 :
7892 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_expires_set",&obj0,&obj1)) SWIG_fail;
7893 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7894 0 : if (!SWIG_IsOK(res1)) {
7895 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expires_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7896 : }
7897 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7898 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
7899 0 : if (!SWIG_IsOK(ecode2)) {
7900 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_expires_set" "', argument " "2"" of type '" "long""'");
7901 : }
7902 0 : arg2 = (long)(val2);
7903 : {
7904 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7905 0 : if (arg1) (arg1)->expires = arg2;
7906 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7907 : }
7908 0 : resultobj = SWIG_Py_Void();
7909 0 : return resultobj;
7910 : fail:
7911 : return NULL;
7912 : }
7913 :
7914 :
7915 27 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expires_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 27 : PyObject *resultobj = 0;
7917 27 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7918 27 : void *argp1 = 0 ;
7919 27 : int res1 = 0 ;
7920 27 : PyObject * obj0 = 0 ;
7921 : long result;
7922 :
7923 27 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_expires_get",&obj0)) SWIG_fail;
7924 27 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7925 27 : if (!SWIG_IsOK(res1)) {
7926 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expires_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7927 : }
7928 27 : arg1 = (struct _gpgme_key_sig *)(argp1);
7929 : {
7930 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7931 27 : result = (long) ((arg1)->expires);
7932 27 : SWIG_PYTHON_THREAD_END_ALLOW;
7933 : }
7934 27 : resultobj = SWIG_From_long((long)(result));
7935 27 : return resultobj;
7936 : fail:
7937 : return NULL;
7938 : }
7939 :
7940 :
7941 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7942 0 : PyObject *resultobj = 0;
7943 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7944 : gpgme_error_t arg2 ;
7945 0 : void *argp1 = 0 ;
7946 0 : int res1 = 0 ;
7947 0 : PyObject * obj0 = 0 ;
7948 0 : PyObject * obj1 = 0 ;
7949 :
7950 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_status_set",&obj0,&obj1)) SWIG_fail;
7951 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7952 0 : if (!SWIG_IsOK(res1)) {
7953 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_status_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7954 : }
7955 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7956 : {
7957 0 : if (PyLong_Check(obj1))
7958 0 : arg2 = PyLong_AsLong(obj1);
7959 :
7960 : else if (PyInt_Check(obj1))
7961 : arg2 = PyInt_AsLong(obj1);
7962 :
7963 : else
7964 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
7965 : }
7966 : {
7967 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7968 0 : if (arg1) (arg1)->status = arg2;
7969 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7970 : }
7971 0 : resultobj = SWIG_Py_Void();
7972 0 : return resultobj;
7973 : fail:
7974 : return NULL;
7975 : }
7976 :
7977 :
7978 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7979 0 : PyObject *resultobj = 0;
7980 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7981 0 : void *argp1 = 0 ;
7982 0 : int res1 = 0 ;
7983 0 : PyObject * obj0 = 0 ;
7984 : gpgme_error_t result;
7985 :
7986 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_status_get",&obj0)) SWIG_fail;
7987 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7988 0 : if (!SWIG_IsOK(res1)) {
7989 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_status_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7990 : }
7991 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7992 : {
7993 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7994 0 : result = ((arg1)->status);
7995 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7996 : }
7997 : {
7998 0 : resultobj = PyLong_FromLong(result);
7999 : }
8000 0 : return resultobj;
8001 : fail:
8002 : return NULL;
8003 : }
8004 :
8005 :
8006 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__obsolete_class_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 0 : PyObject *resultobj = 0;
8008 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8009 : unsigned int arg2 ;
8010 0 : void *argp1 = 0 ;
8011 0 : int res1 = 0 ;
8012 : unsigned int val2 ;
8013 0 : int ecode2 = 0 ;
8014 0 : PyObject * obj0 = 0 ;
8015 0 : PyObject * obj1 = 0 ;
8016 :
8017 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig__obsolete_class_set",&obj0,&obj1)) SWIG_fail;
8018 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8019 0 : if (!SWIG_IsOK(res1)) {
8020 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__obsolete_class_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8021 : }
8022 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8023 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8024 0 : if (!SWIG_IsOK(ecode2)) {
8025 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig__obsolete_class_set" "', argument " "2"" of type '" "unsigned int""'");
8026 : }
8027 0 : arg2 = (unsigned int)(val2);
8028 : {
8029 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8030 0 : if (arg1) (arg1)->_obsolete_class = arg2;
8031 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8032 : }
8033 0 : resultobj = SWIG_Py_Void();
8034 0 : return resultobj;
8035 : fail:
8036 : return NULL;
8037 : }
8038 :
8039 :
8040 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__obsolete_class_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8041 0 : PyObject *resultobj = 0;
8042 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8043 0 : void *argp1 = 0 ;
8044 0 : int res1 = 0 ;
8045 0 : PyObject * obj0 = 0 ;
8046 : unsigned int result;
8047 :
8048 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__obsolete_class_get",&obj0)) SWIG_fail;
8049 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8050 0 : if (!SWIG_IsOK(res1)) {
8051 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__obsolete_class_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8052 : }
8053 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8054 : {
8055 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8056 0 : result = (unsigned int) ((arg1)->_obsolete_class);
8057 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8058 : }
8059 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8060 0 : return resultobj;
8061 : fail:
8062 : return NULL;
8063 : }
8064 :
8065 :
8066 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_uid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8067 0 : PyObject *resultobj = 0;
8068 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8069 0 : char *arg2 = (char *) 0 ;
8070 0 : void *argp1 = 0 ;
8071 0 : int res1 = 0 ;
8072 : int res2 ;
8073 0 : char *buf2 = 0 ;
8074 0 : int alloc2 = 0 ;
8075 0 : PyObject * obj0 = 0 ;
8076 0 : PyObject * obj1 = 0 ;
8077 :
8078 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_uid_set",&obj0,&obj1)) SWIG_fail;
8079 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8080 0 : if (!SWIG_IsOK(res1)) {
8081 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_uid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8082 : }
8083 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8084 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8085 0 : if (!SWIG_IsOK(res2)) {
8086 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_uid_set" "', argument " "2"" of type '" "char *""'");
8087 : }
8088 0 : arg2 = (char *)(buf2);
8089 : {
8090 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8091 0 : if (arg1->uid) free((char*)arg1->uid);
8092 0 : if (arg2) {
8093 0 : size_t size = strlen((const char *)(arg2)) + 1;
8094 0 : arg1->uid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8095 : } else {
8096 0 : arg1->uid = 0;
8097 : }
8098 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8099 : }
8100 0 : resultobj = SWIG_Py_Void();
8101 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8102 : return resultobj;
8103 : fail:
8104 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8105 : return NULL;
8106 : }
8107 :
8108 :
8109 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_uid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8110 0 : PyObject *resultobj = 0;
8111 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8112 0 : void *argp1 = 0 ;
8113 0 : int res1 = 0 ;
8114 0 : PyObject * obj0 = 0 ;
8115 0 : char *result = 0 ;
8116 :
8117 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_uid_get",&obj0)) SWIG_fail;
8118 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8119 0 : if (!SWIG_IsOK(res1)) {
8120 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_uid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8121 : }
8122 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8123 : {
8124 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8125 0 : result = (char *) ((arg1)->uid);
8126 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8127 : }
8128 0 : resultobj = SWIG_FromCharPtr((const char *)result);
8129 0 : return resultobj;
8130 : fail:
8131 : return NULL;
8132 : }
8133 :
8134 :
8135 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8136 0 : PyObject *resultobj = 0;
8137 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8138 0 : char *arg2 = (char *) 0 ;
8139 0 : void *argp1 = 0 ;
8140 0 : int res1 = 0 ;
8141 : int res2 ;
8142 0 : char *buf2 = 0 ;
8143 0 : int alloc2 = 0 ;
8144 0 : PyObject * obj0 = 0 ;
8145 0 : PyObject * obj1 = 0 ;
8146 :
8147 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_name_set",&obj0,&obj1)) SWIG_fail;
8148 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8149 0 : if (!SWIG_IsOK(res1)) {
8150 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_name_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8151 : }
8152 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8153 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8154 0 : if (!SWIG_IsOK(res2)) {
8155 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_name_set" "', argument " "2"" of type '" "char *""'");
8156 : }
8157 0 : arg2 = (char *)(buf2);
8158 : {
8159 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8160 0 : if (arg1->name) free((char*)arg1->name);
8161 0 : if (arg2) {
8162 0 : size_t size = strlen((const char *)(arg2)) + 1;
8163 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8164 : } else {
8165 0 : arg1->name = 0;
8166 : }
8167 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8168 : }
8169 0 : resultobj = SWIG_Py_Void();
8170 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8171 : return resultobj;
8172 : fail:
8173 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8174 : return NULL;
8175 : }
8176 :
8177 :
8178 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8179 0 : PyObject *resultobj = 0;
8180 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8181 0 : void *argp1 = 0 ;
8182 0 : int res1 = 0 ;
8183 0 : PyObject * obj0 = 0 ;
8184 0 : char *result = 0 ;
8185 :
8186 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_name_get",&obj0)) SWIG_fail;
8187 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8188 0 : if (!SWIG_IsOK(res1)) {
8189 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_name_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8190 : }
8191 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8192 : {
8193 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8194 0 : result = (char *) ((arg1)->name);
8195 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8196 : }
8197 0 : resultobj = SWIG_FromCharPtr((const char *)result);
8198 0 : return resultobj;
8199 : fail:
8200 : return NULL;
8201 : }
8202 :
8203 :
8204 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_email_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8205 0 : PyObject *resultobj = 0;
8206 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8207 0 : char *arg2 = (char *) 0 ;
8208 0 : void *argp1 = 0 ;
8209 0 : int res1 = 0 ;
8210 : int res2 ;
8211 0 : char *buf2 = 0 ;
8212 0 : int alloc2 = 0 ;
8213 0 : PyObject * obj0 = 0 ;
8214 0 : PyObject * obj1 = 0 ;
8215 :
8216 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_email_set",&obj0,&obj1)) SWIG_fail;
8217 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8218 0 : if (!SWIG_IsOK(res1)) {
8219 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_email_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8220 : }
8221 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8222 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8223 0 : if (!SWIG_IsOK(res2)) {
8224 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_email_set" "', argument " "2"" of type '" "char *""'");
8225 : }
8226 0 : arg2 = (char *)(buf2);
8227 : {
8228 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8229 0 : if (arg1->email) free((char*)arg1->email);
8230 0 : if (arg2) {
8231 0 : size_t size = strlen((const char *)(arg2)) + 1;
8232 0 : arg1->email = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8233 : } else {
8234 0 : arg1->email = 0;
8235 : }
8236 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8237 : }
8238 0 : resultobj = SWIG_Py_Void();
8239 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8240 : return resultobj;
8241 : fail:
8242 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8243 : return NULL;
8244 : }
8245 :
8246 :
8247 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_email_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8248 0 : PyObject *resultobj = 0;
8249 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8250 0 : void *argp1 = 0 ;
8251 0 : int res1 = 0 ;
8252 0 : PyObject * obj0 = 0 ;
8253 0 : char *result = 0 ;
8254 :
8255 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_email_get",&obj0)) SWIG_fail;
8256 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8257 0 : if (!SWIG_IsOK(res1)) {
8258 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_email_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8259 : }
8260 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8261 : {
8262 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8263 0 : result = (char *) ((arg1)->email);
8264 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8265 : }
8266 0 : resultobj = SWIG_FromCharPtr((const char *)result);
8267 0 : return resultobj;
8268 : fail:
8269 : return NULL;
8270 : }
8271 :
8272 :
8273 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_comment_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274 0 : PyObject *resultobj = 0;
8275 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8276 0 : char *arg2 = (char *) 0 ;
8277 0 : void *argp1 = 0 ;
8278 0 : int res1 = 0 ;
8279 : int res2 ;
8280 0 : char *buf2 = 0 ;
8281 0 : int alloc2 = 0 ;
8282 0 : PyObject * obj0 = 0 ;
8283 0 : PyObject * obj1 = 0 ;
8284 :
8285 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_comment_set",&obj0,&obj1)) SWIG_fail;
8286 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8287 0 : if (!SWIG_IsOK(res1)) {
8288 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_comment_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8289 : }
8290 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8291 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8292 0 : if (!SWIG_IsOK(res2)) {
8293 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_comment_set" "', argument " "2"" of type '" "char *""'");
8294 : }
8295 0 : arg2 = (char *)(buf2);
8296 : {
8297 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8298 0 : if (arg1->comment) free((char*)arg1->comment);
8299 0 : if (arg2) {
8300 0 : size_t size = strlen((const char *)(arg2)) + 1;
8301 0 : arg1->comment = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8302 : } else {
8303 0 : arg1->comment = 0;
8304 : }
8305 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8306 : }
8307 0 : resultobj = SWIG_Py_Void();
8308 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8309 : return resultobj;
8310 : fail:
8311 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8312 : return NULL;
8313 : }
8314 :
8315 :
8316 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_comment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8317 0 : PyObject *resultobj = 0;
8318 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8319 0 : void *argp1 = 0 ;
8320 0 : int res1 = 0 ;
8321 0 : PyObject * obj0 = 0 ;
8322 0 : char *result = 0 ;
8323 :
8324 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_comment_get",&obj0)) SWIG_fail;
8325 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8326 0 : if (!SWIG_IsOK(res1)) {
8327 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_comment_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8328 : }
8329 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8330 : {
8331 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8332 0 : result = (char *) ((arg1)->comment);
8333 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8334 : }
8335 0 : resultobj = SWIG_FromCharPtr((const char *)result);
8336 0 : return resultobj;
8337 : fail:
8338 : return NULL;
8339 : }
8340 :
8341 :
8342 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_sig_class_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8343 0 : PyObject *resultobj = 0;
8344 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8345 : unsigned int arg2 ;
8346 0 : void *argp1 = 0 ;
8347 0 : int res1 = 0 ;
8348 : unsigned int val2 ;
8349 0 : int ecode2 = 0 ;
8350 0 : PyObject * obj0 = 0 ;
8351 0 : PyObject * obj1 = 0 ;
8352 :
8353 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_sig_class_set",&obj0,&obj1)) SWIG_fail;
8354 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8355 0 : if (!SWIG_IsOK(res1)) {
8356 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_sig_class_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8357 : }
8358 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8359 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8360 0 : if (!SWIG_IsOK(ecode2)) {
8361 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_sig_class_set" "', argument " "2"" of type '" "unsigned int""'");
8362 : }
8363 0 : arg2 = (unsigned int)(val2);
8364 : {
8365 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8366 0 : if (arg1) (arg1)->sig_class = arg2;
8367 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8368 : }
8369 0 : resultobj = SWIG_Py_Void();
8370 0 : return resultobj;
8371 : fail:
8372 : return NULL;
8373 : }
8374 :
8375 :
8376 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_sig_class_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8377 0 : PyObject *resultobj = 0;
8378 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8379 0 : void *argp1 = 0 ;
8380 0 : int res1 = 0 ;
8381 0 : PyObject * obj0 = 0 ;
8382 : unsigned int result;
8383 :
8384 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_sig_class_get",&obj0)) SWIG_fail;
8385 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8386 0 : if (!SWIG_IsOK(res1)) {
8387 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_sig_class_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8388 : }
8389 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8390 : {
8391 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8392 0 : result = (unsigned int) ((arg1)->sig_class);
8393 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8394 : }
8395 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8396 0 : return resultobj;
8397 : fail:
8398 : return NULL;
8399 : }
8400 :
8401 :
8402 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_notations_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8403 0 : PyObject *resultobj = 0;
8404 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8405 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
8406 0 : void *argp1 = 0 ;
8407 0 : int res1 = 0 ;
8408 0 : void *argp2 = 0 ;
8409 0 : int res2 = 0 ;
8410 0 : PyObject * obj0 = 0 ;
8411 0 : PyObject * obj1 = 0 ;
8412 :
8413 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_notations_set",&obj0,&obj1)) SWIG_fail;
8414 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8415 0 : if (!SWIG_IsOK(res1)) {
8416 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_notations_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8417 : }
8418 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8419 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
8420 0 : if (!SWIG_IsOK(res2)) {
8421 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_notations_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
8422 : }
8423 0 : arg2 = (gpgme_sig_notation_t)(argp2);
8424 : {
8425 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8426 0 : if (arg1) (arg1)->notations = arg2;
8427 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8428 : }
8429 0 : resultobj = SWIG_Py_Void();
8430 0 : return resultobj;
8431 : fail:
8432 : return NULL;
8433 : }
8434 :
8435 :
8436 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_notations_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8437 0 : PyObject *resultobj = 0;
8438 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8439 0 : void *argp1 = 0 ;
8440 0 : int res1 = 0 ;
8441 0 : PyObject * obj0 = 0 ;
8442 : gpgme_sig_notation_t result;
8443 :
8444 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_notations_get",&obj0)) SWIG_fail;
8445 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8446 0 : if (!SWIG_IsOK(res1)) {
8447 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_notations_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8448 : }
8449 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8450 : {
8451 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8452 0 : result = (gpgme_sig_notation_t) ((arg1)->notations);
8453 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8454 : }
8455 : {
8456 : int i;
8457 0 : int size = 0;
8458 : gpgme_sig_notation_t curr;
8459 0 : for (curr = result; curr != NULL; curr = curr->next) {
8460 0 : size++;
8461 : }
8462 0 : resultobj = PyList_New(size);
8463 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
8464 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
8465 0 : PyList_SetItem(resultobj, i, o);
8466 : }
8467 : }
8468 : return resultobj;
8469 : fail:
8470 : return NULL;
8471 : }
8472 :
8473 :
8474 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__last_notation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8475 0 : PyObject *resultobj = 0;
8476 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8477 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
8478 0 : void *argp1 = 0 ;
8479 0 : int res1 = 0 ;
8480 0 : void *argp2 = 0 ;
8481 0 : int res2 = 0 ;
8482 0 : PyObject * obj0 = 0 ;
8483 0 : PyObject * obj1 = 0 ;
8484 :
8485 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig__last_notation_set",&obj0,&obj1)) SWIG_fail;
8486 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8487 0 : if (!SWIG_IsOK(res1)) {
8488 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__last_notation_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8489 : }
8490 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8491 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
8492 0 : if (!SWIG_IsOK(res2)) {
8493 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig__last_notation_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
8494 : }
8495 0 : arg2 = (gpgme_sig_notation_t)(argp2);
8496 : {
8497 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8498 0 : if (arg1) (arg1)->_last_notation = arg2;
8499 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8500 : }
8501 0 : resultobj = SWIG_Py_Void();
8502 0 : return resultobj;
8503 : fail:
8504 : return NULL;
8505 : }
8506 :
8507 :
8508 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__last_notation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8509 0 : PyObject *resultobj = 0;
8510 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8511 0 : void *argp1 = 0 ;
8512 0 : int res1 = 0 ;
8513 0 : PyObject * obj0 = 0 ;
8514 : gpgme_sig_notation_t result;
8515 :
8516 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__last_notation_get",&obj0)) SWIG_fail;
8517 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8518 0 : if (!SWIG_IsOK(res1)) {
8519 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__last_notation_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8520 : }
8521 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8522 : {
8523 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8524 0 : result = (gpgme_sig_notation_t) ((arg1)->_last_notation);
8525 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8526 : }
8527 : {
8528 : int i;
8529 0 : int size = 0;
8530 : gpgme_sig_notation_t curr;
8531 0 : for (curr = result; curr != NULL; curr = curr->next) {
8532 0 : size++;
8533 : }
8534 0 : resultobj = PyList_New(size);
8535 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
8536 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
8537 0 : PyList_SetItem(resultobj, i, o);
8538 : }
8539 : }
8540 : return resultobj;
8541 : fail:
8542 : return NULL;
8543 : }
8544 :
8545 :
8546 0 : SWIGINTERN PyObject *_wrap_new__gpgme_key_sig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 0 : PyObject *resultobj = 0;
8548 0 : struct _gpgme_key_sig *result = 0 ;
8549 :
8550 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_key_sig")) SWIG_fail;
8551 : {
8552 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8553 0 : result = (struct _gpgme_key_sig *)calloc(1, sizeof(struct _gpgme_key_sig));
8554 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8555 : }
8556 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_NEW | 0 );
8557 0 : return resultobj;
8558 : fail:
8559 : return NULL;
8560 : }
8561 :
8562 :
8563 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_key_sig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8564 0 : PyObject *resultobj = 0;
8565 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8566 0 : void *argp1 = 0 ;
8567 0 : int res1 = 0 ;
8568 0 : PyObject * obj0 = 0 ;
8569 :
8570 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_key_sig",&obj0)) SWIG_fail;
8571 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
8572 0 : if (!SWIG_IsOK(res1)) {
8573 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_key_sig" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8574 : }
8575 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8576 : {
8577 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8578 0 : free((char *) arg1);
8579 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8580 : }
8581 0 : resultobj = SWIG_Py_Void();
8582 0 : return resultobj;
8583 : fail:
8584 : return NULL;
8585 : }
8586 :
8587 :
8588 29 : SWIGINTERN PyObject *_gpgme_key_sig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8589 : PyObject *obj;
8590 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8591 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_key_sig, SWIG_NewClientData(obj));
8592 29 : return SWIG_Py_Void();
8593 : }
8594 :
8595 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_revoked_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8596 0 : PyObject *resultobj = 0;
8597 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8598 : unsigned int arg2 ;
8599 0 : void *argp1 = 0 ;
8600 0 : int res1 = 0 ;
8601 : unsigned int val2 ;
8602 0 : int ecode2 = 0 ;
8603 0 : PyObject * obj0 = 0 ;
8604 0 : PyObject * obj1 = 0 ;
8605 :
8606 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_revoked_set",&obj0,&obj1)) SWIG_fail;
8607 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8608 0 : if (!SWIG_IsOK(res1)) {
8609 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_revoked_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8610 : }
8611 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8612 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8613 0 : if (!SWIG_IsOK(ecode2)) {
8614 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
8615 : }
8616 0 : arg2 = (unsigned int)(val2);
8617 : {
8618 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8619 0 : if (arg1) (arg1)->revoked = arg2;
8620 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8621 : }
8622 0 : resultobj = SWIG_Py_Void();
8623 0 : return resultobj;
8624 : fail:
8625 : return NULL;
8626 : }
8627 :
8628 :
8629 102 : SWIGINTERN PyObject *_wrap__gpgme_user_id_revoked_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8630 102 : PyObject *resultobj = 0;
8631 102 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8632 102 : void *argp1 = 0 ;
8633 102 : int res1 = 0 ;
8634 102 : PyObject * obj0 = 0 ;
8635 : unsigned int result;
8636 :
8637 102 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_revoked_get",&obj0)) SWIG_fail;
8638 102 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8639 102 : if (!SWIG_IsOK(res1)) {
8640 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_revoked_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8641 : }
8642 102 : arg1 = (struct _gpgme_user_id *)(argp1);
8643 : {
8644 102 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8645 102 : result = (unsigned int) ((arg1)->revoked);
8646 102 : SWIG_PYTHON_THREAD_END_ALLOW;
8647 : }
8648 102 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8649 102 : return resultobj;
8650 : fail:
8651 : return NULL;
8652 : }
8653 :
8654 :
8655 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_invalid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8656 0 : PyObject *resultobj = 0;
8657 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8658 : unsigned int arg2 ;
8659 0 : void *argp1 = 0 ;
8660 0 : int res1 = 0 ;
8661 : unsigned int val2 ;
8662 0 : int ecode2 = 0 ;
8663 0 : PyObject * obj0 = 0 ;
8664 0 : PyObject * obj1 = 0 ;
8665 :
8666 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_invalid_set",&obj0,&obj1)) SWIG_fail;
8667 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8668 0 : if (!SWIG_IsOK(res1)) {
8669 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_invalid_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8670 : }
8671 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8672 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8673 0 : if (!SWIG_IsOK(ecode2)) {
8674 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
8675 : }
8676 0 : arg2 = (unsigned int)(val2);
8677 : {
8678 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8679 0 : if (arg1) (arg1)->invalid = arg2;
8680 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8681 : }
8682 0 : resultobj = SWIG_Py_Void();
8683 0 : return resultobj;
8684 : fail:
8685 : return NULL;
8686 : }
8687 :
8688 :
8689 96 : SWIGINTERN PyObject *_wrap__gpgme_user_id_invalid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8690 96 : PyObject *resultobj = 0;
8691 96 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8692 96 : void *argp1 = 0 ;
8693 96 : int res1 = 0 ;
8694 96 : PyObject * obj0 = 0 ;
8695 : unsigned int result;
8696 :
8697 96 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_invalid_get",&obj0)) SWIG_fail;
8698 96 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8699 96 : if (!SWIG_IsOK(res1)) {
8700 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_invalid_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8701 : }
8702 96 : arg1 = (struct _gpgme_user_id *)(argp1);
8703 : {
8704 96 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8705 96 : result = (unsigned int) ((arg1)->invalid);
8706 96 : SWIG_PYTHON_THREAD_END_ALLOW;
8707 : }
8708 96 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8709 96 : return resultobj;
8710 : fail:
8711 : return NULL;
8712 : }
8713 :
8714 :
8715 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8716 0 : PyObject *resultobj = 0;
8717 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8718 : unsigned int arg2 ;
8719 0 : void *argp1 = 0 ;
8720 0 : int res1 = 0 ;
8721 : unsigned int val2 ;
8722 0 : int ecode2 = 0 ;
8723 0 : PyObject * obj0 = 0 ;
8724 0 : PyObject * obj1 = 0 ;
8725 :
8726 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id__unused_set",&obj0,&obj1)) SWIG_fail;
8727 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8728 0 : if (!SWIG_IsOK(res1)) {
8729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__unused_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8730 : }
8731 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8732 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8733 0 : if (!SWIG_IsOK(ecode2)) {
8734 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id__unused_set" "', argument " "2"" of type '" "unsigned int""'");
8735 : }
8736 0 : arg2 = (unsigned int)(val2);
8737 : {
8738 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8739 0 : if (arg1) (arg1)->_unused = arg2;
8740 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8741 : }
8742 0 : resultobj = SWIG_Py_Void();
8743 0 : return resultobj;
8744 : fail:
8745 : return NULL;
8746 : }
8747 :
8748 :
8749 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8750 0 : PyObject *resultobj = 0;
8751 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8752 0 : void *argp1 = 0 ;
8753 0 : int res1 = 0 ;
8754 0 : PyObject * obj0 = 0 ;
8755 : unsigned int result;
8756 :
8757 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id__unused_get",&obj0)) SWIG_fail;
8758 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8759 0 : if (!SWIG_IsOK(res1)) {
8760 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__unused_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8761 : }
8762 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8763 : {
8764 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8765 0 : result = (unsigned int) ((arg1)->_unused);
8766 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8767 : }
8768 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8769 0 : return resultobj;
8770 : fail:
8771 : return NULL;
8772 : }
8773 :
8774 :
8775 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_origin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8776 0 : PyObject *resultobj = 0;
8777 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8778 : unsigned int arg2 ;
8779 0 : void *argp1 = 0 ;
8780 0 : int res1 = 0 ;
8781 : unsigned int val2 ;
8782 0 : int ecode2 = 0 ;
8783 0 : PyObject * obj0 = 0 ;
8784 0 : PyObject * obj1 = 0 ;
8785 :
8786 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_origin_set",&obj0,&obj1)) SWIG_fail;
8787 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8788 0 : if (!SWIG_IsOK(res1)) {
8789 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_origin_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8790 : }
8791 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8792 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8793 0 : if (!SWIG_IsOK(ecode2)) {
8794 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_origin_set" "', argument " "2"" of type '" "unsigned int""'");
8795 : }
8796 0 : arg2 = (unsigned int)(val2);
8797 : {
8798 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8799 0 : if (arg1) (arg1)->origin = arg2;
8800 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8801 : }
8802 0 : resultobj = SWIG_Py_Void();
8803 0 : return resultobj;
8804 : fail:
8805 : return NULL;
8806 : }
8807 :
8808 :
8809 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_origin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8810 0 : PyObject *resultobj = 0;
8811 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8812 0 : void *argp1 = 0 ;
8813 0 : int res1 = 0 ;
8814 0 : PyObject * obj0 = 0 ;
8815 : unsigned int result;
8816 :
8817 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_origin_get",&obj0)) SWIG_fail;
8818 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8819 0 : if (!SWIG_IsOK(res1)) {
8820 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_origin_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8821 : }
8822 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8823 : {
8824 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8825 0 : result = (unsigned int) ((arg1)->origin);
8826 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8827 : }
8828 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8829 0 : return resultobj;
8830 : fail:
8831 : return NULL;
8832 : }
8833 :
8834 :
8835 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8836 0 : PyObject *resultobj = 0;
8837 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8838 : gpgme_validity_t arg2 ;
8839 0 : void *argp1 = 0 ;
8840 0 : int res1 = 0 ;
8841 : int val2 ;
8842 0 : int ecode2 = 0 ;
8843 0 : PyObject * obj0 = 0 ;
8844 0 : PyObject * obj1 = 0 ;
8845 :
8846 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_validity_set",&obj0,&obj1)) SWIG_fail;
8847 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8848 0 : if (!SWIG_IsOK(res1)) {
8849 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_validity_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8850 : }
8851 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8852 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
8853 0 : if (!SWIG_IsOK(ecode2)) {
8854 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_validity_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
8855 : }
8856 0 : arg2 = (gpgme_validity_t)(val2);
8857 : {
8858 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8859 0 : if (arg1) (arg1)->validity = arg2;
8860 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8861 : }
8862 0 : resultobj = SWIG_Py_Void();
8863 0 : return resultobj;
8864 : fail:
8865 : return NULL;
8866 : }
8867 :
8868 :
8869 96 : SWIGINTERN PyObject *_wrap__gpgme_user_id_validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8870 96 : PyObject *resultobj = 0;
8871 96 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8872 96 : void *argp1 = 0 ;
8873 96 : int res1 = 0 ;
8874 96 : PyObject * obj0 = 0 ;
8875 : gpgme_validity_t result;
8876 :
8877 96 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_validity_get",&obj0)) SWIG_fail;
8878 96 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8879 96 : if (!SWIG_IsOK(res1)) {
8880 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_validity_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8881 : }
8882 96 : arg1 = (struct _gpgme_user_id *)(argp1);
8883 : {
8884 96 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8885 96 : result = (gpgme_validity_t) ((arg1)->validity);
8886 96 : SWIG_PYTHON_THREAD_END_ALLOW;
8887 : }
8888 192 : resultobj = SWIG_From_int((int)(result));
8889 96 : return resultobj;
8890 : fail:
8891 : return NULL;
8892 : }
8893 :
8894 :
8895 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_uid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8896 0 : PyObject *resultobj = 0;
8897 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8898 0 : char *arg2 = (char *) 0 ;
8899 0 : void *argp1 = 0 ;
8900 0 : int res1 = 0 ;
8901 : int res2 ;
8902 0 : char *buf2 = 0 ;
8903 0 : int alloc2 = 0 ;
8904 0 : PyObject * obj0 = 0 ;
8905 0 : PyObject * obj1 = 0 ;
8906 :
8907 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_uid_set",&obj0,&obj1)) SWIG_fail;
8908 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8909 0 : if (!SWIG_IsOK(res1)) {
8910 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_uid_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8911 : }
8912 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8913 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8914 0 : if (!SWIG_IsOK(res2)) {
8915 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_uid_set" "', argument " "2"" of type '" "char *""'");
8916 : }
8917 0 : arg2 = (char *)(buf2);
8918 : {
8919 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8920 0 : if (arg1->uid) free((char*)arg1->uid);
8921 0 : if (arg2) {
8922 0 : size_t size = strlen((const char *)(arg2)) + 1;
8923 0 : arg1->uid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8924 : } else {
8925 0 : arg1->uid = 0;
8926 : }
8927 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8928 : }
8929 0 : resultobj = SWIG_Py_Void();
8930 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8931 : return resultobj;
8932 : fail:
8933 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8934 : return NULL;
8935 : }
8936 :
8937 :
8938 36 : SWIGINTERN PyObject *_wrap__gpgme_user_id_uid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8939 36 : PyObject *resultobj = 0;
8940 36 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8941 36 : void *argp1 = 0 ;
8942 36 : int res1 = 0 ;
8943 36 : PyObject * obj0 = 0 ;
8944 36 : char *result = 0 ;
8945 :
8946 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_uid_get",&obj0)) SWIG_fail;
8947 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8948 36 : if (!SWIG_IsOK(res1)) {
8949 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_uid_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8950 : }
8951 36 : arg1 = (struct _gpgme_user_id *)(argp1);
8952 : {
8953 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8954 36 : result = (char *) ((arg1)->uid);
8955 36 : SWIG_PYTHON_THREAD_END_ALLOW;
8956 : }
8957 36 : resultobj = SWIG_FromCharPtr((const char *)result);
8958 36 : return resultobj;
8959 : fail:
8960 : return NULL;
8961 : }
8962 :
8963 :
8964 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8965 0 : PyObject *resultobj = 0;
8966 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8967 0 : char *arg2 = (char *) 0 ;
8968 0 : void *argp1 = 0 ;
8969 0 : int res1 = 0 ;
8970 : int res2 ;
8971 0 : char *buf2 = 0 ;
8972 0 : int alloc2 = 0 ;
8973 0 : PyObject * obj0 = 0 ;
8974 0 : PyObject * obj1 = 0 ;
8975 :
8976 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_name_set",&obj0,&obj1)) SWIG_fail;
8977 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8978 0 : if (!SWIG_IsOK(res1)) {
8979 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_name_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8980 : }
8981 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8982 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8983 0 : if (!SWIG_IsOK(res2)) {
8984 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_name_set" "', argument " "2"" of type '" "char *""'");
8985 : }
8986 0 : arg2 = (char *)(buf2);
8987 : {
8988 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8989 0 : if (arg1->name) free((char*)arg1->name);
8990 0 : if (arg2) {
8991 0 : size_t size = strlen((const char *)(arg2)) + 1;
8992 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8993 : } else {
8994 0 : arg1->name = 0;
8995 : }
8996 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8997 : }
8998 0 : resultobj = SWIG_Py_Void();
8999 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9000 : return resultobj;
9001 : fail:
9002 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9003 : return NULL;
9004 : }
9005 :
9006 :
9007 264 : SWIGINTERN PyObject *_wrap__gpgme_user_id_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9008 264 : PyObject *resultobj = 0;
9009 264 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9010 264 : void *argp1 = 0 ;
9011 264 : int res1 = 0 ;
9012 264 : PyObject * obj0 = 0 ;
9013 264 : char *result = 0 ;
9014 :
9015 264 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_name_get",&obj0)) SWIG_fail;
9016 264 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9017 264 : if (!SWIG_IsOK(res1)) {
9018 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_name_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9019 : }
9020 264 : arg1 = (struct _gpgme_user_id *)(argp1);
9021 : {
9022 264 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9023 264 : result = (char *) ((arg1)->name);
9024 264 : SWIG_PYTHON_THREAD_END_ALLOW;
9025 : }
9026 264 : resultobj = SWIG_FromCharPtr((const char *)result);
9027 264 : return resultobj;
9028 : fail:
9029 : return NULL;
9030 : }
9031 :
9032 :
9033 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_email_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 0 : PyObject *resultobj = 0;
9035 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9036 0 : char *arg2 = (char *) 0 ;
9037 0 : void *argp1 = 0 ;
9038 0 : int res1 = 0 ;
9039 : int res2 ;
9040 0 : char *buf2 = 0 ;
9041 0 : int alloc2 = 0 ;
9042 0 : PyObject * obj0 = 0 ;
9043 0 : PyObject * obj1 = 0 ;
9044 :
9045 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_email_set",&obj0,&obj1)) SWIG_fail;
9046 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9047 0 : if (!SWIG_IsOK(res1)) {
9048 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_email_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9049 : }
9050 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9051 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9052 0 : if (!SWIG_IsOK(res2)) {
9053 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_email_set" "', argument " "2"" of type '" "char *""'");
9054 : }
9055 0 : arg2 = (char *)(buf2);
9056 : {
9057 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9058 0 : if (arg1->email) free((char*)arg1->email);
9059 0 : if (arg2) {
9060 0 : size_t size = strlen((const char *)(arg2)) + 1;
9061 0 : arg1->email = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9062 : } else {
9063 0 : arg1->email = 0;
9064 : }
9065 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9066 : }
9067 0 : resultobj = SWIG_Py_Void();
9068 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9069 : return resultobj;
9070 : fail:
9071 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9072 : return NULL;
9073 : }
9074 :
9075 :
9076 96 : SWIGINTERN PyObject *_wrap__gpgme_user_id_email_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9077 96 : PyObject *resultobj = 0;
9078 96 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9079 96 : void *argp1 = 0 ;
9080 96 : int res1 = 0 ;
9081 96 : PyObject * obj0 = 0 ;
9082 96 : char *result = 0 ;
9083 :
9084 96 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_email_get",&obj0)) SWIG_fail;
9085 96 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9086 96 : if (!SWIG_IsOK(res1)) {
9087 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_email_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9088 : }
9089 96 : arg1 = (struct _gpgme_user_id *)(argp1);
9090 : {
9091 96 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9092 96 : result = (char *) ((arg1)->email);
9093 96 : SWIG_PYTHON_THREAD_END_ALLOW;
9094 : }
9095 96 : resultobj = SWIG_FromCharPtr((const char *)result);
9096 96 : return resultobj;
9097 : fail:
9098 : return NULL;
9099 : }
9100 :
9101 :
9102 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_comment_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 0 : PyObject *resultobj = 0;
9104 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9105 0 : char *arg2 = (char *) 0 ;
9106 0 : void *argp1 = 0 ;
9107 0 : int res1 = 0 ;
9108 : int res2 ;
9109 0 : char *buf2 = 0 ;
9110 0 : int alloc2 = 0 ;
9111 0 : PyObject * obj0 = 0 ;
9112 0 : PyObject * obj1 = 0 ;
9113 :
9114 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_comment_set",&obj0,&obj1)) SWIG_fail;
9115 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9116 0 : if (!SWIG_IsOK(res1)) {
9117 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_comment_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9118 : }
9119 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9120 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9121 0 : if (!SWIG_IsOK(res2)) {
9122 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_comment_set" "', argument " "2"" of type '" "char *""'");
9123 : }
9124 0 : arg2 = (char *)(buf2);
9125 : {
9126 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9127 0 : if (arg1->comment) free((char*)arg1->comment);
9128 0 : if (arg2) {
9129 0 : size_t size = strlen((const char *)(arg2)) + 1;
9130 0 : arg1->comment = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9131 : } else {
9132 0 : arg1->comment = 0;
9133 : }
9134 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9135 : }
9136 0 : resultobj = SWIG_Py_Void();
9137 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9138 : return resultobj;
9139 : fail:
9140 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9141 : return NULL;
9142 : }
9143 :
9144 :
9145 96 : SWIGINTERN PyObject *_wrap__gpgme_user_id_comment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9146 96 : PyObject *resultobj = 0;
9147 96 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9148 96 : void *argp1 = 0 ;
9149 96 : int res1 = 0 ;
9150 96 : PyObject * obj0 = 0 ;
9151 96 : char *result = 0 ;
9152 :
9153 96 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_comment_get",&obj0)) SWIG_fail;
9154 96 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9155 96 : if (!SWIG_IsOK(res1)) {
9156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_comment_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9157 : }
9158 96 : arg1 = (struct _gpgme_user_id *)(argp1);
9159 : {
9160 96 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9161 96 : result = (char *) ((arg1)->comment);
9162 96 : SWIG_PYTHON_THREAD_END_ALLOW;
9163 : }
9164 96 : resultobj = SWIG_FromCharPtr((const char *)result);
9165 96 : return resultobj;
9166 : fail:
9167 : return NULL;
9168 : }
9169 :
9170 :
9171 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_signatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9172 0 : PyObject *resultobj = 0;
9173 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9174 0 : gpgme_key_sig_t arg2 = (gpgme_key_sig_t) 0 ;
9175 0 : void *argp1 = 0 ;
9176 0 : int res1 = 0 ;
9177 0 : void *argp2 = 0 ;
9178 0 : int res2 = 0 ;
9179 0 : PyObject * obj0 = 0 ;
9180 0 : PyObject * obj1 = 0 ;
9181 :
9182 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_signatures_set",&obj0,&obj1)) SWIG_fail;
9183 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9184 0 : if (!SWIG_IsOK(res1)) {
9185 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_signatures_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9186 : }
9187 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9188 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
9189 0 : if (!SWIG_IsOK(res2)) {
9190 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_signatures_set" "', argument " "2"" of type '" "gpgme_key_sig_t""'");
9191 : }
9192 0 : arg2 = (gpgme_key_sig_t)(argp2);
9193 : {
9194 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9195 0 : if (arg1) (arg1)->signatures = arg2;
9196 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9197 : }
9198 0 : resultobj = SWIG_Py_Void();
9199 0 : return resultobj;
9200 : fail:
9201 : return NULL;
9202 : }
9203 :
9204 :
9205 111 : SWIGINTERN PyObject *_wrap__gpgme_user_id_signatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9206 111 : PyObject *resultobj = 0;
9207 111 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9208 111 : void *argp1 = 0 ;
9209 111 : int res1 = 0 ;
9210 111 : PyObject * obj0 = 0 ;
9211 : gpgme_key_sig_t result;
9212 :
9213 111 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_signatures_get",&obj0)) SWIG_fail;
9214 111 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9215 111 : if (!SWIG_IsOK(res1)) {
9216 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_signatures_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9217 : }
9218 111 : arg1 = (struct _gpgme_user_id *)(argp1);
9219 : {
9220 111 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9221 111 : result = (gpgme_key_sig_t) ((arg1)->signatures);
9222 111 : SWIG_PYTHON_THREAD_END_ALLOW;
9223 : }
9224 : {
9225 : int i;
9226 111 : int size = 0;
9227 : gpgme_key_sig_t curr;
9228 138 : for (curr = result; curr != NULL; curr = curr->next) {
9229 27 : size++;
9230 : }
9231 111 : resultobj = PyList_New(size);
9232 138 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9233 27 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_key_sig, 0 );
9234 27 : PyList_SetItem(resultobj, i, o);
9235 : }
9236 : }
9237 : return resultobj;
9238 : fail:
9239 : return NULL;
9240 : }
9241 :
9242 :
9243 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__last_keysig_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 0 : PyObject *resultobj = 0;
9245 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9246 0 : gpgme_key_sig_t arg2 = (gpgme_key_sig_t) 0 ;
9247 0 : void *argp1 = 0 ;
9248 0 : int res1 = 0 ;
9249 0 : void *argp2 = 0 ;
9250 0 : int res2 = 0 ;
9251 0 : PyObject * obj0 = 0 ;
9252 0 : PyObject * obj1 = 0 ;
9253 :
9254 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id__last_keysig_set",&obj0,&obj1)) SWIG_fail;
9255 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9256 0 : if (!SWIG_IsOK(res1)) {
9257 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__last_keysig_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9258 : }
9259 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9260 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
9261 0 : if (!SWIG_IsOK(res2)) {
9262 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id__last_keysig_set" "', argument " "2"" of type '" "gpgme_key_sig_t""'");
9263 : }
9264 0 : arg2 = (gpgme_key_sig_t)(argp2);
9265 : {
9266 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9267 0 : if (arg1) (arg1)->_last_keysig = arg2;
9268 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9269 : }
9270 0 : resultobj = SWIG_Py_Void();
9271 0 : return resultobj;
9272 : fail:
9273 : return NULL;
9274 : }
9275 :
9276 :
9277 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__last_keysig_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9278 0 : PyObject *resultobj = 0;
9279 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9280 0 : void *argp1 = 0 ;
9281 0 : int res1 = 0 ;
9282 0 : PyObject * obj0 = 0 ;
9283 : gpgme_key_sig_t result;
9284 :
9285 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id__last_keysig_get",&obj0)) SWIG_fail;
9286 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9287 0 : if (!SWIG_IsOK(res1)) {
9288 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__last_keysig_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9289 : }
9290 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9291 : {
9292 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9293 0 : result = (gpgme_key_sig_t) ((arg1)->_last_keysig);
9294 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9295 : }
9296 : {
9297 : int i;
9298 0 : int size = 0;
9299 : gpgme_key_sig_t curr;
9300 0 : for (curr = result; curr != NULL; curr = curr->next) {
9301 0 : size++;
9302 : }
9303 0 : resultobj = PyList_New(size);
9304 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9305 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_key_sig, 0 );
9306 0 : PyList_SetItem(resultobj, i, o);
9307 : }
9308 : }
9309 : return resultobj;
9310 : fail:
9311 : return NULL;
9312 : }
9313 :
9314 :
9315 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_address_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9316 0 : PyObject *resultobj = 0;
9317 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9318 0 : char *arg2 = (char *) 0 ;
9319 0 : void *argp1 = 0 ;
9320 0 : int res1 = 0 ;
9321 : int res2 ;
9322 0 : char *buf2 = 0 ;
9323 0 : int alloc2 = 0 ;
9324 0 : PyObject * obj0 = 0 ;
9325 0 : PyObject * obj1 = 0 ;
9326 :
9327 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_address_set",&obj0,&obj1)) SWIG_fail;
9328 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9329 0 : if (!SWIG_IsOK(res1)) {
9330 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_address_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9331 : }
9332 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9333 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9334 0 : if (!SWIG_IsOK(res2)) {
9335 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_address_set" "', argument " "2"" of type '" "char *""'");
9336 : }
9337 0 : arg2 = (char *)(buf2);
9338 : {
9339 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9340 0 : if (arg1->address) free((char*)arg1->address);
9341 0 : if (arg2) {
9342 0 : size_t size = strlen((const char *)(arg2)) + 1;
9343 0 : arg1->address = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9344 : } else {
9345 0 : arg1->address = 0;
9346 : }
9347 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9348 : }
9349 0 : resultobj = SWIG_Py_Void();
9350 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9351 : return resultobj;
9352 : fail:
9353 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9354 : return NULL;
9355 : }
9356 :
9357 :
9358 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_address_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9359 0 : PyObject *resultobj = 0;
9360 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9361 0 : void *argp1 = 0 ;
9362 0 : int res1 = 0 ;
9363 0 : PyObject * obj0 = 0 ;
9364 0 : char *result = 0 ;
9365 :
9366 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_address_get",&obj0)) SWIG_fail;
9367 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9368 0 : if (!SWIG_IsOK(res1)) {
9369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_address_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9370 : }
9371 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9372 : {
9373 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9374 0 : result = (char *) ((arg1)->address);
9375 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9376 : }
9377 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9378 0 : return resultobj;
9379 : fail:
9380 : return NULL;
9381 : }
9382 :
9383 :
9384 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_tofu_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9385 0 : PyObject *resultobj = 0;
9386 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9387 0 : gpgme_tofu_info_t arg2 = (gpgme_tofu_info_t) 0 ;
9388 0 : void *argp1 = 0 ;
9389 0 : int res1 = 0 ;
9390 0 : void *argp2 = 0 ;
9391 0 : int res2 = 0 ;
9392 0 : PyObject * obj0 = 0 ;
9393 0 : PyObject * obj1 = 0 ;
9394 :
9395 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_tofu_set",&obj0,&obj1)) SWIG_fail;
9396 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9397 0 : if (!SWIG_IsOK(res1)) {
9398 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_tofu_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9399 : }
9400 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9401 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_tofu_info, SWIG_POINTER_DISOWN | 0 );
9402 0 : if (!SWIG_IsOK(res2)) {
9403 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_tofu_set" "', argument " "2"" of type '" "gpgme_tofu_info_t""'");
9404 : }
9405 0 : arg2 = (gpgme_tofu_info_t)(argp2);
9406 : {
9407 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9408 0 : if (arg1) (arg1)->tofu = arg2;
9409 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9410 : }
9411 0 : resultobj = SWIG_Py_Void();
9412 0 : return resultobj;
9413 : fail:
9414 : return NULL;
9415 : }
9416 :
9417 :
9418 4 : SWIGINTERN PyObject *_wrap__gpgme_user_id_tofu_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9419 4 : PyObject *resultobj = 0;
9420 4 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9421 4 : void *argp1 = 0 ;
9422 4 : int res1 = 0 ;
9423 4 : PyObject * obj0 = 0 ;
9424 : gpgme_tofu_info_t result;
9425 :
9426 4 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_tofu_get",&obj0)) SWIG_fail;
9427 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9428 4 : if (!SWIG_IsOK(res1)) {
9429 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_tofu_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9430 : }
9431 4 : arg1 = (struct _gpgme_user_id *)(argp1);
9432 : {
9433 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9434 4 : result = (gpgme_tofu_info_t) ((arg1)->tofu);
9435 4 : SWIG_PYTHON_THREAD_END_ALLOW;
9436 : }
9437 : {
9438 : int i;
9439 4 : int size = 0;
9440 : gpgme_tofu_info_t curr;
9441 8 : for (curr = result; curr != NULL; curr = curr->next) {
9442 4 : size++;
9443 : }
9444 4 : resultobj = PyList_New(size);
9445 8 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9446 4 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_tofu_info, 0 );
9447 4 : PyList_SetItem(resultobj, i, o);
9448 : }
9449 : }
9450 : return resultobj;
9451 : fail:
9452 : return NULL;
9453 : }
9454 :
9455 :
9456 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_last_update_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9457 0 : PyObject *resultobj = 0;
9458 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9459 : unsigned long arg2 ;
9460 0 : void *argp1 = 0 ;
9461 0 : int res1 = 0 ;
9462 : unsigned long val2 ;
9463 0 : int ecode2 = 0 ;
9464 0 : PyObject * obj0 = 0 ;
9465 0 : PyObject * obj1 = 0 ;
9466 :
9467 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_last_update_set",&obj0,&obj1)) SWIG_fail;
9468 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9469 0 : if (!SWIG_IsOK(res1)) {
9470 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_last_update_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9471 : }
9472 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9473 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
9474 0 : if (!SWIG_IsOK(ecode2)) {
9475 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_last_update_set" "', argument " "2"" of type '" "unsigned long""'");
9476 : }
9477 0 : arg2 = (unsigned long)(val2);
9478 : {
9479 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9480 0 : if (arg1) (arg1)->last_update = arg2;
9481 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9482 : }
9483 0 : resultobj = SWIG_Py_Void();
9484 0 : return resultobj;
9485 : fail:
9486 : return NULL;
9487 : }
9488 :
9489 :
9490 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_last_update_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9491 0 : PyObject *resultobj = 0;
9492 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9493 0 : void *argp1 = 0 ;
9494 0 : int res1 = 0 ;
9495 0 : PyObject * obj0 = 0 ;
9496 : unsigned long result;
9497 :
9498 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_last_update_get",&obj0)) SWIG_fail;
9499 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9500 0 : if (!SWIG_IsOK(res1)) {
9501 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_last_update_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9502 : }
9503 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9504 : {
9505 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9506 0 : result = (unsigned long) ((arg1)->last_update);
9507 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9508 : }
9509 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9510 0 : return resultobj;
9511 : fail:
9512 : return NULL;
9513 : }
9514 :
9515 :
9516 0 : SWIGINTERN PyObject *_wrap_new__gpgme_user_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9517 0 : PyObject *resultobj = 0;
9518 0 : struct _gpgme_user_id *result = 0 ;
9519 :
9520 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_user_id")) SWIG_fail;
9521 : {
9522 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9523 0 : result = (struct _gpgme_user_id *)calloc(1, sizeof(struct _gpgme_user_id));
9524 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9525 : }
9526 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_NEW | 0 );
9527 0 : return resultobj;
9528 : fail:
9529 : return NULL;
9530 : }
9531 :
9532 :
9533 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_user_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9534 0 : PyObject *resultobj = 0;
9535 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9536 0 : void *argp1 = 0 ;
9537 0 : int res1 = 0 ;
9538 0 : PyObject * obj0 = 0 ;
9539 :
9540 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_user_id",&obj0)) SWIG_fail;
9541 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
9542 0 : if (!SWIG_IsOK(res1)) {
9543 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_user_id" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9544 : }
9545 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9546 : {
9547 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9548 0 : free((char *) arg1);
9549 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9550 : }
9551 0 : resultobj = SWIG_Py_Void();
9552 0 : return resultobj;
9553 : fail:
9554 : return NULL;
9555 : }
9556 :
9557 :
9558 29 : SWIGINTERN PyObject *_gpgme_user_id_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9559 : PyObject *obj;
9560 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9561 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_user_id, SWIG_NewClientData(obj));
9562 29 : return SWIG_Py_Void();
9563 : }
9564 :
9565 0 : SWIGINTERN PyObject *_wrap__gpgme_key__refs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9566 0 : PyObject *resultobj = 0;
9567 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9568 : unsigned int arg2 ;
9569 0 : void *argp1 = 0 ;
9570 0 : int res1 = 0 ;
9571 : unsigned int val2 ;
9572 0 : int ecode2 = 0 ;
9573 0 : PyObject * obj0 = 0 ;
9574 0 : PyObject * obj1 = 0 ;
9575 :
9576 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key__refs_set",&obj0,&obj1)) SWIG_fail;
9577 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9578 0 : if (!SWIG_IsOK(res1)) {
9579 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__refs_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9580 : }
9581 0 : arg1 = (struct _gpgme_key *)(argp1);
9582 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9583 0 : if (!SWIG_IsOK(ecode2)) {
9584 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key__refs_set" "', argument " "2"" of type '" "unsigned int""'");
9585 : }
9586 0 : arg2 = (unsigned int)(val2);
9587 : {
9588 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9589 0 : if (arg1) (arg1)->_refs = arg2;
9590 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9591 : }
9592 0 : resultobj = SWIG_Py_Void();
9593 0 : return resultobj;
9594 : fail:
9595 : return NULL;
9596 : }
9597 :
9598 :
9599 0 : SWIGINTERN PyObject *_wrap__gpgme_key__refs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9600 0 : PyObject *resultobj = 0;
9601 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9602 0 : void *argp1 = 0 ;
9603 0 : int res1 = 0 ;
9604 0 : PyObject * obj0 = 0 ;
9605 : unsigned int result;
9606 :
9607 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__refs_get",&obj0)) SWIG_fail;
9608 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9609 0 : if (!SWIG_IsOK(res1)) {
9610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__refs_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9611 : }
9612 0 : arg1 = (struct _gpgme_key *)(argp1);
9613 : {
9614 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9615 0 : result = (unsigned int) ((arg1)->_refs);
9616 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9617 : }
9618 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9619 0 : return resultobj;
9620 : fail:
9621 : return NULL;
9622 : }
9623 :
9624 :
9625 0 : SWIGINTERN PyObject *_wrap__gpgme_key_revoked_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9626 0 : PyObject *resultobj = 0;
9627 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9628 : unsigned int arg2 ;
9629 0 : void *argp1 = 0 ;
9630 0 : int res1 = 0 ;
9631 : unsigned int val2 ;
9632 0 : int ecode2 = 0 ;
9633 0 : PyObject * obj0 = 0 ;
9634 0 : PyObject * obj1 = 0 ;
9635 :
9636 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_revoked_set",&obj0,&obj1)) SWIG_fail;
9637 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9638 0 : if (!SWIG_IsOK(res1)) {
9639 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_revoked_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9640 : }
9641 0 : arg1 = (struct _gpgme_key *)(argp1);
9642 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9643 0 : if (!SWIG_IsOK(ecode2)) {
9644 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
9645 : }
9646 0 : arg2 = (unsigned int)(val2);
9647 : {
9648 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9649 0 : if (arg1) (arg1)->revoked = arg2;
9650 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9651 : }
9652 0 : resultobj = SWIG_Py_Void();
9653 0 : return resultobj;
9654 : fail:
9655 : return NULL;
9656 : }
9657 :
9658 :
9659 78 : SWIGINTERN PyObject *_wrap__gpgme_key_revoked_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9660 78 : PyObject *resultobj = 0;
9661 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9662 78 : void *argp1 = 0 ;
9663 78 : int res1 = 0 ;
9664 78 : PyObject * obj0 = 0 ;
9665 : unsigned int result;
9666 :
9667 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_revoked_get",&obj0)) SWIG_fail;
9668 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9669 78 : if (!SWIG_IsOK(res1)) {
9670 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_revoked_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9671 : }
9672 78 : arg1 = (struct _gpgme_key *)(argp1);
9673 : {
9674 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9675 78 : result = (unsigned int) ((arg1)->revoked);
9676 78 : SWIG_PYTHON_THREAD_END_ALLOW;
9677 : }
9678 78 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9679 78 : return resultobj;
9680 : fail:
9681 : return NULL;
9682 : }
9683 :
9684 :
9685 0 : SWIGINTERN PyObject *_wrap__gpgme_key_expired_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9686 0 : PyObject *resultobj = 0;
9687 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9688 : unsigned int arg2 ;
9689 0 : void *argp1 = 0 ;
9690 0 : int res1 = 0 ;
9691 : unsigned int val2 ;
9692 0 : int ecode2 = 0 ;
9693 0 : PyObject * obj0 = 0 ;
9694 0 : PyObject * obj1 = 0 ;
9695 :
9696 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_expired_set",&obj0,&obj1)) SWIG_fail;
9697 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9698 0 : if (!SWIG_IsOK(res1)) {
9699 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_expired_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9700 : }
9701 0 : arg1 = (struct _gpgme_key *)(argp1);
9702 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9703 0 : if (!SWIG_IsOK(ecode2)) {
9704 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_expired_set" "', argument " "2"" of type '" "unsigned int""'");
9705 : }
9706 0 : arg2 = (unsigned int)(val2);
9707 : {
9708 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9709 0 : if (arg1) (arg1)->expired = arg2;
9710 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9711 : }
9712 0 : resultobj = SWIG_Py_Void();
9713 0 : return resultobj;
9714 : fail:
9715 : return NULL;
9716 : }
9717 :
9718 :
9719 78 : SWIGINTERN PyObject *_wrap__gpgme_key_expired_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9720 78 : PyObject *resultobj = 0;
9721 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9722 78 : void *argp1 = 0 ;
9723 78 : int res1 = 0 ;
9724 78 : PyObject * obj0 = 0 ;
9725 : unsigned int result;
9726 :
9727 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_expired_get",&obj0)) SWIG_fail;
9728 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9729 78 : if (!SWIG_IsOK(res1)) {
9730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_expired_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9731 : }
9732 78 : arg1 = (struct _gpgme_key *)(argp1);
9733 : {
9734 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9735 78 : result = (unsigned int) ((arg1)->expired);
9736 78 : SWIG_PYTHON_THREAD_END_ALLOW;
9737 : }
9738 78 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9739 78 : return resultobj;
9740 : fail:
9741 : return NULL;
9742 : }
9743 :
9744 :
9745 0 : SWIGINTERN PyObject *_wrap__gpgme_key_disabled_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 0 : PyObject *resultobj = 0;
9747 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9748 : unsigned int arg2 ;
9749 0 : void *argp1 = 0 ;
9750 0 : int res1 = 0 ;
9751 : unsigned int val2 ;
9752 0 : int ecode2 = 0 ;
9753 0 : PyObject * obj0 = 0 ;
9754 0 : PyObject * obj1 = 0 ;
9755 :
9756 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_disabled_set",&obj0,&obj1)) SWIG_fail;
9757 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9758 0 : if (!SWIG_IsOK(res1)) {
9759 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_disabled_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9760 : }
9761 0 : arg1 = (struct _gpgme_key *)(argp1);
9762 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9763 0 : if (!SWIG_IsOK(ecode2)) {
9764 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_disabled_set" "', argument " "2"" of type '" "unsigned int""'");
9765 : }
9766 0 : arg2 = (unsigned int)(val2);
9767 : {
9768 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9769 0 : if (arg1) (arg1)->disabled = arg2;
9770 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9771 : }
9772 0 : resultobj = SWIG_Py_Void();
9773 0 : return resultobj;
9774 : fail:
9775 : return NULL;
9776 : }
9777 :
9778 :
9779 78 : SWIGINTERN PyObject *_wrap__gpgme_key_disabled_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9780 78 : PyObject *resultobj = 0;
9781 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9782 78 : void *argp1 = 0 ;
9783 78 : int res1 = 0 ;
9784 78 : PyObject * obj0 = 0 ;
9785 : unsigned int result;
9786 :
9787 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_disabled_get",&obj0)) SWIG_fail;
9788 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9789 78 : if (!SWIG_IsOK(res1)) {
9790 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_disabled_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9791 : }
9792 78 : arg1 = (struct _gpgme_key *)(argp1);
9793 : {
9794 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9795 78 : result = (unsigned int) ((arg1)->disabled);
9796 78 : SWIG_PYTHON_THREAD_END_ALLOW;
9797 : }
9798 78 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9799 78 : return resultobj;
9800 : fail:
9801 : return NULL;
9802 : }
9803 :
9804 :
9805 0 : SWIGINTERN PyObject *_wrap__gpgme_key_invalid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9806 0 : PyObject *resultobj = 0;
9807 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9808 : unsigned int arg2 ;
9809 0 : void *argp1 = 0 ;
9810 0 : int res1 = 0 ;
9811 : unsigned int val2 ;
9812 0 : int ecode2 = 0 ;
9813 0 : PyObject * obj0 = 0 ;
9814 0 : PyObject * obj1 = 0 ;
9815 :
9816 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_invalid_set",&obj0,&obj1)) SWIG_fail;
9817 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9818 0 : if (!SWIG_IsOK(res1)) {
9819 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_invalid_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9820 : }
9821 0 : arg1 = (struct _gpgme_key *)(argp1);
9822 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9823 0 : if (!SWIG_IsOK(ecode2)) {
9824 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
9825 : }
9826 0 : arg2 = (unsigned int)(val2);
9827 : {
9828 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9829 0 : if (arg1) (arg1)->invalid = arg2;
9830 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9831 : }
9832 0 : resultobj = SWIG_Py_Void();
9833 0 : return resultobj;
9834 : fail:
9835 : return NULL;
9836 : }
9837 :
9838 :
9839 78 : SWIGINTERN PyObject *_wrap__gpgme_key_invalid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9840 78 : PyObject *resultobj = 0;
9841 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9842 78 : void *argp1 = 0 ;
9843 78 : int res1 = 0 ;
9844 78 : PyObject * obj0 = 0 ;
9845 : unsigned int result;
9846 :
9847 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_invalid_get",&obj0)) SWIG_fail;
9848 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9849 78 : if (!SWIG_IsOK(res1)) {
9850 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_invalid_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9851 : }
9852 78 : arg1 = (struct _gpgme_key *)(argp1);
9853 : {
9854 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9855 78 : result = (unsigned int) ((arg1)->invalid);
9856 78 : SWIG_PYTHON_THREAD_END_ALLOW;
9857 : }
9858 78 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9859 78 : return resultobj;
9860 : fail:
9861 : return NULL;
9862 : }
9863 :
9864 :
9865 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_encrypt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 0 : PyObject *resultobj = 0;
9867 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9868 : unsigned int arg2 ;
9869 0 : void *argp1 = 0 ;
9870 0 : int res1 = 0 ;
9871 : unsigned int val2 ;
9872 0 : int ecode2 = 0 ;
9873 0 : PyObject * obj0 = 0 ;
9874 0 : PyObject * obj1 = 0 ;
9875 :
9876 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_can_encrypt_set",&obj0,&obj1)) SWIG_fail;
9877 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9878 0 : if (!SWIG_IsOK(res1)) {
9879 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_encrypt_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9880 : }
9881 0 : arg1 = (struct _gpgme_key *)(argp1);
9882 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9883 0 : if (!SWIG_IsOK(ecode2)) {
9884 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_encrypt_set" "', argument " "2"" of type '" "unsigned int""'");
9885 : }
9886 0 : arg2 = (unsigned int)(val2);
9887 : {
9888 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9889 0 : if (arg1) (arg1)->can_encrypt = arg2;
9890 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9891 : }
9892 0 : resultobj = SWIG_Py_Void();
9893 0 : return resultobj;
9894 : fail:
9895 : return NULL;
9896 : }
9897 :
9898 :
9899 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_encrypt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9900 0 : PyObject *resultobj = 0;
9901 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9902 0 : void *argp1 = 0 ;
9903 0 : int res1 = 0 ;
9904 0 : PyObject * obj0 = 0 ;
9905 : unsigned int result;
9906 :
9907 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_encrypt_get",&obj0)) SWIG_fail;
9908 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9909 0 : if (!SWIG_IsOK(res1)) {
9910 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_encrypt_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9911 : }
9912 0 : arg1 = (struct _gpgme_key *)(argp1);
9913 : {
9914 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9915 0 : result = (unsigned int) ((arg1)->can_encrypt);
9916 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9917 : }
9918 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9919 0 : return resultobj;
9920 : fail:
9921 : return NULL;
9922 : }
9923 :
9924 :
9925 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_sign_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9926 0 : PyObject *resultobj = 0;
9927 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9928 : unsigned int arg2 ;
9929 0 : void *argp1 = 0 ;
9930 0 : int res1 = 0 ;
9931 : unsigned int val2 ;
9932 0 : int ecode2 = 0 ;
9933 0 : PyObject * obj0 = 0 ;
9934 0 : PyObject * obj1 = 0 ;
9935 :
9936 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_can_sign_set",&obj0,&obj1)) SWIG_fail;
9937 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9938 0 : if (!SWIG_IsOK(res1)) {
9939 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_sign_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9940 : }
9941 0 : arg1 = (struct _gpgme_key *)(argp1);
9942 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9943 0 : if (!SWIG_IsOK(ecode2)) {
9944 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_sign_set" "', argument " "2"" of type '" "unsigned int""'");
9945 : }
9946 0 : arg2 = (unsigned int)(val2);
9947 : {
9948 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9949 0 : if (arg1) (arg1)->can_sign = arg2;
9950 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9951 : }
9952 0 : resultobj = SWIG_Py_Void();
9953 0 : return resultobj;
9954 : fail:
9955 : return NULL;
9956 : }
9957 :
9958 :
9959 78 : SWIGINTERN PyObject *_wrap__gpgme_key_can_sign_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9960 78 : PyObject *resultobj = 0;
9961 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9962 78 : void *argp1 = 0 ;
9963 78 : int res1 = 0 ;
9964 78 : PyObject * obj0 = 0 ;
9965 : unsigned int result;
9966 :
9967 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_sign_get",&obj0)) SWIG_fail;
9968 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9969 78 : if (!SWIG_IsOK(res1)) {
9970 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_sign_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9971 : }
9972 78 : arg1 = (struct _gpgme_key *)(argp1);
9973 : {
9974 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9975 78 : result = (unsigned int) ((arg1)->can_sign);
9976 78 : SWIG_PYTHON_THREAD_END_ALLOW;
9977 : }
9978 78 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9979 78 : return resultobj;
9980 : fail:
9981 : return NULL;
9982 : }
9983 :
9984 :
9985 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_certify_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9986 0 : PyObject *resultobj = 0;
9987 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9988 : unsigned int arg2 ;
9989 0 : void *argp1 = 0 ;
9990 0 : int res1 = 0 ;
9991 : unsigned int val2 ;
9992 0 : int ecode2 = 0 ;
9993 0 : PyObject * obj0 = 0 ;
9994 0 : PyObject * obj1 = 0 ;
9995 :
9996 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_can_certify_set",&obj0,&obj1)) SWIG_fail;
9997 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9998 0 : if (!SWIG_IsOK(res1)) {
9999 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_certify_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10000 : }
10001 0 : arg1 = (struct _gpgme_key *)(argp1);
10002 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10003 0 : if (!SWIG_IsOK(ecode2)) {
10004 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_certify_set" "', argument " "2"" of type '" "unsigned int""'");
10005 : }
10006 0 : arg2 = (unsigned int)(val2);
10007 : {
10008 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10009 0 : if (arg1) (arg1)->can_certify = arg2;
10010 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10011 : }
10012 0 : resultobj = SWIG_Py_Void();
10013 0 : return resultobj;
10014 : fail:
10015 : return NULL;
10016 : }
10017 :
10018 :
10019 78 : SWIGINTERN PyObject *_wrap__gpgme_key_can_certify_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10020 78 : PyObject *resultobj = 0;
10021 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10022 78 : void *argp1 = 0 ;
10023 78 : int res1 = 0 ;
10024 78 : PyObject * obj0 = 0 ;
10025 : unsigned int result;
10026 :
10027 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_certify_get",&obj0)) SWIG_fail;
10028 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10029 78 : if (!SWIG_IsOK(res1)) {
10030 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_certify_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10031 : }
10032 78 : arg1 = (struct _gpgme_key *)(argp1);
10033 : {
10034 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10035 78 : result = (unsigned int) ((arg1)->can_certify);
10036 78 : SWIG_PYTHON_THREAD_END_ALLOW;
10037 : }
10038 78 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10039 78 : return resultobj;
10040 : fail:
10041 : return NULL;
10042 : }
10043 :
10044 :
10045 0 : SWIGINTERN PyObject *_wrap__gpgme_key_secret_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10046 0 : PyObject *resultobj = 0;
10047 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10048 : unsigned int arg2 ;
10049 0 : void *argp1 = 0 ;
10050 0 : int res1 = 0 ;
10051 : unsigned int val2 ;
10052 0 : int ecode2 = 0 ;
10053 0 : PyObject * obj0 = 0 ;
10054 0 : PyObject * obj1 = 0 ;
10055 :
10056 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_secret_set",&obj0,&obj1)) SWIG_fail;
10057 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10058 0 : if (!SWIG_IsOK(res1)) {
10059 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_secret_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10060 : }
10061 0 : arg1 = (struct _gpgme_key *)(argp1);
10062 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10063 0 : if (!SWIG_IsOK(ecode2)) {
10064 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_secret_set" "', argument " "2"" of type '" "unsigned int""'");
10065 : }
10066 0 : arg2 = (unsigned int)(val2);
10067 : {
10068 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10069 0 : if (arg1) (arg1)->secret = arg2;
10070 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10071 : }
10072 0 : resultobj = SWIG_Py_Void();
10073 0 : return resultobj;
10074 : fail:
10075 : return NULL;
10076 : }
10077 :
10078 :
10079 78 : SWIGINTERN PyObject *_wrap__gpgme_key_secret_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10080 78 : PyObject *resultobj = 0;
10081 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10082 78 : void *argp1 = 0 ;
10083 78 : int res1 = 0 ;
10084 78 : PyObject * obj0 = 0 ;
10085 : unsigned int result;
10086 :
10087 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_secret_get",&obj0)) SWIG_fail;
10088 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10089 78 : if (!SWIG_IsOK(res1)) {
10090 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_secret_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10091 : }
10092 78 : arg1 = (struct _gpgme_key *)(argp1);
10093 : {
10094 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10095 78 : result = (unsigned int) ((arg1)->secret);
10096 78 : SWIG_PYTHON_THREAD_END_ALLOW;
10097 : }
10098 78 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10099 78 : return resultobj;
10100 : fail:
10101 : return NULL;
10102 : }
10103 :
10104 :
10105 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_authenticate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10106 0 : PyObject *resultobj = 0;
10107 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10108 : unsigned int arg2 ;
10109 0 : void *argp1 = 0 ;
10110 0 : int res1 = 0 ;
10111 : unsigned int val2 ;
10112 0 : int ecode2 = 0 ;
10113 0 : PyObject * obj0 = 0 ;
10114 0 : PyObject * obj1 = 0 ;
10115 :
10116 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_can_authenticate_set",&obj0,&obj1)) SWIG_fail;
10117 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10118 0 : if (!SWIG_IsOK(res1)) {
10119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_authenticate_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10120 : }
10121 0 : arg1 = (struct _gpgme_key *)(argp1);
10122 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10123 0 : if (!SWIG_IsOK(ecode2)) {
10124 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_authenticate_set" "', argument " "2"" of type '" "unsigned int""'");
10125 : }
10126 0 : arg2 = (unsigned int)(val2);
10127 : {
10128 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10129 0 : if (arg1) (arg1)->can_authenticate = arg2;
10130 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10131 : }
10132 0 : resultobj = SWIG_Py_Void();
10133 0 : return resultobj;
10134 : fail:
10135 : return NULL;
10136 : }
10137 :
10138 :
10139 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_authenticate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10140 0 : PyObject *resultobj = 0;
10141 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10142 0 : void *argp1 = 0 ;
10143 0 : int res1 = 0 ;
10144 0 : PyObject * obj0 = 0 ;
10145 : unsigned int result;
10146 :
10147 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_authenticate_get",&obj0)) SWIG_fail;
10148 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10149 0 : if (!SWIG_IsOK(res1)) {
10150 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_authenticate_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10151 : }
10152 0 : arg1 = (struct _gpgme_key *)(argp1);
10153 : {
10154 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10155 0 : result = (unsigned int) ((arg1)->can_authenticate);
10156 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10157 : }
10158 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10159 0 : return resultobj;
10160 : fail:
10161 : return NULL;
10162 : }
10163 :
10164 :
10165 0 : SWIGINTERN PyObject *_wrap__gpgme_key_is_qualified_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10166 0 : PyObject *resultobj = 0;
10167 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10168 : unsigned int arg2 ;
10169 0 : void *argp1 = 0 ;
10170 0 : int res1 = 0 ;
10171 : unsigned int val2 ;
10172 0 : int ecode2 = 0 ;
10173 0 : PyObject * obj0 = 0 ;
10174 0 : PyObject * obj1 = 0 ;
10175 :
10176 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_is_qualified_set",&obj0,&obj1)) SWIG_fail;
10177 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10178 0 : if (!SWIG_IsOK(res1)) {
10179 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_is_qualified_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10180 : }
10181 0 : arg1 = (struct _gpgme_key *)(argp1);
10182 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10183 0 : if (!SWIG_IsOK(ecode2)) {
10184 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_is_qualified_set" "', argument " "2"" of type '" "unsigned int""'");
10185 : }
10186 0 : arg2 = (unsigned int)(val2);
10187 : {
10188 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10189 0 : if (arg1) (arg1)->is_qualified = arg2;
10190 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10191 : }
10192 0 : resultobj = SWIG_Py_Void();
10193 0 : return resultobj;
10194 : fail:
10195 : return NULL;
10196 : }
10197 :
10198 :
10199 0 : SWIGINTERN PyObject *_wrap__gpgme_key_is_qualified_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10200 0 : PyObject *resultobj = 0;
10201 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10202 0 : void *argp1 = 0 ;
10203 0 : int res1 = 0 ;
10204 0 : PyObject * obj0 = 0 ;
10205 : unsigned int result;
10206 :
10207 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_is_qualified_get",&obj0)) SWIG_fail;
10208 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10209 0 : if (!SWIG_IsOK(res1)) {
10210 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_is_qualified_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10211 : }
10212 0 : arg1 = (struct _gpgme_key *)(argp1);
10213 : {
10214 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10215 0 : result = (unsigned int) ((arg1)->is_qualified);
10216 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10217 : }
10218 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10219 0 : return resultobj;
10220 : fail:
10221 : return NULL;
10222 : }
10223 :
10224 :
10225 0 : SWIGINTERN PyObject *_wrap__gpgme_key__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10226 0 : PyObject *resultobj = 0;
10227 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10228 : unsigned int arg2 ;
10229 0 : void *argp1 = 0 ;
10230 0 : int res1 = 0 ;
10231 : unsigned int val2 ;
10232 0 : int ecode2 = 0 ;
10233 0 : PyObject * obj0 = 0 ;
10234 0 : PyObject * obj1 = 0 ;
10235 :
10236 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key__unused_set",&obj0,&obj1)) SWIG_fail;
10237 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10238 0 : if (!SWIG_IsOK(res1)) {
10239 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__unused_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10240 : }
10241 0 : arg1 = (struct _gpgme_key *)(argp1);
10242 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10243 0 : if (!SWIG_IsOK(ecode2)) {
10244 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key__unused_set" "', argument " "2"" of type '" "unsigned int""'");
10245 : }
10246 0 : arg2 = (unsigned int)(val2);
10247 : {
10248 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10249 0 : if (arg1) (arg1)->_unused = arg2;
10250 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10251 : }
10252 0 : resultobj = SWIG_Py_Void();
10253 0 : return resultobj;
10254 : fail:
10255 : return NULL;
10256 : }
10257 :
10258 :
10259 0 : SWIGINTERN PyObject *_wrap__gpgme_key__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10260 0 : PyObject *resultobj = 0;
10261 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10262 0 : void *argp1 = 0 ;
10263 0 : int res1 = 0 ;
10264 0 : PyObject * obj0 = 0 ;
10265 : unsigned int result;
10266 :
10267 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__unused_get",&obj0)) SWIG_fail;
10268 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10269 0 : if (!SWIG_IsOK(res1)) {
10270 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__unused_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10271 : }
10272 0 : arg1 = (struct _gpgme_key *)(argp1);
10273 : {
10274 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10275 0 : result = (unsigned int) ((arg1)->_unused);
10276 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10277 : }
10278 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10279 0 : return resultobj;
10280 : fail:
10281 : return NULL;
10282 : }
10283 :
10284 :
10285 0 : SWIGINTERN PyObject *_wrap__gpgme_key_origin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10286 0 : PyObject *resultobj = 0;
10287 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10288 : unsigned int arg2 ;
10289 0 : void *argp1 = 0 ;
10290 0 : int res1 = 0 ;
10291 : unsigned int val2 ;
10292 0 : int ecode2 = 0 ;
10293 0 : PyObject * obj0 = 0 ;
10294 0 : PyObject * obj1 = 0 ;
10295 :
10296 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_origin_set",&obj0,&obj1)) SWIG_fail;
10297 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10298 0 : if (!SWIG_IsOK(res1)) {
10299 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_origin_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10300 : }
10301 0 : arg1 = (struct _gpgme_key *)(argp1);
10302 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10303 0 : if (!SWIG_IsOK(ecode2)) {
10304 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_origin_set" "', argument " "2"" of type '" "unsigned int""'");
10305 : }
10306 0 : arg2 = (unsigned int)(val2);
10307 : {
10308 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10309 0 : if (arg1) (arg1)->origin = arg2;
10310 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10311 : }
10312 0 : resultobj = SWIG_Py_Void();
10313 0 : return resultobj;
10314 : fail:
10315 : return NULL;
10316 : }
10317 :
10318 :
10319 0 : SWIGINTERN PyObject *_wrap__gpgme_key_origin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10320 0 : PyObject *resultobj = 0;
10321 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10322 0 : void *argp1 = 0 ;
10323 0 : int res1 = 0 ;
10324 0 : PyObject * obj0 = 0 ;
10325 : unsigned int result;
10326 :
10327 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_origin_get",&obj0)) SWIG_fail;
10328 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10329 0 : if (!SWIG_IsOK(res1)) {
10330 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_origin_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10331 : }
10332 0 : arg1 = (struct _gpgme_key *)(argp1);
10333 : {
10334 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10335 0 : result = (unsigned int) ((arg1)->origin);
10336 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10337 : }
10338 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10339 0 : return resultobj;
10340 : fail:
10341 : return NULL;
10342 : }
10343 :
10344 :
10345 0 : SWIGINTERN PyObject *_wrap__gpgme_key_protocol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10346 0 : PyObject *resultobj = 0;
10347 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10348 : gpgme_protocol_t arg2 ;
10349 0 : void *argp1 = 0 ;
10350 0 : int res1 = 0 ;
10351 : int val2 ;
10352 0 : int ecode2 = 0 ;
10353 0 : PyObject * obj0 = 0 ;
10354 0 : PyObject * obj1 = 0 ;
10355 :
10356 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_protocol_set",&obj0,&obj1)) SWIG_fail;
10357 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10358 0 : if (!SWIG_IsOK(res1)) {
10359 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_protocol_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10360 : }
10361 0 : arg1 = (struct _gpgme_key *)(argp1);
10362 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10363 0 : if (!SWIG_IsOK(ecode2)) {
10364 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_protocol_set" "', argument " "2"" of type '" "gpgme_protocol_t""'");
10365 : }
10366 0 : arg2 = (gpgme_protocol_t)(val2);
10367 : {
10368 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10369 0 : if (arg1) (arg1)->protocol = arg2;
10370 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10371 : }
10372 0 : resultobj = SWIG_Py_Void();
10373 0 : return resultobj;
10374 : fail:
10375 : return NULL;
10376 : }
10377 :
10378 :
10379 78 : SWIGINTERN PyObject *_wrap__gpgme_key_protocol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10380 78 : PyObject *resultobj = 0;
10381 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10382 78 : void *argp1 = 0 ;
10383 78 : int res1 = 0 ;
10384 78 : PyObject * obj0 = 0 ;
10385 : gpgme_protocol_t result;
10386 :
10387 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_protocol_get",&obj0)) SWIG_fail;
10388 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10389 78 : if (!SWIG_IsOK(res1)) {
10390 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_protocol_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10391 : }
10392 78 : arg1 = (struct _gpgme_key *)(argp1);
10393 : {
10394 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10395 78 : result = (gpgme_protocol_t) ((arg1)->protocol);
10396 78 : SWIG_PYTHON_THREAD_END_ALLOW;
10397 : }
10398 156 : resultobj = SWIG_From_int((int)(result));
10399 78 : return resultobj;
10400 : fail:
10401 : return NULL;
10402 : }
10403 :
10404 :
10405 0 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_serial_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10406 0 : PyObject *resultobj = 0;
10407 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10408 0 : char *arg2 = (char *) 0 ;
10409 0 : void *argp1 = 0 ;
10410 0 : int res1 = 0 ;
10411 : int res2 ;
10412 0 : char *buf2 = 0 ;
10413 0 : int alloc2 = 0 ;
10414 0 : PyObject * obj0 = 0 ;
10415 0 : PyObject * obj1 = 0 ;
10416 :
10417 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_issuer_serial_set",&obj0,&obj1)) SWIG_fail;
10418 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10419 0 : if (!SWIG_IsOK(res1)) {
10420 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_serial_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10421 : }
10422 0 : arg1 = (struct _gpgme_key *)(argp1);
10423 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10424 0 : if (!SWIG_IsOK(res2)) {
10425 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_issuer_serial_set" "', argument " "2"" of type '" "char *""'");
10426 : }
10427 0 : arg2 = (char *)(buf2);
10428 : {
10429 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10430 0 : if (arg1->issuer_serial) free((char*)arg1->issuer_serial);
10431 0 : if (arg2) {
10432 0 : size_t size = strlen((const char *)(arg2)) + 1;
10433 0 : arg1->issuer_serial = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
10434 : } else {
10435 0 : arg1->issuer_serial = 0;
10436 : }
10437 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10438 : }
10439 0 : resultobj = SWIG_Py_Void();
10440 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10441 : return resultobj;
10442 : fail:
10443 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10444 : return NULL;
10445 : }
10446 :
10447 :
10448 78 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_serial_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10449 78 : PyObject *resultobj = 0;
10450 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10451 78 : void *argp1 = 0 ;
10452 78 : int res1 = 0 ;
10453 78 : PyObject * obj0 = 0 ;
10454 78 : char *result = 0 ;
10455 :
10456 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_issuer_serial_get",&obj0)) SWIG_fail;
10457 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10458 78 : if (!SWIG_IsOK(res1)) {
10459 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_serial_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10460 : }
10461 78 : arg1 = (struct _gpgme_key *)(argp1);
10462 : {
10463 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10464 78 : result = (char *) ((arg1)->issuer_serial);
10465 78 : SWIG_PYTHON_THREAD_END_ALLOW;
10466 : }
10467 78 : resultobj = SWIG_FromCharPtr((const char *)result);
10468 78 : return resultobj;
10469 : fail:
10470 : return NULL;
10471 : }
10472 :
10473 :
10474 0 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10475 0 : PyObject *resultobj = 0;
10476 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10477 0 : char *arg2 = (char *) 0 ;
10478 0 : void *argp1 = 0 ;
10479 0 : int res1 = 0 ;
10480 : int res2 ;
10481 0 : char *buf2 = 0 ;
10482 0 : int alloc2 = 0 ;
10483 0 : PyObject * obj0 = 0 ;
10484 0 : PyObject * obj1 = 0 ;
10485 :
10486 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_issuer_name_set",&obj0,&obj1)) SWIG_fail;
10487 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10488 0 : if (!SWIG_IsOK(res1)) {
10489 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_name_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10490 : }
10491 0 : arg1 = (struct _gpgme_key *)(argp1);
10492 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10493 0 : if (!SWIG_IsOK(res2)) {
10494 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_issuer_name_set" "', argument " "2"" of type '" "char *""'");
10495 : }
10496 0 : arg2 = (char *)(buf2);
10497 : {
10498 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10499 0 : if (arg1->issuer_name) free((char*)arg1->issuer_name);
10500 0 : if (arg2) {
10501 0 : size_t size = strlen((const char *)(arg2)) + 1;
10502 0 : arg1->issuer_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
10503 : } else {
10504 0 : arg1->issuer_name = 0;
10505 : }
10506 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10507 : }
10508 0 : resultobj = SWIG_Py_Void();
10509 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10510 : return resultobj;
10511 : fail:
10512 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10513 : return NULL;
10514 : }
10515 :
10516 :
10517 78 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10518 78 : PyObject *resultobj = 0;
10519 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10520 78 : void *argp1 = 0 ;
10521 78 : int res1 = 0 ;
10522 78 : PyObject * obj0 = 0 ;
10523 78 : char *result = 0 ;
10524 :
10525 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_issuer_name_get",&obj0)) SWIG_fail;
10526 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10527 78 : if (!SWIG_IsOK(res1)) {
10528 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_name_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10529 : }
10530 78 : arg1 = (struct _gpgme_key *)(argp1);
10531 : {
10532 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10533 78 : result = (char *) ((arg1)->issuer_name);
10534 78 : SWIG_PYTHON_THREAD_END_ALLOW;
10535 : }
10536 78 : resultobj = SWIG_FromCharPtr((const char *)result);
10537 78 : return resultobj;
10538 : fail:
10539 : return NULL;
10540 : }
10541 :
10542 :
10543 0 : SWIGINTERN PyObject *_wrap__gpgme_key_chain_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10544 0 : PyObject *resultobj = 0;
10545 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10546 0 : char *arg2 = (char *) 0 ;
10547 0 : void *argp1 = 0 ;
10548 0 : int res1 = 0 ;
10549 : int res2 ;
10550 0 : char *buf2 = 0 ;
10551 0 : int alloc2 = 0 ;
10552 0 : PyObject * obj0 = 0 ;
10553 0 : PyObject * obj1 = 0 ;
10554 :
10555 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_chain_id_set",&obj0,&obj1)) SWIG_fail;
10556 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10557 0 : if (!SWIG_IsOK(res1)) {
10558 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_chain_id_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10559 : }
10560 0 : arg1 = (struct _gpgme_key *)(argp1);
10561 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10562 0 : if (!SWIG_IsOK(res2)) {
10563 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_chain_id_set" "', argument " "2"" of type '" "char *""'");
10564 : }
10565 0 : arg2 = (char *)(buf2);
10566 : {
10567 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10568 0 : if (arg1->chain_id) free((char*)arg1->chain_id);
10569 0 : if (arg2) {
10570 0 : size_t size = strlen((const char *)(arg2)) + 1;
10571 0 : arg1->chain_id = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
10572 : } else {
10573 0 : arg1->chain_id = 0;
10574 : }
10575 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10576 : }
10577 0 : resultobj = SWIG_Py_Void();
10578 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10579 : return resultobj;
10580 : fail:
10581 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10582 : return NULL;
10583 : }
10584 :
10585 :
10586 78 : SWIGINTERN PyObject *_wrap__gpgme_key_chain_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10587 78 : PyObject *resultobj = 0;
10588 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10589 78 : void *argp1 = 0 ;
10590 78 : int res1 = 0 ;
10591 78 : PyObject * obj0 = 0 ;
10592 78 : char *result = 0 ;
10593 :
10594 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_chain_id_get",&obj0)) SWIG_fail;
10595 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10596 78 : if (!SWIG_IsOK(res1)) {
10597 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_chain_id_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10598 : }
10599 78 : arg1 = (struct _gpgme_key *)(argp1);
10600 : {
10601 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10602 78 : result = (char *) ((arg1)->chain_id);
10603 78 : SWIG_PYTHON_THREAD_END_ALLOW;
10604 : }
10605 78 : resultobj = SWIG_FromCharPtr((const char *)result);
10606 78 : return resultobj;
10607 : fail:
10608 : return NULL;
10609 : }
10610 :
10611 :
10612 0 : SWIGINTERN PyObject *_wrap__gpgme_key_owner_trust_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10613 0 : PyObject *resultobj = 0;
10614 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10615 : gpgme_validity_t arg2 ;
10616 0 : void *argp1 = 0 ;
10617 0 : int res1 = 0 ;
10618 : int val2 ;
10619 0 : int ecode2 = 0 ;
10620 0 : PyObject * obj0 = 0 ;
10621 0 : PyObject * obj1 = 0 ;
10622 :
10623 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_owner_trust_set",&obj0,&obj1)) SWIG_fail;
10624 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10625 0 : if (!SWIG_IsOK(res1)) {
10626 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10627 : }
10628 0 : arg1 = (struct _gpgme_key *)(argp1);
10629 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10630 0 : if (!SWIG_IsOK(ecode2)) {
10631 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_owner_trust_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
10632 : }
10633 0 : arg2 = (gpgme_validity_t)(val2);
10634 : {
10635 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10636 0 : if (arg1) (arg1)->owner_trust = arg2;
10637 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10638 : }
10639 0 : resultobj = SWIG_Py_Void();
10640 0 : return resultobj;
10641 : fail:
10642 : return NULL;
10643 : }
10644 :
10645 :
10646 78 : SWIGINTERN PyObject *_wrap__gpgme_key_owner_trust_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10647 78 : PyObject *resultobj = 0;
10648 78 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10649 78 : void *argp1 = 0 ;
10650 78 : int res1 = 0 ;
10651 78 : PyObject * obj0 = 0 ;
10652 : gpgme_validity_t result;
10653 :
10654 78 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_owner_trust_get",&obj0)) SWIG_fail;
10655 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10656 78 : if (!SWIG_IsOK(res1)) {
10657 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10658 : }
10659 78 : arg1 = (struct _gpgme_key *)(argp1);
10660 : {
10661 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10662 78 : result = (gpgme_validity_t) ((arg1)->owner_trust);
10663 78 : SWIG_PYTHON_THREAD_END_ALLOW;
10664 : }
10665 156 : resultobj = SWIG_From_int((int)(result));
10666 78 : return resultobj;
10667 : fail:
10668 : return NULL;
10669 : }
10670 :
10671 :
10672 0 : SWIGINTERN PyObject *_wrap__gpgme_key_subkeys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10673 0 : PyObject *resultobj = 0;
10674 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10675 0 : gpgme_subkey_t arg2 = (gpgme_subkey_t) 0 ;
10676 0 : void *argp1 = 0 ;
10677 0 : int res1 = 0 ;
10678 0 : void *argp2 = 0 ;
10679 0 : int res2 = 0 ;
10680 0 : PyObject * obj0 = 0 ;
10681 0 : PyObject * obj1 = 0 ;
10682 :
10683 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_subkeys_set",&obj0,&obj1)) SWIG_fail;
10684 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10685 0 : if (!SWIG_IsOK(res1)) {
10686 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_subkeys_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10687 : }
10688 0 : arg1 = (struct _gpgme_key *)(argp1);
10689 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
10690 0 : if (!SWIG_IsOK(res2)) {
10691 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_subkeys_set" "', argument " "2"" of type '" "gpgme_subkey_t""'");
10692 : }
10693 0 : arg2 = (gpgme_subkey_t)(argp2);
10694 : {
10695 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10696 0 : if (arg1) (arg1)->subkeys = arg2;
10697 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10698 : }
10699 0 : resultobj = SWIG_Py_Void();
10700 0 : return resultobj;
10701 : fail:
10702 : return NULL;
10703 : }
10704 :
10705 :
10706 284 : SWIGINTERN PyObject *_wrap__gpgme_key_subkeys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10707 284 : PyObject *resultobj = 0;
10708 284 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10709 284 : void *argp1 = 0 ;
10710 284 : int res1 = 0 ;
10711 284 : PyObject * obj0 = 0 ;
10712 : gpgme_subkey_t result;
10713 :
10714 284 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_subkeys_get",&obj0)) SWIG_fail;
10715 284 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10716 284 : if (!SWIG_IsOK(res1)) {
10717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_subkeys_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10718 : }
10719 284 : arg1 = (struct _gpgme_key *)(argp1);
10720 : {
10721 284 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10722 284 : result = (gpgme_subkey_t) ((arg1)->subkeys);
10723 284 : SWIG_PYTHON_THREAD_END_ALLOW;
10724 : }
10725 : {
10726 : int i;
10727 284 : int size = 0;
10728 : gpgme_subkey_t curr;
10729 916 : for (curr = result; curr != NULL; curr = curr->next) {
10730 632 : size++;
10731 : }
10732 284 : resultobj = PyList_New(size);
10733 916 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10734 632 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_subkey, 0 );
10735 632 : PyList_SetItem(resultobj, i, o);
10736 : }
10737 : }
10738 : return resultobj;
10739 : fail:
10740 : return NULL;
10741 : }
10742 :
10743 :
10744 0 : SWIGINTERN PyObject *_wrap__gpgme_key_uids_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10745 0 : PyObject *resultobj = 0;
10746 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10747 0 : gpgme_user_id_t arg2 = (gpgme_user_id_t) 0 ;
10748 0 : void *argp1 = 0 ;
10749 0 : int res1 = 0 ;
10750 0 : void *argp2 = 0 ;
10751 0 : int res2 = 0 ;
10752 0 : PyObject * obj0 = 0 ;
10753 0 : PyObject * obj1 = 0 ;
10754 :
10755 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_uids_set",&obj0,&obj1)) SWIG_fail;
10756 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10757 0 : if (!SWIG_IsOK(res1)) {
10758 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_uids_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10759 : }
10760 0 : arg1 = (struct _gpgme_key *)(argp1);
10761 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
10762 0 : if (!SWIG_IsOK(res2)) {
10763 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_uids_set" "', argument " "2"" of type '" "gpgme_user_id_t""'");
10764 : }
10765 0 : arg2 = (gpgme_user_id_t)(argp2);
10766 : {
10767 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10768 0 : if (arg1) (arg1)->uids = arg2;
10769 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10770 : }
10771 0 : resultobj = SWIG_Py_Void();
10772 0 : return resultobj;
10773 : fail:
10774 : return NULL;
10775 : }
10776 :
10777 :
10778 455 : SWIGINTERN PyObject *_wrap__gpgme_key_uids_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779 455 : PyObject *resultobj = 0;
10780 455 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10781 455 : void *argp1 = 0 ;
10782 455 : int res1 = 0 ;
10783 455 : PyObject * obj0 = 0 ;
10784 : gpgme_user_id_t result;
10785 :
10786 455 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_uids_get",&obj0)) SWIG_fail;
10787 455 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10788 455 : if (!SWIG_IsOK(res1)) {
10789 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_uids_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10790 : }
10791 455 : arg1 = (struct _gpgme_key *)(argp1);
10792 : {
10793 455 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10794 455 : result = (gpgme_user_id_t) ((arg1)->uids);
10795 455 : SWIG_PYTHON_THREAD_END_ALLOW;
10796 : }
10797 : {
10798 : int i;
10799 455 : int size = 0;
10800 : gpgme_user_id_t curr;
10801 1055 : for (curr = result; curr != NULL; curr = curr->next) {
10802 600 : size++;
10803 : }
10804 455 : resultobj = PyList_New(size);
10805 1055 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10806 600 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_user_id, 0 );
10807 600 : PyList_SetItem(resultobj, i, o);
10808 : }
10809 : }
10810 : return resultobj;
10811 : fail:
10812 : return NULL;
10813 : }
10814 :
10815 :
10816 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_subkey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10817 0 : PyObject *resultobj = 0;
10818 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10819 0 : gpgme_subkey_t arg2 = (gpgme_subkey_t) 0 ;
10820 0 : void *argp1 = 0 ;
10821 0 : int res1 = 0 ;
10822 0 : void *argp2 = 0 ;
10823 0 : int res2 = 0 ;
10824 0 : PyObject * obj0 = 0 ;
10825 0 : PyObject * obj1 = 0 ;
10826 :
10827 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key__last_subkey_set",&obj0,&obj1)) SWIG_fail;
10828 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10829 0 : if (!SWIG_IsOK(res1)) {
10830 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_subkey_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10831 : }
10832 0 : arg1 = (struct _gpgme_key *)(argp1);
10833 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
10834 0 : if (!SWIG_IsOK(res2)) {
10835 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key__last_subkey_set" "', argument " "2"" of type '" "gpgme_subkey_t""'");
10836 : }
10837 0 : arg2 = (gpgme_subkey_t)(argp2);
10838 : {
10839 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10840 0 : if (arg1) (arg1)->_last_subkey = arg2;
10841 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10842 : }
10843 0 : resultobj = SWIG_Py_Void();
10844 0 : return resultobj;
10845 : fail:
10846 : return NULL;
10847 : }
10848 :
10849 :
10850 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_subkey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10851 0 : PyObject *resultobj = 0;
10852 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10853 0 : void *argp1 = 0 ;
10854 0 : int res1 = 0 ;
10855 0 : PyObject * obj0 = 0 ;
10856 : gpgme_subkey_t result;
10857 :
10858 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__last_subkey_get",&obj0)) SWIG_fail;
10859 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10860 0 : if (!SWIG_IsOK(res1)) {
10861 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_subkey_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10862 : }
10863 0 : arg1 = (struct _gpgme_key *)(argp1);
10864 : {
10865 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10866 0 : result = (gpgme_subkey_t) ((arg1)->_last_subkey);
10867 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10868 : }
10869 : {
10870 : int i;
10871 0 : int size = 0;
10872 : gpgme_subkey_t curr;
10873 0 : for (curr = result; curr != NULL; curr = curr->next) {
10874 0 : size++;
10875 : }
10876 0 : resultobj = PyList_New(size);
10877 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10878 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_subkey, 0 );
10879 0 : PyList_SetItem(resultobj, i, o);
10880 : }
10881 : }
10882 : return resultobj;
10883 : fail:
10884 : return NULL;
10885 : }
10886 :
10887 :
10888 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_uid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10889 0 : PyObject *resultobj = 0;
10890 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10891 0 : gpgme_user_id_t arg2 = (gpgme_user_id_t) 0 ;
10892 0 : void *argp1 = 0 ;
10893 0 : int res1 = 0 ;
10894 0 : void *argp2 = 0 ;
10895 0 : int res2 = 0 ;
10896 0 : PyObject * obj0 = 0 ;
10897 0 : PyObject * obj1 = 0 ;
10898 :
10899 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key__last_uid_set",&obj0,&obj1)) SWIG_fail;
10900 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10901 0 : if (!SWIG_IsOK(res1)) {
10902 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_uid_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10903 : }
10904 0 : arg1 = (struct _gpgme_key *)(argp1);
10905 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
10906 0 : if (!SWIG_IsOK(res2)) {
10907 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key__last_uid_set" "', argument " "2"" of type '" "gpgme_user_id_t""'");
10908 : }
10909 0 : arg2 = (gpgme_user_id_t)(argp2);
10910 : {
10911 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10912 0 : if (arg1) (arg1)->_last_uid = arg2;
10913 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10914 : }
10915 0 : resultobj = SWIG_Py_Void();
10916 0 : return resultobj;
10917 : fail:
10918 : return NULL;
10919 : }
10920 :
10921 :
10922 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_uid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10923 0 : PyObject *resultobj = 0;
10924 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10925 0 : void *argp1 = 0 ;
10926 0 : int res1 = 0 ;
10927 0 : PyObject * obj0 = 0 ;
10928 : gpgme_user_id_t result;
10929 :
10930 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__last_uid_get",&obj0)) SWIG_fail;
10931 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10932 0 : if (!SWIG_IsOK(res1)) {
10933 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_uid_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10934 : }
10935 0 : arg1 = (struct _gpgme_key *)(argp1);
10936 : {
10937 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10938 0 : result = (gpgme_user_id_t) ((arg1)->_last_uid);
10939 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10940 : }
10941 : {
10942 : int i;
10943 0 : int size = 0;
10944 : gpgme_user_id_t curr;
10945 0 : for (curr = result; curr != NULL; curr = curr->next) {
10946 0 : size++;
10947 : }
10948 0 : resultobj = PyList_New(size);
10949 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10950 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_user_id, 0 );
10951 0 : PyList_SetItem(resultobj, i, o);
10952 : }
10953 : }
10954 : return resultobj;
10955 : fail:
10956 : return NULL;
10957 : }
10958 :
10959 :
10960 0 : SWIGINTERN PyObject *_wrap__gpgme_key_keylist_mode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10961 0 : PyObject *resultobj = 0;
10962 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10963 : gpgme_keylist_mode_t arg2 ;
10964 0 : void *argp1 = 0 ;
10965 0 : int res1 = 0 ;
10966 : unsigned int val2 ;
10967 0 : int ecode2 = 0 ;
10968 0 : PyObject * obj0 = 0 ;
10969 0 : PyObject * obj1 = 0 ;
10970 :
10971 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_keylist_mode_set",&obj0,&obj1)) SWIG_fail;
10972 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10973 0 : if (!SWIG_IsOK(res1)) {
10974 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_keylist_mode_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10975 : }
10976 0 : arg1 = (struct _gpgme_key *)(argp1);
10977 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10978 0 : if (!SWIG_IsOK(ecode2)) {
10979 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_keylist_mode_set" "', argument " "2"" of type '" "gpgme_keylist_mode_t""'");
10980 : }
10981 0 : arg2 = (gpgme_keylist_mode_t)(val2);
10982 : {
10983 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10984 0 : if (arg1) (arg1)->keylist_mode = arg2;
10985 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10986 : }
10987 0 : resultobj = SWIG_Py_Void();
10988 0 : return resultobj;
10989 : fail:
10990 : return NULL;
10991 : }
10992 :
10993 :
10994 0 : SWIGINTERN PyObject *_wrap__gpgme_key_keylist_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10995 0 : PyObject *resultobj = 0;
10996 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10997 0 : void *argp1 = 0 ;
10998 0 : int res1 = 0 ;
10999 0 : PyObject * obj0 = 0 ;
11000 : gpgme_keylist_mode_t result;
11001 :
11002 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_keylist_mode_get",&obj0)) SWIG_fail;
11003 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
11004 0 : if (!SWIG_IsOK(res1)) {
11005 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_keylist_mode_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
11006 : }
11007 0 : arg1 = (struct _gpgme_key *)(argp1);
11008 : {
11009 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11010 0 : result = (gpgme_keylist_mode_t) ((arg1)->keylist_mode);
11011 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11012 : }
11013 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
11014 0 : return resultobj;
11015 : fail:
11016 : return NULL;
11017 : }
11018 :
11019 :
11020 0 : SWIGINTERN PyObject *_wrap__gpgme_key_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11021 0 : PyObject *resultobj = 0;
11022 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
11023 0 : char *arg2 = (char *) 0 ;
11024 0 : void *argp1 = 0 ;
11025 0 : int res1 = 0 ;
11026 : int res2 ;
11027 0 : char *buf2 = 0 ;
11028 0 : int alloc2 = 0 ;
11029 0 : PyObject * obj0 = 0 ;
11030 0 : PyObject * obj1 = 0 ;
11031 :
11032 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_fpr_set",&obj0,&obj1)) SWIG_fail;
11033 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
11034 0 : if (!SWIG_IsOK(res1)) {
11035 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_fpr_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
11036 : }
11037 0 : arg1 = (struct _gpgme_key *)(argp1);
11038 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11039 0 : if (!SWIG_IsOK(res2)) {
11040 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_fpr_set" "', argument " "2"" of type '" "char *""'");
11041 : }
11042 0 : arg2 = (char *)(buf2);
11043 : {
11044 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11045 0 : if (arg1->fpr) free((char*)arg1->fpr);
11046 0 : if (arg2) {
11047 0 : size_t size = strlen((const char *)(arg2)) + 1;
11048 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
11049 : } else {
11050 0 : arg1->fpr = 0;
11051 : }
11052 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11053 : }
11054 0 : resultobj = SWIG_Py_Void();
11055 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11056 : return resultobj;
11057 : fail:
11058 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11059 : return NULL;
11060 : }
11061 :
11062 :
11063 49 : SWIGINTERN PyObject *_wrap__gpgme_key_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11064 49 : PyObject *resultobj = 0;
11065 49 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
11066 49 : void *argp1 = 0 ;
11067 49 : int res1 = 0 ;
11068 49 : PyObject * obj0 = 0 ;
11069 49 : char *result = 0 ;
11070 :
11071 49 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_fpr_get",&obj0)) SWIG_fail;
11072 49 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
11073 49 : if (!SWIG_IsOK(res1)) {
11074 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_fpr_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
11075 : }
11076 49 : arg1 = (struct _gpgme_key *)(argp1);
11077 : {
11078 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11079 49 : result = (char *) ((arg1)->fpr);
11080 49 : SWIG_PYTHON_THREAD_END_ALLOW;
11081 : }
11082 49 : resultobj = SWIG_FromCharPtr((const char *)result);
11083 49 : return resultobj;
11084 : fail:
11085 : return NULL;
11086 : }
11087 :
11088 :
11089 0 : SWIGINTERN PyObject *_wrap__gpgme_key_last_update_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11090 0 : PyObject *resultobj = 0;
11091 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
11092 : unsigned long arg2 ;
11093 0 : void *argp1 = 0 ;
11094 0 : int res1 = 0 ;
11095 : unsigned long val2 ;
11096 0 : int ecode2 = 0 ;
11097 0 : PyObject * obj0 = 0 ;
11098 0 : PyObject * obj1 = 0 ;
11099 :
11100 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_last_update_set",&obj0,&obj1)) SWIG_fail;
11101 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
11102 0 : if (!SWIG_IsOK(res1)) {
11103 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_last_update_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
11104 : }
11105 0 : arg1 = (struct _gpgme_key *)(argp1);
11106 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
11107 0 : if (!SWIG_IsOK(ecode2)) {
11108 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_last_update_set" "', argument " "2"" of type '" "unsigned long""'");
11109 : }
11110 0 : arg2 = (unsigned long)(val2);
11111 : {
11112 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11113 0 : if (arg1) (arg1)->last_update = arg2;
11114 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11115 : }
11116 0 : resultobj = SWIG_Py_Void();
11117 0 : return resultobj;
11118 : fail:
11119 : return NULL;
11120 : }
11121 :
11122 :
11123 0 : SWIGINTERN PyObject *_wrap__gpgme_key_last_update_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11124 0 : PyObject *resultobj = 0;
11125 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
11126 0 : void *argp1 = 0 ;
11127 0 : int res1 = 0 ;
11128 0 : PyObject * obj0 = 0 ;
11129 : unsigned long result;
11130 :
11131 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_last_update_get",&obj0)) SWIG_fail;
11132 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
11133 0 : if (!SWIG_IsOK(res1)) {
11134 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_last_update_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
11135 : }
11136 0 : arg1 = (struct _gpgme_key *)(argp1);
11137 : {
11138 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11139 0 : result = (unsigned long) ((arg1)->last_update);
11140 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11141 : }
11142 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11143 0 : return resultobj;
11144 : fail:
11145 : return NULL;
11146 : }
11147 :
11148 :
11149 0 : SWIGINTERN PyObject *_wrap_new__gpgme_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11150 0 : PyObject *resultobj = 0;
11151 0 : struct _gpgme_key *result = 0 ;
11152 :
11153 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_key")) SWIG_fail;
11154 : {
11155 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11156 0 : result = (struct _gpgme_key *)calloc(1, sizeof(struct _gpgme_key));
11157 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11158 : }
11159 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, SWIG_POINTER_NEW | 0 );
11160 0 : return resultobj;
11161 : fail:
11162 : return NULL;
11163 : }
11164 :
11165 :
11166 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11167 0 : PyObject *resultobj = 0;
11168 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
11169 0 : void *argp1 = 0 ;
11170 0 : int res1 = 0 ;
11171 0 : PyObject * obj0 = 0 ;
11172 :
11173 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_key",&obj0)) SWIG_fail;
11174 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, SWIG_POINTER_DISOWN | 0 );
11175 0 : if (!SWIG_IsOK(res1)) {
11176 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_key" "', argument " "1"" of type '" "struct _gpgme_key *""'");
11177 : }
11178 0 : arg1 = (struct _gpgme_key *)(argp1);
11179 : {
11180 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11181 0 : free((char *) arg1);
11182 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11183 : }
11184 0 : resultobj = SWIG_Py_Void();
11185 0 : return resultobj;
11186 : fail:
11187 : return NULL;
11188 : }
11189 :
11190 :
11191 29 : SWIGINTERN PyObject *_gpgme_key_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11192 : PyObject *obj;
11193 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
11194 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_key, SWIG_NewClientData(obj));
11195 29 : return SWIG_Py_Void();
11196 : }
11197 :
11198 0 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199 0 : PyObject *resultobj = 0;
11200 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
11201 0 : char *arg2 = (char *) 0 ;
11202 0 : void *argp1 = 0 ;
11203 0 : int res1 = 0 ;
11204 : int res2 ;
11205 0 : char *buf2 = 0 ;
11206 0 : int alloc2 = 0 ;
11207 0 : PyObject * obj0 = 0 ;
11208 0 : PyObject * obj1 = 0 ;
11209 :
11210 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_invalid_key_fpr_set",&obj0,&obj1)) SWIG_fail;
11211 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
11212 0 : if (!SWIG_IsOK(res1)) {
11213 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_fpr_set" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
11214 : }
11215 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
11216 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11217 0 : if (!SWIG_IsOK(res2)) {
11218 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_invalid_key_fpr_set" "', argument " "2"" of type '" "char *""'");
11219 : }
11220 0 : arg2 = (char *)(buf2);
11221 : {
11222 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11223 0 : if (arg1->fpr) free((char*)arg1->fpr);
11224 0 : if (arg2) {
11225 0 : size_t size = strlen((const char *)(arg2)) + 1;
11226 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
11227 : } else {
11228 0 : arg1->fpr = 0;
11229 : }
11230 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11231 : }
11232 0 : resultobj = SWIG_Py_Void();
11233 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11234 : return resultobj;
11235 : fail:
11236 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11237 : return NULL;
11238 : }
11239 :
11240 :
11241 4 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11242 4 : PyObject *resultobj = 0;
11243 4 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
11244 4 : void *argp1 = 0 ;
11245 4 : int res1 = 0 ;
11246 4 : PyObject * obj0 = 0 ;
11247 4 : char *result = 0 ;
11248 :
11249 4 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_invalid_key_fpr_get",&obj0)) SWIG_fail;
11250 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
11251 4 : if (!SWIG_IsOK(res1)) {
11252 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_fpr_get" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
11253 : }
11254 4 : arg1 = (struct _gpgme_invalid_key *)(argp1);
11255 : {
11256 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11257 4 : result = (char *) ((arg1)->fpr);
11258 4 : SWIG_PYTHON_THREAD_END_ALLOW;
11259 : }
11260 4 : resultobj = SWIG_FromCharPtr((const char *)result);
11261 4 : return resultobj;
11262 : fail:
11263 : return NULL;
11264 : }
11265 :
11266 :
11267 0 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_reason_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11268 0 : PyObject *resultobj = 0;
11269 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
11270 : gpgme_error_t arg2 ;
11271 0 : void *argp1 = 0 ;
11272 0 : int res1 = 0 ;
11273 0 : PyObject * obj0 = 0 ;
11274 0 : PyObject * obj1 = 0 ;
11275 :
11276 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_invalid_key_reason_set",&obj0,&obj1)) SWIG_fail;
11277 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
11278 0 : if (!SWIG_IsOK(res1)) {
11279 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_reason_set" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
11280 : }
11281 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
11282 : {
11283 0 : if (PyLong_Check(obj1))
11284 0 : arg2 = PyLong_AsLong(obj1);
11285 :
11286 : else if (PyInt_Check(obj1))
11287 : arg2 = PyInt_AsLong(obj1);
11288 :
11289 : else
11290 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
11291 : }
11292 : {
11293 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11294 0 : if (arg1) (arg1)->reason = arg2;
11295 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11296 : }
11297 0 : resultobj = SWIG_Py_Void();
11298 0 : return resultobj;
11299 : fail:
11300 : return NULL;
11301 : }
11302 :
11303 :
11304 4 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_reason_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11305 4 : PyObject *resultobj = 0;
11306 4 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
11307 4 : void *argp1 = 0 ;
11308 4 : int res1 = 0 ;
11309 4 : PyObject * obj0 = 0 ;
11310 : gpgme_error_t result;
11311 :
11312 4 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_invalid_key_reason_get",&obj0)) SWIG_fail;
11313 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
11314 4 : if (!SWIG_IsOK(res1)) {
11315 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_reason_get" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
11316 : }
11317 4 : arg1 = (struct _gpgme_invalid_key *)(argp1);
11318 : {
11319 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11320 4 : result = ((arg1)->reason);
11321 4 : SWIG_PYTHON_THREAD_END_ALLOW;
11322 : }
11323 : {
11324 4 : resultobj = PyLong_FromLong(result);
11325 : }
11326 4 : return resultobj;
11327 : fail:
11328 : return NULL;
11329 : }
11330 :
11331 :
11332 0 : SWIGINTERN PyObject *_wrap_new__gpgme_invalid_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11333 0 : PyObject *resultobj = 0;
11334 0 : struct _gpgme_invalid_key *result = 0 ;
11335 :
11336 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_invalid_key")) SWIG_fail;
11337 : {
11338 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11339 0 : result = (struct _gpgme_invalid_key *)calloc(1, sizeof(struct _gpgme_invalid_key));
11340 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11341 : }
11342 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_NEW | 0 );
11343 0 : return resultobj;
11344 : fail:
11345 : return NULL;
11346 : }
11347 :
11348 :
11349 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_invalid_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11350 0 : PyObject *resultobj = 0;
11351 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
11352 0 : void *argp1 = 0 ;
11353 0 : int res1 = 0 ;
11354 0 : PyObject * obj0 = 0 ;
11355 :
11356 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_invalid_key",&obj0)) SWIG_fail;
11357 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
11358 0 : if (!SWIG_IsOK(res1)) {
11359 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_invalid_key" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
11360 : }
11361 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
11362 : {
11363 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11364 0 : free((char *) arg1);
11365 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11366 : }
11367 0 : resultobj = SWIG_Py_Void();
11368 0 : return resultobj;
11369 : fail:
11370 : return NULL;
11371 : }
11372 :
11373 :
11374 29 : SWIGINTERN PyObject *_gpgme_invalid_key_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11375 : PyObject *obj;
11376 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
11377 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_invalid_key, SWIG_NewClientData(obj));
11378 29 : return SWIG_Py_Void();
11379 : }
11380 :
11381 84 : SWIGINTERN PyObject *_wrap_gpgme_new(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11382 84 : PyObject *resultobj = 0;
11383 84 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
11384 84 : void *argp1 = 0 ;
11385 84 : int res1 = 0 ;
11386 84 : PyObject * obj0 = 0 ;
11387 : gpgme_error_t result;
11388 :
11389 84 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_new",&obj0)) SWIG_fail;
11390 84 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
11391 84 : if (!SWIG_IsOK(res1)) {
11392 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_new" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
11393 : }
11394 84 : arg1 = (gpgme_ctx_t *)(argp1);
11395 : {
11396 84 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11397 84 : result = gpgme_new(arg1);
11398 84 : SWIG_PYTHON_THREAD_END_ALLOW;
11399 : }
11400 : {
11401 84 : resultobj = PyLong_FromLong(result);
11402 : }
11403 84 : return resultobj;
11404 : fail:
11405 : return NULL;
11406 : }
11407 :
11408 :
11409 80 : SWIGINTERN PyObject *_wrap_gpgme_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11410 80 : PyObject *resultobj = 0;
11411 80 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11412 80 : void *argp1 = 0 ;
11413 80 : int res1 = 0 ;
11414 80 : PyObject * obj0 = 0 ;
11415 :
11416 80 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_release",&obj0)) SWIG_fail;
11417 80 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11418 80 : if (!SWIG_IsOK(res1)) {
11419 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_release" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11420 : }
11421 80 : arg1 = (gpgme_ctx_t)(argp1);
11422 : {
11423 80 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11424 80 : gpgme_release(arg1);
11425 80 : SWIG_PYTHON_THREAD_END_ALLOW;
11426 : }
11427 80 : resultobj = SWIG_Py_Void();
11428 80 : return resultobj;
11429 : fail:
11430 : return NULL;
11431 : }
11432 :
11433 :
11434 2 : SWIGINTERN PyObject *_wrap_gpgme_set_ctx_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11435 2 : PyObject *resultobj = 0;
11436 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11437 2 : char *arg2 = (char *) 0 ;
11438 2 : char *arg3 = (char *) 0 ;
11439 2 : void *argp1 = 0 ;
11440 2 : int res1 = 0 ;
11441 2 : PyObject *encodedInput2 = NULL ;
11442 2 : PyObject *encodedInput3 = NULL ;
11443 2 : PyObject * obj0 = 0 ;
11444 2 : PyObject * obj1 = 0 ;
11445 2 : PyObject * obj2 = 0 ;
11446 : gpgme_error_t result;
11447 :
11448 2 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_ctx_flag",&obj0,&obj1,&obj2)) SWIG_fail;
11449 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11450 2 : if (!SWIG_IsOK(res1)) {
11451 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_ctx_flag" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11452 : }
11453 2 : arg1 = (gpgme_ctx_t)(argp1);
11454 : {
11455 2 : if (obj1 == Py_None)
11456 : arg2 = NULL;
11457 2 : else if (PyUnicode_Check(obj1))
11458 : {
11459 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
11460 2 : if (encodedInput2 == NULL)
11461 : return NULL;
11462 2 : arg2 = PyBytes_AsString(encodedInput2);
11463 : }
11464 0 : else if (PyBytes_Check(obj1))
11465 0 : arg2 = PyBytes_AsString(obj1);
11466 : else {
11467 0 : PyErr_Format(PyExc_TypeError,
11468 : "arg %d: expected str, bytes, or None, got %s",
11469 : 2, obj1->ob_type->tp_name);
11470 0 : return NULL;
11471 : }
11472 : }
11473 : {
11474 2 : if (obj2 == Py_None)
11475 : arg3 = NULL;
11476 2 : else if (PyUnicode_Check(obj2))
11477 : {
11478 2 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
11479 2 : if (encodedInput3 == NULL)
11480 : return NULL;
11481 2 : arg3 = PyBytes_AsString(encodedInput3);
11482 : }
11483 0 : else if (PyBytes_Check(obj2))
11484 0 : arg3 = PyBytes_AsString(obj2);
11485 : else {
11486 0 : PyErr_Format(PyExc_TypeError,
11487 : "arg %d: expected str, bytes, or None, got %s",
11488 : 3, obj2->ob_type->tp_name);
11489 0 : return NULL;
11490 : }
11491 : }
11492 : {
11493 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11494 2 : result = gpgme_set_ctx_flag(arg1,(char const *)arg2,(char const *)arg3);
11495 2 : SWIG_PYTHON_THREAD_END_ALLOW;
11496 : }
11497 : {
11498 2 : resultobj = PyLong_FromLong(result);
11499 : }
11500 : {
11501 2 : Py_XDECREF(encodedInput2);
11502 : }
11503 : {
11504 2 : Py_XDECREF(encodedInput3);
11505 : }
11506 : return resultobj;
11507 : fail:
11508 : {
11509 : Py_XDECREF(encodedInput2);
11510 : }
11511 : {
11512 : Py_XDECREF(encodedInput3);
11513 : }
11514 : return NULL;
11515 : }
11516 :
11517 :
11518 0 : SWIGINTERN PyObject *_wrap_gpgme_get_ctx_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11519 0 : PyObject *resultobj = 0;
11520 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11521 0 : char *arg2 = (char *) 0 ;
11522 0 : void *argp1 = 0 ;
11523 0 : int res1 = 0 ;
11524 0 : PyObject *encodedInput2 = NULL ;
11525 0 : PyObject * obj0 = 0 ;
11526 0 : PyObject * obj1 = 0 ;
11527 0 : char *result = 0 ;
11528 :
11529 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_get_ctx_flag",&obj0,&obj1)) SWIG_fail;
11530 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11531 0 : if (!SWIG_IsOK(res1)) {
11532 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_ctx_flag" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11533 : }
11534 0 : arg1 = (gpgme_ctx_t)(argp1);
11535 : {
11536 0 : if (obj1 == Py_None)
11537 : arg2 = NULL;
11538 0 : else if (PyUnicode_Check(obj1))
11539 : {
11540 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
11541 0 : if (encodedInput2 == NULL)
11542 : return NULL;
11543 0 : arg2 = PyBytes_AsString(encodedInput2);
11544 : }
11545 0 : else if (PyBytes_Check(obj1))
11546 0 : arg2 = PyBytes_AsString(obj1);
11547 : else {
11548 0 : PyErr_Format(PyExc_TypeError,
11549 : "arg %d: expected str, bytes, or None, got %s",
11550 : 2, obj1->ob_type->tp_name);
11551 0 : return NULL;
11552 : }
11553 : }
11554 : {
11555 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11556 0 : result = (char *)gpgme_get_ctx_flag(arg1,(char const *)arg2);
11557 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11558 : }
11559 0 : resultobj = SWIG_FromCharPtr((const char *)result);
11560 : {
11561 0 : Py_XDECREF(encodedInput2);
11562 : }
11563 : return resultobj;
11564 : fail:
11565 : {
11566 : Py_XDECREF(encodedInput2);
11567 : }
11568 : return NULL;
11569 : }
11570 :
11571 :
11572 90 : SWIGINTERN PyObject *_wrap_gpgme_set_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11573 90 : PyObject *resultobj = 0;
11574 90 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11575 : gpgme_protocol_t arg2 ;
11576 90 : void *argp1 = 0 ;
11577 90 : int res1 = 0 ;
11578 : int val2 ;
11579 90 : int ecode2 = 0 ;
11580 90 : PyObject * obj0 = 0 ;
11581 90 : PyObject * obj1 = 0 ;
11582 : gpgme_error_t result;
11583 :
11584 90 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_protocol",&obj0,&obj1)) SWIG_fail;
11585 90 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11586 90 : if (!SWIG_IsOK(res1)) {
11587 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11588 : }
11589 90 : arg1 = (gpgme_ctx_t)(argp1);
11590 180 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11591 90 : if (!SWIG_IsOK(ecode2)) {
11592 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_protocol" "', argument " "2"" of type '" "gpgme_protocol_t""'");
11593 : }
11594 90 : arg2 = (gpgme_protocol_t)(val2);
11595 : {
11596 90 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11597 90 : result = gpgme_set_protocol(arg1,arg2);
11598 90 : SWIG_PYTHON_THREAD_END_ALLOW;
11599 : }
11600 : {
11601 90 : resultobj = PyLong_FromLong(result);
11602 : }
11603 90 : return resultobj;
11604 : fail:
11605 : return NULL;
11606 : }
11607 :
11608 :
11609 125 : SWIGINTERN PyObject *_wrap_gpgme_get_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11610 125 : PyObject *resultobj = 0;
11611 125 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11612 125 : void *argp1 = 0 ;
11613 125 : int res1 = 0 ;
11614 125 : PyObject * obj0 = 0 ;
11615 : gpgme_protocol_t result;
11616 :
11617 125 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_protocol",&obj0)) SWIG_fail;
11618 125 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11619 125 : if (!SWIG_IsOK(res1)) {
11620 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11621 : }
11622 125 : arg1 = (gpgme_ctx_t)(argp1);
11623 : {
11624 125 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11625 125 : result = (gpgme_protocol_t)gpgme_get_protocol(arg1);
11626 125 : SWIG_PYTHON_THREAD_END_ALLOW;
11627 : }
11628 250 : resultobj = SWIG_From_int((int)(result));
11629 125 : return resultobj;
11630 : fail:
11631 : return NULL;
11632 : }
11633 :
11634 :
11635 0 : SWIGINTERN PyObject *_wrap_gpgme_set_sub_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11636 0 : PyObject *resultobj = 0;
11637 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11638 : gpgme_protocol_t arg2 ;
11639 0 : void *argp1 = 0 ;
11640 0 : int res1 = 0 ;
11641 : int val2 ;
11642 0 : int ecode2 = 0 ;
11643 0 : PyObject * obj0 = 0 ;
11644 0 : PyObject * obj1 = 0 ;
11645 : gpgme_error_t result;
11646 :
11647 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_sub_protocol",&obj0,&obj1)) SWIG_fail;
11648 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11649 0 : if (!SWIG_IsOK(res1)) {
11650 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_sub_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11651 : }
11652 0 : arg1 = (gpgme_ctx_t)(argp1);
11653 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11654 0 : if (!SWIG_IsOK(ecode2)) {
11655 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_sub_protocol" "', argument " "2"" of type '" "gpgme_protocol_t""'");
11656 : }
11657 0 : arg2 = (gpgme_protocol_t)(val2);
11658 : {
11659 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11660 0 : result = gpgme_set_sub_protocol(arg1,arg2);
11661 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11662 : }
11663 : {
11664 0 : resultobj = PyLong_FromLong(result);
11665 : }
11666 0 : return resultobj;
11667 : fail:
11668 : return NULL;
11669 : }
11670 :
11671 :
11672 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sub_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11673 0 : PyObject *resultobj = 0;
11674 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11675 0 : void *argp1 = 0 ;
11676 0 : int res1 = 0 ;
11677 0 : PyObject * obj0 = 0 ;
11678 : gpgme_protocol_t result;
11679 :
11680 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_sub_protocol",&obj0)) SWIG_fail;
11681 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11682 0 : if (!SWIG_IsOK(res1)) {
11683 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sub_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11684 : }
11685 0 : arg1 = (gpgme_ctx_t)(argp1);
11686 : {
11687 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11688 0 : result = (gpgme_protocol_t)gpgme_get_sub_protocol(arg1);
11689 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11690 : }
11691 0 : resultobj = SWIG_From_int((int)(result));
11692 0 : return resultobj;
11693 : fail:
11694 : return NULL;
11695 : }
11696 :
11697 :
11698 0 : SWIGINTERN PyObject *_wrap_gpgme_get_protocol_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11699 0 : PyObject *resultobj = 0;
11700 : gpgme_protocol_t arg1 ;
11701 : int val1 ;
11702 0 : int ecode1 = 0 ;
11703 0 : PyObject * obj0 = 0 ;
11704 0 : char *result = 0 ;
11705 :
11706 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_protocol_name",&obj0)) SWIG_fail;
11707 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
11708 0 : if (!SWIG_IsOK(ecode1)) {
11709 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_get_protocol_name" "', argument " "1"" of type '" "gpgme_protocol_t""'");
11710 : }
11711 0 : arg1 = (gpgme_protocol_t)(val1);
11712 : {
11713 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11714 0 : result = (char *)gpgme_get_protocol_name(arg1);
11715 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11716 : }
11717 0 : resultobj = SWIG_FromCharPtr((const char *)result);
11718 0 : return resultobj;
11719 : fail:
11720 : return NULL;
11721 : }
11722 :
11723 :
11724 97 : SWIGINTERN PyObject *_wrap_gpgme_set_armor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11725 97 : PyObject *resultobj = 0;
11726 97 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11727 : int arg2 ;
11728 97 : void *argp1 = 0 ;
11729 97 : int res1 = 0 ;
11730 : int val2 ;
11731 97 : int ecode2 = 0 ;
11732 97 : PyObject * obj0 = 0 ;
11733 97 : PyObject * obj1 = 0 ;
11734 :
11735 97 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_armor",&obj0,&obj1)) SWIG_fail;
11736 97 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11737 97 : if (!SWIG_IsOK(res1)) {
11738 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_armor" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11739 : }
11740 97 : arg1 = (gpgme_ctx_t)(argp1);
11741 194 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11742 97 : if (!SWIG_IsOK(ecode2)) {
11743 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_armor" "', argument " "2"" of type '" "int""'");
11744 : }
11745 97 : arg2 = (int)(val2);
11746 : {
11747 97 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11748 97 : gpgme_set_armor(arg1,arg2);
11749 97 : SWIG_PYTHON_THREAD_END_ALLOW;
11750 : }
11751 97 : resultobj = SWIG_Py_Void();
11752 97 : return resultobj;
11753 : fail:
11754 : return NULL;
11755 : }
11756 :
11757 :
11758 0 : SWIGINTERN PyObject *_wrap_gpgme_get_armor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11759 0 : PyObject *resultobj = 0;
11760 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11761 0 : void *argp1 = 0 ;
11762 0 : int res1 = 0 ;
11763 0 : PyObject * obj0 = 0 ;
11764 : int result;
11765 :
11766 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_armor",&obj0)) SWIG_fail;
11767 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11768 0 : if (!SWIG_IsOK(res1)) {
11769 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_armor" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11770 : }
11771 0 : arg1 = (gpgme_ctx_t)(argp1);
11772 : {
11773 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11774 0 : result = (int)gpgme_get_armor(arg1);
11775 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11776 : }
11777 0 : resultobj = SWIG_From_int((int)(result));
11778 0 : return resultobj;
11779 : fail:
11780 : return NULL;
11781 : }
11782 :
11783 :
11784 86 : SWIGINTERN PyObject *_wrap_gpgme_set_textmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11785 86 : PyObject *resultobj = 0;
11786 86 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11787 : int arg2 ;
11788 86 : void *argp1 = 0 ;
11789 86 : int res1 = 0 ;
11790 : int val2 ;
11791 86 : int ecode2 = 0 ;
11792 86 : PyObject * obj0 = 0 ;
11793 86 : PyObject * obj1 = 0 ;
11794 :
11795 86 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_textmode",&obj0,&obj1)) SWIG_fail;
11796 86 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11797 86 : if (!SWIG_IsOK(res1)) {
11798 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_textmode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11799 : }
11800 86 : arg1 = (gpgme_ctx_t)(argp1);
11801 172 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11802 86 : if (!SWIG_IsOK(ecode2)) {
11803 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_textmode" "', argument " "2"" of type '" "int""'");
11804 : }
11805 86 : arg2 = (int)(val2);
11806 : {
11807 86 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11808 86 : gpgme_set_textmode(arg1,arg2);
11809 86 : SWIG_PYTHON_THREAD_END_ALLOW;
11810 : }
11811 86 : resultobj = SWIG_Py_Void();
11812 86 : return resultobj;
11813 : fail:
11814 : return NULL;
11815 : }
11816 :
11817 :
11818 0 : SWIGINTERN PyObject *_wrap_gpgme_get_textmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11819 0 : PyObject *resultobj = 0;
11820 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11821 0 : void *argp1 = 0 ;
11822 0 : int res1 = 0 ;
11823 0 : PyObject * obj0 = 0 ;
11824 : int result;
11825 :
11826 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_textmode",&obj0)) SWIG_fail;
11827 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11828 0 : if (!SWIG_IsOK(res1)) {
11829 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_textmode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11830 : }
11831 0 : arg1 = (gpgme_ctx_t)(argp1);
11832 : {
11833 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11834 0 : result = (int)gpgme_get_textmode(arg1);
11835 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11836 : }
11837 0 : resultobj = SWIG_From_int((int)(result));
11838 0 : return resultobj;
11839 : fail:
11840 : return NULL;
11841 : }
11842 :
11843 :
11844 84 : SWIGINTERN PyObject *_wrap_gpgme_set_offline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11845 84 : PyObject *resultobj = 0;
11846 84 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11847 : int arg2 ;
11848 84 : void *argp1 = 0 ;
11849 84 : int res1 = 0 ;
11850 : int val2 ;
11851 84 : int ecode2 = 0 ;
11852 84 : PyObject * obj0 = 0 ;
11853 84 : PyObject * obj1 = 0 ;
11854 :
11855 84 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_offline",&obj0,&obj1)) SWIG_fail;
11856 84 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11857 84 : if (!SWIG_IsOK(res1)) {
11858 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_offline" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11859 : }
11860 84 : arg1 = (gpgme_ctx_t)(argp1);
11861 168 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11862 84 : if (!SWIG_IsOK(ecode2)) {
11863 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_offline" "', argument " "2"" of type '" "int""'");
11864 : }
11865 84 : arg2 = (int)(val2);
11866 : {
11867 84 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11868 84 : gpgme_set_offline(arg1,arg2);
11869 84 : SWIG_PYTHON_THREAD_END_ALLOW;
11870 : }
11871 84 : resultobj = SWIG_Py_Void();
11872 84 : return resultobj;
11873 : fail:
11874 : return NULL;
11875 : }
11876 :
11877 :
11878 0 : SWIGINTERN PyObject *_wrap_gpgme_get_offline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11879 0 : PyObject *resultobj = 0;
11880 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11881 0 : void *argp1 = 0 ;
11882 0 : int res1 = 0 ;
11883 0 : PyObject * obj0 = 0 ;
11884 : int result;
11885 :
11886 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_offline",&obj0)) SWIG_fail;
11887 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11888 0 : if (!SWIG_IsOK(res1)) {
11889 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_offline" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11890 : }
11891 0 : arg1 = (gpgme_ctx_t)(argp1);
11892 : {
11893 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11894 0 : result = (int)gpgme_get_offline(arg1);
11895 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11896 : }
11897 0 : resultobj = SWIG_From_int((int)(result));
11898 0 : return resultobj;
11899 : fail:
11900 : return NULL;
11901 : }
11902 :
11903 :
11904 0 : SWIGINTERN PyObject *_wrap_gpgme_set_include_certs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11905 0 : PyObject *resultobj = 0;
11906 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11907 : int arg2 ;
11908 0 : void *argp1 = 0 ;
11909 0 : int res1 = 0 ;
11910 : int val2 ;
11911 0 : int ecode2 = 0 ;
11912 0 : PyObject * obj0 = 0 ;
11913 0 : PyObject * obj1 = 0 ;
11914 :
11915 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_include_certs",&obj0,&obj1)) SWIG_fail;
11916 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11917 0 : if (!SWIG_IsOK(res1)) {
11918 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_include_certs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11919 : }
11920 0 : arg1 = (gpgme_ctx_t)(argp1);
11921 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11922 0 : if (!SWIG_IsOK(ecode2)) {
11923 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_include_certs" "', argument " "2"" of type '" "int""'");
11924 : }
11925 0 : arg2 = (int)(val2);
11926 : {
11927 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11928 0 : gpgme_set_include_certs(arg1,arg2);
11929 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11930 : }
11931 0 : resultobj = SWIG_Py_Void();
11932 0 : return resultobj;
11933 : fail:
11934 : return NULL;
11935 : }
11936 :
11937 :
11938 0 : SWIGINTERN PyObject *_wrap_gpgme_get_include_certs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11939 0 : PyObject *resultobj = 0;
11940 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11941 0 : void *argp1 = 0 ;
11942 0 : int res1 = 0 ;
11943 0 : PyObject * obj0 = 0 ;
11944 : int result;
11945 :
11946 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_include_certs",&obj0)) SWIG_fail;
11947 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11948 0 : if (!SWIG_IsOK(res1)) {
11949 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_include_certs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11950 : }
11951 0 : arg1 = (gpgme_ctx_t)(argp1);
11952 : {
11953 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11954 0 : result = (int)gpgme_get_include_certs(arg1);
11955 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11956 : }
11957 0 : resultobj = SWIG_From_int((int)(result));
11958 0 : return resultobj;
11959 : fail:
11960 : return NULL;
11961 : }
11962 :
11963 :
11964 16 : SWIGINTERN PyObject *_wrap_gpgme_set_keylist_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11965 16 : PyObject *resultobj = 0;
11966 16 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11967 : gpgme_keylist_mode_t arg2 ;
11968 16 : void *argp1 = 0 ;
11969 16 : int res1 = 0 ;
11970 : unsigned int val2 ;
11971 16 : int ecode2 = 0 ;
11972 16 : PyObject * obj0 = 0 ;
11973 16 : PyObject * obj1 = 0 ;
11974 : gpgme_error_t result;
11975 :
11976 16 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_keylist_mode",&obj0,&obj1)) SWIG_fail;
11977 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11978 16 : if (!SWIG_IsOK(res1)) {
11979 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_keylist_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11980 : }
11981 16 : arg1 = (gpgme_ctx_t)(argp1);
11982 32 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
11983 16 : if (!SWIG_IsOK(ecode2)) {
11984 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_keylist_mode" "', argument " "2"" of type '" "gpgme_keylist_mode_t""'");
11985 : }
11986 16 : arg2 = (gpgme_keylist_mode_t)(val2);
11987 : {
11988 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11989 16 : result = gpgme_set_keylist_mode(arg1,arg2);
11990 16 : SWIG_PYTHON_THREAD_END_ALLOW;
11991 : }
11992 : {
11993 16 : resultobj = PyLong_FromLong(result);
11994 : }
11995 16 : return resultobj;
11996 : fail:
11997 : return NULL;
11998 : }
11999 :
12000 :
12001 0 : SWIGINTERN PyObject *_wrap_gpgme_get_keylist_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12002 0 : PyObject *resultobj = 0;
12003 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12004 0 : void *argp1 = 0 ;
12005 0 : int res1 = 0 ;
12006 0 : PyObject * obj0 = 0 ;
12007 : gpgme_keylist_mode_t result;
12008 :
12009 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_keylist_mode",&obj0)) SWIG_fail;
12010 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12011 0 : if (!SWIG_IsOK(res1)) {
12012 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_keylist_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12013 : }
12014 0 : arg1 = (gpgme_ctx_t)(argp1);
12015 : {
12016 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12017 0 : result = (gpgme_keylist_mode_t)gpgme_get_keylist_mode(arg1);
12018 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12019 : }
12020 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
12021 0 : return resultobj;
12022 : fail:
12023 : return NULL;
12024 : }
12025 :
12026 :
12027 106 : SWIGINTERN PyObject *_wrap_gpgme_set_pinentry_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12028 106 : PyObject *resultobj = 0;
12029 106 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12030 : gpgme_pinentry_mode_t arg2 ;
12031 106 : void *argp1 = 0 ;
12032 106 : int res1 = 0 ;
12033 : int val2 ;
12034 106 : int ecode2 = 0 ;
12035 106 : PyObject * obj0 = 0 ;
12036 106 : PyObject * obj1 = 0 ;
12037 : gpgme_error_t result;
12038 :
12039 106 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_pinentry_mode",&obj0,&obj1)) SWIG_fail;
12040 106 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12041 106 : if (!SWIG_IsOK(res1)) {
12042 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_pinentry_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12043 : }
12044 106 : arg1 = (gpgme_ctx_t)(argp1);
12045 212 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12046 106 : if (!SWIG_IsOK(ecode2)) {
12047 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_pinentry_mode" "', argument " "2"" of type '" "gpgme_pinentry_mode_t""'");
12048 : }
12049 106 : arg2 = (gpgme_pinentry_mode_t)(val2);
12050 : {
12051 106 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12052 106 : result = gpgme_set_pinentry_mode(arg1,arg2);
12053 106 : SWIG_PYTHON_THREAD_END_ALLOW;
12054 : }
12055 : {
12056 106 : resultobj = PyLong_FromLong(result);
12057 : }
12058 106 : return resultobj;
12059 : fail:
12060 : return NULL;
12061 : }
12062 :
12063 :
12064 6 : SWIGINTERN PyObject *_wrap_gpgme_get_pinentry_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12065 6 : PyObject *resultobj = 0;
12066 6 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12067 6 : void *argp1 = 0 ;
12068 6 : int res1 = 0 ;
12069 6 : PyObject * obj0 = 0 ;
12070 : gpgme_pinentry_mode_t result;
12071 :
12072 6 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_pinentry_mode",&obj0)) SWIG_fail;
12073 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12074 6 : if (!SWIG_IsOK(res1)) {
12075 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_pinentry_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12076 : }
12077 6 : arg1 = (gpgme_ctx_t)(argp1);
12078 : {
12079 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12080 6 : result = (gpgme_pinentry_mode_t)gpgme_get_pinentry_mode(arg1);
12081 6 : SWIG_PYTHON_THREAD_END_ALLOW;
12082 : }
12083 12 : resultobj = SWIG_From_int((int)(result));
12084 6 : return resultobj;
12085 : fail:
12086 : return NULL;
12087 : }
12088 :
12089 :
12090 0 : SWIGINTERN PyObject *_wrap_gpgme_set_passphrase_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12091 0 : PyObject *resultobj = 0;
12092 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12093 0 : gpgme_passphrase_cb_t arg2 = (gpgme_passphrase_cb_t) 0 ;
12094 0 : void *arg3 = (void *) 0 ;
12095 0 : void *argp1 = 0 ;
12096 0 : int res1 = 0 ;
12097 : int res3 ;
12098 0 : PyObject * obj0 = 0 ;
12099 0 : PyObject * obj1 = 0 ;
12100 0 : PyObject * obj2 = 0 ;
12101 :
12102 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_passphrase_cb",&obj0,&obj1,&obj2)) SWIG_fail;
12103 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12104 0 : if (!SWIG_IsOK(res1)) {
12105 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_passphrase_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12106 : }
12107 0 : arg1 = (gpgme_ctx_t)(argp1);
12108 : {
12109 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);
12110 0 : if (!SWIG_IsOK(res)) {
12111 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_passphrase_cb" "', argument " "2"" of type '" "gpgme_passphrase_cb_t""'");
12112 : }
12113 : }
12114 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
12115 0 : if (!SWIG_IsOK(res3)) {
12116 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_passphrase_cb" "', argument " "3"" of type '" "void *""'");
12117 : }
12118 : {
12119 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12120 0 : gpgme_set_passphrase_cb(arg1,arg2,arg3);
12121 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12122 : }
12123 0 : resultobj = SWIG_Py_Void();
12124 0 : return resultobj;
12125 : fail:
12126 : return NULL;
12127 : }
12128 :
12129 :
12130 0 : SWIGINTERN PyObject *_wrap_gpgme_get_passphrase_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12131 0 : PyObject *resultobj = 0;
12132 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12133 0 : gpgme_passphrase_cb_t *arg2 = (gpgme_passphrase_cb_t *) 0 ;
12134 0 : void **arg3 = (void **) 0 ;
12135 0 : void *argp1 = 0 ;
12136 0 : int res1 = 0 ;
12137 0 : void *argp2 = 0 ;
12138 0 : int res2 = 0 ;
12139 0 : void *argp3 = 0 ;
12140 0 : int res3 = 0 ;
12141 0 : PyObject * obj0 = 0 ;
12142 0 : PyObject * obj1 = 0 ;
12143 0 : PyObject * obj2 = 0 ;
12144 :
12145 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_passphrase_cb",&obj0,&obj1,&obj2)) SWIG_fail;
12146 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12147 0 : if (!SWIG_IsOK(res1)) {
12148 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_passphrase_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12149 : }
12150 0 : arg1 = (gpgme_ctx_t)(argp1);
12151 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 );
12152 0 : if (!SWIG_IsOK(res2)) {
12153 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_passphrase_cb" "', argument " "2"" of type '" "gpgme_passphrase_cb_t *""'");
12154 : }
12155 0 : arg2 = (gpgme_passphrase_cb_t *)(argp2);
12156 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
12157 0 : if (!SWIG_IsOK(res3)) {
12158 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_passphrase_cb" "', argument " "3"" of type '" "void **""'");
12159 : }
12160 0 : arg3 = (void **)(argp3);
12161 : {
12162 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12163 0 : gpgme_get_passphrase_cb(arg1,arg2,arg3);
12164 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12165 : }
12166 0 : resultobj = SWIG_Py_Void();
12167 0 : return resultobj;
12168 : fail:
12169 : return NULL;
12170 : }
12171 :
12172 :
12173 0 : SWIGINTERN PyObject *_wrap_gpgme_set_progress_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12174 0 : PyObject *resultobj = 0;
12175 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12176 0 : gpgme_progress_cb_t arg2 = (gpgme_progress_cb_t) 0 ;
12177 0 : void *arg3 = (void *) 0 ;
12178 0 : void *argp1 = 0 ;
12179 0 : int res1 = 0 ;
12180 : int res3 ;
12181 0 : PyObject * obj0 = 0 ;
12182 0 : PyObject * obj1 = 0 ;
12183 0 : PyObject * obj2 = 0 ;
12184 :
12185 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_progress_cb",&obj0,&obj1,&obj2)) SWIG_fail;
12186 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12187 0 : if (!SWIG_IsOK(res1)) {
12188 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_progress_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12189 : }
12190 0 : arg1 = (gpgme_ctx_t)(argp1);
12191 : {
12192 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_int_int_int__void);
12193 0 : if (!SWIG_IsOK(res)) {
12194 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_progress_cb" "', argument " "2"" of type '" "gpgme_progress_cb_t""'");
12195 : }
12196 : }
12197 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
12198 0 : if (!SWIG_IsOK(res3)) {
12199 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_progress_cb" "', argument " "3"" of type '" "void *""'");
12200 : }
12201 : {
12202 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12203 0 : gpgme_set_progress_cb(arg1,arg2,arg3);
12204 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12205 : }
12206 0 : resultobj = SWIG_Py_Void();
12207 0 : return resultobj;
12208 : fail:
12209 : return NULL;
12210 : }
12211 :
12212 :
12213 0 : SWIGINTERN PyObject *_wrap_gpgme_get_progress_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12214 0 : PyObject *resultobj = 0;
12215 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12216 0 : gpgme_progress_cb_t *arg2 = (gpgme_progress_cb_t *) 0 ;
12217 0 : void **arg3 = (void **) 0 ;
12218 0 : void *argp1 = 0 ;
12219 0 : int res1 = 0 ;
12220 0 : void *argp2 = 0 ;
12221 0 : int res2 = 0 ;
12222 0 : void *argp3 = 0 ;
12223 0 : int res3 = 0 ;
12224 0 : PyObject * obj0 = 0 ;
12225 0 : PyObject * obj1 = 0 ;
12226 0 : PyObject * obj2 = 0 ;
12227 :
12228 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_progress_cb",&obj0,&obj1,&obj2)) SWIG_fail;
12229 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12230 0 : if (!SWIG_IsOK(res1)) {
12231 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_progress_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12232 : }
12233 0 : arg1 = (gpgme_ctx_t)(argp1);
12234 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_int_int_int__void, 0 | 0 );
12235 0 : if (!SWIG_IsOK(res2)) {
12236 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_progress_cb" "', argument " "2"" of type '" "gpgme_progress_cb_t *""'");
12237 : }
12238 0 : arg2 = (gpgme_progress_cb_t *)(argp2);
12239 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
12240 0 : if (!SWIG_IsOK(res3)) {
12241 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_progress_cb" "', argument " "3"" of type '" "void **""'");
12242 : }
12243 0 : arg3 = (void **)(argp3);
12244 : {
12245 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12246 0 : gpgme_get_progress_cb(arg1,arg2,arg3);
12247 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12248 : }
12249 0 : resultobj = SWIG_Py_Void();
12250 0 : return resultobj;
12251 : fail:
12252 : return NULL;
12253 : }
12254 :
12255 :
12256 0 : SWIGINTERN PyObject *_wrap_gpgme_set_status_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12257 0 : PyObject *resultobj = 0;
12258 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12259 0 : gpgme_status_cb_t arg2 = (gpgme_status_cb_t) 0 ;
12260 0 : void *arg3 = (void *) 0 ;
12261 0 : void *argp1 = 0 ;
12262 0 : int res1 = 0 ;
12263 : int res3 ;
12264 0 : PyObject * obj0 = 0 ;
12265 0 : PyObject * obj1 = 0 ;
12266 0 : PyObject * obj2 = 0 ;
12267 :
12268 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_status_cb",&obj0,&obj1,&obj2)) SWIG_fail;
12269 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12270 0 : if (!SWIG_IsOK(res1)) {
12271 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_status_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12272 : }
12273 0 : arg1 = (gpgme_ctx_t)(argp1);
12274 : {
12275 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t);
12276 0 : if (!SWIG_IsOK(res)) {
12277 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_status_cb" "', argument " "2"" of type '" "gpgme_status_cb_t""'");
12278 : }
12279 : }
12280 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
12281 0 : if (!SWIG_IsOK(res3)) {
12282 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_status_cb" "', argument " "3"" of type '" "void *""'");
12283 : }
12284 : {
12285 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12286 0 : gpgme_set_status_cb(arg1,arg2,arg3);
12287 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12288 : }
12289 0 : resultobj = SWIG_Py_Void();
12290 0 : return resultobj;
12291 : fail:
12292 : return NULL;
12293 : }
12294 :
12295 :
12296 0 : SWIGINTERN PyObject *_wrap_gpgme_get_status_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12297 0 : PyObject *resultobj = 0;
12298 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12299 0 : gpgme_status_cb_t *arg2 = (gpgme_status_cb_t *) 0 ;
12300 0 : void **arg3 = (void **) 0 ;
12301 0 : void *argp1 = 0 ;
12302 0 : int res1 = 0 ;
12303 0 : void *argp2 = 0 ;
12304 0 : int res2 = 0 ;
12305 0 : void *argp3 = 0 ;
12306 0 : int res3 = 0 ;
12307 0 : PyObject * obj0 = 0 ;
12308 0 : PyObject * obj1 = 0 ;
12309 0 : PyObject * obj2 = 0 ;
12310 :
12311 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_status_cb",&obj0,&obj1,&obj2)) SWIG_fail;
12312 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12313 0 : if (!SWIG_IsOK(res1)) {
12314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_status_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12315 : }
12316 0 : arg1 = (gpgme_ctx_t)(argp1);
12317 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 );
12318 0 : if (!SWIG_IsOK(res2)) {
12319 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_status_cb" "', argument " "2"" of type '" "gpgme_status_cb_t *""'");
12320 : }
12321 0 : arg2 = (gpgme_status_cb_t *)(argp2);
12322 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
12323 0 : if (!SWIG_IsOK(res3)) {
12324 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_status_cb" "', argument " "3"" of type '" "void **""'");
12325 : }
12326 0 : arg3 = (void **)(argp3);
12327 : {
12328 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12329 0 : gpgme_get_status_cb(arg1,arg2,arg3);
12330 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12331 : }
12332 0 : resultobj = SWIG_Py_Void();
12333 0 : return resultobj;
12334 : fail:
12335 : return NULL;
12336 : }
12337 :
12338 :
12339 0 : SWIGINTERN PyObject *_wrap_gpgme_set_locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12340 0 : PyObject *resultobj = 0;
12341 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12342 : int arg2 ;
12343 0 : char *arg3 = (char *) 0 ;
12344 0 : void *argp1 = 0 ;
12345 0 : int res1 = 0 ;
12346 : int val2 ;
12347 0 : int ecode2 = 0 ;
12348 0 : PyObject *encodedInput3 = NULL ;
12349 0 : PyObject * obj0 = 0 ;
12350 0 : PyObject * obj1 = 0 ;
12351 0 : PyObject * obj2 = 0 ;
12352 : gpgme_error_t result;
12353 :
12354 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_locale",&obj0,&obj1,&obj2)) SWIG_fail;
12355 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12356 0 : if (!SWIG_IsOK(res1)) {
12357 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_locale" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12358 : }
12359 0 : arg1 = (gpgme_ctx_t)(argp1);
12360 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12361 0 : if (!SWIG_IsOK(ecode2)) {
12362 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_locale" "', argument " "2"" of type '" "int""'");
12363 : }
12364 0 : arg2 = (int)(val2);
12365 : {
12366 0 : if (obj2 == Py_None)
12367 : arg3 = NULL;
12368 0 : else if (PyUnicode_Check(obj2))
12369 : {
12370 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
12371 0 : if (encodedInput3 == NULL)
12372 : return NULL;
12373 0 : arg3 = PyBytes_AsString(encodedInput3);
12374 : }
12375 0 : else if (PyBytes_Check(obj2))
12376 0 : arg3 = PyBytes_AsString(obj2);
12377 : else {
12378 0 : PyErr_Format(PyExc_TypeError,
12379 : "arg %d: expected str, bytes, or None, got %s",
12380 : 3, obj2->ob_type->tp_name);
12381 0 : return NULL;
12382 : }
12383 : }
12384 : {
12385 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12386 0 : result = gpgme_set_locale(arg1,arg2,(char const *)arg3);
12387 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12388 : }
12389 : {
12390 0 : resultobj = PyLong_FromLong(result);
12391 : }
12392 : {
12393 0 : Py_XDECREF(encodedInput3);
12394 : }
12395 : return resultobj;
12396 : fail:
12397 : {
12398 : Py_XDECREF(encodedInput3);
12399 : }
12400 : return NULL;
12401 : }
12402 :
12403 :
12404 36 : SWIGINTERN PyObject *_wrap_gpgme_ctx_get_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12405 36 : PyObject *resultobj = 0;
12406 36 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12407 36 : void *argp1 = 0 ;
12408 36 : int res1 = 0 ;
12409 36 : PyObject * obj0 = 0 ;
12410 : gpgme_engine_info_t result;
12411 :
12412 36 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_ctx_get_engine_info",&obj0)) SWIG_fail;
12413 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12414 36 : if (!SWIG_IsOK(res1)) {
12415 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_get_engine_info" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12416 : }
12417 36 : arg1 = (gpgme_ctx_t)(argp1);
12418 : {
12419 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12420 36 : result = (gpgme_engine_info_t)gpgme_ctx_get_engine_info(arg1);
12421 36 : SWIG_PYTHON_THREAD_END_ALLOW;
12422 : }
12423 : {
12424 : int i;
12425 36 : int size = 0;
12426 : gpgme_engine_info_t curr;
12427 252 : for (curr = result; curr != NULL; curr = curr->next) {
12428 216 : size++;
12429 : }
12430 36 : resultobj = PyList_New(size);
12431 36 : if (resultobj == NULL)
12432 : return NULL; /* raise */
12433 216 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
12434 : PyObject *fragile, *o;
12435 216 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_engine_info,
12436 : 0 );
12437 216 : if (fragile == NULL)
12438 : {
12439 0 : Py_DECREF(resultobj);
12440 : return NULL; /* raise */
12441 : }
12442 216 : o = _gpg_wrap_result(fragile, "EngineInfo");
12443 216 : Py_DECREF(fragile);
12444 216 : if (o == NULL)
12445 : {
12446 0 : Py_DECREF(resultobj);
12447 : return NULL; /* raise */
12448 : }
12449 216 : PyList_SetItem(resultobj, i, o);
12450 : }
12451 : }
12452 : return resultobj;
12453 : fail:
12454 : return NULL;
12455 : }
12456 :
12457 :
12458 90 : SWIGINTERN PyObject *_wrap_gpgme_ctx_set_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12459 90 : PyObject *resultobj = 0;
12460 90 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12461 : gpgme_protocol_t arg2 ;
12462 90 : char *arg3 = (char *) 0 ;
12463 90 : char *arg4 = (char *) 0 ;
12464 90 : void *argp1 = 0 ;
12465 90 : int res1 = 0 ;
12466 : int val2 ;
12467 90 : int ecode2 = 0 ;
12468 90 : PyObject *encodedInput3 = NULL ;
12469 90 : PyObject *encodedInput4 = NULL ;
12470 90 : PyObject * obj0 = 0 ;
12471 90 : PyObject * obj1 = 0 ;
12472 90 : PyObject * obj2 = 0 ;
12473 90 : PyObject * obj3 = 0 ;
12474 : gpgme_error_t result;
12475 :
12476 90 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_ctx_set_engine_info",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12477 90 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12478 90 : if (!SWIG_IsOK(res1)) {
12479 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_set_engine_info" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12480 : }
12481 90 : arg1 = (gpgme_ctx_t)(argp1);
12482 180 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12483 90 : if (!SWIG_IsOK(ecode2)) {
12484 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_ctx_set_engine_info" "', argument " "2"" of type '" "gpgme_protocol_t""'");
12485 : }
12486 90 : arg2 = (gpgme_protocol_t)(val2);
12487 : {
12488 90 : if (obj2 == Py_None)
12489 : arg3 = NULL;
12490 6 : else if (PyUnicode_Check(obj2))
12491 : {
12492 6 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
12493 6 : if (encodedInput3 == NULL)
12494 : return NULL;
12495 6 : arg3 = PyBytes_AsString(encodedInput3);
12496 : }
12497 0 : else if (PyBytes_Check(obj2))
12498 0 : arg3 = PyBytes_AsString(obj2);
12499 : else {
12500 0 : PyErr_Format(PyExc_TypeError,
12501 : "arg %d: expected str, bytes, or None, got %s",
12502 : 3, obj2->ob_type->tp_name);
12503 0 : return NULL;
12504 : }
12505 : }
12506 : {
12507 90 : if (obj3 == Py_None)
12508 : arg4 = NULL;
12509 6 : else if (PyUnicode_Check(obj3))
12510 : {
12511 6 : encodedInput4 = PyUnicode_AsUTF8String(obj3);
12512 6 : if (encodedInput4 == NULL)
12513 : return NULL;
12514 6 : arg4 = PyBytes_AsString(encodedInput4);
12515 : }
12516 0 : else if (PyBytes_Check(obj3))
12517 0 : arg4 = PyBytes_AsString(obj3);
12518 : else {
12519 0 : PyErr_Format(PyExc_TypeError,
12520 : "arg %d: expected str, bytes, or None, got %s",
12521 : 4, obj3->ob_type->tp_name);
12522 0 : return NULL;
12523 : }
12524 : }
12525 : {
12526 90 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12527 90 : result = gpgme_ctx_set_engine_info(arg1,arg2,(char const *)arg3,(char const *)arg4);
12528 90 : SWIG_PYTHON_THREAD_END_ALLOW;
12529 : }
12530 : {
12531 90 : resultobj = PyLong_FromLong(result);
12532 : }
12533 : {
12534 90 : Py_XDECREF(encodedInput3);
12535 : }
12536 : {
12537 90 : Py_XDECREF(encodedInput4);
12538 : }
12539 : return resultobj;
12540 : fail:
12541 : {
12542 : Py_XDECREF(encodedInput3);
12543 : }
12544 : {
12545 : Py_XDECREF(encodedInput4);
12546 : }
12547 : return NULL;
12548 : }
12549 :
12550 :
12551 91 : SWIGINTERN PyObject *_wrap_gpgme_signers_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12552 91 : PyObject *resultobj = 0;
12553 91 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12554 91 : void *argp1 = 0 ;
12555 91 : int res1 = 0 ;
12556 91 : PyObject * obj0 = 0 ;
12557 :
12558 91 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_signers_clear",&obj0)) SWIG_fail;
12559 91 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12560 91 : if (!SWIG_IsOK(res1)) {
12561 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_clear" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12562 : }
12563 91 : arg1 = (gpgme_ctx_t)(argp1);
12564 : {
12565 91 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12566 91 : gpgme_signers_clear(arg1);
12567 91 : SWIG_PYTHON_THREAD_END_ALLOW;
12568 : }
12569 91 : resultobj = SWIG_Py_Void();
12570 91 : return resultobj;
12571 : fail:
12572 : return NULL;
12573 : }
12574 :
12575 :
12576 12 : SWIGINTERN PyObject *_wrap_gpgme_signers_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12577 12 : PyObject *resultobj = 0;
12578 12 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12579 12 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
12580 12 : void *argp1 = 0 ;
12581 12 : int res1 = 0 ;
12582 12 : void *argp2 = 0 ;
12583 12 : int res2 = 0 ;
12584 12 : PyObject * obj0 = 0 ;
12585 12 : PyObject * obj1 = 0 ;
12586 : gpgme_error_t result;
12587 :
12588 12 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_signers_add",&obj0,&obj1)) SWIG_fail;
12589 12 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12590 12 : if (!SWIG_IsOK(res1)) {
12591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_add" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12592 : }
12593 12 : arg1 = (gpgme_ctx_t)(argp1);
12594 12 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
12595 12 : if (!SWIG_IsOK(res2)) {
12596 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_signers_add" "', argument " "2"" of type '" "gpgme_key_t const""'");
12597 : }
12598 12 : arg2 = (gpgme_key_t)(argp2);
12599 : {
12600 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12601 12 : result = gpgme_signers_add(arg1,arg2);
12602 12 : SWIG_PYTHON_THREAD_END_ALLOW;
12603 : }
12604 : {
12605 12 : resultobj = PyLong_FromLong(result);
12606 : }
12607 12 : return resultobj;
12608 : fail:
12609 : return NULL;
12610 : }
12611 :
12612 :
12613 91 : SWIGINTERN PyObject *_wrap_gpgme_signers_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12614 91 : PyObject *resultobj = 0;
12615 91 : gpgme_ctx_t arg1 = (gpgme_ctx_t) (gpgme_ctx_t)0 ;
12616 91 : void *argp1 = 0 ;
12617 91 : int res1 = 0 ;
12618 91 : PyObject * obj0 = 0 ;
12619 : unsigned int result;
12620 :
12621 91 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_signers_count",&obj0)) SWIG_fail;
12622 91 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12623 91 : if (!SWIG_IsOK(res1)) {
12624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_count" "', argument " "1"" of type '" "gpgme_ctx_t const""'");
12625 : }
12626 91 : arg1 = (gpgme_ctx_t)(argp1);
12627 : {
12628 91 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12629 91 : result = (unsigned int)gpgme_signers_count(arg1);
12630 91 : SWIG_PYTHON_THREAD_END_ALLOW;
12631 : }
12632 91 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
12633 91 : return resultobj;
12634 : fail:
12635 : return NULL;
12636 : }
12637 :
12638 :
12639 5 : SWIGINTERN PyObject *_wrap_gpgme_signers_enum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12640 5 : PyObject *resultobj = 0;
12641 5 : gpgme_ctx_t arg1 = (gpgme_ctx_t) (gpgme_ctx_t)0 ;
12642 : int arg2 ;
12643 5 : void *argp1 = 0 ;
12644 5 : int res1 = 0 ;
12645 : int val2 ;
12646 5 : int ecode2 = 0 ;
12647 5 : PyObject * obj0 = 0 ;
12648 5 : PyObject * obj1 = 0 ;
12649 : gpgme_key_t result;
12650 :
12651 5 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_signers_enum",&obj0,&obj1)) SWIG_fail;
12652 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12653 5 : if (!SWIG_IsOK(res1)) {
12654 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_enum" "', argument " "1"" of type '" "gpgme_ctx_t const""'");
12655 : }
12656 5 : arg1 = (gpgme_ctx_t)(argp1);
12657 10 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12658 5 : if (!SWIG_IsOK(ecode2)) {
12659 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_signers_enum" "', argument " "2"" of type '" "int""'");
12660 : }
12661 5 : arg2 = (int)(val2);
12662 : {
12663 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12664 5 : result = (gpgme_key_t)gpgme_signers_enum(arg1,arg2);
12665 5 : SWIG_PYTHON_THREAD_END_ALLOW;
12666 : }
12667 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
12668 5 : return resultobj;
12669 : fail:
12670 : return NULL;
12671 : }
12672 :
12673 :
12674 0 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12675 0 : PyObject *resultobj = 0;
12676 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12677 0 : void *argp1 = 0 ;
12678 0 : int res1 = 0 ;
12679 0 : PyObject * obj0 = 0 ;
12680 :
12681 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_sig_notation_clear",&obj0)) SWIG_fail;
12682 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12683 0 : if (!SWIG_IsOK(res1)) {
12684 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_clear" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12685 : }
12686 0 : arg1 = (gpgme_ctx_t)(argp1);
12687 : {
12688 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12689 0 : gpgme_sig_notation_clear(arg1);
12690 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12691 : }
12692 0 : resultobj = SWIG_Py_Void();
12693 0 : return resultobj;
12694 : fail:
12695 : return NULL;
12696 : }
12697 :
12698 :
12699 3 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12700 3 : PyObject *resultobj = 0;
12701 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12702 3 : char *arg2 = (char *) 0 ;
12703 3 : char *arg3 = (char *) 0 ;
12704 : gpgme_sig_notation_flags_t arg4 ;
12705 3 : void *argp1 = 0 ;
12706 3 : int res1 = 0 ;
12707 3 : PyObject *encodedInput2 = NULL ;
12708 3 : PyObject *encodedInput3 = NULL ;
12709 : unsigned int val4 ;
12710 3 : int ecode4 = 0 ;
12711 3 : PyObject * obj0 = 0 ;
12712 3 : PyObject * obj1 = 0 ;
12713 3 : PyObject * obj2 = 0 ;
12714 3 : PyObject * obj3 = 0 ;
12715 : gpgme_error_t result;
12716 :
12717 3 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_sig_notation_add",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12718 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12719 3 : if (!SWIG_IsOK(res1)) {
12720 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_add" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12721 : }
12722 3 : arg1 = (gpgme_ctx_t)(argp1);
12723 : {
12724 3 : if (obj1 == Py_None)
12725 : arg2 = NULL;
12726 2 : else if (PyUnicode_Check(obj1))
12727 : {
12728 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
12729 2 : if (encodedInput2 == NULL)
12730 : return NULL;
12731 2 : arg2 = PyBytes_AsString(encodedInput2);
12732 : }
12733 0 : else if (PyBytes_Check(obj1))
12734 0 : arg2 = PyBytes_AsString(obj1);
12735 : else {
12736 0 : PyErr_Format(PyExc_TypeError,
12737 : "arg %d: expected str, bytes, or None, got %s",
12738 : 2, obj1->ob_type->tp_name);
12739 0 : return NULL;
12740 : }
12741 : }
12742 : {
12743 3 : if (obj2 == Py_None)
12744 : arg3 = NULL;
12745 3 : else if (PyUnicode_Check(obj2))
12746 : {
12747 3 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
12748 3 : if (encodedInput3 == NULL)
12749 : return NULL;
12750 3 : arg3 = PyBytes_AsString(encodedInput3);
12751 : }
12752 0 : else if (PyBytes_Check(obj2))
12753 0 : arg3 = PyBytes_AsString(obj2);
12754 : else {
12755 0 : PyErr_Format(PyExc_TypeError,
12756 : "arg %d: expected str, bytes, or None, got %s",
12757 : 3, obj2->ob_type->tp_name);
12758 0 : return NULL;
12759 : }
12760 : }
12761 6 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
12762 3 : if (!SWIG_IsOK(ecode4)) {
12763 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_sig_notation_add" "', argument " "4"" of type '" "gpgme_sig_notation_flags_t""'");
12764 : }
12765 3 : arg4 = (gpgme_sig_notation_flags_t)(val4);
12766 : {
12767 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12768 3 : result = gpgme_sig_notation_add(arg1,(char const *)arg2,(char const *)arg3,arg4);
12769 3 : SWIG_PYTHON_THREAD_END_ALLOW;
12770 : }
12771 : {
12772 3 : resultobj = PyLong_FromLong(result);
12773 : }
12774 : {
12775 3 : Py_XDECREF(encodedInput2);
12776 : }
12777 : {
12778 3 : Py_XDECREF(encodedInput3);
12779 : }
12780 : return resultobj;
12781 : fail:
12782 : {
12783 0 : Py_XDECREF(encodedInput2);
12784 : }
12785 : {
12786 0 : Py_XDECREF(encodedInput3);
12787 : }
12788 : return NULL;
12789 : }
12790 :
12791 :
12792 0 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12793 0 : PyObject *resultobj = 0;
12794 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12795 0 : void *argp1 = 0 ;
12796 0 : int res1 = 0 ;
12797 0 : PyObject * obj0 = 0 ;
12798 : gpgme_sig_notation_t result;
12799 :
12800 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_sig_notation_get",&obj0)) SWIG_fail;
12801 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12802 0 : if (!SWIG_IsOK(res1)) {
12803 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_get" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12804 : }
12805 0 : arg1 = (gpgme_ctx_t)(argp1);
12806 : {
12807 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12808 0 : result = (gpgme_sig_notation_t)gpgme_sig_notation_get(arg1);
12809 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12810 : }
12811 : {
12812 : int i;
12813 0 : int size = 0;
12814 : gpgme_sig_notation_t curr;
12815 0 : for (curr = result; curr != NULL; curr = curr->next) {
12816 0 : size++;
12817 : }
12818 0 : resultobj = PyList_New(size);
12819 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
12820 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
12821 0 : PyList_SetItem(resultobj, i, o);
12822 : }
12823 : }
12824 : return resultobj;
12825 : fail:
12826 : return NULL;
12827 : }
12828 :
12829 :
12830 0 : SWIGINTERN PyObject *_wrap_gpgme_set_sender(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12831 0 : PyObject *resultobj = 0;
12832 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12833 0 : char *arg2 = (char *) 0 ;
12834 0 : void *argp1 = 0 ;
12835 0 : int res1 = 0 ;
12836 0 : PyObject *encodedInput2 = NULL ;
12837 0 : PyObject * obj0 = 0 ;
12838 0 : PyObject * obj1 = 0 ;
12839 : gpgme_error_t result;
12840 :
12841 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_sender",&obj0,&obj1)) SWIG_fail;
12842 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12843 0 : if (!SWIG_IsOK(res1)) {
12844 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_sender" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12845 : }
12846 0 : arg1 = (gpgme_ctx_t)(argp1);
12847 : {
12848 0 : if (obj1 == Py_None)
12849 : arg2 = NULL;
12850 0 : else if (PyUnicode_Check(obj1))
12851 : {
12852 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
12853 0 : if (encodedInput2 == NULL)
12854 : return NULL;
12855 0 : arg2 = PyBytes_AsString(encodedInput2);
12856 : }
12857 0 : else if (PyBytes_Check(obj1))
12858 0 : arg2 = PyBytes_AsString(obj1);
12859 : else {
12860 0 : PyErr_Format(PyExc_TypeError,
12861 : "arg %d: expected str, bytes, or None, got %s",
12862 : 2, obj1->ob_type->tp_name);
12863 0 : return NULL;
12864 : }
12865 : }
12866 : {
12867 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12868 0 : result = gpgme_set_sender(arg1,(char const *)arg2);
12869 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12870 : }
12871 : {
12872 0 : resultobj = PyLong_FromLong(result);
12873 : }
12874 : {
12875 0 : Py_XDECREF(encodedInput2);
12876 : }
12877 : return resultobj;
12878 : fail:
12879 : {
12880 : Py_XDECREF(encodedInput2);
12881 : }
12882 : return NULL;
12883 : }
12884 :
12885 :
12886 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sender(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12887 0 : PyObject *resultobj = 0;
12888 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12889 0 : void *argp1 = 0 ;
12890 0 : int res1 = 0 ;
12891 0 : PyObject * obj0 = 0 ;
12892 0 : char *result = 0 ;
12893 :
12894 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_sender",&obj0)) SWIG_fail;
12895 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12896 0 : if (!SWIG_IsOK(res1)) {
12897 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sender" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12898 : }
12899 0 : arg1 = (gpgme_ctx_t)(argp1);
12900 : {
12901 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12902 0 : result = (char *)gpgme_get_sender(arg1);
12903 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12904 : }
12905 0 : resultobj = SWIG_FromCharPtr((const char *)result);
12906 0 : return resultobj;
12907 : fail:
12908 : return NULL;
12909 : }
12910 :
12911 :
12912 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_err_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 0 : PyObject *resultobj = 0;
12914 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
12915 : gpgme_error_t arg2 ;
12916 0 : void *argp1 = 0 ;
12917 0 : int res1 = 0 ;
12918 0 : PyObject * obj0 = 0 ;
12919 0 : PyObject * obj1 = 0 ;
12920 :
12921 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_event_done_data_err_set",&obj0,&obj1)) SWIG_fail;
12922 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
12923 0 : if (!SWIG_IsOK(res1)) {
12924 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 *""'");
12925 : }
12926 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
12927 : {
12928 0 : if (PyLong_Check(obj1))
12929 0 : arg2 = PyLong_AsLong(obj1);
12930 :
12931 : else if (PyInt_Check(obj1))
12932 : arg2 = PyInt_AsLong(obj1);
12933 :
12934 : else
12935 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
12936 : }
12937 : {
12938 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12939 0 : if (arg1) (arg1)->err = arg2;
12940 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12941 : }
12942 0 : resultobj = SWIG_Py_Void();
12943 0 : return resultobj;
12944 : fail:
12945 : return NULL;
12946 : }
12947 :
12948 :
12949 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_err_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12950 0 : PyObject *resultobj = 0;
12951 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
12952 0 : void *argp1 = 0 ;
12953 0 : int res1 = 0 ;
12954 0 : PyObject * obj0 = 0 ;
12955 : gpgme_error_t result;
12956 :
12957 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_event_done_data_err_get",&obj0)) SWIG_fail;
12958 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
12959 0 : if (!SWIG_IsOK(res1)) {
12960 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 *""'");
12961 : }
12962 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
12963 : {
12964 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12965 0 : result = ((arg1)->err);
12966 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12967 : }
12968 : {
12969 0 : resultobj = PyLong_FromLong(result);
12970 : }
12971 0 : return resultobj;
12972 : fail:
12973 : return NULL;
12974 : }
12975 :
12976 :
12977 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_op_err_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 0 : PyObject *resultobj = 0;
12979 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
12980 : gpgme_error_t arg2 ;
12981 0 : void *argp1 = 0 ;
12982 0 : int res1 = 0 ;
12983 0 : PyObject * obj0 = 0 ;
12984 0 : PyObject * obj1 = 0 ;
12985 :
12986 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_event_done_data_op_err_set",&obj0,&obj1)) SWIG_fail;
12987 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
12988 0 : if (!SWIG_IsOK(res1)) {
12989 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 *""'");
12990 : }
12991 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
12992 : {
12993 0 : if (PyLong_Check(obj1))
12994 0 : arg2 = PyLong_AsLong(obj1);
12995 :
12996 : else if (PyInt_Check(obj1))
12997 : arg2 = PyInt_AsLong(obj1);
12998 :
12999 : else
13000 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
13001 : }
13002 : {
13003 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13004 0 : if (arg1) (arg1)->op_err = arg2;
13005 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13006 : }
13007 0 : resultobj = SWIG_Py_Void();
13008 0 : return resultobj;
13009 : fail:
13010 : return NULL;
13011 : }
13012 :
13013 :
13014 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_op_err_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 0 : PyObject *resultobj = 0;
13016 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
13017 0 : void *argp1 = 0 ;
13018 0 : int res1 = 0 ;
13019 0 : PyObject * obj0 = 0 ;
13020 : gpgme_error_t result;
13021 :
13022 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_event_done_data_op_err_get",&obj0)) SWIG_fail;
13023 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
13024 0 : if (!SWIG_IsOK(res1)) {
13025 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 *""'");
13026 : }
13027 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
13028 : {
13029 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13030 0 : result = ((arg1)->op_err);
13031 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13032 : }
13033 : {
13034 0 : resultobj = PyLong_FromLong(result);
13035 : }
13036 0 : return resultobj;
13037 : fail:
13038 : return NULL;
13039 : }
13040 :
13041 :
13042 0 : SWIGINTERN PyObject *_wrap_new_gpgme_io_event_done_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13043 0 : PyObject *resultobj = 0;
13044 0 : struct gpgme_io_event_done_data *result = 0 ;
13045 :
13046 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_io_event_done_data")) SWIG_fail;
13047 : {
13048 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13049 0 : result = (struct gpgme_io_event_done_data *)calloc(1, sizeof(struct gpgme_io_event_done_data));
13050 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13051 : }
13052 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_io_event_done_data, SWIG_POINTER_NEW | 0 );
13053 0 : return resultobj;
13054 : fail:
13055 : return NULL;
13056 : }
13057 :
13058 :
13059 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_io_event_done_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13060 0 : PyObject *resultobj = 0;
13061 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
13062 0 : void *argp1 = 0 ;
13063 0 : int res1 = 0 ;
13064 0 : PyObject * obj0 = 0 ;
13065 :
13066 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_io_event_done_data",&obj0)) SWIG_fail;
13067 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, SWIG_POINTER_DISOWN | 0 );
13068 0 : if (!SWIG_IsOK(res1)) {
13069 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 *""'");
13070 : }
13071 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
13072 : {
13073 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13074 0 : free((char *) arg1);
13075 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13076 : }
13077 0 : resultobj = SWIG_Py_Void();
13078 0 : return resultobj;
13079 : fail:
13080 : return NULL;
13081 : }
13082 :
13083 :
13084 29 : SWIGINTERN PyObject *gpgme_io_event_done_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 : PyObject *obj;
13086 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
13087 58 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_io_event_done_data, SWIG_NewClientData(obj));
13088 29 : return SWIG_Py_Void();
13089 : }
13090 :
13091 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13092 0 : PyObject *resultobj = 0;
13093 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13094 0 : gpgme_register_io_cb_t arg2 = (gpgme_register_io_cb_t) 0 ;
13095 0 : void *argp1 = 0 ;
13096 0 : int res1 = 0 ;
13097 0 : PyObject * obj0 = 0 ;
13098 0 : PyObject * obj1 = 0 ;
13099 :
13100 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_add_set",&obj0,&obj1)) SWIG_fail;
13101 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13102 0 : if (!SWIG_IsOK(res1)) {
13103 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13104 : }
13105 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13106 : {
13107 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);
13108 0 : if (!SWIG_IsOK(res)) {
13109 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_add_set" "', argument " "2"" of type '" "gpgme_register_io_cb_t""'");
13110 : }
13111 : }
13112 : {
13113 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13114 0 : if (arg1) (arg1)->add = arg2;
13115 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13116 : }
13117 0 : resultobj = SWIG_Py_Void();
13118 0 : return resultobj;
13119 : fail:
13120 : return NULL;
13121 : }
13122 :
13123 :
13124 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13125 0 : PyObject *resultobj = 0;
13126 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13127 0 : void *argp1 = 0 ;
13128 0 : int res1 = 0 ;
13129 0 : PyObject * obj0 = 0 ;
13130 : gpgme_register_io_cb_t result;
13131 :
13132 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_add_get",&obj0)) SWIG_fail;
13133 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13134 0 : if (!SWIG_IsOK(res1)) {
13135 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13136 : }
13137 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13138 : {
13139 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13140 0 : result = (gpgme_register_io_cb_t) ((arg1)->add);
13141 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13142 : }
13143 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);
13144 0 : return resultobj;
13145 : fail:
13146 : return NULL;
13147 : }
13148 :
13149 :
13150 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_priv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13151 0 : PyObject *resultobj = 0;
13152 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13153 0 : void *arg2 = (void *) 0 ;
13154 0 : void *argp1 = 0 ;
13155 0 : int res1 = 0 ;
13156 : int res2 ;
13157 0 : PyObject * obj0 = 0 ;
13158 0 : PyObject * obj1 = 0 ;
13159 :
13160 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_add_priv_set",&obj0,&obj1)) SWIG_fail;
13161 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13162 0 : if (!SWIG_IsOK(res1)) {
13163 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_priv_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13164 : }
13165 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13166 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
13167 0 : if (!SWIG_IsOK(res2)) {
13168 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_cbs_add_priv_set" "', argument " "2"" of type '" "void *""'");
13169 : }
13170 : {
13171 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13172 0 : if (arg1) (arg1)->add_priv = arg2;
13173 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13174 : }
13175 0 : resultobj = SWIG_Py_Void();
13176 0 : return resultobj;
13177 : fail:
13178 : return NULL;
13179 : }
13180 :
13181 :
13182 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_priv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13183 0 : PyObject *resultobj = 0;
13184 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13185 0 : void *argp1 = 0 ;
13186 0 : int res1 = 0 ;
13187 0 : PyObject * obj0 = 0 ;
13188 0 : void *result = 0 ;
13189 :
13190 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_add_priv_get",&obj0)) SWIG_fail;
13191 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13192 0 : if (!SWIG_IsOK(res1)) {
13193 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_priv_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13194 : }
13195 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13196 : {
13197 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13198 0 : result = (void *) ((arg1)->add_priv);
13199 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13200 : }
13201 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
13202 0 : return resultobj;
13203 : fail:
13204 : return NULL;
13205 : }
13206 :
13207 :
13208 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_remove_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13209 0 : PyObject *resultobj = 0;
13210 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13211 0 : gpgme_remove_io_cb_t arg2 = (gpgme_remove_io_cb_t) 0 ;
13212 0 : void *argp1 = 0 ;
13213 0 : int res1 = 0 ;
13214 0 : PyObject * obj0 = 0 ;
13215 0 : PyObject * obj1 = 0 ;
13216 :
13217 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_remove_set",&obj0,&obj1)) SWIG_fail;
13218 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13219 0 : if (!SWIG_IsOK(res1)) {
13220 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_remove_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13221 : }
13222 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13223 : {
13224 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
13225 0 : if (!SWIG_IsOK(res)) {
13226 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_remove_set" "', argument " "2"" of type '" "gpgme_remove_io_cb_t""'");
13227 : }
13228 : }
13229 : {
13230 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13231 0 : if (arg1) (arg1)->remove = arg2;
13232 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13233 : }
13234 0 : resultobj = SWIG_Py_Void();
13235 0 : return resultobj;
13236 : fail:
13237 : return NULL;
13238 : }
13239 :
13240 :
13241 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_remove_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13242 0 : PyObject *resultobj = 0;
13243 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13244 0 : void *argp1 = 0 ;
13245 0 : int res1 = 0 ;
13246 0 : PyObject * obj0 = 0 ;
13247 : gpgme_remove_io_cb_t result;
13248 :
13249 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_remove_get",&obj0)) SWIG_fail;
13250 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13251 0 : if (!SWIG_IsOK(res1)) {
13252 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_remove_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13253 : }
13254 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13255 : {
13256 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13257 0 : result = (gpgme_remove_io_cb_t) ((arg1)->remove);
13258 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13259 : }
13260 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
13261 0 : return resultobj;
13262 : fail:
13263 : return NULL;
13264 : }
13265 :
13266 :
13267 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13268 0 : PyObject *resultobj = 0;
13269 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13270 0 : gpgme_event_io_cb_t arg2 = (gpgme_event_io_cb_t) 0 ;
13271 0 : void *argp1 = 0 ;
13272 0 : int res1 = 0 ;
13273 0 : PyObject * obj0 = 0 ;
13274 0 : PyObject * obj1 = 0 ;
13275 :
13276 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_event_set",&obj0,&obj1)) SWIG_fail;
13277 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13278 0 : if (!SWIG_IsOK(res1)) {
13279 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13280 : }
13281 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13282 : {
13283 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_enum_gpgme_event_io_t_p_void__void);
13284 0 : if (!SWIG_IsOK(res)) {
13285 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_event_set" "', argument " "2"" of type '" "gpgme_event_io_cb_t""'");
13286 : }
13287 : }
13288 : {
13289 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13290 0 : if (arg1) (arg1)->event = arg2;
13291 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13292 : }
13293 0 : resultobj = SWIG_Py_Void();
13294 0 : return resultobj;
13295 : fail:
13296 : return NULL;
13297 : }
13298 :
13299 :
13300 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13301 0 : PyObject *resultobj = 0;
13302 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13303 0 : void *argp1 = 0 ;
13304 0 : int res1 = 0 ;
13305 0 : PyObject * obj0 = 0 ;
13306 : gpgme_event_io_cb_t result;
13307 :
13308 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_event_get",&obj0)) SWIG_fail;
13309 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13310 0 : if (!SWIG_IsOK(res1)) {
13311 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13312 : }
13313 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13314 : {
13315 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13316 0 : result = (gpgme_event_io_cb_t) ((arg1)->event);
13317 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13318 : }
13319 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_enum_gpgme_event_io_t_p_void__void);
13320 0 : return resultobj;
13321 : fail:
13322 : return NULL;
13323 : }
13324 :
13325 :
13326 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_priv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13327 0 : PyObject *resultobj = 0;
13328 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13329 0 : void *arg2 = (void *) 0 ;
13330 0 : void *argp1 = 0 ;
13331 0 : int res1 = 0 ;
13332 : int res2 ;
13333 0 : PyObject * obj0 = 0 ;
13334 0 : PyObject * obj1 = 0 ;
13335 :
13336 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_event_priv_set",&obj0,&obj1)) SWIG_fail;
13337 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13338 0 : if (!SWIG_IsOK(res1)) {
13339 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_priv_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13340 : }
13341 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13342 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
13343 0 : if (!SWIG_IsOK(res2)) {
13344 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_cbs_event_priv_set" "', argument " "2"" of type '" "void *""'");
13345 : }
13346 : {
13347 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13348 0 : if (arg1) (arg1)->event_priv = arg2;
13349 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13350 : }
13351 0 : resultobj = SWIG_Py_Void();
13352 0 : return resultobj;
13353 : fail:
13354 : return NULL;
13355 : }
13356 :
13357 :
13358 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_priv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13359 0 : PyObject *resultobj = 0;
13360 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13361 0 : void *argp1 = 0 ;
13362 0 : int res1 = 0 ;
13363 0 : PyObject * obj0 = 0 ;
13364 0 : void *result = 0 ;
13365 :
13366 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_event_priv_get",&obj0)) SWIG_fail;
13367 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13368 0 : if (!SWIG_IsOK(res1)) {
13369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_priv_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13370 : }
13371 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13372 : {
13373 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13374 0 : result = (void *) ((arg1)->event_priv);
13375 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13376 : }
13377 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
13378 0 : return resultobj;
13379 : fail:
13380 : return NULL;
13381 : }
13382 :
13383 :
13384 0 : SWIGINTERN PyObject *_wrap_new_gpgme_io_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13385 0 : PyObject *resultobj = 0;
13386 0 : struct gpgme_io_cbs *result = 0 ;
13387 :
13388 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_io_cbs")) SWIG_fail;
13389 : {
13390 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13391 0 : result = (struct gpgme_io_cbs *)calloc(1, sizeof(struct gpgme_io_cbs));
13392 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13393 : }
13394 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_io_cbs, SWIG_POINTER_NEW | 0 );
13395 0 : return resultobj;
13396 : fail:
13397 : return NULL;
13398 : }
13399 :
13400 :
13401 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_io_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13402 0 : PyObject *resultobj = 0;
13403 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
13404 0 : void *argp1 = 0 ;
13405 0 : int res1 = 0 ;
13406 0 : PyObject * obj0 = 0 ;
13407 :
13408 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_io_cbs",&obj0)) SWIG_fail;
13409 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, SWIG_POINTER_DISOWN | 0 );
13410 0 : if (!SWIG_IsOK(res1)) {
13411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_io_cbs" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
13412 : }
13413 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
13414 : {
13415 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13416 0 : free((char *) arg1);
13417 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13418 : }
13419 0 : resultobj = SWIG_Py_Void();
13420 0 : return resultobj;
13421 : fail:
13422 : return NULL;
13423 : }
13424 :
13425 :
13426 29 : SWIGINTERN PyObject *gpgme_io_cbs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13427 : PyObject *obj;
13428 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
13429 58 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_io_cbs, SWIG_NewClientData(obj));
13430 29 : return SWIG_Py_Void();
13431 : }
13432 :
13433 0 : SWIGINTERN PyObject *_wrap_gpgme_set_io_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13434 0 : PyObject *resultobj = 0;
13435 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13436 0 : gpgme_io_cbs_t arg2 = (gpgme_io_cbs_t) 0 ;
13437 0 : void *argp1 = 0 ;
13438 0 : int res1 = 0 ;
13439 0 : void *argp2 = 0 ;
13440 0 : int res2 = 0 ;
13441 0 : PyObject * obj0 = 0 ;
13442 0 : PyObject * obj1 = 0 ;
13443 :
13444 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_io_cbs",&obj0,&obj1)) SWIG_fail;
13445 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13446 0 : if (!SWIG_IsOK(res1)) {
13447 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_io_cbs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13448 : }
13449 0 : arg1 = (gpgme_ctx_t)(argp1);
13450 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13451 0 : if (!SWIG_IsOK(res2)) {
13452 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_set_io_cbs" "', argument " "2"" of type '" "gpgme_io_cbs_t""'");
13453 : }
13454 0 : arg2 = (gpgme_io_cbs_t)(argp2);
13455 : {
13456 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13457 0 : gpgme_set_io_cbs(arg1,arg2);
13458 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13459 : }
13460 0 : resultobj = SWIG_Py_Void();
13461 0 : return resultobj;
13462 : fail:
13463 : return NULL;
13464 : }
13465 :
13466 :
13467 0 : SWIGINTERN PyObject *_wrap_gpgme_get_io_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13468 0 : PyObject *resultobj = 0;
13469 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13470 0 : gpgme_io_cbs_t arg2 = (gpgme_io_cbs_t) 0 ;
13471 0 : void *argp1 = 0 ;
13472 0 : int res1 = 0 ;
13473 0 : void *argp2 = 0 ;
13474 0 : int res2 = 0 ;
13475 0 : PyObject * obj0 = 0 ;
13476 0 : PyObject * obj1 = 0 ;
13477 :
13478 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_get_io_cbs",&obj0,&obj1)) SWIG_fail;
13479 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13480 0 : if (!SWIG_IsOK(res1)) {
13481 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_io_cbs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13482 : }
13483 0 : arg1 = (gpgme_ctx_t)(argp1);
13484 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13485 0 : if (!SWIG_IsOK(res2)) {
13486 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_io_cbs" "', argument " "2"" of type '" "gpgme_io_cbs_t""'");
13487 : }
13488 0 : arg2 = (gpgme_io_cbs_t)(argp2);
13489 : {
13490 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13491 0 : gpgme_get_io_cbs(arg1,arg2);
13492 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13493 : }
13494 0 : resultobj = SWIG_Py_Void();
13495 0 : return resultobj;
13496 : fail:
13497 : return NULL;
13498 : }
13499 :
13500 :
13501 0 : SWIGINTERN PyObject *_wrap_gpgme_io_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13502 0 : PyObject *resultobj = 0;
13503 : int arg1 ;
13504 0 : void *arg2 = (void *) 0 ;
13505 : size_t arg3 ;
13506 : int val1 ;
13507 0 : int ecode1 = 0 ;
13508 : int res2 ;
13509 : size_t val3 ;
13510 0 : int ecode3 = 0 ;
13511 0 : PyObject * obj0 = 0 ;
13512 0 : PyObject * obj1 = 0 ;
13513 0 : PyObject * obj2 = 0 ;
13514 : ssize_t result;
13515 :
13516 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_read",&obj0,&obj1,&obj2)) SWIG_fail;
13517 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
13518 0 : if (!SWIG_IsOK(ecode1)) {
13519 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_read" "', argument " "1"" of type '" "int""'");
13520 : }
13521 0 : arg1 = (int)(val1);
13522 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
13523 0 : if (!SWIG_IsOK(res2)) {
13524 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_read" "', argument " "2"" of type '" "void *""'");
13525 : }
13526 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13527 0 : if (!SWIG_IsOK(ecode3)) {
13528 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_read" "', argument " "3"" of type '" "size_t""'");
13529 : }
13530 0 : arg3 = (size_t)(val3);
13531 : {
13532 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13533 0 : result = gpgme_io_read(arg1,arg2,arg3);
13534 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13535 : }
13536 : {
13537 0 : resultobj = PyLong_FromLong(result);
13538 : }
13539 0 : return resultobj;
13540 : fail:
13541 : return NULL;
13542 : }
13543 :
13544 :
13545 0 : SWIGINTERN PyObject *_wrap_gpgme_io_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13546 0 : PyObject *resultobj = 0;
13547 : int arg1 ;
13548 0 : void *arg2 = (void *) 0 ;
13549 : size_t arg3 ;
13550 : int val1 ;
13551 0 : int ecode1 = 0 ;
13552 : int res2 ;
13553 : size_t val3 ;
13554 0 : int ecode3 = 0 ;
13555 0 : PyObject * obj0 = 0 ;
13556 0 : PyObject * obj1 = 0 ;
13557 0 : PyObject * obj2 = 0 ;
13558 : ssize_t result;
13559 :
13560 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_write",&obj0,&obj1,&obj2)) SWIG_fail;
13561 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
13562 0 : if (!SWIG_IsOK(ecode1)) {
13563 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_write" "', argument " "1"" of type '" "int""'");
13564 : }
13565 0 : arg1 = (int)(val1);
13566 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
13567 0 : if (!SWIG_IsOK(res2)) {
13568 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_write" "', argument " "2"" of type '" "void const *""'");
13569 : }
13570 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13571 0 : if (!SWIG_IsOK(ecode3)) {
13572 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_write" "', argument " "3"" of type '" "size_t""'");
13573 : }
13574 0 : arg3 = (size_t)(val3);
13575 : {
13576 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13577 0 : result = gpgme_io_write(arg1,(void const *)arg2,arg3);
13578 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13579 : }
13580 : {
13581 0 : resultobj = PyLong_FromLong(result);
13582 : }
13583 0 : return resultobj;
13584 : fail:
13585 : return NULL;
13586 : }
13587 :
13588 :
13589 0 : SWIGINTERN PyObject *_wrap_gpgme_io_writen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13590 0 : PyObject *resultobj = 0;
13591 : int arg1 ;
13592 0 : void *arg2 = (void *) 0 ;
13593 : size_t arg3 ;
13594 : int val1 ;
13595 0 : int ecode1 = 0 ;
13596 : int res2 ;
13597 : size_t val3 ;
13598 0 : int ecode3 = 0 ;
13599 0 : PyObject * obj0 = 0 ;
13600 0 : PyObject * obj1 = 0 ;
13601 0 : PyObject * obj2 = 0 ;
13602 : int result;
13603 :
13604 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_writen",&obj0,&obj1,&obj2)) SWIG_fail;
13605 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
13606 0 : if (!SWIG_IsOK(ecode1)) {
13607 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_writen" "', argument " "1"" of type '" "int""'");
13608 : }
13609 0 : arg1 = (int)(val1);
13610 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
13611 0 : if (!SWIG_IsOK(res2)) {
13612 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_writen" "', argument " "2"" of type '" "void const *""'");
13613 : }
13614 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13615 0 : if (!SWIG_IsOK(ecode3)) {
13616 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_writen" "', argument " "3"" of type '" "size_t""'");
13617 : }
13618 0 : arg3 = (size_t)(val3);
13619 : {
13620 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13621 0 : result = (int)gpgme_io_writen(arg1,(void const *)arg2,arg3);
13622 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13623 : }
13624 0 : resultobj = SWIG_From_int((int)(result));
13625 0 : return resultobj;
13626 : fail:
13627 : return NULL;
13628 : }
13629 :
13630 :
13631 3 : SWIGINTERN PyObject *_wrap_gpgme_wait(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13632 3 : PyObject *resultobj = 0;
13633 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13634 3 : gpgme_error_t *arg2 = (gpgme_error_t *) 0 ;
13635 : int arg3 ;
13636 3 : void *argp1 = 0 ;
13637 3 : int res1 = 0 ;
13638 3 : void *argp2 = 0 ;
13639 3 : int res2 = 0 ;
13640 : int val3 ;
13641 3 : int ecode3 = 0 ;
13642 3 : PyObject * obj0 = 0 ;
13643 3 : PyObject * obj1 = 0 ;
13644 3 : PyObject * obj2 = 0 ;
13645 : gpgme_ctx_t result;
13646 :
13647 3 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_wait",&obj0,&obj1,&obj2)) SWIG_fail;
13648 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13649 3 : if (!SWIG_IsOK(res1)) {
13650 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_wait" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13651 : }
13652 3 : arg1 = (gpgme_ctx_t)(argp1);
13653 3 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpg_error_t, 0 | 0 );
13654 3 : if (!SWIG_IsOK(res2)) {
13655 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_wait" "', argument " "2"" of type '" "gpgme_error_t *""'");
13656 : }
13657 3 : arg2 = (gpgme_error_t *)(argp2);
13658 6 : ecode3 = SWIG_AsVal_int(obj2, &val3);
13659 3 : if (!SWIG_IsOK(ecode3)) {
13660 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_wait" "', argument " "3"" of type '" "int""'");
13661 : }
13662 3 : arg3 = (int)(val3);
13663 : {
13664 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13665 3 : result = (gpgme_ctx_t)gpgme_wait(arg1,arg2,arg3);
13666 3 : SWIG_PYTHON_THREAD_END_ALLOW;
13667 : }
13668 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
13669 3 : return resultobj;
13670 : fail:
13671 : return NULL;
13672 : }
13673 :
13674 :
13675 0 : SWIGINTERN PyObject *_wrap_gpgme_wait_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13676 0 : PyObject *resultobj = 0;
13677 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13678 0 : gpgme_error_t *arg2 = (gpgme_error_t *) 0 ;
13679 0 : gpgme_error_t *arg3 = (gpgme_error_t *) 0 ;
13680 : int arg4 ;
13681 0 : void *argp1 = 0 ;
13682 0 : int res1 = 0 ;
13683 0 : void *argp2 = 0 ;
13684 0 : int res2 = 0 ;
13685 0 : void *argp3 = 0 ;
13686 0 : int res3 = 0 ;
13687 : int val4 ;
13688 0 : int ecode4 = 0 ;
13689 0 : PyObject * obj0 = 0 ;
13690 0 : PyObject * obj1 = 0 ;
13691 0 : PyObject * obj2 = 0 ;
13692 0 : PyObject * obj3 = 0 ;
13693 : gpgme_ctx_t result;
13694 :
13695 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_wait_ext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13696 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13697 0 : if (!SWIG_IsOK(res1)) {
13698 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_wait_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13699 : }
13700 0 : arg1 = (gpgme_ctx_t)(argp1);
13701 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpg_error_t, 0 | 0 );
13702 0 : if (!SWIG_IsOK(res2)) {
13703 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_wait_ext" "', argument " "2"" of type '" "gpgme_error_t *""'");
13704 : }
13705 0 : arg2 = (gpgme_error_t *)(argp2);
13706 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_gpg_error_t, 0 | 0 );
13707 0 : if (!SWIG_IsOK(res3)) {
13708 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_wait_ext" "', argument " "3"" of type '" "gpgme_error_t *""'");
13709 : }
13710 0 : arg3 = (gpgme_error_t *)(argp3);
13711 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
13712 0 : if (!SWIG_IsOK(ecode4)) {
13713 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_wait_ext" "', argument " "4"" of type '" "int""'");
13714 : }
13715 0 : arg4 = (int)(val4);
13716 : {
13717 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13718 0 : result = (gpgme_ctx_t)gpgme_wait_ext(arg1,arg2,arg3,arg4);
13719 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13720 : }
13721 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
13722 0 : return resultobj;
13723 : fail:
13724 : return NULL;
13725 : }
13726 :
13727 :
13728 0 : SWIGINTERN PyObject *_wrap_gpgme_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13729 0 : PyObject *resultobj = 0;
13730 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13731 0 : void *argp1 = 0 ;
13732 0 : int res1 = 0 ;
13733 0 : PyObject * obj0 = 0 ;
13734 : gpgme_error_t result;
13735 :
13736 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_cancel",&obj0)) SWIG_fail;
13737 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13738 0 : if (!SWIG_IsOK(res1)) {
13739 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_cancel" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13740 : }
13741 0 : arg1 = (gpgme_ctx_t)(argp1);
13742 : {
13743 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13744 0 : result = gpgme_cancel(arg1);
13745 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13746 : }
13747 : {
13748 0 : resultobj = PyLong_FromLong(result);
13749 : }
13750 0 : return resultobj;
13751 : fail:
13752 : return NULL;
13753 : }
13754 :
13755 :
13756 0 : SWIGINTERN PyObject *_wrap_gpgme_cancel_async(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13757 0 : PyObject *resultobj = 0;
13758 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13759 0 : void *argp1 = 0 ;
13760 0 : int res1 = 0 ;
13761 0 : PyObject * obj0 = 0 ;
13762 : gpgme_error_t result;
13763 :
13764 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_cancel_async",&obj0)) SWIG_fail;
13765 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13766 0 : if (!SWIG_IsOK(res1)) {
13767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_cancel_async" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13768 : }
13769 0 : arg1 = (gpgme_ctx_t)(argp1);
13770 : {
13771 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13772 0 : result = gpgme_cancel_async(arg1);
13773 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13774 : }
13775 : {
13776 0 : resultobj = PyLong_FromLong(result);
13777 : }
13778 0 : return resultobj;
13779 : fail:
13780 : return NULL;
13781 : }
13782 :
13783 :
13784 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_read_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13785 0 : PyObject *resultobj = 0;
13786 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13787 0 : gpgme_data_read_cb_t arg2 = (gpgme_data_read_cb_t) 0 ;
13788 0 : void *argp1 = 0 ;
13789 0 : int res1 = 0 ;
13790 0 : PyObject * obj0 = 0 ;
13791 0 : PyObject * obj1 = 0 ;
13792 :
13793 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_cbs_read_set",&obj0,&obj1)) SWIG_fail;
13794 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13795 0 : if (!SWIG_IsOK(res1)) {
13796 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_read_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13797 : }
13798 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13799 : {
13800 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t);
13801 0 : if (!SWIG_IsOK(res)) {
13802 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_read_set" "', argument " "2"" of type '" "gpgme_data_read_cb_t""'");
13803 : }
13804 : }
13805 : {
13806 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13807 0 : if (arg1) (arg1)->read = arg2;
13808 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13809 : }
13810 0 : resultobj = SWIG_Py_Void();
13811 0 : return resultobj;
13812 : fail:
13813 : return NULL;
13814 : }
13815 :
13816 :
13817 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_read_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13818 0 : PyObject *resultobj = 0;
13819 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13820 0 : void *argp1 = 0 ;
13821 0 : int res1 = 0 ;
13822 0 : PyObject * obj0 = 0 ;
13823 : gpgme_data_read_cb_t result;
13824 :
13825 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_read_get",&obj0)) SWIG_fail;
13826 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13827 0 : if (!SWIG_IsOK(res1)) {
13828 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_read_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13829 : }
13830 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13831 : {
13832 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13833 0 : result = (gpgme_data_read_cb_t) ((arg1)->read);
13834 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13835 : }
13836 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t);
13837 0 : return resultobj;
13838 : fail:
13839 : return NULL;
13840 : }
13841 :
13842 :
13843 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_write_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13844 0 : PyObject *resultobj = 0;
13845 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13846 0 : gpgme_data_write_cb_t arg2 = (gpgme_data_write_cb_t) 0 ;
13847 0 : void *argp1 = 0 ;
13848 0 : int res1 = 0 ;
13849 0 : PyObject * obj0 = 0 ;
13850 0 : PyObject * obj1 = 0 ;
13851 :
13852 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_cbs_write_set",&obj0,&obj1)) SWIG_fail;
13853 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13854 0 : if (!SWIG_IsOK(res1)) {
13855 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_write_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13856 : }
13857 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13858 : {
13859 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t);
13860 0 : if (!SWIG_IsOK(res)) {
13861 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_write_set" "', argument " "2"" of type '" "gpgme_data_write_cb_t""'");
13862 : }
13863 : }
13864 : {
13865 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13866 0 : if (arg1) (arg1)->write = arg2;
13867 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13868 : }
13869 0 : resultobj = SWIG_Py_Void();
13870 0 : return resultobj;
13871 : fail:
13872 : return NULL;
13873 : }
13874 :
13875 :
13876 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_write_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13877 0 : PyObject *resultobj = 0;
13878 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13879 0 : void *argp1 = 0 ;
13880 0 : int res1 = 0 ;
13881 0 : PyObject * obj0 = 0 ;
13882 : gpgme_data_write_cb_t result;
13883 :
13884 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_write_get",&obj0)) SWIG_fail;
13885 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13886 0 : if (!SWIG_IsOK(res1)) {
13887 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_write_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13888 : }
13889 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13890 : {
13891 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13892 0 : result = (gpgme_data_write_cb_t) ((arg1)->write);
13893 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13894 : }
13895 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t);
13896 0 : return resultobj;
13897 : fail:
13898 : return NULL;
13899 : }
13900 :
13901 :
13902 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_seek_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13903 0 : PyObject *resultobj = 0;
13904 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13905 0 : gpgme_data_seek_cb_t arg2 = (gpgme_data_seek_cb_t) 0 ;
13906 0 : void *argp1 = 0 ;
13907 0 : int res1 = 0 ;
13908 0 : PyObject * obj0 = 0 ;
13909 0 : PyObject * obj1 = 0 ;
13910 :
13911 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_cbs_seek_set",&obj0,&obj1)) SWIG_fail;
13912 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13913 0 : if (!SWIG_IsOK(res1)) {
13914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_seek_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13915 : }
13916 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13917 : {
13918 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_off_t_int__off_t);
13919 0 : if (!SWIG_IsOK(res)) {
13920 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_seek_set" "', argument " "2"" of type '" "gpgme_data_seek_cb_t""'");
13921 : }
13922 : }
13923 : {
13924 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13925 0 : if (arg1) (arg1)->seek = arg2;
13926 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13927 : }
13928 0 : resultobj = SWIG_Py_Void();
13929 0 : return resultobj;
13930 : fail:
13931 : return NULL;
13932 : }
13933 :
13934 :
13935 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_seek_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13936 0 : PyObject *resultobj = 0;
13937 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13938 0 : void *argp1 = 0 ;
13939 0 : int res1 = 0 ;
13940 0 : PyObject * obj0 = 0 ;
13941 : gpgme_data_seek_cb_t result;
13942 :
13943 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_seek_get",&obj0)) SWIG_fail;
13944 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13945 0 : if (!SWIG_IsOK(res1)) {
13946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_seek_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13947 : }
13948 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13949 : {
13950 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13951 0 : result = (gpgme_data_seek_cb_t) ((arg1)->seek);
13952 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13953 : }
13954 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_off_t_int__off_t);
13955 0 : return resultobj;
13956 : fail:
13957 : return NULL;
13958 : }
13959 :
13960 :
13961 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_release_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13962 0 : PyObject *resultobj = 0;
13963 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13964 0 : gpgme_data_release_cb_t arg2 = (gpgme_data_release_cb_t) 0 ;
13965 0 : void *argp1 = 0 ;
13966 0 : int res1 = 0 ;
13967 0 : PyObject * obj0 = 0 ;
13968 0 : PyObject * obj1 = 0 ;
13969 :
13970 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_cbs_release_set",&obj0,&obj1)) SWIG_fail;
13971 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13972 0 : if (!SWIG_IsOK(res1)) {
13973 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_release_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13974 : }
13975 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13976 : {
13977 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
13978 0 : if (!SWIG_IsOK(res)) {
13979 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_release_set" "', argument " "2"" of type '" "gpgme_data_release_cb_t""'");
13980 : }
13981 : }
13982 : {
13983 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13984 0 : if (arg1) (arg1)->release = arg2;
13985 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13986 : }
13987 0 : resultobj = SWIG_Py_Void();
13988 0 : return resultobj;
13989 : fail:
13990 : return NULL;
13991 : }
13992 :
13993 :
13994 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_release_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13995 0 : PyObject *resultobj = 0;
13996 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13997 0 : void *argp1 = 0 ;
13998 0 : int res1 = 0 ;
13999 0 : PyObject * obj0 = 0 ;
14000 : gpgme_data_release_cb_t result;
14001 :
14002 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_release_get",&obj0)) SWIG_fail;
14003 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
14004 0 : if (!SWIG_IsOK(res1)) {
14005 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_release_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
14006 : }
14007 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
14008 : {
14009 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14010 0 : result = (gpgme_data_release_cb_t) ((arg1)->release);
14011 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14012 : }
14013 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
14014 0 : return resultobj;
14015 : fail:
14016 : return NULL;
14017 : }
14018 :
14019 :
14020 0 : SWIGINTERN PyObject *_wrap_new_gpgme_data_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14021 0 : PyObject *resultobj = 0;
14022 0 : struct gpgme_data_cbs *result = 0 ;
14023 :
14024 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_data_cbs")) SWIG_fail;
14025 : {
14026 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14027 0 : result = (struct gpgme_data_cbs *)calloc(1, sizeof(struct gpgme_data_cbs));
14028 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14029 : }
14030 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data_cbs, SWIG_POINTER_NEW | 0 );
14031 0 : return resultobj;
14032 : fail:
14033 : return NULL;
14034 : }
14035 :
14036 :
14037 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_data_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14038 0 : PyObject *resultobj = 0;
14039 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
14040 0 : void *argp1 = 0 ;
14041 0 : int res1 = 0 ;
14042 0 : PyObject * obj0 = 0 ;
14043 :
14044 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_data_cbs",&obj0)) SWIG_fail;
14045 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, SWIG_POINTER_DISOWN | 0 );
14046 0 : if (!SWIG_IsOK(res1)) {
14047 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_data_cbs" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
14048 : }
14049 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
14050 : {
14051 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14052 0 : free((char *) arg1);
14053 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14054 : }
14055 0 : resultobj = SWIG_Py_Void();
14056 0 : return resultobj;
14057 : fail:
14058 : return NULL;
14059 : }
14060 :
14061 :
14062 29 : SWIGINTERN PyObject *gpgme_data_cbs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14063 : PyObject *obj;
14064 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
14065 58 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_data_cbs, SWIG_NewClientData(obj));
14066 29 : return SWIG_Py_Void();
14067 : }
14068 :
14069 89 : SWIGINTERN PyObject *_wrap_gpgme_data_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14070 89 : PyObject *resultobj = 0;
14071 89 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14072 89 : void *arg2 = (void *) 0 ;
14073 : size_t arg3 ;
14074 89 : void *argp1 = 0 ;
14075 89 : int res1 = 0 ;
14076 89 : PyObject * obj0 = 0 ;
14077 89 : PyObject * obj1 = 0 ;
14078 : ssize_t result;
14079 :
14080 89 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_read",&obj0,&obj1)) SWIG_fail;
14081 89 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14082 89 : if (!SWIG_IsOK(res1)) {
14083 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_read" "', argument " "1"" of type '" "gpgme_data_t""'");
14084 : }
14085 89 : arg1 = (gpgme_data_t)(argp1);
14086 : {
14087 : {
14088 : long tmp2;
14089 89 : if (PyLong_Check(obj1))
14090 89 : tmp2 = PyLong_AsLong(obj1);
14091 :
14092 : else if (PyInt_Check(obj1))
14093 : tmp2 = PyInt_AsLong(obj1);
14094 :
14095 : else
14096 : {
14097 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
14098 0 : return NULL;
14099 : }
14100 :
14101 89 : if (tmp2 < 0) {
14102 0 : PyErr_SetString(PyExc_ValueError, "Positive integer expected");
14103 0 : return NULL;
14104 : }
14105 89 : arg3 = (size_t) tmp2;
14106 89 : arg2 = (void *) malloc(arg3+1);
14107 : }
14108 : }
14109 : {
14110 89 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14111 89 : result = gpgme_data_read(arg1,arg2,arg3);
14112 89 : SWIG_PYTHON_THREAD_END_ALLOW;
14113 : }
14114 : {
14115 89 : resultobj = PyLong_FromLong(result);
14116 : }
14117 : {
14118 89 : Py_XDECREF(resultobj); /* Blow away any previous result */
14119 89 : if (result < 0) {
14120 : /* Check for I/O error */
14121 2 : free(arg2);
14122 2 : return PyErr_SetFromErrno(PyExc_RuntimeError);
14123 : }
14124 87 : resultobj = PyBytes_FromStringAndSize(arg2,result);
14125 87 : free(arg2);
14126 : }
14127 87 : return resultobj;
14128 : fail:
14129 : return NULL;
14130 : }
14131 :
14132 :
14133 9 : SWIGINTERN PyObject *_wrap_gpgme_data_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14134 9 : PyObject *resultobj = 0;
14135 9 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14136 9 : void *arg2 = (void *) 0 ;
14137 : size_t arg3 ;
14138 9 : void *argp1 = 0 ;
14139 9 : int res1 = 0 ;
14140 9 : PyObject *encodedInput2 = NULL ;
14141 9 : PyObject * obj0 = 0 ;
14142 9 : PyObject * obj1 = 0 ;
14143 : ssize_t result;
14144 :
14145 9 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_write",&obj0,&obj1)) SWIG_fail;
14146 9 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14147 9 : if (!SWIG_IsOK(res1)) {
14148 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_write" "', argument " "1"" of type '" "gpgme_data_t""'");
14149 : }
14150 9 : arg1 = (gpgme_data_t)(argp1);
14151 : {
14152 : Py_ssize_t ssize;
14153 :
14154 9 : if (obj1 == Py_None)
14155 0 : arg2 = NULL, arg3 = 0;
14156 9 : else if (PyUnicode_Check(obj1))
14157 : {
14158 3 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14159 3 : if (encodedInput2 == NULL)
14160 0 : return NULL;
14161 3 : if (PyBytes_AsStringAndSize(encodedInput2, (char **) &arg2, &ssize) == -1)
14162 : {
14163 0 : Py_DECREF(encodedInput2);
14164 : return NULL;
14165 : }
14166 : }
14167 6 : else if (PyBytes_Check(obj1))
14168 6 : PyBytes_AsStringAndSize(obj1, (char **) &arg2, &ssize);
14169 : else {
14170 0 : PyErr_Format(PyExc_TypeError,
14171 : "arg %d: expected str, bytes, or None, got %s",
14172 : 2, obj1->ob_type->tp_name);
14173 0 : return NULL;
14174 : }
14175 :
14176 9 : if (! arg2)
14177 : arg3 = 0;
14178 : else
14179 : {
14180 : assert (ssize >= 0);
14181 9 : arg3 = (size_t) ssize;
14182 : }
14183 : }
14184 : {
14185 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14186 9 : result = gpgme_data_write(arg1,(void const *)arg2,arg3);
14187 9 : SWIG_PYTHON_THREAD_END_ALLOW;
14188 : }
14189 : {
14190 9 : resultobj = PyLong_FromLong(result);
14191 : }
14192 : {
14193 12 : Py_XDECREF(encodedInput2);
14194 : }
14195 : return resultobj;
14196 : fail:
14197 : {
14198 : Py_XDECREF(encodedInput2);
14199 : }
14200 : return NULL;
14201 : }
14202 :
14203 :
14204 69 : SWIGINTERN PyObject *_wrap_gpgme_data_new(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14205 69 : PyObject *resultobj = 0;
14206 69 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14207 69 : void *argp1 = 0 ;
14208 69 : int res1 = 0 ;
14209 69 : PyObject * obj0 = 0 ;
14210 : gpgme_error_t result;
14211 :
14212 69 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_new",&obj0)) SWIG_fail;
14213 69 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14214 69 : if (!SWIG_IsOK(res1)) {
14215 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new" "', argument " "1"" of type '" "gpgme_data_t *""'");
14216 : }
14217 69 : arg1 = (gpgme_data_t *)(argp1);
14218 : {
14219 69 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14220 69 : result = gpgme_data_new(arg1);
14221 69 : SWIG_PYTHON_THREAD_END_ALLOW;
14222 : }
14223 : {
14224 69 : resultobj = PyLong_FromLong(result);
14225 : }
14226 69 : return resultobj;
14227 : fail:
14228 : return NULL;
14229 : }
14230 :
14231 :
14232 101 : SWIGINTERN PyObject *_wrap_gpgme_data_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14233 101 : PyObject *resultobj = 0;
14234 101 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14235 101 : void *argp1 = 0 ;
14236 101 : int res1 = 0 ;
14237 101 : PyObject * obj0 = 0 ;
14238 :
14239 101 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_release",&obj0)) SWIG_fail;
14240 101 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14241 101 : if (!SWIG_IsOK(res1)) {
14242 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_release" "', argument " "1"" of type '" "gpgme_data_t""'");
14243 : }
14244 101 : arg1 = (gpgme_data_t)(argp1);
14245 : {
14246 101 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14247 101 : gpgme_data_release(arg1);
14248 101 : SWIG_PYTHON_THREAD_END_ALLOW;
14249 : }
14250 101 : resultobj = SWIG_Py_Void();
14251 101 : return resultobj;
14252 : fail:
14253 : return NULL;
14254 : }
14255 :
14256 :
14257 24 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_mem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14258 24 : PyObject *resultobj = 0;
14259 24 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14260 24 : char *arg2 = (char *) 0 ;
14261 : size_t arg3 ;
14262 : int arg4 ;
14263 24 : void *argp1 = 0 ;
14264 24 : int res1 = 0 ;
14265 24 : PyObject *encodedInput2 = NULL ;
14266 : size_t val3 ;
14267 24 : int ecode3 = 0 ;
14268 : int val4 ;
14269 24 : int ecode4 = 0 ;
14270 24 : PyObject * obj0 = 0 ;
14271 24 : PyObject * obj1 = 0 ;
14272 24 : PyObject * obj2 = 0 ;
14273 24 : PyObject * obj3 = 0 ;
14274 : gpgme_error_t result;
14275 :
14276 24 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_data_new_from_mem",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14277 24 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14278 24 : if (!SWIG_IsOK(res1)) {
14279 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_mem" "', argument " "1"" of type '" "gpgme_data_t *""'");
14280 : }
14281 24 : arg1 = (gpgme_data_t *)(argp1);
14282 : {
14283 24 : if (obj1 == Py_None)
14284 : arg2 = NULL;
14285 24 : else if (PyUnicode_Check(obj1))
14286 : {
14287 16 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14288 16 : if (encodedInput2 == NULL)
14289 : return NULL;
14290 16 : arg2 = PyBytes_AsString(encodedInput2);
14291 : }
14292 8 : else if (PyBytes_Check(obj1))
14293 8 : 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 48 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14302 24 : if (!SWIG_IsOK(ecode3)) {
14303 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_new_from_mem" "', argument " "3"" of type '" "size_t""'");
14304 : }
14305 24 : arg3 = (size_t)(val3);
14306 48 : ecode4 = SWIG_AsVal_int(obj3, &val4);
14307 24 : if (!SWIG_IsOK(ecode4)) {
14308 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_data_new_from_mem" "', argument " "4"" of type '" "int""'");
14309 : }
14310 24 : arg4 = (int)(val4);
14311 : {
14312 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14313 24 : result = gpgme_data_new_from_mem(arg1,(char const *)arg2,arg3,arg4);
14314 24 : SWIG_PYTHON_THREAD_END_ALLOW;
14315 : }
14316 : {
14317 24 : resultobj = PyLong_FromLong(result);
14318 : }
14319 : {
14320 24 : Py_XDECREF(encodedInput2);
14321 : }
14322 : return resultobj;
14323 : fail:
14324 : {
14325 0 : Py_XDECREF(encodedInput2);
14326 : }
14327 : return NULL;
14328 : }
14329 :
14330 :
14331 0 : SWIGINTERN PyObject *_wrap_gpgme_data_release_and_get_mem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14332 0 : PyObject *resultobj = 0;
14333 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14334 0 : size_t *arg2 = (size_t *) 0 ;
14335 0 : void *argp1 = 0 ;
14336 0 : int res1 = 0 ;
14337 0 : void *argp2 = 0 ;
14338 0 : int res2 = 0 ;
14339 0 : PyObject * obj0 = 0 ;
14340 0 : PyObject * obj1 = 0 ;
14341 0 : char *result = 0 ;
14342 :
14343 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_release_and_get_mem",&obj0,&obj1)) SWIG_fail;
14344 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14345 0 : if (!SWIG_IsOK(res1)) {
14346 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_release_and_get_mem" "', argument " "1"" of type '" "gpgme_data_t""'");
14347 : }
14348 0 : arg1 = (gpgme_data_t)(argp1);
14349 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_size_t, 0 | 0 );
14350 0 : if (!SWIG_IsOK(res2)) {
14351 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_release_and_get_mem" "', argument " "2"" of type '" "size_t *""'");
14352 : }
14353 0 : arg2 = (size_t *)(argp2);
14354 : {
14355 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14356 0 : result = (char *)gpgme_data_release_and_get_mem(arg1,arg2);
14357 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14358 : }
14359 0 : resultobj = SWIG_FromCharPtr((const char *)result);
14360 0 : gpgme_free(result);
14361 0 : return resultobj;
14362 : fail:
14363 : return NULL;
14364 : }
14365 :
14366 :
14367 0 : SWIGINTERN PyObject *_wrap_gpgme_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14368 0 : PyObject *resultobj = 0;
14369 0 : void *arg1 = (void *) 0 ;
14370 : int res1 ;
14371 0 : PyObject * obj0 = 0 ;
14372 :
14373 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_free",&obj0)) SWIG_fail;
14374 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
14375 0 : if (!SWIG_IsOK(res1)) {
14376 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_free" "', argument " "1"" of type '" "void *""'");
14377 : }
14378 : {
14379 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14380 0 : gpgme_free(arg1);
14381 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14382 : }
14383 0 : resultobj = SWIG_Py_Void();
14384 0 : return resultobj;
14385 : fail:
14386 : return NULL;
14387 : }
14388 :
14389 :
14390 0 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14391 0 : PyObject *resultobj = 0;
14392 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14393 0 : gpgme_data_cbs_t arg2 = (gpgme_data_cbs_t) 0 ;
14394 0 : void *arg3 = (void *) 0 ;
14395 0 : void *argp1 = 0 ;
14396 0 : int res1 = 0 ;
14397 0 : void *argp2 = 0 ;
14398 0 : int res2 = 0 ;
14399 : int res3 ;
14400 0 : PyObject * obj0 = 0 ;
14401 0 : PyObject * obj1 = 0 ;
14402 0 : PyObject * obj2 = 0 ;
14403 : gpgme_error_t result;
14404 :
14405 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_new_from_cbs",&obj0,&obj1,&obj2)) SWIG_fail;
14406 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14407 0 : if (!SWIG_IsOK(res1)) {
14408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_cbs" "', argument " "1"" of type '" "gpgme_data_t *""'");
14409 : }
14410 0 : arg1 = (gpgme_data_t *)(argp1);
14411 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
14412 0 : if (!SWIG_IsOK(res2)) {
14413 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_new_from_cbs" "', argument " "2"" of type '" "gpgme_data_cbs_t""'");
14414 : }
14415 0 : arg2 = (gpgme_data_cbs_t)(argp2);
14416 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
14417 0 : if (!SWIG_IsOK(res3)) {
14418 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_data_new_from_cbs" "', argument " "3"" of type '" "void *""'");
14419 : }
14420 : {
14421 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14422 0 : result = gpgme_data_new_from_cbs(arg1,arg2,arg3);
14423 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14424 : }
14425 : {
14426 0 : resultobj = PyLong_FromLong(result);
14427 : }
14428 0 : return resultobj;
14429 : fail:
14430 : return NULL;
14431 : }
14432 :
14433 :
14434 1 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_fd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14435 1 : PyObject *resultobj = 0;
14436 1 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14437 : int arg2 ;
14438 1 : void *argp1 = 0 ;
14439 1 : int res1 = 0 ;
14440 : int val2 ;
14441 1 : int ecode2 = 0 ;
14442 1 : PyObject * obj0 = 0 ;
14443 1 : PyObject * obj1 = 0 ;
14444 : gpgme_error_t result;
14445 :
14446 1 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_new_from_fd",&obj0,&obj1)) SWIG_fail;
14447 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14448 1 : if (!SWIG_IsOK(res1)) {
14449 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_fd" "', argument " "1"" of type '" "gpgme_data_t *""'");
14450 : }
14451 1 : arg1 = (gpgme_data_t *)(argp1);
14452 2 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14453 1 : if (!SWIG_IsOK(ecode2)) {
14454 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_new_from_fd" "', argument " "2"" of type '" "int""'");
14455 : }
14456 1 : arg2 = (int)(val2);
14457 : {
14458 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14459 1 : result = gpgme_data_new_from_fd(arg1,arg2);
14460 1 : SWIG_PYTHON_THREAD_END_ALLOW;
14461 : }
14462 : {
14463 1 : resultobj = PyLong_FromLong(result);
14464 : }
14465 1 : return resultobj;
14466 : fail:
14467 : return NULL;
14468 : }
14469 :
14470 :
14471 0 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_stream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14472 0 : PyObject *resultobj = 0;
14473 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14474 0 : FILE *arg2 = (FILE *) 0 ;
14475 0 : void *argp1 = 0 ;
14476 0 : int res1 = 0 ;
14477 0 : void *argp2 = 0 ;
14478 0 : int res2 = 0 ;
14479 0 : PyObject * obj0 = 0 ;
14480 0 : PyObject * obj1 = 0 ;
14481 : gpgme_error_t result;
14482 :
14483 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_new_from_stream",&obj0,&obj1)) SWIG_fail;
14484 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14485 0 : if (!SWIG_IsOK(res1)) {
14486 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_stream" "', argument " "1"" of type '" "gpgme_data_t *""'");
14487 : }
14488 0 : arg1 = (gpgme_data_t *)(argp1);
14489 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 | 0 );
14490 0 : if (!SWIG_IsOK(res2)) {
14491 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_new_from_stream" "', argument " "2"" of type '" "FILE *""'");
14492 : }
14493 0 : arg2 = (FILE *)(argp2);
14494 : {
14495 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14496 0 : result = gpgme_data_new_from_stream(arg1,arg2);
14497 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14498 : }
14499 : {
14500 0 : resultobj = PyLong_FromLong(result);
14501 : }
14502 0 : return resultobj;
14503 : fail:
14504 : return NULL;
14505 : }
14506 :
14507 :
14508 0 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_estream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14509 0 : PyObject *resultobj = 0;
14510 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14511 : gpgrt_stream_t arg2 ;
14512 0 : void *argp1 = 0 ;
14513 0 : int res1 = 0 ;
14514 : void *argp2 ;
14515 0 : int res2 = 0 ;
14516 0 : PyObject * obj0 = 0 ;
14517 0 : PyObject * obj1 = 0 ;
14518 : gpgme_error_t result;
14519 :
14520 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_new_from_estream",&obj0,&obj1)) SWIG_fail;
14521 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14522 0 : if (!SWIG_IsOK(res1)) {
14523 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_estream" "', argument " "1"" of type '" "gpgme_data_t *""'");
14524 : }
14525 0 : arg1 = (gpgme_data_t *)(argp1);
14526 : {
14527 0 : res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gpgrt_stream_t, 0 );
14528 0 : if (!SWIG_IsOK(res2)) {
14529 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_new_from_estream" "', argument " "2"" of type '" "gpgrt_stream_t""'");
14530 : }
14531 0 : if (!argp2) {
14532 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gpgme_data_new_from_estream" "', argument " "2"" of type '" "gpgrt_stream_t""'");
14533 : } else {
14534 0 : arg2 = *((gpgrt_stream_t *)(argp2));
14535 : }
14536 : }
14537 : {
14538 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14539 0 : result = gpgme_data_new_from_estream(arg1,arg2);
14540 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14541 : }
14542 : {
14543 0 : resultobj = PyLong_FromLong(result);
14544 : }
14545 0 : return resultobj;
14546 : fail:
14547 : return NULL;
14548 : }
14549 :
14550 :
14551 0 : SWIGINTERN PyObject *_wrap_gpgme_data_get_encoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14552 0 : PyObject *resultobj = 0;
14553 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14554 0 : void *argp1 = 0 ;
14555 0 : int res1 = 0 ;
14556 0 : PyObject * obj0 = 0 ;
14557 : gpgme_data_encoding_t result;
14558 :
14559 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_get_encoding",&obj0)) SWIG_fail;
14560 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14561 0 : if (!SWIG_IsOK(res1)) {
14562 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_get_encoding" "', argument " "1"" of type '" "gpgme_data_t""'");
14563 : }
14564 0 : arg1 = (gpgme_data_t)(argp1);
14565 : {
14566 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14567 0 : result = (gpgme_data_encoding_t)gpgme_data_get_encoding(arg1);
14568 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14569 : }
14570 0 : resultobj = SWIG_From_int((int)(result));
14571 0 : return resultobj;
14572 : fail:
14573 : return NULL;
14574 : }
14575 :
14576 :
14577 0 : SWIGINTERN PyObject *_wrap_gpgme_data_set_encoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14578 0 : PyObject *resultobj = 0;
14579 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14580 : gpgme_data_encoding_t arg2 ;
14581 0 : void *argp1 = 0 ;
14582 0 : int res1 = 0 ;
14583 : int val2 ;
14584 0 : int ecode2 = 0 ;
14585 0 : PyObject * obj0 = 0 ;
14586 0 : PyObject * obj1 = 0 ;
14587 : gpgme_error_t result;
14588 :
14589 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_set_encoding",&obj0,&obj1)) SWIG_fail;
14590 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14591 0 : if (!SWIG_IsOK(res1)) {
14592 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_encoding" "', argument " "1"" of type '" "gpgme_data_t""'");
14593 : }
14594 0 : arg1 = (gpgme_data_t)(argp1);
14595 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14596 0 : if (!SWIG_IsOK(ecode2)) {
14597 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_set_encoding" "', argument " "2"" of type '" "gpgme_data_encoding_t""'");
14598 : }
14599 0 : arg2 = (gpgme_data_encoding_t)(val2);
14600 : {
14601 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14602 0 : result = gpgme_data_set_encoding(arg1,arg2);
14603 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14604 : }
14605 : {
14606 0 : resultobj = PyLong_FromLong(result);
14607 : }
14608 0 : return resultobj;
14609 : fail:
14610 : return NULL;
14611 : }
14612 :
14613 :
14614 1 : SWIGINTERN PyObject *_wrap_gpgme_data_get_file_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14615 1 : PyObject *resultobj = 0;
14616 1 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14617 1 : void *argp1 = 0 ;
14618 1 : int res1 = 0 ;
14619 1 : PyObject * obj0 = 0 ;
14620 1 : char *result = 0 ;
14621 :
14622 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_get_file_name",&obj0)) SWIG_fail;
14623 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14624 1 : if (!SWIG_IsOK(res1)) {
14625 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_get_file_name" "', argument " "1"" of type '" "gpgme_data_t""'");
14626 : }
14627 1 : arg1 = (gpgme_data_t)(argp1);
14628 : {
14629 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14630 1 : result = (char *)gpgme_data_get_file_name(arg1);
14631 1 : SWIG_PYTHON_THREAD_END_ALLOW;
14632 : }
14633 1 : resultobj = SWIG_FromCharPtr((const char *)result);
14634 1 : return resultobj;
14635 : fail:
14636 : return NULL;
14637 : }
14638 :
14639 :
14640 2 : SWIGINTERN PyObject *_wrap_gpgme_data_set_file_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14641 2 : PyObject *resultobj = 0;
14642 2 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14643 2 : char *arg2 = (char *) 0 ;
14644 2 : void *argp1 = 0 ;
14645 2 : int res1 = 0 ;
14646 2 : PyObject *encodedInput2 = NULL ;
14647 2 : PyObject * obj0 = 0 ;
14648 2 : PyObject * obj1 = 0 ;
14649 : gpgme_error_t result;
14650 :
14651 2 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_set_file_name",&obj0,&obj1)) SWIG_fail;
14652 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14653 2 : if (!SWIG_IsOK(res1)) {
14654 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_file_name" "', argument " "1"" of type '" "gpgme_data_t""'");
14655 : }
14656 2 : arg1 = (gpgme_data_t)(argp1);
14657 : {
14658 2 : if (obj1 == Py_None)
14659 : arg2 = NULL;
14660 2 : else if (PyUnicode_Check(obj1))
14661 : {
14662 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14663 2 : if (encodedInput2 == NULL)
14664 : return NULL;
14665 2 : arg2 = PyBytes_AsString(encodedInput2);
14666 : }
14667 0 : else if (PyBytes_Check(obj1))
14668 0 : arg2 = PyBytes_AsString(obj1);
14669 : else {
14670 0 : PyErr_Format(PyExc_TypeError,
14671 : "arg %d: expected str, bytes, or None, got %s",
14672 : 2, obj1->ob_type->tp_name);
14673 0 : return NULL;
14674 : }
14675 : }
14676 : {
14677 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14678 2 : result = gpgme_data_set_file_name(arg1,(char const *)arg2);
14679 2 : SWIG_PYTHON_THREAD_END_ALLOW;
14680 : }
14681 : {
14682 2 : resultobj = PyLong_FromLong(result);
14683 : }
14684 : {
14685 2 : Py_XDECREF(encodedInput2);
14686 : }
14687 : return resultobj;
14688 : fail:
14689 : {
14690 : Py_XDECREF(encodedInput2);
14691 : }
14692 : return NULL;
14693 : }
14694 :
14695 :
14696 0 : SWIGINTERN PyObject *_wrap_gpgme_data_set_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14697 0 : PyObject *resultobj = 0;
14698 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14699 0 : char *arg2 = (char *) 0 ;
14700 0 : char *arg3 = (char *) 0 ;
14701 0 : void *argp1 = 0 ;
14702 0 : int res1 = 0 ;
14703 0 : PyObject *encodedInput2 = NULL ;
14704 0 : PyObject *encodedInput3 = NULL ;
14705 0 : PyObject * obj0 = 0 ;
14706 0 : PyObject * obj1 = 0 ;
14707 0 : PyObject * obj2 = 0 ;
14708 : gpg_error_t result;
14709 :
14710 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_set_flag",&obj0,&obj1,&obj2)) SWIG_fail;
14711 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14712 0 : if (!SWIG_IsOK(res1)) {
14713 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_flag" "', argument " "1"" of type '" "gpgme_data_t""'");
14714 : }
14715 0 : arg1 = (gpgme_data_t)(argp1);
14716 : {
14717 0 : if (obj1 == Py_None)
14718 : arg2 = NULL;
14719 0 : else if (PyUnicode_Check(obj1))
14720 : {
14721 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14722 0 : if (encodedInput2 == NULL)
14723 : return NULL;
14724 0 : arg2 = PyBytes_AsString(encodedInput2);
14725 : }
14726 0 : else if (PyBytes_Check(obj1))
14727 0 : arg2 = PyBytes_AsString(obj1);
14728 : else {
14729 0 : PyErr_Format(PyExc_TypeError,
14730 : "arg %d: expected str, bytes, or None, got %s",
14731 : 2, obj1->ob_type->tp_name);
14732 0 : return NULL;
14733 : }
14734 : }
14735 : {
14736 0 : if (obj2 == Py_None)
14737 : arg3 = NULL;
14738 0 : else if (PyUnicode_Check(obj2))
14739 : {
14740 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
14741 0 : if (encodedInput3 == NULL)
14742 : return NULL;
14743 0 : arg3 = PyBytes_AsString(encodedInput3);
14744 : }
14745 0 : else if (PyBytes_Check(obj2))
14746 0 : arg3 = PyBytes_AsString(obj2);
14747 : else {
14748 0 : PyErr_Format(PyExc_TypeError,
14749 : "arg %d: expected str, bytes, or None, got %s",
14750 : 3, obj2->ob_type->tp_name);
14751 0 : return NULL;
14752 : }
14753 : }
14754 : {
14755 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14756 0 : result = gpgme_data_set_flag(arg1,(char const *)arg2,(char const *)arg3);
14757 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14758 : }
14759 : {
14760 0 : resultobj = PyLong_FromLong(result);
14761 : }
14762 : {
14763 0 : Py_XDECREF(encodedInput2);
14764 : }
14765 : {
14766 0 : Py_XDECREF(encodedInput3);
14767 : }
14768 : return resultobj;
14769 : fail:
14770 : {
14771 : Py_XDECREF(encodedInput2);
14772 : }
14773 : {
14774 : Py_XDECREF(encodedInput3);
14775 : }
14776 : return NULL;
14777 : }
14778 :
14779 :
14780 0 : SWIGINTERN PyObject *_wrap_gpgme_data_identify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14781 0 : PyObject *resultobj = 0;
14782 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14783 : int arg2 ;
14784 0 : void *argp1 = 0 ;
14785 0 : int res1 = 0 ;
14786 : int val2 ;
14787 0 : int ecode2 = 0 ;
14788 0 : PyObject * obj0 = 0 ;
14789 0 : PyObject * obj1 = 0 ;
14790 : gpgme_data_type_t result;
14791 :
14792 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_identify",&obj0,&obj1)) SWIG_fail;
14793 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14794 0 : if (!SWIG_IsOK(res1)) {
14795 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_identify" "', argument " "1"" of type '" "gpgme_data_t""'");
14796 : }
14797 0 : arg1 = (gpgme_data_t)(argp1);
14798 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14799 0 : if (!SWIG_IsOK(ecode2)) {
14800 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_identify" "', argument " "2"" of type '" "int""'");
14801 : }
14802 0 : arg2 = (int)(val2);
14803 : {
14804 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14805 0 : result = (gpgme_data_type_t)gpgme_data_identify(arg1,arg2);
14806 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14807 : }
14808 0 : resultobj = SWIG_From_int((int)(result));
14809 0 : return resultobj;
14810 : fail:
14811 : return NULL;
14812 : }
14813 :
14814 :
14815 3 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14816 3 : PyObject *resultobj = 0;
14817 3 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14818 3 : char *arg2 = (char *) 0 ;
14819 : int arg3 ;
14820 3 : void *argp1 = 0 ;
14821 3 : int res1 = 0 ;
14822 3 : PyObject *encodedInput2 = NULL ;
14823 : int val3 ;
14824 3 : int ecode3 = 0 ;
14825 3 : PyObject * obj0 = 0 ;
14826 3 : PyObject * obj1 = 0 ;
14827 3 : PyObject * obj2 = 0 ;
14828 : gpgme_error_t result;
14829 :
14830 3 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_new_from_file",&obj0,&obj1,&obj2)) SWIG_fail;
14831 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14832 3 : if (!SWIG_IsOK(res1)) {
14833 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_file" "', argument " "1"" of type '" "gpgme_data_t *""'");
14834 : }
14835 3 : arg1 = (gpgme_data_t *)(argp1);
14836 : {
14837 3 : if (obj1 == Py_None)
14838 : arg2 = NULL;
14839 3 : else if (PyUnicode_Check(obj1))
14840 : {
14841 3 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14842 3 : if (encodedInput2 == NULL)
14843 : return NULL;
14844 3 : arg2 = PyBytes_AsString(encodedInput2);
14845 : }
14846 0 : else if (PyBytes_Check(obj1))
14847 0 : arg2 = PyBytes_AsString(obj1);
14848 : else {
14849 0 : PyErr_Format(PyExc_TypeError,
14850 : "arg %d: expected str, bytes, or None, got %s",
14851 : 2, obj1->ob_type->tp_name);
14852 0 : return NULL;
14853 : }
14854 : }
14855 6 : ecode3 = SWIG_AsVal_int(obj2, &val3);
14856 3 : if (!SWIG_IsOK(ecode3)) {
14857 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_new_from_file" "', argument " "3"" of type '" "int""'");
14858 : }
14859 3 : arg3 = (int)(val3);
14860 : {
14861 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14862 3 : result = gpgme_data_new_from_file(arg1,(char const *)arg2,arg3);
14863 3 : SWIG_PYTHON_THREAD_END_ALLOW;
14864 : }
14865 : {
14866 3 : resultobj = PyLong_FromLong(result);
14867 : }
14868 : {
14869 3 : Py_XDECREF(encodedInput2);
14870 : }
14871 : return resultobj;
14872 : fail:
14873 : {
14874 0 : Py_XDECREF(encodedInput2);
14875 : }
14876 : return NULL;
14877 : }
14878 :
14879 :
14880 2 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_filepart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14881 2 : PyObject *resultobj = 0;
14882 2 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14883 2 : char *arg2 = (char *) 0 ;
14884 2 : FILE *arg3 = (FILE *) 0 ;
14885 : off_t arg4 ;
14886 : size_t arg5 ;
14887 2 : void *argp1 = 0 ;
14888 2 : int res1 = 0 ;
14889 2 : PyObject *encodedInput2 = NULL ;
14890 2 : void *argp3 = 0 ;
14891 2 : int res3 = 0 ;
14892 : size_t val5 ;
14893 2 : int ecode5 = 0 ;
14894 2 : PyObject * obj0 = 0 ;
14895 2 : PyObject * obj1 = 0 ;
14896 2 : PyObject * obj2 = 0 ;
14897 2 : PyObject * obj3 = 0 ;
14898 2 : PyObject * obj4 = 0 ;
14899 : gpgme_error_t result;
14900 :
14901 2 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_data_new_from_filepart",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14902 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14903 2 : if (!SWIG_IsOK(res1)) {
14904 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_filepart" "', argument " "1"" of type '" "gpgme_data_t *""'");
14905 : }
14906 2 : arg1 = (gpgme_data_t *)(argp1);
14907 : {
14908 2 : if (obj1 == Py_None)
14909 : arg2 = NULL;
14910 1 : else if (PyUnicode_Check(obj1))
14911 : {
14912 1 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14913 1 : if (encodedInput2 == NULL)
14914 : return NULL;
14915 1 : arg2 = PyBytes_AsString(encodedInput2);
14916 : }
14917 0 : else if (PyBytes_Check(obj1))
14918 0 : arg2 = PyBytes_AsString(obj1);
14919 : else {
14920 0 : PyErr_Format(PyExc_TypeError,
14921 : "arg %d: expected str, bytes, or None, got %s",
14922 : 2, obj1->ob_type->tp_name);
14923 0 : return NULL;
14924 : }
14925 : }
14926 2 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FILE, 0 | 0 );
14927 2 : if (!SWIG_IsOK(res3)) {
14928 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_data_new_from_filepart" "', argument " "3"" of type '" "FILE *""'");
14929 : }
14930 2 : arg3 = (FILE *)(argp3);
14931 : {
14932 2 : if (PyLong_Check(obj3))
14933 :
14934 :
14935 :
14936 2 : arg4 = PyLong_AsLong(obj3);
14937 :
14938 :
14939 : else if (PyInt_Check(obj3))
14940 : arg4 = PyInt_AsLong(obj3);
14941 :
14942 : else
14943 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
14944 : }
14945 4 : ecode5 = SWIG_AsVal_size_t(obj4, &val5);
14946 2 : if (!SWIG_IsOK(ecode5)) {
14947 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_data_new_from_filepart" "', argument " "5"" of type '" "size_t""'");
14948 : }
14949 2 : arg5 = (size_t)(val5);
14950 : {
14951 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14952 2 : result = gpgme_data_new_from_filepart(arg1,(char const *)arg2,arg3,arg4,arg5);
14953 2 : SWIG_PYTHON_THREAD_END_ALLOW;
14954 : }
14955 : {
14956 2 : resultobj = PyLong_FromLong(result);
14957 : }
14958 : {
14959 2 : Py_XDECREF(encodedInput2);
14960 : }
14961 : return resultobj;
14962 : fail:
14963 : {
14964 0 : Py_XDECREF(encodedInput2);
14965 : }
14966 : return NULL;
14967 : }
14968 :
14969 :
14970 1 : SWIGINTERN PyObject *_wrap_gpgme_data_rewind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14971 1 : PyObject *resultobj = 0;
14972 1 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14973 1 : void *argp1 = 0 ;
14974 1 : int res1 = 0 ;
14975 1 : PyObject * obj0 = 0 ;
14976 : gpgme_error_t result;
14977 :
14978 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_rewind",&obj0)) SWIG_fail;
14979 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14980 1 : if (!SWIG_IsOK(res1)) {
14981 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_rewind" "', argument " "1"" of type '" "gpgme_data_t""'");
14982 : }
14983 1 : arg1 = (gpgme_data_t)(argp1);
14984 : {
14985 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14986 1 : result = gpgme_data_rewind(arg1);
14987 1 : SWIG_PYTHON_THREAD_END_ALLOW;
14988 : }
14989 : {
14990 1 : resultobj = PyLong_FromLong(result);
14991 : }
14992 1 : return resultobj;
14993 : fail:
14994 : return NULL;
14995 : }
14996 :
14997 :
14998 92 : SWIGINTERN PyObject *_wrap_gpgme_get_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14999 92 : PyObject *resultobj = 0;
15000 92 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
15001 92 : char *arg2 = (char *) 0 ;
15002 92 : gpgme_key_t *arg3 = (gpgme_key_t *) 0 ;
15003 : int arg4 ;
15004 92 : void *argp1 = 0 ;
15005 92 : int res1 = 0 ;
15006 92 : PyObject *encodedInput2 = NULL ;
15007 92 : void *argp3 = 0 ;
15008 92 : int res3 = 0 ;
15009 : int val4 ;
15010 92 : int ecode4 = 0 ;
15011 92 : PyObject * obj0 = 0 ;
15012 92 : PyObject * obj1 = 0 ;
15013 92 : PyObject * obj2 = 0 ;
15014 92 : PyObject * obj3 = 0 ;
15015 : gpgme_error_t result;
15016 :
15017 92 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_get_key",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15018 92 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
15019 92 : if (!SWIG_IsOK(res1)) {
15020 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_key" "', argument " "1"" of type '" "gpgme_ctx_t""'");
15021 : }
15022 92 : arg1 = (gpgme_ctx_t)(argp1);
15023 : {
15024 92 : if (obj1 == Py_None)
15025 : arg2 = NULL;
15026 92 : else if (PyUnicode_Check(obj1))
15027 : {
15028 92 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
15029 92 : if (encodedInput2 == NULL)
15030 : return NULL;
15031 92 : arg2 = PyBytes_AsString(encodedInput2);
15032 : }
15033 0 : else if (PyBytes_Check(obj1))
15034 0 : arg2 = PyBytes_AsString(obj1);
15035 : else {
15036 0 : PyErr_Format(PyExc_TypeError,
15037 : "arg %d: expected str, bytes, or None, got %s",
15038 : 2, obj1->ob_type->tp_name);
15039 0 : return NULL;
15040 : }
15041 : }
15042 92 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
15043 92 : if (!SWIG_IsOK(res3)) {
15044 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_key" "', argument " "3"" of type '" "gpgme_key_t *""'");
15045 : }
15046 92 : arg3 = (gpgme_key_t *)(argp3);
15047 184 : ecode4 = SWIG_AsVal_int(obj3, &val4);
15048 92 : if (!SWIG_IsOK(ecode4)) {
15049 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_get_key" "', argument " "4"" of type '" "int""'");
15050 : }
15051 92 : arg4 = (int)(val4);
15052 : {
15053 92 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15054 92 : result = gpgme_get_key(arg1,(char const *)arg2,arg3,arg4);
15055 92 : SWIG_PYTHON_THREAD_END_ALLOW;
15056 : }
15057 : {
15058 92 : resultobj = PyLong_FromLong(result);
15059 : }
15060 : {
15061 92 : Py_XDECREF(encodedInput2);
15062 : }
15063 : return resultobj;
15064 : fail:
15065 : {
15066 0 : Py_XDECREF(encodedInput2);
15067 : }
15068 : return NULL;
15069 : }
15070 :
15071 :
15072 0 : SWIGINTERN PyObject *_wrap_gpgme_key_from_uid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15073 0 : PyObject *resultobj = 0;
15074 0 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
15075 0 : char *arg2 = (char *) 0 ;
15076 0 : void *argp1 = 0 ;
15077 0 : int res1 = 0 ;
15078 0 : PyObject *encodedInput2 = NULL ;
15079 0 : PyObject * obj0 = 0 ;
15080 0 : PyObject * obj1 = 0 ;
15081 : gpgme_error_t result;
15082 :
15083 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_key_from_uid",&obj0,&obj1)) SWIG_fail;
15084 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
15085 0 : if (!SWIG_IsOK(res1)) {
15086 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_from_uid" "', argument " "1"" of type '" "gpgme_key_t *""'");
15087 : }
15088 0 : arg1 = (gpgme_key_t *)(argp1);
15089 : {
15090 0 : if (obj1 == Py_None)
15091 : arg2 = NULL;
15092 0 : else if (PyUnicode_Check(obj1))
15093 : {
15094 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
15095 0 : if (encodedInput2 == NULL)
15096 : return NULL;
15097 0 : arg2 = PyBytes_AsString(encodedInput2);
15098 : }
15099 0 : else if (PyBytes_Check(obj1))
15100 0 : arg2 = PyBytes_AsString(obj1);
15101 : else {
15102 0 : PyErr_Format(PyExc_TypeError,
15103 : "arg %d: expected str, bytes, or None, got %s",
15104 : 2, obj1->ob_type->tp_name);
15105 0 : return NULL;
15106 : }
15107 : }
15108 : {
15109 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15110 0 : result = gpgme_key_from_uid(arg1,(char const *)arg2);
15111 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15112 : }
15113 : {
15114 0 : resultobj = PyLong_FromLong(result);
15115 : }
15116 : {
15117 0 : Py_XDECREF(encodedInput2);
15118 : }
15119 : return resultobj;
15120 : fail:
15121 : {
15122 : Py_XDECREF(encodedInput2);
15123 : }
15124 : return NULL;
15125 : }
15126 :
15127 :
15128 0 : SWIGINTERN PyObject *_wrap_gpgme_key_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15129 0 : PyObject *resultobj = 0;
15130 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
15131 0 : void *argp1 = 0 ;
15132 0 : int res1 = 0 ;
15133 0 : PyObject * obj0 = 0 ;
15134 :
15135 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_ref",&obj0)) SWIG_fail;
15136 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
15137 0 : if (!SWIG_IsOK(res1)) {
15138 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_ref" "', argument " "1"" of type '" "gpgme_key_t""'");
15139 : }
15140 0 : arg1 = (gpgme_key_t)(argp1);
15141 : {
15142 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15143 0 : gpgme_key_ref(arg1);
15144 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15145 : }
15146 0 : resultobj = SWIG_Py_Void();
15147 0 : return resultobj;
15148 : fail:
15149 : return NULL;
15150 : }
15151 :
15152 :
15153 0 : SWIGINTERN PyObject *_wrap_gpgme_key_unref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15154 0 : PyObject *resultobj = 0;
15155 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
15156 0 : void *argp1 = 0 ;
15157 0 : int res1 = 0 ;
15158 0 : PyObject * obj0 = 0 ;
15159 :
15160 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_unref",&obj0)) SWIG_fail;
15161 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
15162 0 : if (!SWIG_IsOK(res1)) {
15163 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_unref" "', argument " "1"" of type '" "gpgme_key_t""'");
15164 : }
15165 0 : arg1 = (gpgme_key_t)(argp1);
15166 : {
15167 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15168 0 : gpgme_key_unref(arg1);
15169 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15170 : }
15171 0 : resultobj = SWIG_Py_Void();
15172 0 : return resultobj;
15173 : fail:
15174 : return NULL;
15175 : }
15176 :
15177 :
15178 0 : SWIGINTERN PyObject *_wrap_gpgme_key_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15179 0 : PyObject *resultobj = 0;
15180 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
15181 0 : void *argp1 = 0 ;
15182 0 : int res1 = 0 ;
15183 0 : PyObject * obj0 = 0 ;
15184 :
15185 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_release",&obj0)) SWIG_fail;
15186 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
15187 0 : if (!SWIG_IsOK(res1)) {
15188 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_release" "', argument " "1"" of type '" "gpgme_key_t""'");
15189 : }
15190 0 : arg1 = (gpgme_key_t)(argp1);
15191 : {
15192 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15193 0 : gpgme_key_release(arg1);
15194 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15195 : }
15196 0 : resultobj = SWIG_Py_Void();
15197 0 : return resultobj;
15198 : fail:
15199 : return NULL;
15200 : }
15201 :
15202 :
15203 0 : SWIGINTERN PyObject *_wrap__gpgme_op_encrypt_result_invalid_recipients_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15204 0 : PyObject *resultobj = 0;
15205 0 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
15206 0 : gpgme_invalid_key_t arg2 = (gpgme_invalid_key_t) 0 ;
15207 0 : void *argp1 = 0 ;
15208 0 : int res1 = 0 ;
15209 0 : void *argp2 = 0 ;
15210 0 : int res2 = 0 ;
15211 0 : PyObject * obj0 = 0 ;
15212 0 : PyObject * obj1 = 0 ;
15213 :
15214 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_encrypt_result_invalid_recipients_set",&obj0,&obj1)) SWIG_fail;
15215 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, 0 | 0 );
15216 0 : if (!SWIG_IsOK(res1)) {
15217 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 *""'");
15218 : }
15219 0 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
15220 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
15221 0 : if (!SWIG_IsOK(res2)) {
15222 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_encrypt_result_invalid_recipients_set" "', argument " "2"" of type '" "gpgme_invalid_key_t""'");
15223 : }
15224 0 : arg2 = (gpgme_invalid_key_t)(argp2);
15225 : {
15226 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15227 0 : if (arg1) (arg1)->invalid_recipients = arg2;
15228 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15229 : }
15230 0 : resultobj = SWIG_Py_Void();
15231 0 : return resultobj;
15232 : fail:
15233 : return NULL;
15234 : }
15235 :
15236 :
15237 28 : SWIGINTERN PyObject *_wrap__gpgme_op_encrypt_result_invalid_recipients_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15238 28 : PyObject *resultobj = 0;
15239 28 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
15240 28 : void *argp1 = 0 ;
15241 28 : int res1 = 0 ;
15242 28 : PyObject * obj0 = 0 ;
15243 : gpgme_invalid_key_t result;
15244 :
15245 28 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_encrypt_result_invalid_recipients_get",&obj0)) SWIG_fail;
15246 28 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, 0 | 0 );
15247 28 : if (!SWIG_IsOK(res1)) {
15248 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 *""'");
15249 : }
15250 28 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
15251 : {
15252 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15253 28 : result = (gpgme_invalid_key_t) ((arg1)->invalid_recipients);
15254 28 : SWIG_PYTHON_THREAD_END_ALLOW;
15255 : }
15256 : {
15257 : int i;
15258 28 : int size = 0;
15259 : gpgme_invalid_key_t curr;
15260 30 : for (curr = result; curr != NULL; curr = curr->next) {
15261 2 : size++;
15262 : }
15263 28 : resultobj = PyList_New(size);
15264 30 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
15265 2 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_invalid_key, 0 );
15266 2 : PyList_SetItem(resultobj, i, o);
15267 : }
15268 : }
15269 : return resultobj;
15270 : fail:
15271 : return NULL;
15272 : }
15273 :
15274 :
15275 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_encrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15276 0 : PyObject *resultobj = 0;
15277 0 : struct _gpgme_op_encrypt_result *result = 0 ;
15278 :
15279 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_encrypt_result")) SWIG_fail;
15280 : {
15281 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15282 0 : result = (struct _gpgme_op_encrypt_result *)calloc(1, sizeof(struct _gpgme_op_encrypt_result));
15283 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15284 : }
15285 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_encrypt_result, SWIG_POINTER_NEW | 0 );
15286 0 : return resultobj;
15287 : fail:
15288 : return NULL;
15289 : }
15290 :
15291 :
15292 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_encrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15293 0 : PyObject *resultobj = 0;
15294 0 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
15295 0 : void *argp1 = 0 ;
15296 0 : int res1 = 0 ;
15297 0 : PyObject * obj0 = 0 ;
15298 :
15299 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_encrypt_result",&obj0)) SWIG_fail;
15300 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, SWIG_POINTER_DISOWN | 0 );
15301 0 : if (!SWIG_IsOK(res1)) {
15302 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_encrypt_result" "', argument " "1"" of type '" "struct _gpgme_op_encrypt_result *""'");
15303 : }
15304 0 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
15305 : {
15306 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15307 0 : free((char *) arg1);
15308 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15309 : }
15310 0 : resultobj = SWIG_Py_Void();
15311 0 : return resultobj;
15312 : fail:
15313 : return NULL;
15314 : }
15315 :
15316 :
15317 29 : SWIGINTERN PyObject *_gpgme_op_encrypt_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15318 : PyObject *obj;
15319 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
15320 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_encrypt_result, SWIG_NewClientData(obj));
15321 29 : return SWIG_Py_Void();
15322 : }
15323 :
15324 14 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15325 14 : PyObject *resultobj = 0;
15326 14 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
15327 14 : void *argp1 = 0 ;
15328 14 : int res1 = 0 ;
15329 14 : PyObject * obj0 = 0 ;
15330 : gpgme_encrypt_result_t result;
15331 :
15332 14 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_encrypt_result",&obj0)) SWIG_fail;
15333 14 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
15334 14 : if (!SWIG_IsOK(res1)) {
15335 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
15336 : }
15337 14 : arg1 = (gpgme_ctx_t)(argp1);
15338 : {
15339 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15340 14 : result = (gpgme_encrypt_result_t)gpgme_op_encrypt_result(arg1);
15341 14 : SWIG_PYTHON_THREAD_END_ALLOW;
15342 : }
15343 : {
15344 : PyObject *fragile;
15345 14 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_encrypt_result,
15346 : 0 );
15347 14 : resultobj = _gpg_wrap_result(fragile, "EncryptResult");
15348 14 : Py_DECREF(fragile);
15349 : }
15350 : return resultobj;
15351 : fail:
15352 : return NULL;
15353 : }
15354 :
15355 :
15356 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15357 0 : PyObject *resultobj = 0;
15358 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
15359 : gpgme_key_t *arg2 ;
15360 : gpgme_encrypt_flags_t arg3 ;
15361 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
15362 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
15363 0 : void *argp1 = 0 ;
15364 0 : int res1 = 0 ;
15365 : int val3 ;
15366 0 : int ecode3 = 0 ;
15367 0 : gpgme_data_t wrapper4 = NULL ;
15368 0 : PyObject *bytesio4 = NULL ;
15369 : Py_buffer view4 ;
15370 0 : int have_view4 = 0 ;
15371 0 : gpgme_data_t wrapper5 = NULL ;
15372 0 : PyObject *bytesio5 = NULL ;
15373 : Py_buffer view5 ;
15374 0 : int have_view5 = 0 ;
15375 0 : PyObject * obj0 = 0 ;
15376 0 : PyObject * obj1 = 0 ;
15377 0 : PyObject * obj2 = 0 ;
15378 0 : PyObject * obj3 = 0 ;
15379 0 : PyObject * obj4 = 0 ;
15380 : gpgme_error_t result;
15381 :
15382 : {
15383 0 : arg2 = NULL;
15384 : }
15385 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15386 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
15387 0 : if (!SWIG_IsOK(res1)) {
15388 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
15389 : }
15390 0 : arg1 = (gpgme_ctx_t)(argp1);
15391 : {
15392 0 : int i, numb = 0;
15393 0 : if (!PySequence_Check(obj1)) {
15394 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
15395 : 2);
15396 0 : return NULL;
15397 : }
15398 0 : if((numb = PySequence_Length(obj1)) != 0) {
15399 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
15400 0 : for(i=0; i<numb; i++) {
15401 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
15402 :
15403 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
15404 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
15405 :
15406 : /* Following code is from swig's python.swg. */
15407 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15408 0 : Py_DECREF(pypointer);
15409 0 : PyErr_Format(PyExc_TypeError,
15410 : "arg %d: list must contain only gpgme_key_ts, got %s "
15411 : "at position %d",
15412 0 : 2, pypointer->ob_type->tp_name, i);
15413 0 : free(arg2);
15414 0 : return NULL;
15415 : }
15416 0 : Py_DECREF(pypointer);
15417 : }
15418 0 : arg2[numb] = NULL;
15419 : }
15420 : }
15421 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
15422 0 : if (!SWIG_IsOK(ecode3)) {
15423 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_start" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
15424 : }
15425 0 : arg3 = (gpgme_encrypt_flags_t)(val3);
15426 : {
15427 : /* If we create a temporary wrapper4 object, we will store it in
15428 : wrapperN, where N is 4. Here in this fragment, SWIG will
15429 : automatically append 4. */
15430 0 : memset(&view4, 0, sizeof view4);
15431 0 : if (obj3 == Py_None)
15432 0 : arg4 = NULL;
15433 : else {
15434 : PyObject *pypointer;
15435 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
15436 : &bytesio4, &view4);
15437 0 : if (pypointer == NULL)
15438 : return NULL;
15439 0 : have_view4 = !! view4.obj;
15440 :
15441 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
15442 :
15443 : /* Following code is from swig's python.swg. */
15444 :
15445 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
15446 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15447 0 : Py_DECREF(pypointer);
15448 : return NULL;
15449 : }
15450 0 : Py_DECREF(pypointer);
15451 : }
15452 : }
15453 : {
15454 : /* If we create a temporary wrapper5 object, we will store it in
15455 : wrapperN, where N is 5. Here in this fragment, SWIG will
15456 : automatically append 5. */
15457 0 : memset(&view5, 0, sizeof view5);
15458 0 : if (obj4 == Py_None)
15459 0 : arg5 = NULL;
15460 : else {
15461 : PyObject *pypointer;
15462 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
15463 : &bytesio5, &view5);
15464 0 : if (pypointer == NULL)
15465 : return NULL;
15466 0 : have_view5 = !! view5.obj;
15467 :
15468 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
15469 :
15470 : /* Following code is from swig's python.swg. */
15471 :
15472 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
15473 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15474 0 : Py_DECREF(pypointer);
15475 : return NULL;
15476 : }
15477 0 : Py_DECREF(pypointer);
15478 : }
15479 : }
15480 : {
15481 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15482 0 : result = gpgme_op_encrypt_start(arg1,arg2,arg3,arg4,arg5);
15483 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15484 : }
15485 : {
15486 0 : resultobj = PyLong_FromLong(result);
15487 : }
15488 : {
15489 0 : if (arg2) free(arg2);
15490 : }
15491 : {
15492 : /* See whether we need to update the Python buffer. */
15493 0 : if (resultobj && wrapper4 && view4.buf)
15494 : {
15495 : int dirty;
15496 0 : char *new_data = NULL;
15497 : size_t new_size;
15498 :
15499 :
15500 0 : new_data = wrapper4->data.mem.buffer;
15501 0 : new_size = wrapper4->data.mem.length;
15502 0 : dirty = new_data != NULL;
15503 :
15504 :
15505 :
15506 :
15507 :
15508 :
15509 :
15510 0 : if (dirty)
15511 : {
15512 : /* The buffer is dirty. */
15513 0 : if (view4.readonly)
15514 : {
15515 0 : Py_XDECREF(resultobj);
15516 0 : resultobj = NULL;
15517 0 : PyErr_SetString(PyExc_ValueError,
15518 : "cannot update read-only buffer");
15519 : }
15520 :
15521 : /* See if we need to truncate the buffer. */
15522 0 : if (resultobj && view4.len != new_size)
15523 : {
15524 0 : if (bytesio4 == NULL)
15525 : {
15526 0 : Py_XDECREF(resultobj);
15527 0 : resultobj = NULL;
15528 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15529 : }
15530 : else
15531 : {
15532 : PyObject *retval;
15533 0 : PyBuffer_Release(&view4);
15534 : assert(view4.obj == NULL);
15535 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
15536 : "l", (long) new_size);
15537 0 : if (retval == NULL)
15538 : {
15539 0 : Py_XDECREF(resultobj);
15540 : resultobj = NULL;
15541 : }
15542 : else
15543 : {
15544 0 : Py_DECREF(retval);
15545 :
15546 0 : retval = PyObject_CallMethod(bytesio4,
15547 : "getbuffer", NULL);
15548 0 : if (retval == NULL
15549 0 : || PyObject_GetBuffer(retval, &view4,
15550 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15551 : {
15552 0 : Py_XDECREF(resultobj);
15553 : resultobj = NULL;
15554 : }
15555 :
15556 0 : Py_XDECREF(retval);
15557 :
15558 0 : if (resultobj && view4.len
15559 : != new_size)
15560 : {
15561 0 : Py_XDECREF(resultobj);
15562 0 : resultobj = NULL;
15563 0 : PyErr_Format(PyExc_ValueError,
15564 : "Expected buffer of length %zu, got %zi",
15565 : new_size,
15566 : view4.len);
15567 : }
15568 : }
15569 : }
15570 : }
15571 0 : if (resultobj)
15572 0 : memcpy(view4.buf, new_data, new_size);
15573 : }
15574 :
15575 :
15576 :
15577 : }
15578 :
15579 : /* Free the temporary wrapper, if any. */
15580 0 : if (wrapper4)
15581 0 : gpgme_data_release(wrapper4);
15582 0 : Py_XDECREF (bytesio4);
15583 0 : if (have_view4 && view4.buf)
15584 0 : PyBuffer_Release(&view4);
15585 : }
15586 : {
15587 : /* See whether we need to update the Python buffer. */
15588 0 : if (resultobj && wrapper5 && view5.buf)
15589 : {
15590 : int dirty;
15591 0 : char *new_data = NULL;
15592 : size_t new_size;
15593 :
15594 :
15595 0 : new_data = wrapper5->data.mem.buffer;
15596 0 : new_size = wrapper5->data.mem.length;
15597 0 : dirty = new_data != NULL;
15598 :
15599 :
15600 :
15601 :
15602 :
15603 :
15604 :
15605 0 : if (dirty)
15606 : {
15607 : /* The buffer is dirty. */
15608 0 : if (view5.readonly)
15609 : {
15610 0 : Py_XDECREF(resultobj);
15611 0 : resultobj = NULL;
15612 0 : PyErr_SetString(PyExc_ValueError,
15613 : "cannot update read-only buffer");
15614 : }
15615 :
15616 : /* See if we need to truncate the buffer. */
15617 0 : if (resultobj && view5.len != new_size)
15618 : {
15619 0 : if (bytesio5 == NULL)
15620 : {
15621 0 : Py_XDECREF(resultobj);
15622 0 : resultobj = NULL;
15623 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15624 : }
15625 : else
15626 : {
15627 : PyObject *retval;
15628 0 : PyBuffer_Release(&view5);
15629 : assert(view5.obj == NULL);
15630 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
15631 : "l", (long) new_size);
15632 0 : if (retval == NULL)
15633 : {
15634 0 : Py_XDECREF(resultobj);
15635 : resultobj = NULL;
15636 : }
15637 : else
15638 : {
15639 0 : Py_DECREF(retval);
15640 :
15641 0 : retval = PyObject_CallMethod(bytesio5,
15642 : "getbuffer", NULL);
15643 0 : if (retval == NULL
15644 0 : || PyObject_GetBuffer(retval, &view5,
15645 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15646 : {
15647 0 : Py_XDECREF(resultobj);
15648 : resultobj = NULL;
15649 : }
15650 :
15651 0 : Py_XDECREF(retval);
15652 :
15653 0 : if (resultobj && view5.len
15654 : != new_size)
15655 : {
15656 0 : Py_XDECREF(resultobj);
15657 0 : resultobj = NULL;
15658 0 : PyErr_Format(PyExc_ValueError,
15659 : "Expected buffer of length %zu, got %zi",
15660 : new_size,
15661 : view5.len);
15662 : }
15663 : }
15664 : }
15665 : }
15666 0 : if (resultobj)
15667 0 : memcpy(view5.buf, new_data, new_size);
15668 : }
15669 :
15670 :
15671 :
15672 : }
15673 :
15674 : /* Free the temporary wrapper, if any. */
15675 0 : if (wrapper5)
15676 0 : gpgme_data_release(wrapper5);
15677 0 : Py_XDECREF (bytesio5);
15678 0 : if (have_view5 && view5.buf)
15679 0 : PyBuffer_Release(&view5);
15680 : }
15681 : return resultobj;
15682 : fail:
15683 : {
15684 0 : if (arg2) free(arg2);
15685 : }
15686 : {
15687 : /* See whether we need to update the Python buffer. */
15688 : if (resultobj && wrapper4 && view4.buf)
15689 : {
15690 : int dirty;
15691 : char *new_data = NULL;
15692 : size_t new_size;
15693 :
15694 :
15695 : new_data = wrapper4->data.mem.buffer;
15696 : new_size = wrapper4->data.mem.length;
15697 : dirty = new_data != NULL;
15698 :
15699 :
15700 :
15701 :
15702 :
15703 :
15704 :
15705 : if (dirty)
15706 : {
15707 : /* The buffer is dirty. */
15708 : if (view4.readonly)
15709 : {
15710 : Py_XDECREF(resultobj);
15711 : resultobj = NULL;
15712 : PyErr_SetString(PyExc_ValueError,
15713 : "cannot update read-only buffer");
15714 : }
15715 :
15716 : /* See if we need to truncate the buffer. */
15717 : if (resultobj && view4.len != new_size)
15718 : {
15719 : if (bytesio4 == NULL)
15720 : {
15721 : Py_XDECREF(resultobj);
15722 : resultobj = NULL;
15723 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15724 : }
15725 : else
15726 : {
15727 : PyObject *retval;
15728 : PyBuffer_Release(&view4);
15729 : assert(view4.obj == NULL);
15730 : retval = PyObject_CallMethod(bytesio4, "truncate",
15731 : "l", (long) new_size);
15732 : if (retval == NULL)
15733 : {
15734 : Py_XDECREF(resultobj);
15735 : resultobj = NULL;
15736 : }
15737 : else
15738 : {
15739 : Py_DECREF(retval);
15740 :
15741 : retval = PyObject_CallMethod(bytesio4,
15742 : "getbuffer", NULL);
15743 : if (retval == NULL
15744 : || PyObject_GetBuffer(retval, &view4,
15745 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15746 : {
15747 : Py_XDECREF(resultobj);
15748 : resultobj = NULL;
15749 : }
15750 :
15751 : Py_XDECREF(retval);
15752 :
15753 : if (resultobj && view4.len
15754 : != new_size)
15755 : {
15756 : Py_XDECREF(resultobj);
15757 : resultobj = NULL;
15758 : PyErr_Format(PyExc_ValueError,
15759 : "Expected buffer of length %zu, got %zi",
15760 : new_size,
15761 : view4.len);
15762 : }
15763 : }
15764 : }
15765 : }
15766 : if (resultobj)
15767 : memcpy(view4.buf, new_data, new_size);
15768 : }
15769 :
15770 :
15771 :
15772 : }
15773 :
15774 : /* Free the temporary wrapper, if any. */
15775 0 : if (wrapper4)
15776 0 : gpgme_data_release(wrapper4);
15777 0 : Py_XDECREF (bytesio4);
15778 : if (have_view4 && view4.buf)
15779 : PyBuffer_Release(&view4);
15780 : }
15781 : {
15782 : /* See whether we need to update the Python buffer. */
15783 : if (resultobj && wrapper5 && view5.buf)
15784 : {
15785 : int dirty;
15786 : char *new_data = NULL;
15787 : size_t new_size;
15788 :
15789 :
15790 : new_data = wrapper5->data.mem.buffer;
15791 : new_size = wrapper5->data.mem.length;
15792 : dirty = new_data != NULL;
15793 :
15794 :
15795 :
15796 :
15797 :
15798 :
15799 :
15800 : if (dirty)
15801 : {
15802 : /* The buffer is dirty. */
15803 : if (view5.readonly)
15804 : {
15805 : Py_XDECREF(resultobj);
15806 : resultobj = NULL;
15807 : PyErr_SetString(PyExc_ValueError,
15808 : "cannot update read-only buffer");
15809 : }
15810 :
15811 : /* See if we need to truncate the buffer. */
15812 : if (resultobj && view5.len != new_size)
15813 : {
15814 : if (bytesio5 == NULL)
15815 : {
15816 : Py_XDECREF(resultobj);
15817 : resultobj = NULL;
15818 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15819 : }
15820 : else
15821 : {
15822 : PyObject *retval;
15823 : PyBuffer_Release(&view5);
15824 : assert(view5.obj == NULL);
15825 : retval = PyObject_CallMethod(bytesio5, "truncate",
15826 : "l", (long) new_size);
15827 : if (retval == NULL)
15828 : {
15829 : Py_XDECREF(resultobj);
15830 : resultobj = NULL;
15831 : }
15832 : else
15833 : {
15834 : Py_DECREF(retval);
15835 :
15836 : retval = PyObject_CallMethod(bytesio5,
15837 : "getbuffer", NULL);
15838 : if (retval == NULL
15839 : || PyObject_GetBuffer(retval, &view5,
15840 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15841 : {
15842 : Py_XDECREF(resultobj);
15843 : resultobj = NULL;
15844 : }
15845 :
15846 : Py_XDECREF(retval);
15847 :
15848 : if (resultobj && view5.len
15849 : != new_size)
15850 : {
15851 : Py_XDECREF(resultobj);
15852 : resultobj = NULL;
15853 : PyErr_Format(PyExc_ValueError,
15854 : "Expected buffer of length %zu, got %zi",
15855 : new_size,
15856 : view5.len);
15857 : }
15858 : }
15859 : }
15860 : }
15861 : if (resultobj)
15862 : memcpy(view5.buf, new_data, new_size);
15863 : }
15864 :
15865 :
15866 :
15867 : }
15868 :
15869 : /* Free the temporary wrapper, if any. */
15870 0 : if (wrapper5)
15871 0 : gpgme_data_release(wrapper5);
15872 0 : Py_XDECREF (bytesio5);
15873 : if (have_view5 && view5.buf)
15874 : PyBuffer_Release(&view5);
15875 : }
15876 : return NULL;
15877 : }
15878 :
15879 :
15880 18 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15881 18 : PyObject *resultobj = 0;
15882 18 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
15883 : gpgme_key_t *arg2 ;
15884 : gpgme_encrypt_flags_t arg3 ;
15885 18 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
15886 18 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
15887 18 : void *argp1 = 0 ;
15888 18 : int res1 = 0 ;
15889 : int val3 ;
15890 18 : int ecode3 = 0 ;
15891 18 : gpgme_data_t wrapper4 = NULL ;
15892 18 : PyObject *bytesio4 = NULL ;
15893 : Py_buffer view4 ;
15894 18 : int have_view4 = 0 ;
15895 18 : gpgme_data_t wrapper5 = NULL ;
15896 18 : PyObject *bytesio5 = NULL ;
15897 : Py_buffer view5 ;
15898 18 : int have_view5 = 0 ;
15899 18 : PyObject * obj0 = 0 ;
15900 18 : PyObject * obj1 = 0 ;
15901 18 : PyObject * obj2 = 0 ;
15902 18 : PyObject * obj3 = 0 ;
15903 18 : PyObject * obj4 = 0 ;
15904 : gpgme_error_t result;
15905 :
15906 : {
15907 18 : arg2 = NULL;
15908 : }
15909 18 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15910 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
15911 18 : if (!SWIG_IsOK(res1)) {
15912 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt" "', argument " "1"" of type '" "gpgme_ctx_t""'");
15913 : }
15914 18 : arg1 = (gpgme_ctx_t)(argp1);
15915 : {
15916 18 : int i, numb = 0;
15917 18 : if (!PySequence_Check(obj1)) {
15918 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
15919 : 2);
15920 0 : return NULL;
15921 : }
15922 18 : if((numb = PySequence_Length(obj1)) != 0) {
15923 9 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
15924 22 : for(i=0; i<numb; i++) {
15925 13 : PyObject *pypointer = PySequence_GetItem(obj1, i);
15926 :
15927 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
15928 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
15929 :
15930 : /* Following code is from swig's python.swg. */
15931 13 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15932 0 : Py_DECREF(pypointer);
15933 0 : PyErr_Format(PyExc_TypeError,
15934 : "arg %d: list must contain only gpgme_key_ts, got %s "
15935 : "at position %d",
15936 0 : 2, pypointer->ob_type->tp_name, i);
15937 0 : free(arg2);
15938 0 : return NULL;
15939 : }
15940 13 : Py_DECREF(pypointer);
15941 : }
15942 9 : arg2[numb] = NULL;
15943 : }
15944 : }
15945 36 : ecode3 = SWIG_AsVal_int(obj2, &val3);
15946 18 : if (!SWIG_IsOK(ecode3)) {
15947 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
15948 : }
15949 18 : arg3 = (gpgme_encrypt_flags_t)(val3);
15950 : {
15951 : /* If we create a temporary wrapper4 object, we will store it in
15952 : wrapperN, where N is 4. Here in this fragment, SWIG will
15953 : automatically append 4. */
15954 18 : memset(&view4, 0, sizeof view4);
15955 18 : if (obj3 == Py_None)
15956 0 : arg4 = NULL;
15957 : else {
15958 : PyObject *pypointer;
15959 18 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
15960 : &bytesio4, &view4);
15961 18 : if (pypointer == NULL)
15962 : return NULL;
15963 17 : have_view4 = !! view4.obj;
15964 :
15965 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
15966 :
15967 : /* Following code is from swig's python.swg. */
15968 :
15969 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
15970 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15971 0 : Py_DECREF(pypointer);
15972 : return NULL;
15973 : }
15974 17 : Py_DECREF(pypointer);
15975 : }
15976 : }
15977 : {
15978 : /* If we create a temporary wrapper5 object, we will store it in
15979 : wrapperN, where N is 5. Here in this fragment, SWIG will
15980 : automatically append 5. */
15981 17 : memset(&view5, 0, sizeof view5);
15982 17 : if (obj4 == Py_None)
15983 0 : arg5 = NULL;
15984 : else {
15985 : PyObject *pypointer;
15986 17 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
15987 : &bytesio5, &view5);
15988 17 : if (pypointer == NULL)
15989 : return NULL;
15990 17 : have_view5 = !! view5.obj;
15991 :
15992 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
15993 :
15994 : /* Following code is from swig's python.swg. */
15995 :
15996 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
15997 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15998 0 : Py_DECREF(pypointer);
15999 : return NULL;
16000 : }
16001 17 : Py_DECREF(pypointer);
16002 : }
16003 : }
16004 : {
16005 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16006 17 : result = gpgme_op_encrypt(arg1,arg2,arg3,arg4,arg5);
16007 17 : SWIG_PYTHON_THREAD_END_ALLOW;
16008 : }
16009 : {
16010 17 : resultobj = PyLong_FromLong(result);
16011 : }
16012 : {
16013 17 : if (arg2) free(arg2);
16014 : }
16015 : {
16016 : /* See whether we need to update the Python buffer. */
16017 17 : if (resultobj && wrapper4 && view4.buf)
16018 : {
16019 : int dirty;
16020 5 : char *new_data = NULL;
16021 : size_t new_size;
16022 :
16023 :
16024 5 : new_data = wrapper4->data.mem.buffer;
16025 5 : new_size = wrapper4->data.mem.length;
16026 5 : dirty = new_data != NULL;
16027 :
16028 :
16029 :
16030 :
16031 :
16032 :
16033 :
16034 5 : if (dirty)
16035 : {
16036 : /* The buffer is dirty. */
16037 0 : if (view4.readonly)
16038 : {
16039 0 : Py_XDECREF(resultobj);
16040 0 : resultobj = NULL;
16041 0 : PyErr_SetString(PyExc_ValueError,
16042 : "cannot update read-only buffer");
16043 : }
16044 :
16045 : /* See if we need to truncate the buffer. */
16046 0 : if (resultobj && view4.len != new_size)
16047 : {
16048 0 : if (bytesio4 == NULL)
16049 : {
16050 0 : Py_XDECREF(resultobj);
16051 0 : resultobj = NULL;
16052 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16053 : }
16054 : else
16055 : {
16056 : PyObject *retval;
16057 0 : PyBuffer_Release(&view4);
16058 : assert(view4.obj == NULL);
16059 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
16060 : "l", (long) new_size);
16061 0 : if (retval == NULL)
16062 : {
16063 0 : Py_XDECREF(resultobj);
16064 : resultobj = NULL;
16065 : }
16066 : else
16067 : {
16068 0 : Py_DECREF(retval);
16069 :
16070 0 : retval = PyObject_CallMethod(bytesio4,
16071 : "getbuffer", NULL);
16072 0 : if (retval == NULL
16073 0 : || PyObject_GetBuffer(retval, &view4,
16074 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16075 : {
16076 0 : Py_XDECREF(resultobj);
16077 : resultobj = NULL;
16078 : }
16079 :
16080 0 : Py_XDECREF(retval);
16081 :
16082 0 : if (resultobj && view4.len
16083 : != new_size)
16084 : {
16085 0 : Py_XDECREF(resultobj);
16086 0 : resultobj = NULL;
16087 0 : PyErr_Format(PyExc_ValueError,
16088 : "Expected buffer of length %zu, got %zi",
16089 : new_size,
16090 : view4.len);
16091 : }
16092 : }
16093 : }
16094 : }
16095 0 : if (resultobj)
16096 0 : memcpy(view4.buf, new_data, new_size);
16097 : }
16098 :
16099 :
16100 :
16101 : }
16102 :
16103 : /* Free the temporary wrapper, if any. */
16104 17 : if (wrapper4)
16105 5 : gpgme_data_release(wrapper4);
16106 17 : Py_XDECREF (bytesio4);
16107 17 : if (have_view4 && view4.buf)
16108 5 : PyBuffer_Release(&view4);
16109 : }
16110 : {
16111 : /* See whether we need to update the Python buffer. */
16112 17 : if (resultobj && wrapper5 && view5.buf)
16113 : {
16114 : int dirty;
16115 0 : char *new_data = NULL;
16116 : size_t new_size;
16117 :
16118 :
16119 0 : new_data = wrapper5->data.mem.buffer;
16120 0 : new_size = wrapper5->data.mem.length;
16121 0 : dirty = new_data != NULL;
16122 :
16123 :
16124 :
16125 :
16126 :
16127 :
16128 :
16129 0 : if (dirty)
16130 : {
16131 : /* The buffer is dirty. */
16132 0 : if (view5.readonly)
16133 : {
16134 0 : Py_XDECREF(resultobj);
16135 0 : resultobj = NULL;
16136 0 : PyErr_SetString(PyExc_ValueError,
16137 : "cannot update read-only buffer");
16138 : }
16139 :
16140 : /* See if we need to truncate the buffer. */
16141 0 : if (resultobj && view5.len != new_size)
16142 : {
16143 0 : if (bytesio5 == NULL)
16144 : {
16145 0 : Py_XDECREF(resultobj);
16146 0 : resultobj = NULL;
16147 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16148 : }
16149 : else
16150 : {
16151 : PyObject *retval;
16152 0 : PyBuffer_Release(&view5);
16153 : assert(view5.obj == NULL);
16154 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
16155 : "l", (long) new_size);
16156 0 : if (retval == NULL)
16157 : {
16158 0 : Py_XDECREF(resultobj);
16159 : resultobj = NULL;
16160 : }
16161 : else
16162 : {
16163 0 : Py_DECREF(retval);
16164 :
16165 0 : retval = PyObject_CallMethod(bytesio5,
16166 : "getbuffer", NULL);
16167 0 : if (retval == NULL
16168 0 : || PyObject_GetBuffer(retval, &view5,
16169 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16170 : {
16171 0 : Py_XDECREF(resultobj);
16172 : resultobj = NULL;
16173 : }
16174 :
16175 0 : Py_XDECREF(retval);
16176 :
16177 0 : if (resultobj && view5.len
16178 : != new_size)
16179 : {
16180 0 : Py_XDECREF(resultobj);
16181 0 : resultobj = NULL;
16182 0 : PyErr_Format(PyExc_ValueError,
16183 : "Expected buffer of length %zu, got %zi",
16184 : new_size,
16185 : view5.len);
16186 : }
16187 : }
16188 : }
16189 : }
16190 0 : if (resultobj)
16191 0 : memcpy(view5.buf, new_data, new_size);
16192 : }
16193 :
16194 :
16195 :
16196 : }
16197 :
16198 : /* Free the temporary wrapper, if any. */
16199 17 : if (wrapper5)
16200 0 : gpgme_data_release(wrapper5);
16201 17 : Py_XDECREF (bytesio5);
16202 17 : if (have_view5 && view5.buf)
16203 0 : PyBuffer_Release(&view5);
16204 : }
16205 : return resultobj;
16206 : fail:
16207 : {
16208 0 : if (arg2) free(arg2);
16209 : }
16210 : {
16211 : /* See whether we need to update the Python buffer. */
16212 : if (resultobj && wrapper4 && view4.buf)
16213 : {
16214 : int dirty;
16215 : char *new_data = NULL;
16216 : size_t new_size;
16217 :
16218 :
16219 : new_data = wrapper4->data.mem.buffer;
16220 : new_size = wrapper4->data.mem.length;
16221 : dirty = new_data != NULL;
16222 :
16223 :
16224 :
16225 :
16226 :
16227 :
16228 :
16229 : if (dirty)
16230 : {
16231 : /* The buffer is dirty. */
16232 : if (view4.readonly)
16233 : {
16234 : Py_XDECREF(resultobj);
16235 : resultobj = NULL;
16236 : PyErr_SetString(PyExc_ValueError,
16237 : "cannot update read-only buffer");
16238 : }
16239 :
16240 : /* See if we need to truncate the buffer. */
16241 : if (resultobj && view4.len != new_size)
16242 : {
16243 : if (bytesio4 == NULL)
16244 : {
16245 : Py_XDECREF(resultobj);
16246 : resultobj = NULL;
16247 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16248 : }
16249 : else
16250 : {
16251 : PyObject *retval;
16252 : PyBuffer_Release(&view4);
16253 : assert(view4.obj == NULL);
16254 : retval = PyObject_CallMethod(bytesio4, "truncate",
16255 : "l", (long) new_size);
16256 : if (retval == NULL)
16257 : {
16258 : Py_XDECREF(resultobj);
16259 : resultobj = NULL;
16260 : }
16261 : else
16262 : {
16263 : Py_DECREF(retval);
16264 :
16265 : retval = PyObject_CallMethod(bytesio4,
16266 : "getbuffer", NULL);
16267 : if (retval == NULL
16268 : || PyObject_GetBuffer(retval, &view4,
16269 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16270 : {
16271 : Py_XDECREF(resultobj);
16272 : resultobj = NULL;
16273 : }
16274 :
16275 : Py_XDECREF(retval);
16276 :
16277 : if (resultobj && view4.len
16278 : != new_size)
16279 : {
16280 : Py_XDECREF(resultobj);
16281 : resultobj = NULL;
16282 : PyErr_Format(PyExc_ValueError,
16283 : "Expected buffer of length %zu, got %zi",
16284 : new_size,
16285 : view4.len);
16286 : }
16287 : }
16288 : }
16289 : }
16290 : if (resultobj)
16291 : memcpy(view4.buf, new_data, new_size);
16292 : }
16293 :
16294 :
16295 :
16296 : }
16297 :
16298 : /* Free the temporary wrapper, if any. */
16299 0 : if (wrapper4)
16300 0 : gpgme_data_release(wrapper4);
16301 0 : Py_XDECREF (bytesio4);
16302 : if (have_view4 && view4.buf)
16303 : PyBuffer_Release(&view4);
16304 : }
16305 : {
16306 : /* See whether we need to update the Python buffer. */
16307 : if (resultobj && wrapper5 && view5.buf)
16308 : {
16309 : int dirty;
16310 : char *new_data = NULL;
16311 : size_t new_size;
16312 :
16313 :
16314 : new_data = wrapper5->data.mem.buffer;
16315 : new_size = wrapper5->data.mem.length;
16316 : dirty = new_data != NULL;
16317 :
16318 :
16319 :
16320 :
16321 :
16322 :
16323 :
16324 : if (dirty)
16325 : {
16326 : /* The buffer is dirty. */
16327 : if (view5.readonly)
16328 : {
16329 : Py_XDECREF(resultobj);
16330 : resultobj = NULL;
16331 : PyErr_SetString(PyExc_ValueError,
16332 : "cannot update read-only buffer");
16333 : }
16334 :
16335 : /* See if we need to truncate the buffer. */
16336 : if (resultobj && view5.len != new_size)
16337 : {
16338 : if (bytesio5 == NULL)
16339 : {
16340 : Py_XDECREF(resultobj);
16341 : resultobj = NULL;
16342 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16343 : }
16344 : else
16345 : {
16346 : PyObject *retval;
16347 : PyBuffer_Release(&view5);
16348 : assert(view5.obj == NULL);
16349 : retval = PyObject_CallMethod(bytesio5, "truncate",
16350 : "l", (long) new_size);
16351 : if (retval == NULL)
16352 : {
16353 : Py_XDECREF(resultobj);
16354 : resultobj = NULL;
16355 : }
16356 : else
16357 : {
16358 : Py_DECREF(retval);
16359 :
16360 : retval = PyObject_CallMethod(bytesio5,
16361 : "getbuffer", NULL);
16362 : if (retval == NULL
16363 : || PyObject_GetBuffer(retval, &view5,
16364 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16365 : {
16366 : Py_XDECREF(resultobj);
16367 : resultobj = NULL;
16368 : }
16369 :
16370 : Py_XDECREF(retval);
16371 :
16372 : if (resultobj && view5.len
16373 : != new_size)
16374 : {
16375 : Py_XDECREF(resultobj);
16376 : resultobj = NULL;
16377 : PyErr_Format(PyExc_ValueError,
16378 : "Expected buffer of length %zu, got %zi",
16379 : new_size,
16380 : view5.len);
16381 : }
16382 : }
16383 : }
16384 : }
16385 : if (resultobj)
16386 : memcpy(view5.buf, new_data, new_size);
16387 : }
16388 :
16389 :
16390 :
16391 : }
16392 :
16393 : /* Free the temporary wrapper, if any. */
16394 0 : if (wrapper5)
16395 0 : gpgme_data_release(wrapper5);
16396 0 : Py_XDECREF (bytesio5);
16397 : if (have_view5 && view5.buf)
16398 : PyBuffer_Release(&view5);
16399 : }
16400 : return NULL;
16401 : }
16402 :
16403 :
16404 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_ext_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16405 0 : PyObject *resultobj = 0;
16406 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
16407 : gpgme_key_t *arg2 ;
16408 0 : char *arg3 = (char *) 0 ;
16409 : gpgme_encrypt_flags_t arg4 ;
16410 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
16411 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
16412 0 : void *argp1 = 0 ;
16413 0 : int res1 = 0 ;
16414 0 : PyObject *encodedInput3 = NULL ;
16415 : int val4 ;
16416 0 : int ecode4 = 0 ;
16417 0 : gpgme_data_t wrapper5 = NULL ;
16418 0 : PyObject *bytesio5 = NULL ;
16419 : Py_buffer view5 ;
16420 0 : int have_view5 = 0 ;
16421 0 : gpgme_data_t wrapper6 = NULL ;
16422 0 : PyObject *bytesio6 = NULL ;
16423 : Py_buffer view6 ;
16424 0 : int have_view6 = 0 ;
16425 0 : PyObject * obj0 = 0 ;
16426 0 : PyObject * obj1 = 0 ;
16427 0 : PyObject * obj2 = 0 ;
16428 0 : PyObject * obj3 = 0 ;
16429 0 : PyObject * obj4 = 0 ;
16430 0 : PyObject * obj5 = 0 ;
16431 : gpgme_error_t result;
16432 :
16433 : {
16434 0 : arg2 = NULL;
16435 : }
16436 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_encrypt_ext_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16437 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
16438 0 : if (!SWIG_IsOK(res1)) {
16439 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
16440 : }
16441 0 : arg1 = (gpgme_ctx_t)(argp1);
16442 : {
16443 0 : int i, numb = 0;
16444 0 : if (!PySequence_Check(obj1)) {
16445 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
16446 : 2);
16447 0 : return NULL;
16448 : }
16449 0 : if((numb = PySequence_Length(obj1)) != 0) {
16450 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
16451 0 : for(i=0; i<numb; i++) {
16452 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
16453 :
16454 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
16455 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
16456 :
16457 : /* Following code is from swig's python.swg. */
16458 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16459 0 : Py_DECREF(pypointer);
16460 0 : PyErr_Format(PyExc_TypeError,
16461 : "arg %d: list must contain only gpgme_key_ts, got %s "
16462 : "at position %d",
16463 0 : 2, pypointer->ob_type->tp_name, i);
16464 0 : free(arg2);
16465 0 : return NULL;
16466 : }
16467 0 : Py_DECREF(pypointer);
16468 : }
16469 0 : arg2[numb] = NULL;
16470 : }
16471 : }
16472 : {
16473 0 : if (obj2 == Py_None)
16474 : arg3 = NULL;
16475 0 : else if (PyUnicode_Check(obj2))
16476 : {
16477 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
16478 0 : if (encodedInput3 == NULL)
16479 : return NULL;
16480 0 : arg3 = PyBytes_AsString(encodedInput3);
16481 : }
16482 0 : else if (PyBytes_Check(obj2))
16483 0 : arg3 = PyBytes_AsString(obj2);
16484 : else {
16485 0 : PyErr_Format(PyExc_TypeError,
16486 : "arg %d: expected str, bytes, or None, got %s",
16487 : 3, obj2->ob_type->tp_name);
16488 0 : return NULL;
16489 : }
16490 : }
16491 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
16492 0 : if (!SWIG_IsOK(ecode4)) {
16493 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_encrypt_ext_start" "', argument " "4"" of type '" "gpgme_encrypt_flags_t""'");
16494 : }
16495 0 : arg4 = (gpgme_encrypt_flags_t)(val4);
16496 : {
16497 : /* If we create a temporary wrapper5 object, we will store it in
16498 : wrapperN, where N is 5. Here in this fragment, SWIG will
16499 : automatically append 5. */
16500 0 : memset(&view5, 0, sizeof view5);
16501 0 : if (obj4 == Py_None)
16502 0 : arg5 = NULL;
16503 : else {
16504 : PyObject *pypointer;
16505 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
16506 : &bytesio5, &view5);
16507 0 : if (pypointer == NULL)
16508 : return NULL;
16509 0 : have_view5 = !! view5.obj;
16510 :
16511 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
16512 :
16513 : /* Following code is from swig's python.swg. */
16514 :
16515 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
16516 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16517 0 : Py_DECREF(pypointer);
16518 : return NULL;
16519 : }
16520 0 : Py_DECREF(pypointer);
16521 : }
16522 : }
16523 : {
16524 : /* If we create a temporary wrapper6 object, we will store it in
16525 : wrapperN, where N is 6. Here in this fragment, SWIG will
16526 : automatically append 6. */
16527 0 : memset(&view6, 0, sizeof view6);
16528 0 : if (obj5 == Py_None)
16529 0 : arg6 = NULL;
16530 : else {
16531 : PyObject *pypointer;
16532 0 : pypointer = _gpg_obj2gpgme_data_t(obj5, 6, &wrapper6,
16533 : &bytesio6, &view6);
16534 0 : if (pypointer == NULL)
16535 : return NULL;
16536 0 : have_view6 = !! view6.obj;
16537 :
16538 : /* input = obj5, 1 = arg6, 1_descriptor = SWIGTYPE_p_gpgme_data */
16539 :
16540 : /* Following code is from swig's python.swg. */
16541 :
16542 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg6, SWIGTYPE_p_gpgme_data,
16543 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16544 0 : Py_DECREF(pypointer);
16545 : return NULL;
16546 : }
16547 0 : Py_DECREF(pypointer);
16548 : }
16549 : }
16550 : {
16551 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16552 0 : result = gpgme_op_encrypt_ext_start(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
16553 0 : SWIG_PYTHON_THREAD_END_ALLOW;
16554 : }
16555 : {
16556 0 : resultobj = PyLong_FromLong(result);
16557 : }
16558 : {
16559 0 : if (arg2) free(arg2);
16560 : }
16561 : {
16562 0 : Py_XDECREF(encodedInput3);
16563 : }
16564 : {
16565 : /* See whether we need to update the Python buffer. */
16566 0 : if (resultobj && wrapper5 && view5.buf)
16567 : {
16568 : int dirty;
16569 0 : char *new_data = NULL;
16570 : size_t new_size;
16571 :
16572 :
16573 0 : new_data = wrapper5->data.mem.buffer;
16574 0 : new_size = wrapper5->data.mem.length;
16575 0 : dirty = new_data != NULL;
16576 :
16577 :
16578 :
16579 :
16580 :
16581 :
16582 :
16583 0 : if (dirty)
16584 : {
16585 : /* The buffer is dirty. */
16586 0 : if (view5.readonly)
16587 : {
16588 0 : Py_XDECREF(resultobj);
16589 0 : resultobj = NULL;
16590 0 : PyErr_SetString(PyExc_ValueError,
16591 : "cannot update read-only buffer");
16592 : }
16593 :
16594 : /* See if we need to truncate the buffer. */
16595 0 : if (resultobj && view5.len != new_size)
16596 : {
16597 0 : if (bytesio5 == NULL)
16598 : {
16599 0 : Py_XDECREF(resultobj);
16600 0 : resultobj = NULL;
16601 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16602 : }
16603 : else
16604 : {
16605 : PyObject *retval;
16606 0 : PyBuffer_Release(&view5);
16607 : assert(view5.obj == NULL);
16608 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
16609 : "l", (long) new_size);
16610 0 : if (retval == NULL)
16611 : {
16612 0 : Py_XDECREF(resultobj);
16613 : resultobj = NULL;
16614 : }
16615 : else
16616 : {
16617 0 : Py_DECREF(retval);
16618 :
16619 0 : retval = PyObject_CallMethod(bytesio5,
16620 : "getbuffer", NULL);
16621 0 : if (retval == NULL
16622 0 : || PyObject_GetBuffer(retval, &view5,
16623 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16624 : {
16625 0 : Py_XDECREF(resultobj);
16626 : resultobj = NULL;
16627 : }
16628 :
16629 0 : Py_XDECREF(retval);
16630 :
16631 0 : if (resultobj && view5.len
16632 : != new_size)
16633 : {
16634 0 : Py_XDECREF(resultobj);
16635 0 : resultobj = NULL;
16636 0 : PyErr_Format(PyExc_ValueError,
16637 : "Expected buffer of length %zu, got %zi",
16638 : new_size,
16639 : view5.len);
16640 : }
16641 : }
16642 : }
16643 : }
16644 0 : if (resultobj)
16645 0 : memcpy(view5.buf, new_data, new_size);
16646 : }
16647 :
16648 :
16649 :
16650 : }
16651 :
16652 : /* Free the temporary wrapper, if any. */
16653 0 : if (wrapper5)
16654 0 : gpgme_data_release(wrapper5);
16655 0 : Py_XDECREF (bytesio5);
16656 0 : if (have_view5 && view5.buf)
16657 0 : PyBuffer_Release(&view5);
16658 : }
16659 : {
16660 : /* See whether we need to update the Python buffer. */
16661 0 : if (resultobj && wrapper6 && view6.buf)
16662 : {
16663 : int dirty;
16664 0 : char *new_data = NULL;
16665 : size_t new_size;
16666 :
16667 :
16668 0 : new_data = wrapper6->data.mem.buffer;
16669 0 : new_size = wrapper6->data.mem.length;
16670 0 : dirty = new_data != NULL;
16671 :
16672 :
16673 :
16674 :
16675 :
16676 :
16677 :
16678 0 : if (dirty)
16679 : {
16680 : /* The buffer is dirty. */
16681 0 : if (view6.readonly)
16682 : {
16683 0 : Py_XDECREF(resultobj);
16684 0 : resultobj = NULL;
16685 0 : PyErr_SetString(PyExc_ValueError,
16686 : "cannot update read-only buffer");
16687 : }
16688 :
16689 : /* See if we need to truncate the buffer. */
16690 0 : if (resultobj && view6.len != new_size)
16691 : {
16692 0 : if (bytesio6 == NULL)
16693 : {
16694 0 : Py_XDECREF(resultobj);
16695 0 : resultobj = NULL;
16696 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16697 : }
16698 : else
16699 : {
16700 : PyObject *retval;
16701 0 : PyBuffer_Release(&view6);
16702 : assert(view6.obj == NULL);
16703 0 : retval = PyObject_CallMethod(bytesio6, "truncate",
16704 : "l", (long) new_size);
16705 0 : if (retval == NULL)
16706 : {
16707 0 : Py_XDECREF(resultobj);
16708 : resultobj = NULL;
16709 : }
16710 : else
16711 : {
16712 0 : Py_DECREF(retval);
16713 :
16714 0 : retval = PyObject_CallMethod(bytesio6,
16715 : "getbuffer", NULL);
16716 0 : if (retval == NULL
16717 0 : || PyObject_GetBuffer(retval, &view6,
16718 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16719 : {
16720 0 : Py_XDECREF(resultobj);
16721 : resultobj = NULL;
16722 : }
16723 :
16724 0 : Py_XDECREF(retval);
16725 :
16726 0 : if (resultobj && view6.len
16727 : != new_size)
16728 : {
16729 0 : Py_XDECREF(resultobj);
16730 0 : resultobj = NULL;
16731 0 : PyErr_Format(PyExc_ValueError,
16732 : "Expected buffer of length %zu, got %zi",
16733 : new_size,
16734 : view6.len);
16735 : }
16736 : }
16737 : }
16738 : }
16739 0 : if (resultobj)
16740 0 : memcpy(view6.buf, new_data, new_size);
16741 : }
16742 :
16743 :
16744 :
16745 : }
16746 :
16747 : /* Free the temporary wrapper, if any. */
16748 0 : if (wrapper6)
16749 0 : gpgme_data_release(wrapper6);
16750 0 : Py_XDECREF (bytesio6);
16751 0 : if (have_view6 && view6.buf)
16752 0 : PyBuffer_Release(&view6);
16753 : }
16754 : return resultobj;
16755 : fail:
16756 : {
16757 0 : if (arg2) free(arg2);
16758 : }
16759 : {
16760 0 : Py_XDECREF(encodedInput3);
16761 : }
16762 : {
16763 : /* See whether we need to update the Python buffer. */
16764 : if (resultobj && wrapper5 && view5.buf)
16765 : {
16766 : int dirty;
16767 : char *new_data = NULL;
16768 : size_t new_size;
16769 :
16770 :
16771 : new_data = wrapper5->data.mem.buffer;
16772 : new_size = wrapper5->data.mem.length;
16773 : dirty = new_data != NULL;
16774 :
16775 :
16776 :
16777 :
16778 :
16779 :
16780 :
16781 : if (dirty)
16782 : {
16783 : /* The buffer is dirty. */
16784 : if (view5.readonly)
16785 : {
16786 : Py_XDECREF(resultobj);
16787 : resultobj = NULL;
16788 : PyErr_SetString(PyExc_ValueError,
16789 : "cannot update read-only buffer");
16790 : }
16791 :
16792 : /* See if we need to truncate the buffer. */
16793 : if (resultobj && view5.len != new_size)
16794 : {
16795 : if (bytesio5 == NULL)
16796 : {
16797 : Py_XDECREF(resultobj);
16798 : resultobj = NULL;
16799 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16800 : }
16801 : else
16802 : {
16803 : PyObject *retval;
16804 : PyBuffer_Release(&view5);
16805 : assert(view5.obj == NULL);
16806 : retval = PyObject_CallMethod(bytesio5, "truncate",
16807 : "l", (long) new_size);
16808 : if (retval == NULL)
16809 : {
16810 : Py_XDECREF(resultobj);
16811 : resultobj = NULL;
16812 : }
16813 : else
16814 : {
16815 : Py_DECREF(retval);
16816 :
16817 : retval = PyObject_CallMethod(bytesio5,
16818 : "getbuffer", NULL);
16819 : if (retval == NULL
16820 : || PyObject_GetBuffer(retval, &view5,
16821 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16822 : {
16823 : Py_XDECREF(resultobj);
16824 : resultobj = NULL;
16825 : }
16826 :
16827 : Py_XDECREF(retval);
16828 :
16829 : if (resultobj && view5.len
16830 : != new_size)
16831 : {
16832 : Py_XDECREF(resultobj);
16833 : resultobj = NULL;
16834 : PyErr_Format(PyExc_ValueError,
16835 : "Expected buffer of length %zu, got %zi",
16836 : new_size,
16837 : view5.len);
16838 : }
16839 : }
16840 : }
16841 : }
16842 : if (resultobj)
16843 : memcpy(view5.buf, new_data, new_size);
16844 : }
16845 :
16846 :
16847 :
16848 : }
16849 :
16850 : /* Free the temporary wrapper, if any. */
16851 0 : if (wrapper5)
16852 0 : gpgme_data_release(wrapper5);
16853 0 : Py_XDECREF (bytesio5);
16854 : if (have_view5 && view5.buf)
16855 : PyBuffer_Release(&view5);
16856 : }
16857 : {
16858 : /* See whether we need to update the Python buffer. */
16859 : if (resultobj && wrapper6 && view6.buf)
16860 : {
16861 : int dirty;
16862 : char *new_data = NULL;
16863 : size_t new_size;
16864 :
16865 :
16866 : new_data = wrapper6->data.mem.buffer;
16867 : new_size = wrapper6->data.mem.length;
16868 : dirty = new_data != NULL;
16869 :
16870 :
16871 :
16872 :
16873 :
16874 :
16875 :
16876 : if (dirty)
16877 : {
16878 : /* The buffer is dirty. */
16879 : if (view6.readonly)
16880 : {
16881 : Py_XDECREF(resultobj);
16882 : resultobj = NULL;
16883 : PyErr_SetString(PyExc_ValueError,
16884 : "cannot update read-only buffer");
16885 : }
16886 :
16887 : /* See if we need to truncate the buffer. */
16888 : if (resultobj && view6.len != new_size)
16889 : {
16890 : if (bytesio6 == NULL)
16891 : {
16892 : Py_XDECREF(resultobj);
16893 : resultobj = NULL;
16894 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16895 : }
16896 : else
16897 : {
16898 : PyObject *retval;
16899 : PyBuffer_Release(&view6);
16900 : assert(view6.obj == NULL);
16901 : retval = PyObject_CallMethod(bytesio6, "truncate",
16902 : "l", (long) new_size);
16903 : if (retval == NULL)
16904 : {
16905 : Py_XDECREF(resultobj);
16906 : resultobj = NULL;
16907 : }
16908 : else
16909 : {
16910 : Py_DECREF(retval);
16911 :
16912 : retval = PyObject_CallMethod(bytesio6,
16913 : "getbuffer", NULL);
16914 : if (retval == NULL
16915 : || PyObject_GetBuffer(retval, &view6,
16916 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16917 : {
16918 : Py_XDECREF(resultobj);
16919 : resultobj = NULL;
16920 : }
16921 :
16922 : Py_XDECREF(retval);
16923 :
16924 : if (resultobj && view6.len
16925 : != new_size)
16926 : {
16927 : Py_XDECREF(resultobj);
16928 : resultobj = NULL;
16929 : PyErr_Format(PyExc_ValueError,
16930 : "Expected buffer of length %zu, got %zi",
16931 : new_size,
16932 : view6.len);
16933 : }
16934 : }
16935 : }
16936 : }
16937 : if (resultobj)
16938 : memcpy(view6.buf, new_data, new_size);
16939 : }
16940 :
16941 :
16942 :
16943 : }
16944 :
16945 : /* Free the temporary wrapper, if any. */
16946 0 : if (wrapper6)
16947 0 : gpgme_data_release(wrapper6);
16948 0 : Py_XDECREF (bytesio6);
16949 : if (have_view6 && view6.buf)
16950 : PyBuffer_Release(&view6);
16951 : }
16952 : return NULL;
16953 : }
16954 :
16955 :
16956 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16957 0 : PyObject *resultobj = 0;
16958 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
16959 : gpgme_key_t *arg2 ;
16960 0 : char *arg3 = (char *) 0 ;
16961 : gpgme_encrypt_flags_t arg4 ;
16962 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
16963 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
16964 0 : void *argp1 = 0 ;
16965 0 : int res1 = 0 ;
16966 0 : PyObject *encodedInput3 = NULL ;
16967 : int val4 ;
16968 0 : int ecode4 = 0 ;
16969 0 : gpgme_data_t wrapper5 = NULL ;
16970 0 : PyObject *bytesio5 = NULL ;
16971 : Py_buffer view5 ;
16972 0 : int have_view5 = 0 ;
16973 0 : gpgme_data_t wrapper6 = NULL ;
16974 0 : PyObject *bytesio6 = NULL ;
16975 : Py_buffer view6 ;
16976 0 : int have_view6 = 0 ;
16977 0 : PyObject * obj0 = 0 ;
16978 0 : PyObject * obj1 = 0 ;
16979 0 : PyObject * obj2 = 0 ;
16980 0 : PyObject * obj3 = 0 ;
16981 0 : PyObject * obj4 = 0 ;
16982 0 : PyObject * obj5 = 0 ;
16983 : gpgme_error_t result;
16984 :
16985 : {
16986 0 : arg2 = NULL;
16987 : }
16988 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_encrypt_ext",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16989 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
16990 0 : if (!SWIG_IsOK(res1)) {
16991 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
16992 : }
16993 0 : arg1 = (gpgme_ctx_t)(argp1);
16994 : {
16995 0 : int i, numb = 0;
16996 0 : if (!PySequence_Check(obj1)) {
16997 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
16998 : 2);
16999 0 : return NULL;
17000 : }
17001 0 : if((numb = PySequence_Length(obj1)) != 0) {
17002 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
17003 0 : for(i=0; i<numb; i++) {
17004 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
17005 :
17006 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
17007 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
17008 :
17009 : /* Following code is from swig's python.swg. */
17010 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17011 0 : Py_DECREF(pypointer);
17012 0 : PyErr_Format(PyExc_TypeError,
17013 : "arg %d: list must contain only gpgme_key_ts, got %s "
17014 : "at position %d",
17015 0 : 2, pypointer->ob_type->tp_name, i);
17016 0 : free(arg2);
17017 0 : return NULL;
17018 : }
17019 0 : Py_DECREF(pypointer);
17020 : }
17021 0 : arg2[numb] = NULL;
17022 : }
17023 : }
17024 : {
17025 0 : if (obj2 == Py_None)
17026 : arg3 = NULL;
17027 0 : else if (PyUnicode_Check(obj2))
17028 : {
17029 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
17030 0 : if (encodedInput3 == NULL)
17031 : return NULL;
17032 0 : arg3 = PyBytes_AsString(encodedInput3);
17033 : }
17034 0 : else if (PyBytes_Check(obj2))
17035 0 : arg3 = PyBytes_AsString(obj2);
17036 : else {
17037 0 : PyErr_Format(PyExc_TypeError,
17038 : "arg %d: expected str, bytes, or None, got %s",
17039 : 3, obj2->ob_type->tp_name);
17040 0 : return NULL;
17041 : }
17042 : }
17043 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
17044 0 : if (!SWIG_IsOK(ecode4)) {
17045 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_encrypt_ext" "', argument " "4"" of type '" "gpgme_encrypt_flags_t""'");
17046 : }
17047 0 : arg4 = (gpgme_encrypt_flags_t)(val4);
17048 : {
17049 : /* If we create a temporary wrapper5 object, we will store it in
17050 : wrapperN, where N is 5. Here in this fragment, SWIG will
17051 : automatically append 5. */
17052 0 : memset(&view5, 0, sizeof view5);
17053 0 : if (obj4 == Py_None)
17054 0 : arg5 = NULL;
17055 : else {
17056 : PyObject *pypointer;
17057 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
17058 : &bytesio5, &view5);
17059 0 : if (pypointer == NULL)
17060 : return NULL;
17061 0 : have_view5 = !! view5.obj;
17062 :
17063 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
17064 :
17065 : /* Following code is from swig's python.swg. */
17066 :
17067 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
17068 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17069 0 : Py_DECREF(pypointer);
17070 : return NULL;
17071 : }
17072 0 : Py_DECREF(pypointer);
17073 : }
17074 : }
17075 : {
17076 : /* If we create a temporary wrapper6 object, we will store it in
17077 : wrapperN, where N is 6. Here in this fragment, SWIG will
17078 : automatically append 6. */
17079 0 : memset(&view6, 0, sizeof view6);
17080 0 : if (obj5 == Py_None)
17081 0 : arg6 = NULL;
17082 : else {
17083 : PyObject *pypointer;
17084 0 : pypointer = _gpg_obj2gpgme_data_t(obj5, 6, &wrapper6,
17085 : &bytesio6, &view6);
17086 0 : if (pypointer == NULL)
17087 : return NULL;
17088 0 : have_view6 = !! view6.obj;
17089 :
17090 : /* input = obj5, 1 = arg6, 1_descriptor = SWIGTYPE_p_gpgme_data */
17091 :
17092 : /* Following code is from swig's python.swg. */
17093 :
17094 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg6, SWIGTYPE_p_gpgme_data,
17095 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17096 0 : Py_DECREF(pypointer);
17097 : return NULL;
17098 : }
17099 0 : Py_DECREF(pypointer);
17100 : }
17101 : }
17102 : {
17103 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17104 0 : result = gpgme_op_encrypt_ext(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
17105 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17106 : }
17107 : {
17108 0 : resultobj = PyLong_FromLong(result);
17109 : }
17110 : {
17111 0 : if (arg2) free(arg2);
17112 : }
17113 : {
17114 0 : Py_XDECREF(encodedInput3);
17115 : }
17116 : {
17117 : /* See whether we need to update the Python buffer. */
17118 0 : if (resultobj && wrapper5 && view5.buf)
17119 : {
17120 : int dirty;
17121 0 : char *new_data = NULL;
17122 : size_t new_size;
17123 :
17124 :
17125 0 : new_data = wrapper5->data.mem.buffer;
17126 0 : new_size = wrapper5->data.mem.length;
17127 0 : dirty = new_data != NULL;
17128 :
17129 :
17130 :
17131 :
17132 :
17133 :
17134 :
17135 0 : if (dirty)
17136 : {
17137 : /* The buffer is dirty. */
17138 0 : if (view5.readonly)
17139 : {
17140 0 : Py_XDECREF(resultobj);
17141 0 : resultobj = NULL;
17142 0 : PyErr_SetString(PyExc_ValueError,
17143 : "cannot update read-only buffer");
17144 : }
17145 :
17146 : /* See if we need to truncate the buffer. */
17147 0 : if (resultobj && view5.len != new_size)
17148 : {
17149 0 : if (bytesio5 == NULL)
17150 : {
17151 0 : Py_XDECREF(resultobj);
17152 0 : resultobj = NULL;
17153 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17154 : }
17155 : else
17156 : {
17157 : PyObject *retval;
17158 0 : PyBuffer_Release(&view5);
17159 : assert(view5.obj == NULL);
17160 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
17161 : "l", (long) new_size);
17162 0 : if (retval == NULL)
17163 : {
17164 0 : Py_XDECREF(resultobj);
17165 : resultobj = NULL;
17166 : }
17167 : else
17168 : {
17169 0 : Py_DECREF(retval);
17170 :
17171 0 : retval = PyObject_CallMethod(bytesio5,
17172 : "getbuffer", NULL);
17173 0 : if (retval == NULL
17174 0 : || PyObject_GetBuffer(retval, &view5,
17175 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17176 : {
17177 0 : Py_XDECREF(resultobj);
17178 : resultobj = NULL;
17179 : }
17180 :
17181 0 : Py_XDECREF(retval);
17182 :
17183 0 : if (resultobj && view5.len
17184 : != new_size)
17185 : {
17186 0 : Py_XDECREF(resultobj);
17187 0 : resultobj = NULL;
17188 0 : PyErr_Format(PyExc_ValueError,
17189 : "Expected buffer of length %zu, got %zi",
17190 : new_size,
17191 : view5.len);
17192 : }
17193 : }
17194 : }
17195 : }
17196 0 : if (resultobj)
17197 0 : memcpy(view5.buf, new_data, new_size);
17198 : }
17199 :
17200 :
17201 :
17202 : }
17203 :
17204 : /* Free the temporary wrapper, if any. */
17205 0 : if (wrapper5)
17206 0 : gpgme_data_release(wrapper5);
17207 0 : Py_XDECREF (bytesio5);
17208 0 : if (have_view5 && view5.buf)
17209 0 : PyBuffer_Release(&view5);
17210 : }
17211 : {
17212 : /* See whether we need to update the Python buffer. */
17213 0 : if (resultobj && wrapper6 && view6.buf)
17214 : {
17215 : int dirty;
17216 0 : char *new_data = NULL;
17217 : size_t new_size;
17218 :
17219 :
17220 0 : new_data = wrapper6->data.mem.buffer;
17221 0 : new_size = wrapper6->data.mem.length;
17222 0 : dirty = new_data != NULL;
17223 :
17224 :
17225 :
17226 :
17227 :
17228 :
17229 :
17230 0 : if (dirty)
17231 : {
17232 : /* The buffer is dirty. */
17233 0 : if (view6.readonly)
17234 : {
17235 0 : Py_XDECREF(resultobj);
17236 0 : resultobj = NULL;
17237 0 : PyErr_SetString(PyExc_ValueError,
17238 : "cannot update read-only buffer");
17239 : }
17240 :
17241 : /* See if we need to truncate the buffer. */
17242 0 : if (resultobj && view6.len != new_size)
17243 : {
17244 0 : if (bytesio6 == NULL)
17245 : {
17246 0 : Py_XDECREF(resultobj);
17247 0 : resultobj = NULL;
17248 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17249 : }
17250 : else
17251 : {
17252 : PyObject *retval;
17253 0 : PyBuffer_Release(&view6);
17254 : assert(view6.obj == NULL);
17255 0 : retval = PyObject_CallMethod(bytesio6, "truncate",
17256 : "l", (long) new_size);
17257 0 : if (retval == NULL)
17258 : {
17259 0 : Py_XDECREF(resultobj);
17260 : resultobj = NULL;
17261 : }
17262 : else
17263 : {
17264 0 : Py_DECREF(retval);
17265 :
17266 0 : retval = PyObject_CallMethod(bytesio6,
17267 : "getbuffer", NULL);
17268 0 : if (retval == NULL
17269 0 : || PyObject_GetBuffer(retval, &view6,
17270 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17271 : {
17272 0 : Py_XDECREF(resultobj);
17273 : resultobj = NULL;
17274 : }
17275 :
17276 0 : Py_XDECREF(retval);
17277 :
17278 0 : if (resultobj && view6.len
17279 : != new_size)
17280 : {
17281 0 : Py_XDECREF(resultobj);
17282 0 : resultobj = NULL;
17283 0 : PyErr_Format(PyExc_ValueError,
17284 : "Expected buffer of length %zu, got %zi",
17285 : new_size,
17286 : view6.len);
17287 : }
17288 : }
17289 : }
17290 : }
17291 0 : if (resultobj)
17292 0 : memcpy(view6.buf, new_data, new_size);
17293 : }
17294 :
17295 :
17296 :
17297 : }
17298 :
17299 : /* Free the temporary wrapper, if any. */
17300 0 : if (wrapper6)
17301 0 : gpgme_data_release(wrapper6);
17302 0 : Py_XDECREF (bytesio6);
17303 0 : if (have_view6 && view6.buf)
17304 0 : PyBuffer_Release(&view6);
17305 : }
17306 : return resultobj;
17307 : fail:
17308 : {
17309 0 : if (arg2) free(arg2);
17310 : }
17311 : {
17312 0 : Py_XDECREF(encodedInput3);
17313 : }
17314 : {
17315 : /* See whether we need to update the Python buffer. */
17316 : if (resultobj && wrapper5 && view5.buf)
17317 : {
17318 : int dirty;
17319 : char *new_data = NULL;
17320 : size_t new_size;
17321 :
17322 :
17323 : new_data = wrapper5->data.mem.buffer;
17324 : new_size = wrapper5->data.mem.length;
17325 : dirty = new_data != NULL;
17326 :
17327 :
17328 :
17329 :
17330 :
17331 :
17332 :
17333 : if (dirty)
17334 : {
17335 : /* The buffer is dirty. */
17336 : if (view5.readonly)
17337 : {
17338 : Py_XDECREF(resultobj);
17339 : resultobj = NULL;
17340 : PyErr_SetString(PyExc_ValueError,
17341 : "cannot update read-only buffer");
17342 : }
17343 :
17344 : /* See if we need to truncate the buffer. */
17345 : if (resultobj && view5.len != new_size)
17346 : {
17347 : if (bytesio5 == NULL)
17348 : {
17349 : Py_XDECREF(resultobj);
17350 : resultobj = NULL;
17351 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17352 : }
17353 : else
17354 : {
17355 : PyObject *retval;
17356 : PyBuffer_Release(&view5);
17357 : assert(view5.obj == NULL);
17358 : retval = PyObject_CallMethod(bytesio5, "truncate",
17359 : "l", (long) new_size);
17360 : if (retval == NULL)
17361 : {
17362 : Py_XDECREF(resultobj);
17363 : resultobj = NULL;
17364 : }
17365 : else
17366 : {
17367 : Py_DECREF(retval);
17368 :
17369 : retval = PyObject_CallMethod(bytesio5,
17370 : "getbuffer", NULL);
17371 : if (retval == NULL
17372 : || PyObject_GetBuffer(retval, &view5,
17373 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17374 : {
17375 : Py_XDECREF(resultobj);
17376 : resultobj = NULL;
17377 : }
17378 :
17379 : Py_XDECREF(retval);
17380 :
17381 : if (resultobj && view5.len
17382 : != new_size)
17383 : {
17384 : Py_XDECREF(resultobj);
17385 : resultobj = NULL;
17386 : PyErr_Format(PyExc_ValueError,
17387 : "Expected buffer of length %zu, got %zi",
17388 : new_size,
17389 : view5.len);
17390 : }
17391 : }
17392 : }
17393 : }
17394 : if (resultobj)
17395 : memcpy(view5.buf, new_data, new_size);
17396 : }
17397 :
17398 :
17399 :
17400 : }
17401 :
17402 : /* Free the temporary wrapper, if any. */
17403 0 : if (wrapper5)
17404 0 : gpgme_data_release(wrapper5);
17405 0 : Py_XDECREF (bytesio5);
17406 : if (have_view5 && view5.buf)
17407 : PyBuffer_Release(&view5);
17408 : }
17409 : {
17410 : /* See whether we need to update the Python buffer. */
17411 : if (resultobj && wrapper6 && view6.buf)
17412 : {
17413 : int dirty;
17414 : char *new_data = NULL;
17415 : size_t new_size;
17416 :
17417 :
17418 : new_data = wrapper6->data.mem.buffer;
17419 : new_size = wrapper6->data.mem.length;
17420 : dirty = new_data != NULL;
17421 :
17422 :
17423 :
17424 :
17425 :
17426 :
17427 :
17428 : if (dirty)
17429 : {
17430 : /* The buffer is dirty. */
17431 : if (view6.readonly)
17432 : {
17433 : Py_XDECREF(resultobj);
17434 : resultobj = NULL;
17435 : PyErr_SetString(PyExc_ValueError,
17436 : "cannot update read-only buffer");
17437 : }
17438 :
17439 : /* See if we need to truncate the buffer. */
17440 : if (resultobj && view6.len != new_size)
17441 : {
17442 : if (bytesio6 == NULL)
17443 : {
17444 : Py_XDECREF(resultobj);
17445 : resultobj = NULL;
17446 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17447 : }
17448 : else
17449 : {
17450 : PyObject *retval;
17451 : PyBuffer_Release(&view6);
17452 : assert(view6.obj == NULL);
17453 : retval = PyObject_CallMethod(bytesio6, "truncate",
17454 : "l", (long) new_size);
17455 : if (retval == NULL)
17456 : {
17457 : Py_XDECREF(resultobj);
17458 : resultobj = NULL;
17459 : }
17460 : else
17461 : {
17462 : Py_DECREF(retval);
17463 :
17464 : retval = PyObject_CallMethod(bytesio6,
17465 : "getbuffer", NULL);
17466 : if (retval == NULL
17467 : || PyObject_GetBuffer(retval, &view6,
17468 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17469 : {
17470 : Py_XDECREF(resultobj);
17471 : resultobj = NULL;
17472 : }
17473 :
17474 : Py_XDECREF(retval);
17475 :
17476 : if (resultobj && view6.len
17477 : != new_size)
17478 : {
17479 : Py_XDECREF(resultobj);
17480 : resultobj = NULL;
17481 : PyErr_Format(PyExc_ValueError,
17482 : "Expected buffer of length %zu, got %zi",
17483 : new_size,
17484 : view6.len);
17485 : }
17486 : }
17487 : }
17488 : }
17489 : if (resultobj)
17490 : memcpy(view6.buf, new_data, new_size);
17491 : }
17492 :
17493 :
17494 :
17495 : }
17496 :
17497 : /* Free the temporary wrapper, if any. */
17498 0 : if (wrapper6)
17499 0 : gpgme_data_release(wrapper6);
17500 0 : Py_XDECREF (bytesio6);
17501 : if (have_view6 && view6.buf)
17502 : PyBuffer_Release(&view6);
17503 : }
17504 : return NULL;
17505 : }
17506 :
17507 :
17508 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_sign_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17509 0 : PyObject *resultobj = 0;
17510 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
17511 : gpgme_key_t *arg2 ;
17512 : gpgme_encrypt_flags_t arg3 ;
17513 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
17514 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
17515 0 : void *argp1 = 0 ;
17516 0 : int res1 = 0 ;
17517 : int val3 ;
17518 0 : int ecode3 = 0 ;
17519 0 : gpgme_data_t wrapper4 = NULL ;
17520 0 : PyObject *bytesio4 = NULL ;
17521 : Py_buffer view4 ;
17522 0 : int have_view4 = 0 ;
17523 0 : gpgme_data_t wrapper5 = NULL ;
17524 0 : PyObject *bytesio5 = NULL ;
17525 : Py_buffer view5 ;
17526 0 : int have_view5 = 0 ;
17527 0 : PyObject * obj0 = 0 ;
17528 0 : PyObject * obj1 = 0 ;
17529 0 : PyObject * obj2 = 0 ;
17530 0 : PyObject * obj3 = 0 ;
17531 0 : PyObject * obj4 = 0 ;
17532 : gpgme_error_t result;
17533 :
17534 : {
17535 0 : arg2 = NULL;
17536 : }
17537 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_sign_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17538 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
17539 0 : if (!SWIG_IsOK(res1)) {
17540 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_sign_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
17541 : }
17542 0 : arg1 = (gpgme_ctx_t)(argp1);
17543 : {
17544 0 : int i, numb = 0;
17545 0 : if (!PySequence_Check(obj1)) {
17546 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
17547 : 2);
17548 0 : return NULL;
17549 : }
17550 0 : if((numb = PySequence_Length(obj1)) != 0) {
17551 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
17552 0 : for(i=0; i<numb; i++) {
17553 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
17554 :
17555 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
17556 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
17557 :
17558 : /* Following code is from swig's python.swg. */
17559 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17560 0 : Py_DECREF(pypointer);
17561 0 : PyErr_Format(PyExc_TypeError,
17562 : "arg %d: list must contain only gpgme_key_ts, got %s "
17563 : "at position %d",
17564 0 : 2, pypointer->ob_type->tp_name, i);
17565 0 : free(arg2);
17566 0 : return NULL;
17567 : }
17568 0 : Py_DECREF(pypointer);
17569 : }
17570 0 : arg2[numb] = NULL;
17571 : }
17572 : }
17573 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
17574 0 : if (!SWIG_IsOK(ecode3)) {
17575 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_sign_start" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
17576 : }
17577 0 : arg3 = (gpgme_encrypt_flags_t)(val3);
17578 : {
17579 : /* If we create a temporary wrapper4 object, we will store it in
17580 : wrapperN, where N is 4. Here in this fragment, SWIG will
17581 : automatically append 4. */
17582 0 : memset(&view4, 0, sizeof view4);
17583 0 : if (obj3 == Py_None)
17584 0 : arg4 = NULL;
17585 : else {
17586 : PyObject *pypointer;
17587 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
17588 : &bytesio4, &view4);
17589 0 : if (pypointer == NULL)
17590 : return NULL;
17591 0 : have_view4 = !! view4.obj;
17592 :
17593 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
17594 :
17595 : /* Following code is from swig's python.swg. */
17596 :
17597 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
17598 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17599 0 : Py_DECREF(pypointer);
17600 : return NULL;
17601 : }
17602 0 : Py_DECREF(pypointer);
17603 : }
17604 : }
17605 : {
17606 : /* If we create a temporary wrapper5 object, we will store it in
17607 : wrapperN, where N is 5. Here in this fragment, SWIG will
17608 : automatically append 5. */
17609 0 : memset(&view5, 0, sizeof view5);
17610 0 : if (obj4 == Py_None)
17611 0 : arg5 = NULL;
17612 : else {
17613 : PyObject *pypointer;
17614 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
17615 : &bytesio5, &view5);
17616 0 : if (pypointer == NULL)
17617 : return NULL;
17618 0 : have_view5 = !! view5.obj;
17619 :
17620 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
17621 :
17622 : /* Following code is from swig's python.swg. */
17623 :
17624 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
17625 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17626 0 : Py_DECREF(pypointer);
17627 : return NULL;
17628 : }
17629 0 : Py_DECREF(pypointer);
17630 : }
17631 : }
17632 : {
17633 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17634 0 : result = gpgme_op_encrypt_sign_start(arg1,arg2,arg3,arg4,arg5);
17635 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17636 : }
17637 : {
17638 0 : resultobj = PyLong_FromLong(result);
17639 : }
17640 : {
17641 0 : if (arg2) free(arg2);
17642 : }
17643 : {
17644 : /* See whether we need to update the Python buffer. */
17645 0 : if (resultobj && wrapper4 && view4.buf)
17646 : {
17647 : int dirty;
17648 0 : char *new_data = NULL;
17649 : size_t new_size;
17650 :
17651 :
17652 0 : new_data = wrapper4->data.mem.buffer;
17653 0 : new_size = wrapper4->data.mem.length;
17654 0 : dirty = new_data != NULL;
17655 :
17656 :
17657 :
17658 :
17659 :
17660 :
17661 :
17662 0 : if (dirty)
17663 : {
17664 : /* The buffer is dirty. */
17665 0 : if (view4.readonly)
17666 : {
17667 0 : Py_XDECREF(resultobj);
17668 0 : resultobj = NULL;
17669 0 : PyErr_SetString(PyExc_ValueError,
17670 : "cannot update read-only buffer");
17671 : }
17672 :
17673 : /* See if we need to truncate the buffer. */
17674 0 : if (resultobj && view4.len != new_size)
17675 : {
17676 0 : if (bytesio4 == NULL)
17677 : {
17678 0 : Py_XDECREF(resultobj);
17679 0 : resultobj = NULL;
17680 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17681 : }
17682 : else
17683 : {
17684 : PyObject *retval;
17685 0 : PyBuffer_Release(&view4);
17686 : assert(view4.obj == NULL);
17687 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
17688 : "l", (long) new_size);
17689 0 : if (retval == NULL)
17690 : {
17691 0 : Py_XDECREF(resultobj);
17692 : resultobj = NULL;
17693 : }
17694 : else
17695 : {
17696 0 : Py_DECREF(retval);
17697 :
17698 0 : retval = PyObject_CallMethod(bytesio4,
17699 : "getbuffer", NULL);
17700 0 : if (retval == NULL
17701 0 : || PyObject_GetBuffer(retval, &view4,
17702 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17703 : {
17704 0 : Py_XDECREF(resultobj);
17705 : resultobj = NULL;
17706 : }
17707 :
17708 0 : Py_XDECREF(retval);
17709 :
17710 0 : if (resultobj && view4.len
17711 : != new_size)
17712 : {
17713 0 : Py_XDECREF(resultobj);
17714 0 : resultobj = NULL;
17715 0 : PyErr_Format(PyExc_ValueError,
17716 : "Expected buffer of length %zu, got %zi",
17717 : new_size,
17718 : view4.len);
17719 : }
17720 : }
17721 : }
17722 : }
17723 0 : if (resultobj)
17724 0 : memcpy(view4.buf, new_data, new_size);
17725 : }
17726 :
17727 :
17728 :
17729 : }
17730 :
17731 : /* Free the temporary wrapper, if any. */
17732 0 : if (wrapper4)
17733 0 : gpgme_data_release(wrapper4);
17734 0 : Py_XDECREF (bytesio4);
17735 0 : if (have_view4 && view4.buf)
17736 0 : PyBuffer_Release(&view4);
17737 : }
17738 : {
17739 : /* See whether we need to update the Python buffer. */
17740 0 : if (resultobj && wrapper5 && view5.buf)
17741 : {
17742 : int dirty;
17743 0 : char *new_data = NULL;
17744 : size_t new_size;
17745 :
17746 :
17747 0 : new_data = wrapper5->data.mem.buffer;
17748 0 : new_size = wrapper5->data.mem.length;
17749 0 : dirty = new_data != NULL;
17750 :
17751 :
17752 :
17753 :
17754 :
17755 :
17756 :
17757 0 : if (dirty)
17758 : {
17759 : /* The buffer is dirty. */
17760 0 : if (view5.readonly)
17761 : {
17762 0 : Py_XDECREF(resultobj);
17763 0 : resultobj = NULL;
17764 0 : PyErr_SetString(PyExc_ValueError,
17765 : "cannot update read-only buffer");
17766 : }
17767 :
17768 : /* See if we need to truncate the buffer. */
17769 0 : if (resultobj && view5.len != new_size)
17770 : {
17771 0 : if (bytesio5 == NULL)
17772 : {
17773 0 : Py_XDECREF(resultobj);
17774 0 : resultobj = NULL;
17775 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17776 : }
17777 : else
17778 : {
17779 : PyObject *retval;
17780 0 : PyBuffer_Release(&view5);
17781 : assert(view5.obj == NULL);
17782 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
17783 : "l", (long) new_size);
17784 0 : if (retval == NULL)
17785 : {
17786 0 : Py_XDECREF(resultobj);
17787 : resultobj = NULL;
17788 : }
17789 : else
17790 : {
17791 0 : Py_DECREF(retval);
17792 :
17793 0 : retval = PyObject_CallMethod(bytesio5,
17794 : "getbuffer", NULL);
17795 0 : if (retval == NULL
17796 0 : || PyObject_GetBuffer(retval, &view5,
17797 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17798 : {
17799 0 : Py_XDECREF(resultobj);
17800 : resultobj = NULL;
17801 : }
17802 :
17803 0 : Py_XDECREF(retval);
17804 :
17805 0 : if (resultobj && view5.len
17806 : != new_size)
17807 : {
17808 0 : Py_XDECREF(resultobj);
17809 0 : resultobj = NULL;
17810 0 : PyErr_Format(PyExc_ValueError,
17811 : "Expected buffer of length %zu, got %zi",
17812 : new_size,
17813 : view5.len);
17814 : }
17815 : }
17816 : }
17817 : }
17818 0 : if (resultobj)
17819 0 : memcpy(view5.buf, new_data, new_size);
17820 : }
17821 :
17822 :
17823 :
17824 : }
17825 :
17826 : /* Free the temporary wrapper, if any. */
17827 0 : if (wrapper5)
17828 0 : gpgme_data_release(wrapper5);
17829 0 : Py_XDECREF (bytesio5);
17830 0 : if (have_view5 && view5.buf)
17831 0 : PyBuffer_Release(&view5);
17832 : }
17833 : return resultobj;
17834 : fail:
17835 : {
17836 0 : if (arg2) free(arg2);
17837 : }
17838 : {
17839 : /* See whether we need to update the Python buffer. */
17840 : if (resultobj && wrapper4 && view4.buf)
17841 : {
17842 : int dirty;
17843 : char *new_data = NULL;
17844 : size_t new_size;
17845 :
17846 :
17847 : new_data = wrapper4->data.mem.buffer;
17848 : new_size = wrapper4->data.mem.length;
17849 : dirty = new_data != NULL;
17850 :
17851 :
17852 :
17853 :
17854 :
17855 :
17856 :
17857 : if (dirty)
17858 : {
17859 : /* The buffer is dirty. */
17860 : if (view4.readonly)
17861 : {
17862 : Py_XDECREF(resultobj);
17863 : resultobj = NULL;
17864 : PyErr_SetString(PyExc_ValueError,
17865 : "cannot update read-only buffer");
17866 : }
17867 :
17868 : /* See if we need to truncate the buffer. */
17869 : if (resultobj && view4.len != new_size)
17870 : {
17871 : if (bytesio4 == NULL)
17872 : {
17873 : Py_XDECREF(resultobj);
17874 : resultobj = NULL;
17875 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17876 : }
17877 : else
17878 : {
17879 : PyObject *retval;
17880 : PyBuffer_Release(&view4);
17881 : assert(view4.obj == NULL);
17882 : retval = PyObject_CallMethod(bytesio4, "truncate",
17883 : "l", (long) new_size);
17884 : if (retval == NULL)
17885 : {
17886 : Py_XDECREF(resultobj);
17887 : resultobj = NULL;
17888 : }
17889 : else
17890 : {
17891 : Py_DECREF(retval);
17892 :
17893 : retval = PyObject_CallMethod(bytesio4,
17894 : "getbuffer", NULL);
17895 : if (retval == NULL
17896 : || PyObject_GetBuffer(retval, &view4,
17897 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17898 : {
17899 : Py_XDECREF(resultobj);
17900 : resultobj = NULL;
17901 : }
17902 :
17903 : Py_XDECREF(retval);
17904 :
17905 : if (resultobj && view4.len
17906 : != new_size)
17907 : {
17908 : Py_XDECREF(resultobj);
17909 : resultobj = NULL;
17910 : PyErr_Format(PyExc_ValueError,
17911 : "Expected buffer of length %zu, got %zi",
17912 : new_size,
17913 : view4.len);
17914 : }
17915 : }
17916 : }
17917 : }
17918 : if (resultobj)
17919 : memcpy(view4.buf, new_data, new_size);
17920 : }
17921 :
17922 :
17923 :
17924 : }
17925 :
17926 : /* Free the temporary wrapper, if any. */
17927 0 : if (wrapper4)
17928 0 : gpgme_data_release(wrapper4);
17929 0 : Py_XDECREF (bytesio4);
17930 : if (have_view4 && view4.buf)
17931 : PyBuffer_Release(&view4);
17932 : }
17933 : {
17934 : /* See whether we need to update the Python buffer. */
17935 : if (resultobj && wrapper5 && view5.buf)
17936 : {
17937 : int dirty;
17938 : char *new_data = NULL;
17939 : size_t new_size;
17940 :
17941 :
17942 : new_data = wrapper5->data.mem.buffer;
17943 : new_size = wrapper5->data.mem.length;
17944 : dirty = new_data != NULL;
17945 :
17946 :
17947 :
17948 :
17949 :
17950 :
17951 :
17952 : if (dirty)
17953 : {
17954 : /* The buffer is dirty. */
17955 : if (view5.readonly)
17956 : {
17957 : Py_XDECREF(resultobj);
17958 : resultobj = NULL;
17959 : PyErr_SetString(PyExc_ValueError,
17960 : "cannot update read-only buffer");
17961 : }
17962 :
17963 : /* See if we need to truncate the buffer. */
17964 : if (resultobj && view5.len != new_size)
17965 : {
17966 : if (bytesio5 == NULL)
17967 : {
17968 : Py_XDECREF(resultobj);
17969 : resultobj = NULL;
17970 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17971 : }
17972 : else
17973 : {
17974 : PyObject *retval;
17975 : PyBuffer_Release(&view5);
17976 : assert(view5.obj == NULL);
17977 : retval = PyObject_CallMethod(bytesio5, "truncate",
17978 : "l", (long) new_size);
17979 : if (retval == NULL)
17980 : {
17981 : Py_XDECREF(resultobj);
17982 : resultobj = NULL;
17983 : }
17984 : else
17985 : {
17986 : Py_DECREF(retval);
17987 :
17988 : retval = PyObject_CallMethod(bytesio5,
17989 : "getbuffer", NULL);
17990 : if (retval == NULL
17991 : || PyObject_GetBuffer(retval, &view5,
17992 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17993 : {
17994 : Py_XDECREF(resultobj);
17995 : resultobj = NULL;
17996 : }
17997 :
17998 : Py_XDECREF(retval);
17999 :
18000 : if (resultobj && view5.len
18001 : != new_size)
18002 : {
18003 : Py_XDECREF(resultobj);
18004 : resultobj = NULL;
18005 : PyErr_Format(PyExc_ValueError,
18006 : "Expected buffer of length %zu, got %zi",
18007 : new_size,
18008 : view5.len);
18009 : }
18010 : }
18011 : }
18012 : }
18013 : if (resultobj)
18014 : memcpy(view5.buf, new_data, new_size);
18015 : }
18016 :
18017 :
18018 :
18019 : }
18020 :
18021 : /* Free the temporary wrapper, if any. */
18022 0 : if (wrapper5)
18023 0 : gpgme_data_release(wrapper5);
18024 0 : Py_XDECREF (bytesio5);
18025 : if (have_view5 && view5.buf)
18026 : PyBuffer_Release(&view5);
18027 : }
18028 : return NULL;
18029 : }
18030 :
18031 :
18032 7 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18033 7 : PyObject *resultobj = 0;
18034 7 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
18035 : gpgme_key_t *arg2 ;
18036 : gpgme_encrypt_flags_t arg3 ;
18037 7 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
18038 7 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
18039 7 : void *argp1 = 0 ;
18040 7 : int res1 = 0 ;
18041 : int val3 ;
18042 7 : int ecode3 = 0 ;
18043 7 : gpgme_data_t wrapper4 = NULL ;
18044 7 : PyObject *bytesio4 = NULL ;
18045 : Py_buffer view4 ;
18046 7 : int have_view4 = 0 ;
18047 7 : gpgme_data_t wrapper5 = NULL ;
18048 7 : PyObject *bytesio5 = NULL ;
18049 : Py_buffer view5 ;
18050 7 : int have_view5 = 0 ;
18051 7 : PyObject * obj0 = 0 ;
18052 7 : PyObject * obj1 = 0 ;
18053 7 : PyObject * obj2 = 0 ;
18054 7 : PyObject * obj3 = 0 ;
18055 7 : PyObject * obj4 = 0 ;
18056 : gpgme_error_t result;
18057 :
18058 : {
18059 7 : arg2 = NULL;
18060 : }
18061 7 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_sign",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18062 7 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
18063 7 : if (!SWIG_IsOK(res1)) {
18064 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_sign" "', argument " "1"" of type '" "gpgme_ctx_t""'");
18065 : }
18066 7 : arg1 = (gpgme_ctx_t)(argp1);
18067 : {
18068 7 : int i, numb = 0;
18069 7 : if (!PySequence_Check(obj1)) {
18070 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
18071 : 2);
18072 0 : return NULL;
18073 : }
18074 7 : if((numb = PySequence_Length(obj1)) != 0) {
18075 6 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
18076 16 : for(i=0; i<numb; i++) {
18077 10 : PyObject *pypointer = PySequence_GetItem(obj1, i);
18078 :
18079 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
18080 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
18081 :
18082 : /* Following code is from swig's python.swg. */
18083 10 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18084 0 : Py_DECREF(pypointer);
18085 0 : PyErr_Format(PyExc_TypeError,
18086 : "arg %d: list must contain only gpgme_key_ts, got %s "
18087 : "at position %d",
18088 0 : 2, pypointer->ob_type->tp_name, i);
18089 0 : free(arg2);
18090 0 : return NULL;
18091 : }
18092 10 : Py_DECREF(pypointer);
18093 : }
18094 6 : arg2[numb] = NULL;
18095 : }
18096 : }
18097 14 : ecode3 = SWIG_AsVal_int(obj2, &val3);
18098 7 : if (!SWIG_IsOK(ecode3)) {
18099 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_sign" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
18100 : }
18101 7 : arg3 = (gpgme_encrypt_flags_t)(val3);
18102 : {
18103 : /* If we create a temporary wrapper4 object, we will store it in
18104 : wrapperN, where N is 4. Here in this fragment, SWIG will
18105 : automatically append 4. */
18106 7 : memset(&view4, 0, sizeof view4);
18107 7 : if (obj3 == Py_None)
18108 0 : arg4 = NULL;
18109 : else {
18110 : PyObject *pypointer;
18111 7 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
18112 : &bytesio4, &view4);
18113 7 : if (pypointer == NULL)
18114 : return NULL;
18115 7 : have_view4 = !! view4.obj;
18116 :
18117 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
18118 :
18119 : /* Following code is from swig's python.swg. */
18120 :
18121 7 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
18122 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18123 0 : Py_DECREF(pypointer);
18124 : return NULL;
18125 : }
18126 7 : Py_DECREF(pypointer);
18127 : }
18128 : }
18129 : {
18130 : /* If we create a temporary wrapper5 object, we will store it in
18131 : wrapperN, where N is 5. Here in this fragment, SWIG will
18132 : automatically append 5. */
18133 7 : memset(&view5, 0, sizeof view5);
18134 7 : if (obj4 == Py_None)
18135 0 : arg5 = NULL;
18136 : else {
18137 : PyObject *pypointer;
18138 7 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
18139 : &bytesio5, &view5);
18140 7 : if (pypointer == NULL)
18141 : return NULL;
18142 7 : have_view5 = !! view5.obj;
18143 :
18144 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
18145 :
18146 : /* Following code is from swig's python.swg. */
18147 :
18148 7 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
18149 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18150 0 : Py_DECREF(pypointer);
18151 : return NULL;
18152 : }
18153 7 : Py_DECREF(pypointer);
18154 : }
18155 : }
18156 : {
18157 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18158 7 : result = gpgme_op_encrypt_sign(arg1,arg2,arg3,arg4,arg5);
18159 7 : SWIG_PYTHON_THREAD_END_ALLOW;
18160 : }
18161 : {
18162 7 : resultobj = PyLong_FromLong(result);
18163 : }
18164 : {
18165 7 : if (arg2) free(arg2);
18166 : }
18167 : {
18168 : /* See whether we need to update the Python buffer. */
18169 7 : if (resultobj && wrapper4 && view4.buf)
18170 : {
18171 : int dirty;
18172 5 : char *new_data = NULL;
18173 : size_t new_size;
18174 :
18175 :
18176 5 : new_data = wrapper4->data.mem.buffer;
18177 5 : new_size = wrapper4->data.mem.length;
18178 5 : dirty = new_data != NULL;
18179 :
18180 :
18181 :
18182 :
18183 :
18184 :
18185 :
18186 5 : if (dirty)
18187 : {
18188 : /* The buffer is dirty. */
18189 0 : if (view4.readonly)
18190 : {
18191 0 : Py_XDECREF(resultobj);
18192 0 : resultobj = NULL;
18193 0 : PyErr_SetString(PyExc_ValueError,
18194 : "cannot update read-only buffer");
18195 : }
18196 :
18197 : /* See if we need to truncate the buffer. */
18198 0 : if (resultobj && view4.len != new_size)
18199 : {
18200 0 : if (bytesio4 == NULL)
18201 : {
18202 0 : Py_XDECREF(resultobj);
18203 0 : resultobj = NULL;
18204 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18205 : }
18206 : else
18207 : {
18208 : PyObject *retval;
18209 0 : PyBuffer_Release(&view4);
18210 : assert(view4.obj == NULL);
18211 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
18212 : "l", (long) new_size);
18213 0 : if (retval == NULL)
18214 : {
18215 0 : Py_XDECREF(resultobj);
18216 : resultobj = NULL;
18217 : }
18218 : else
18219 : {
18220 0 : Py_DECREF(retval);
18221 :
18222 0 : retval = PyObject_CallMethod(bytesio4,
18223 : "getbuffer", NULL);
18224 0 : if (retval == NULL
18225 0 : || PyObject_GetBuffer(retval, &view4,
18226 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18227 : {
18228 0 : Py_XDECREF(resultobj);
18229 : resultobj = NULL;
18230 : }
18231 :
18232 0 : Py_XDECREF(retval);
18233 :
18234 0 : if (resultobj && view4.len
18235 : != new_size)
18236 : {
18237 0 : Py_XDECREF(resultobj);
18238 0 : resultobj = NULL;
18239 0 : PyErr_Format(PyExc_ValueError,
18240 : "Expected buffer of length %zu, got %zi",
18241 : new_size,
18242 : view4.len);
18243 : }
18244 : }
18245 : }
18246 : }
18247 0 : if (resultobj)
18248 0 : memcpy(view4.buf, new_data, new_size);
18249 : }
18250 :
18251 :
18252 :
18253 : }
18254 :
18255 : /* Free the temporary wrapper, if any. */
18256 7 : if (wrapper4)
18257 5 : gpgme_data_release(wrapper4);
18258 7 : Py_XDECREF (bytesio4);
18259 7 : if (have_view4 && view4.buf)
18260 5 : PyBuffer_Release(&view4);
18261 : }
18262 : {
18263 : /* See whether we need to update the Python buffer. */
18264 7 : if (resultobj && wrapper5 && view5.buf)
18265 : {
18266 : int dirty;
18267 0 : char *new_data = NULL;
18268 : size_t new_size;
18269 :
18270 :
18271 0 : new_data = wrapper5->data.mem.buffer;
18272 0 : new_size = wrapper5->data.mem.length;
18273 0 : dirty = new_data != NULL;
18274 :
18275 :
18276 :
18277 :
18278 :
18279 :
18280 :
18281 0 : if (dirty)
18282 : {
18283 : /* The buffer is dirty. */
18284 0 : if (view5.readonly)
18285 : {
18286 0 : Py_XDECREF(resultobj);
18287 0 : resultobj = NULL;
18288 0 : PyErr_SetString(PyExc_ValueError,
18289 : "cannot update read-only buffer");
18290 : }
18291 :
18292 : /* See if we need to truncate the buffer. */
18293 0 : if (resultobj && view5.len != new_size)
18294 : {
18295 0 : if (bytesio5 == NULL)
18296 : {
18297 0 : Py_XDECREF(resultobj);
18298 0 : resultobj = NULL;
18299 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18300 : }
18301 : else
18302 : {
18303 : PyObject *retval;
18304 0 : PyBuffer_Release(&view5);
18305 : assert(view5.obj == NULL);
18306 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
18307 : "l", (long) new_size);
18308 0 : if (retval == NULL)
18309 : {
18310 0 : Py_XDECREF(resultobj);
18311 : resultobj = NULL;
18312 : }
18313 : else
18314 : {
18315 0 : Py_DECREF(retval);
18316 :
18317 0 : retval = PyObject_CallMethod(bytesio5,
18318 : "getbuffer", NULL);
18319 0 : if (retval == NULL
18320 0 : || PyObject_GetBuffer(retval, &view5,
18321 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18322 : {
18323 0 : Py_XDECREF(resultobj);
18324 : resultobj = NULL;
18325 : }
18326 :
18327 0 : Py_XDECREF(retval);
18328 :
18329 0 : if (resultobj && view5.len
18330 : != new_size)
18331 : {
18332 0 : Py_XDECREF(resultobj);
18333 0 : resultobj = NULL;
18334 0 : PyErr_Format(PyExc_ValueError,
18335 : "Expected buffer of length %zu, got %zi",
18336 : new_size,
18337 : view5.len);
18338 : }
18339 : }
18340 : }
18341 : }
18342 0 : if (resultobj)
18343 0 : memcpy(view5.buf, new_data, new_size);
18344 : }
18345 :
18346 :
18347 :
18348 : }
18349 :
18350 : /* Free the temporary wrapper, if any. */
18351 7 : if (wrapper5)
18352 0 : gpgme_data_release(wrapper5);
18353 7 : Py_XDECREF (bytesio5);
18354 7 : if (have_view5 && view5.buf)
18355 0 : PyBuffer_Release(&view5);
18356 : }
18357 : return resultobj;
18358 : fail:
18359 : {
18360 0 : if (arg2) free(arg2);
18361 : }
18362 : {
18363 : /* See whether we need to update the Python buffer. */
18364 : if (resultobj && wrapper4 && view4.buf)
18365 : {
18366 : int dirty;
18367 : char *new_data = NULL;
18368 : size_t new_size;
18369 :
18370 :
18371 : new_data = wrapper4->data.mem.buffer;
18372 : new_size = wrapper4->data.mem.length;
18373 : dirty = new_data != NULL;
18374 :
18375 :
18376 :
18377 :
18378 :
18379 :
18380 :
18381 : if (dirty)
18382 : {
18383 : /* The buffer is dirty. */
18384 : if (view4.readonly)
18385 : {
18386 : Py_XDECREF(resultobj);
18387 : resultobj = NULL;
18388 : PyErr_SetString(PyExc_ValueError,
18389 : "cannot update read-only buffer");
18390 : }
18391 :
18392 : /* See if we need to truncate the buffer. */
18393 : if (resultobj && view4.len != new_size)
18394 : {
18395 : if (bytesio4 == NULL)
18396 : {
18397 : Py_XDECREF(resultobj);
18398 : resultobj = NULL;
18399 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18400 : }
18401 : else
18402 : {
18403 : PyObject *retval;
18404 : PyBuffer_Release(&view4);
18405 : assert(view4.obj == NULL);
18406 : retval = PyObject_CallMethod(bytesio4, "truncate",
18407 : "l", (long) new_size);
18408 : if (retval == NULL)
18409 : {
18410 : Py_XDECREF(resultobj);
18411 : resultobj = NULL;
18412 : }
18413 : else
18414 : {
18415 : Py_DECREF(retval);
18416 :
18417 : retval = PyObject_CallMethod(bytesio4,
18418 : "getbuffer", NULL);
18419 : if (retval == NULL
18420 : || PyObject_GetBuffer(retval, &view4,
18421 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18422 : {
18423 : Py_XDECREF(resultobj);
18424 : resultobj = NULL;
18425 : }
18426 :
18427 : Py_XDECREF(retval);
18428 :
18429 : if (resultobj && view4.len
18430 : != new_size)
18431 : {
18432 : Py_XDECREF(resultobj);
18433 : resultobj = NULL;
18434 : PyErr_Format(PyExc_ValueError,
18435 : "Expected buffer of length %zu, got %zi",
18436 : new_size,
18437 : view4.len);
18438 : }
18439 : }
18440 : }
18441 : }
18442 : if (resultobj)
18443 : memcpy(view4.buf, new_data, new_size);
18444 : }
18445 :
18446 :
18447 :
18448 : }
18449 :
18450 : /* Free the temporary wrapper, if any. */
18451 0 : if (wrapper4)
18452 0 : gpgme_data_release(wrapper4);
18453 0 : Py_XDECREF (bytesio4);
18454 : if (have_view4 && view4.buf)
18455 : PyBuffer_Release(&view4);
18456 : }
18457 : {
18458 : /* See whether we need to update the Python buffer. */
18459 : if (resultobj && wrapper5 && view5.buf)
18460 : {
18461 : int dirty;
18462 : char *new_data = NULL;
18463 : size_t new_size;
18464 :
18465 :
18466 : new_data = wrapper5->data.mem.buffer;
18467 : new_size = wrapper5->data.mem.length;
18468 : dirty = new_data != NULL;
18469 :
18470 :
18471 :
18472 :
18473 :
18474 :
18475 :
18476 : if (dirty)
18477 : {
18478 : /* The buffer is dirty. */
18479 : if (view5.readonly)
18480 : {
18481 : Py_XDECREF(resultobj);
18482 : resultobj = NULL;
18483 : PyErr_SetString(PyExc_ValueError,
18484 : "cannot update read-only buffer");
18485 : }
18486 :
18487 : /* See if we need to truncate the buffer. */
18488 : if (resultobj && view5.len != new_size)
18489 : {
18490 : if (bytesio5 == NULL)
18491 : {
18492 : Py_XDECREF(resultobj);
18493 : resultobj = NULL;
18494 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18495 : }
18496 : else
18497 : {
18498 : PyObject *retval;
18499 : PyBuffer_Release(&view5);
18500 : assert(view5.obj == NULL);
18501 : retval = PyObject_CallMethod(bytesio5, "truncate",
18502 : "l", (long) new_size);
18503 : if (retval == NULL)
18504 : {
18505 : Py_XDECREF(resultobj);
18506 : resultobj = NULL;
18507 : }
18508 : else
18509 : {
18510 : Py_DECREF(retval);
18511 :
18512 : retval = PyObject_CallMethod(bytesio5,
18513 : "getbuffer", NULL);
18514 : if (retval == NULL
18515 : || PyObject_GetBuffer(retval, &view5,
18516 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18517 : {
18518 : Py_XDECREF(resultobj);
18519 : resultobj = NULL;
18520 : }
18521 :
18522 : Py_XDECREF(retval);
18523 :
18524 : if (resultobj && view5.len
18525 : != new_size)
18526 : {
18527 : Py_XDECREF(resultobj);
18528 : resultobj = NULL;
18529 : PyErr_Format(PyExc_ValueError,
18530 : "Expected buffer of length %zu, got %zi",
18531 : new_size,
18532 : view5.len);
18533 : }
18534 : }
18535 : }
18536 : }
18537 : if (resultobj)
18538 : memcpy(view5.buf, new_data, new_size);
18539 : }
18540 :
18541 :
18542 :
18543 : }
18544 :
18545 : /* Free the temporary wrapper, if any. */
18546 0 : if (wrapper5)
18547 0 : gpgme_data_release(wrapper5);
18548 0 : Py_XDECREF (bytesio5);
18549 : if (have_view5 && view5.buf)
18550 : PyBuffer_Release(&view5);
18551 : }
18552 : return NULL;
18553 : }
18554 :
18555 :
18556 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_sign_ext_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18557 0 : PyObject *resultobj = 0;
18558 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
18559 : gpgme_key_t *arg2 ;
18560 0 : char *arg3 = (char *) 0 ;
18561 : gpgme_encrypt_flags_t arg4 ;
18562 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
18563 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
18564 0 : void *argp1 = 0 ;
18565 0 : int res1 = 0 ;
18566 0 : PyObject *encodedInput3 = NULL ;
18567 : int val4 ;
18568 0 : int ecode4 = 0 ;
18569 0 : gpgme_data_t wrapper5 = NULL ;
18570 0 : PyObject *bytesio5 = NULL ;
18571 : Py_buffer view5 ;
18572 0 : int have_view5 = 0 ;
18573 0 : gpgme_data_t wrapper6 = NULL ;
18574 0 : PyObject *bytesio6 = NULL ;
18575 : Py_buffer view6 ;
18576 0 : int have_view6 = 0 ;
18577 0 : PyObject * obj0 = 0 ;
18578 0 : PyObject * obj1 = 0 ;
18579 0 : PyObject * obj2 = 0 ;
18580 0 : PyObject * obj3 = 0 ;
18581 0 : PyObject * obj4 = 0 ;
18582 0 : PyObject * obj5 = 0 ;
18583 : gpgme_error_t result;
18584 :
18585 : {
18586 0 : arg2 = NULL;
18587 : }
18588 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_encrypt_sign_ext_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18589 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
18590 0 : if (!SWIG_IsOK(res1)) {
18591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_sign_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
18592 : }
18593 0 : arg1 = (gpgme_ctx_t)(argp1);
18594 : {
18595 0 : int i, numb = 0;
18596 0 : if (!PySequence_Check(obj1)) {
18597 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
18598 : 2);
18599 0 : return NULL;
18600 : }
18601 0 : if((numb = PySequence_Length(obj1)) != 0) {
18602 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
18603 0 : for(i=0; i<numb; i++) {
18604 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
18605 :
18606 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
18607 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
18608 :
18609 : /* Following code is from swig's python.swg. */
18610 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18611 0 : Py_DECREF(pypointer);
18612 0 : PyErr_Format(PyExc_TypeError,
18613 : "arg %d: list must contain only gpgme_key_ts, got %s "
18614 : "at position %d",
18615 0 : 2, pypointer->ob_type->tp_name, i);
18616 0 : free(arg2);
18617 0 : return NULL;
18618 : }
18619 0 : Py_DECREF(pypointer);
18620 : }
18621 0 : arg2[numb] = NULL;
18622 : }
18623 : }
18624 : {
18625 0 : if (obj2 == Py_None)
18626 : arg3 = NULL;
18627 0 : else if (PyUnicode_Check(obj2))
18628 : {
18629 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
18630 0 : if (encodedInput3 == NULL)
18631 : return NULL;
18632 0 : arg3 = PyBytes_AsString(encodedInput3);
18633 : }
18634 0 : else if (PyBytes_Check(obj2))
18635 0 : arg3 = PyBytes_AsString(obj2);
18636 : else {
18637 0 : PyErr_Format(PyExc_TypeError,
18638 : "arg %d: expected str, bytes, or None, got %s",
18639 : 3, obj2->ob_type->tp_name);
18640 0 : return NULL;
18641 : }
18642 : }
18643 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
18644 0 : if (!SWIG_IsOK(ecode4)) {
18645 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_encrypt_sign_ext_start" "', argument " "4"" of type '" "gpgme_encrypt_flags_t""'");
18646 : }
18647 0 : arg4 = (gpgme_encrypt_flags_t)(val4);
18648 : {
18649 : /* If we create a temporary wrapper5 object, we will store it in
18650 : wrapperN, where N is 5. Here in this fragment, SWIG will
18651 : automatically append 5. */
18652 0 : memset(&view5, 0, sizeof view5);
18653 0 : if (obj4 == Py_None)
18654 0 : arg5 = NULL;
18655 : else {
18656 : PyObject *pypointer;
18657 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
18658 : &bytesio5, &view5);
18659 0 : if (pypointer == NULL)
18660 : return NULL;
18661 0 : have_view5 = !! view5.obj;
18662 :
18663 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
18664 :
18665 : /* Following code is from swig's python.swg. */
18666 :
18667 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
18668 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18669 0 : Py_DECREF(pypointer);
18670 : return NULL;
18671 : }
18672 0 : Py_DECREF(pypointer);
18673 : }
18674 : }
18675 : {
18676 : /* If we create a temporary wrapper6 object, we will store it in
18677 : wrapperN, where N is 6. Here in this fragment, SWIG will
18678 : automatically append 6. */
18679 0 : memset(&view6, 0, sizeof view6);
18680 0 : if (obj5 == Py_None)
18681 0 : arg6 = NULL;
18682 : else {
18683 : PyObject *pypointer;
18684 0 : pypointer = _gpg_obj2gpgme_data_t(obj5, 6, &wrapper6,
18685 : &bytesio6, &view6);
18686 0 : if (pypointer == NULL)
18687 : return NULL;
18688 0 : have_view6 = !! view6.obj;
18689 :
18690 : /* input = obj5, 1 = arg6, 1_descriptor = SWIGTYPE_p_gpgme_data */
18691 :
18692 : /* Following code is from swig's python.swg. */
18693 :
18694 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg6, SWIGTYPE_p_gpgme_data,
18695 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18696 0 : Py_DECREF(pypointer);
18697 : return NULL;
18698 : }
18699 0 : Py_DECREF(pypointer);
18700 : }
18701 : }
18702 : {
18703 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18704 0 : result = gpgme_op_encrypt_sign_ext_start(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
18705 0 : SWIG_PYTHON_THREAD_END_ALLOW;
18706 : }
18707 : {
18708 0 : resultobj = PyLong_FromLong(result);
18709 : }
18710 : {
18711 0 : if (arg2) free(arg2);
18712 : }
18713 : {
18714 0 : Py_XDECREF(encodedInput3);
18715 : }
18716 : {
18717 : /* See whether we need to update the Python buffer. */
18718 0 : if (resultobj && wrapper5 && view5.buf)
18719 : {
18720 : int dirty;
18721 0 : char *new_data = NULL;
18722 : size_t new_size;
18723 :
18724 :
18725 0 : new_data = wrapper5->data.mem.buffer;
18726 0 : new_size = wrapper5->data.mem.length;
18727 0 : dirty = new_data != NULL;
18728 :
18729 :
18730 :
18731 :
18732 :
18733 :
18734 :
18735 0 : if (dirty)
18736 : {
18737 : /* The buffer is dirty. */
18738 0 : if (view5.readonly)
18739 : {
18740 0 : Py_XDECREF(resultobj);
18741 0 : resultobj = NULL;
18742 0 : PyErr_SetString(PyExc_ValueError,
18743 : "cannot update read-only buffer");
18744 : }
18745 :
18746 : /* See if we need to truncate the buffer. */
18747 0 : if (resultobj && view5.len != new_size)
18748 : {
18749 0 : if (bytesio5 == NULL)
18750 : {
18751 0 : Py_XDECREF(resultobj);
18752 0 : resultobj = NULL;
18753 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18754 : }
18755 : else
18756 : {
18757 : PyObject *retval;
18758 0 : PyBuffer_Release(&view5);
18759 : assert(view5.obj == NULL);
18760 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
18761 : "l", (long) new_size);
18762 0 : if (retval == NULL)
18763 : {
18764 0 : Py_XDECREF(resultobj);
18765 : resultobj = NULL;
18766 : }
18767 : else
18768 : {
18769 0 : Py_DECREF(retval);
18770 :
18771 0 : retval = PyObject_CallMethod(bytesio5,
18772 : "getbuffer", NULL);
18773 0 : if (retval == NULL
18774 0 : || PyObject_GetBuffer(retval, &view5,
18775 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18776 : {
18777 0 : Py_XDECREF(resultobj);
18778 : resultobj = NULL;
18779 : }
18780 :
18781 0 : Py_XDECREF(retval);
18782 :
18783 0 : if (resultobj && view5.len
18784 : != new_size)
18785 : {
18786 0 : Py_XDECREF(resultobj);
18787 0 : resultobj = NULL;
18788 0 : PyErr_Format(PyExc_ValueError,
18789 : "Expected buffer of length %zu, got %zi",
18790 : new_size,
18791 : view5.len);
18792 : }
18793 : }
18794 : }
18795 : }
18796 0 : if (resultobj)
18797 0 : memcpy(view5.buf, new_data, new_size);
18798 : }
18799 :
18800 :
18801 :
18802 : }
18803 :
18804 : /* Free the temporary wrapper, if any. */
18805 0 : if (wrapper5)
18806 0 : gpgme_data_release(wrapper5);
18807 0 : Py_XDECREF (bytesio5);
18808 0 : if (have_view5 && view5.buf)
18809 0 : PyBuffer_Release(&view5);
18810 : }
18811 : {
18812 : /* See whether we need to update the Python buffer. */
18813 0 : if (resultobj && wrapper6 && view6.buf)
18814 : {
18815 : int dirty;
18816 0 : char *new_data = NULL;
18817 : size_t new_size;
18818 :
18819 :
18820 0 : new_data = wrapper6->data.mem.buffer;
18821 0 : new_size = wrapper6->data.mem.length;
18822 0 : dirty = new_data != NULL;
18823 :
18824 :
18825 :
18826 :
18827 :
18828 :
18829 :
18830 0 : if (dirty)
18831 : {
18832 : /* The buffer is dirty. */
18833 0 : if (view6.readonly)
18834 : {
18835 0 : Py_XDECREF(resultobj);
18836 0 : resultobj = NULL;
18837 0 : PyErr_SetString(PyExc_ValueError,
18838 : "cannot update read-only buffer");
18839 : }
18840 :
18841 : /* See if we need to truncate the buffer. */
18842 0 : if (resultobj && view6.len != new_size)
18843 : {
18844 0 : if (bytesio6 == NULL)
18845 : {
18846 0 : Py_XDECREF(resultobj);
18847 0 : resultobj = NULL;
18848 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18849 : }
18850 : else
18851 : {
18852 : PyObject *retval;
18853 0 : PyBuffer_Release(&view6);
18854 : assert(view6.obj == NULL);
18855 0 : retval = PyObject_CallMethod(bytesio6, "truncate",
18856 : "l", (long) new_size);
18857 0 : if (retval == NULL)
18858 : {
18859 0 : Py_XDECREF(resultobj);
18860 : resultobj = NULL;
18861 : }
18862 : else
18863 : {
18864 0 : Py_DECREF(retval);
18865 :
18866 0 : retval = PyObject_CallMethod(bytesio6,
18867 : "getbuffer", NULL);
18868 0 : if (retval == NULL
18869 0 : || PyObject_GetBuffer(retval, &view6,
18870 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18871 : {
18872 0 : Py_XDECREF(resultobj);
18873 : resultobj = NULL;
18874 : }
18875 :
18876 0 : Py_XDECREF(retval);
18877 :
18878 0 : if (resultobj && view6.len
18879 : != new_size)
18880 : {
18881 0 : Py_XDECREF(resultobj);
18882 0 : resultobj = NULL;
18883 0 : PyErr_Format(PyExc_ValueError,
18884 : "Expected buffer of length %zu, got %zi",
18885 : new_size,
18886 : view6.len);
18887 : }
18888 : }
18889 : }
18890 : }
18891 0 : if (resultobj)
18892 0 : memcpy(view6.buf, new_data, new_size);
18893 : }
18894 :
18895 :
18896 :
18897 : }
18898 :
18899 : /* Free the temporary wrapper, if any. */
18900 0 : if (wrapper6)
18901 0 : gpgme_data_release(wrapper6);
18902 0 : Py_XDECREF (bytesio6);
18903 0 : if (have_view6 && view6.buf)
18904 0 : PyBuffer_Release(&view6);
18905 : }
18906 : return resultobj;
18907 : fail:
18908 : {
18909 0 : if (arg2) free(arg2);
18910 : }
18911 : {
18912 0 : Py_XDECREF(encodedInput3);
18913 : }
18914 : {
18915 : /* See whether we need to update the Python buffer. */
18916 : if (resultobj && wrapper5 && view5.buf)
18917 : {
18918 : int dirty;
18919 : char *new_data = NULL;
18920 : size_t new_size;
18921 :
18922 :
18923 : new_data = wrapper5->data.mem.buffer;
18924 : new_size = wrapper5->data.mem.length;
18925 : dirty = new_data != NULL;
18926 :
18927 :
18928 :
18929 :
18930 :
18931 :
18932 :
18933 : if (dirty)
18934 : {
18935 : /* The buffer is dirty. */
18936 : if (view5.readonly)
18937 : {
18938 : Py_XDECREF(resultobj);
18939 : resultobj = NULL;
18940 : PyErr_SetString(PyExc_ValueError,
18941 : "cannot update read-only buffer");
18942 : }
18943 :
18944 : /* See if we need to truncate the buffer. */
18945 : if (resultobj && view5.len != new_size)
18946 : {
18947 : if (bytesio5 == NULL)
18948 : {
18949 : Py_XDECREF(resultobj);
18950 : resultobj = NULL;
18951 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18952 : }
18953 : else
18954 : {
18955 : PyObject *retval;
18956 : PyBuffer_Release(&view5);
18957 : assert(view5.obj == NULL);
18958 : retval = PyObject_CallMethod(bytesio5, "truncate",
18959 : "l", (long) new_size);
18960 : if (retval == NULL)
18961 : {
18962 : Py_XDECREF(resultobj);
18963 : resultobj = NULL;
18964 : }
18965 : else
18966 : {
18967 : Py_DECREF(retval);
18968 :
18969 : retval = PyObject_CallMethod(bytesio5,
18970 : "getbuffer", NULL);
18971 : if (retval == NULL
18972 : || PyObject_GetBuffer(retval, &view5,
18973 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18974 : {
18975 : Py_XDECREF(resultobj);
18976 : resultobj = NULL;
18977 : }
18978 :
18979 : Py_XDECREF(retval);
18980 :
18981 : if (resultobj && view5.len
18982 : != new_size)
18983 : {
18984 : Py_XDECREF(resultobj);
18985 : resultobj = NULL;
18986 : PyErr_Format(PyExc_ValueError,
18987 : "Expected buffer of length %zu, got %zi",
18988 : new_size,
18989 : view5.len);
18990 : }
18991 : }
18992 : }
18993 : }
18994 : if (resultobj)
18995 : memcpy(view5.buf, new_data, new_size);
18996 : }
18997 :
18998 :
18999 :
19000 : }
19001 :
19002 : /* Free the temporary wrapper, if any. */
19003 0 : if (wrapper5)
19004 0 : gpgme_data_release(wrapper5);
19005 0 : Py_XDECREF (bytesio5);
19006 : if (have_view5 && view5.buf)
19007 : PyBuffer_Release(&view5);
19008 : }
19009 : {
19010 : /* See whether we need to update the Python buffer. */
19011 : if (resultobj && wrapper6 && view6.buf)
19012 : {
19013 : int dirty;
19014 : char *new_data = NULL;
19015 : size_t new_size;
19016 :
19017 :
19018 : new_data = wrapper6->data.mem.buffer;
19019 : new_size = wrapper6->data.mem.length;
19020 : dirty = new_data != NULL;
19021 :
19022 :
19023 :
19024 :
19025 :
19026 :
19027 :
19028 : if (dirty)
19029 : {
19030 : /* The buffer is dirty. */
19031 : if (view6.readonly)
19032 : {
19033 : Py_XDECREF(resultobj);
19034 : resultobj = NULL;
19035 : PyErr_SetString(PyExc_ValueError,
19036 : "cannot update read-only buffer");
19037 : }
19038 :
19039 : /* See if we need to truncate the buffer. */
19040 : if (resultobj && view6.len != new_size)
19041 : {
19042 : if (bytesio6 == NULL)
19043 : {
19044 : Py_XDECREF(resultobj);
19045 : resultobj = NULL;
19046 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19047 : }
19048 : else
19049 : {
19050 : PyObject *retval;
19051 : PyBuffer_Release(&view6);
19052 : assert(view6.obj == NULL);
19053 : retval = PyObject_CallMethod(bytesio6, "truncate",
19054 : "l", (long) new_size);
19055 : if (retval == NULL)
19056 : {
19057 : Py_XDECREF(resultobj);
19058 : resultobj = NULL;
19059 : }
19060 : else
19061 : {
19062 : Py_DECREF(retval);
19063 :
19064 : retval = PyObject_CallMethod(bytesio6,
19065 : "getbuffer", NULL);
19066 : if (retval == NULL
19067 : || PyObject_GetBuffer(retval, &view6,
19068 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19069 : {
19070 : Py_XDECREF(resultobj);
19071 : resultobj = NULL;
19072 : }
19073 :
19074 : Py_XDECREF(retval);
19075 :
19076 : if (resultobj && view6.len
19077 : != new_size)
19078 : {
19079 : Py_XDECREF(resultobj);
19080 : resultobj = NULL;
19081 : PyErr_Format(PyExc_ValueError,
19082 : "Expected buffer of length %zu, got %zi",
19083 : new_size,
19084 : view6.len);
19085 : }
19086 : }
19087 : }
19088 : }
19089 : if (resultobj)
19090 : memcpy(view6.buf, new_data, new_size);
19091 : }
19092 :
19093 :
19094 :
19095 : }
19096 :
19097 : /* Free the temporary wrapper, if any. */
19098 0 : if (wrapper6)
19099 0 : gpgme_data_release(wrapper6);
19100 0 : Py_XDECREF (bytesio6);
19101 : if (have_view6 && view6.buf)
19102 : PyBuffer_Release(&view6);
19103 : }
19104 : return NULL;
19105 : }
19106 :
19107 :
19108 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_sign_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19109 0 : PyObject *resultobj = 0;
19110 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
19111 : gpgme_key_t *arg2 ;
19112 0 : char *arg3 = (char *) 0 ;
19113 : gpgme_encrypt_flags_t arg4 ;
19114 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
19115 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
19116 0 : void *argp1 = 0 ;
19117 0 : int res1 = 0 ;
19118 0 : PyObject *encodedInput3 = NULL ;
19119 : int val4 ;
19120 0 : int ecode4 = 0 ;
19121 0 : gpgme_data_t wrapper5 = NULL ;
19122 0 : PyObject *bytesio5 = NULL ;
19123 : Py_buffer view5 ;
19124 0 : int have_view5 = 0 ;
19125 0 : gpgme_data_t wrapper6 = NULL ;
19126 0 : PyObject *bytesio6 = NULL ;
19127 : Py_buffer view6 ;
19128 0 : int have_view6 = 0 ;
19129 0 : PyObject * obj0 = 0 ;
19130 0 : PyObject * obj1 = 0 ;
19131 0 : PyObject * obj2 = 0 ;
19132 0 : PyObject * obj3 = 0 ;
19133 0 : PyObject * obj4 = 0 ;
19134 0 : PyObject * obj5 = 0 ;
19135 : gpgme_error_t result;
19136 :
19137 : {
19138 0 : arg2 = NULL;
19139 : }
19140 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_encrypt_sign_ext",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
19141 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
19142 0 : if (!SWIG_IsOK(res1)) {
19143 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_sign_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
19144 : }
19145 0 : arg1 = (gpgme_ctx_t)(argp1);
19146 : {
19147 0 : int i, numb = 0;
19148 0 : if (!PySequence_Check(obj1)) {
19149 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
19150 : 2);
19151 0 : return NULL;
19152 : }
19153 0 : if((numb = PySequence_Length(obj1)) != 0) {
19154 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
19155 0 : for(i=0; i<numb; i++) {
19156 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
19157 :
19158 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
19159 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
19160 :
19161 : /* Following code is from swig's python.swg. */
19162 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
19163 0 : Py_DECREF(pypointer);
19164 0 : PyErr_Format(PyExc_TypeError,
19165 : "arg %d: list must contain only gpgme_key_ts, got %s "
19166 : "at position %d",
19167 0 : 2, pypointer->ob_type->tp_name, i);
19168 0 : free(arg2);
19169 0 : return NULL;
19170 : }
19171 0 : Py_DECREF(pypointer);
19172 : }
19173 0 : arg2[numb] = NULL;
19174 : }
19175 : }
19176 : {
19177 0 : if (obj2 == Py_None)
19178 : arg3 = NULL;
19179 0 : else if (PyUnicode_Check(obj2))
19180 : {
19181 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
19182 0 : if (encodedInput3 == NULL)
19183 : return NULL;
19184 0 : arg3 = PyBytes_AsString(encodedInput3);
19185 : }
19186 0 : else if (PyBytes_Check(obj2))
19187 0 : arg3 = PyBytes_AsString(obj2);
19188 : else {
19189 0 : PyErr_Format(PyExc_TypeError,
19190 : "arg %d: expected str, bytes, or None, got %s",
19191 : 3, obj2->ob_type->tp_name);
19192 0 : return NULL;
19193 : }
19194 : }
19195 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
19196 0 : if (!SWIG_IsOK(ecode4)) {
19197 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_encrypt_sign_ext" "', argument " "4"" of type '" "gpgme_encrypt_flags_t""'");
19198 : }
19199 0 : arg4 = (gpgme_encrypt_flags_t)(val4);
19200 : {
19201 : /* If we create a temporary wrapper5 object, we will store it in
19202 : wrapperN, where N is 5. Here in this fragment, SWIG will
19203 : automatically append 5. */
19204 0 : memset(&view5, 0, sizeof view5);
19205 0 : if (obj4 == Py_None)
19206 0 : arg5 = NULL;
19207 : else {
19208 : PyObject *pypointer;
19209 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
19210 : &bytesio5, &view5);
19211 0 : if (pypointer == NULL)
19212 : return NULL;
19213 0 : have_view5 = !! view5.obj;
19214 :
19215 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
19216 :
19217 : /* Following code is from swig's python.swg. */
19218 :
19219 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
19220 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
19221 0 : Py_DECREF(pypointer);
19222 : return NULL;
19223 : }
19224 0 : Py_DECREF(pypointer);
19225 : }
19226 : }
19227 : {
19228 : /* If we create a temporary wrapper6 object, we will store it in
19229 : wrapperN, where N is 6. Here in this fragment, SWIG will
19230 : automatically append 6. */
19231 0 : memset(&view6, 0, sizeof view6);
19232 0 : if (obj5 == Py_None)
19233 0 : arg6 = NULL;
19234 : else {
19235 : PyObject *pypointer;
19236 0 : pypointer = _gpg_obj2gpgme_data_t(obj5, 6, &wrapper6,
19237 : &bytesio6, &view6);
19238 0 : if (pypointer == NULL)
19239 : return NULL;
19240 0 : have_view6 = !! view6.obj;
19241 :
19242 : /* input = obj5, 1 = arg6, 1_descriptor = SWIGTYPE_p_gpgme_data */
19243 :
19244 : /* Following code is from swig's python.swg. */
19245 :
19246 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg6, SWIGTYPE_p_gpgme_data,
19247 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
19248 0 : Py_DECREF(pypointer);
19249 : return NULL;
19250 : }
19251 0 : Py_DECREF(pypointer);
19252 : }
19253 : }
19254 : {
19255 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19256 0 : result = gpgme_op_encrypt_sign_ext(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
19257 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19258 : }
19259 : {
19260 0 : resultobj = PyLong_FromLong(result);
19261 : }
19262 : {
19263 0 : if (arg2) free(arg2);
19264 : }
19265 : {
19266 0 : Py_XDECREF(encodedInput3);
19267 : }
19268 : {
19269 : /* See whether we need to update the Python buffer. */
19270 0 : if (resultobj && wrapper5 && view5.buf)
19271 : {
19272 : int dirty;
19273 0 : char *new_data = NULL;
19274 : size_t new_size;
19275 :
19276 :
19277 0 : new_data = wrapper5->data.mem.buffer;
19278 0 : new_size = wrapper5->data.mem.length;
19279 0 : dirty = new_data != NULL;
19280 :
19281 :
19282 :
19283 :
19284 :
19285 :
19286 :
19287 0 : if (dirty)
19288 : {
19289 : /* The buffer is dirty. */
19290 0 : if (view5.readonly)
19291 : {
19292 0 : Py_XDECREF(resultobj);
19293 0 : resultobj = NULL;
19294 0 : PyErr_SetString(PyExc_ValueError,
19295 : "cannot update read-only buffer");
19296 : }
19297 :
19298 : /* See if we need to truncate the buffer. */
19299 0 : if (resultobj && view5.len != new_size)
19300 : {
19301 0 : if (bytesio5 == NULL)
19302 : {
19303 0 : Py_XDECREF(resultobj);
19304 0 : resultobj = NULL;
19305 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19306 : }
19307 : else
19308 : {
19309 : PyObject *retval;
19310 0 : PyBuffer_Release(&view5);
19311 : assert(view5.obj == NULL);
19312 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
19313 : "l", (long) new_size);
19314 0 : if (retval == NULL)
19315 : {
19316 0 : Py_XDECREF(resultobj);
19317 : resultobj = NULL;
19318 : }
19319 : else
19320 : {
19321 0 : Py_DECREF(retval);
19322 :
19323 0 : retval = PyObject_CallMethod(bytesio5,
19324 : "getbuffer", NULL);
19325 0 : if (retval == NULL
19326 0 : || PyObject_GetBuffer(retval, &view5,
19327 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19328 : {
19329 0 : Py_XDECREF(resultobj);
19330 : resultobj = NULL;
19331 : }
19332 :
19333 0 : Py_XDECREF(retval);
19334 :
19335 0 : if (resultobj && view5.len
19336 : != new_size)
19337 : {
19338 0 : Py_XDECREF(resultobj);
19339 0 : resultobj = NULL;
19340 0 : PyErr_Format(PyExc_ValueError,
19341 : "Expected buffer of length %zu, got %zi",
19342 : new_size,
19343 : view5.len);
19344 : }
19345 : }
19346 : }
19347 : }
19348 0 : if (resultobj)
19349 0 : memcpy(view5.buf, new_data, new_size);
19350 : }
19351 :
19352 :
19353 :
19354 : }
19355 :
19356 : /* Free the temporary wrapper, if any. */
19357 0 : if (wrapper5)
19358 0 : gpgme_data_release(wrapper5);
19359 0 : Py_XDECREF (bytesio5);
19360 0 : if (have_view5 && view5.buf)
19361 0 : PyBuffer_Release(&view5);
19362 : }
19363 : {
19364 : /* See whether we need to update the Python buffer. */
19365 0 : if (resultobj && wrapper6 && view6.buf)
19366 : {
19367 : int dirty;
19368 0 : char *new_data = NULL;
19369 : size_t new_size;
19370 :
19371 :
19372 0 : new_data = wrapper6->data.mem.buffer;
19373 0 : new_size = wrapper6->data.mem.length;
19374 0 : dirty = new_data != NULL;
19375 :
19376 :
19377 :
19378 :
19379 :
19380 :
19381 :
19382 0 : if (dirty)
19383 : {
19384 : /* The buffer is dirty. */
19385 0 : if (view6.readonly)
19386 : {
19387 0 : Py_XDECREF(resultobj);
19388 0 : resultobj = NULL;
19389 0 : PyErr_SetString(PyExc_ValueError,
19390 : "cannot update read-only buffer");
19391 : }
19392 :
19393 : /* See if we need to truncate the buffer. */
19394 0 : if (resultobj && view6.len != new_size)
19395 : {
19396 0 : if (bytesio6 == NULL)
19397 : {
19398 0 : Py_XDECREF(resultobj);
19399 0 : resultobj = NULL;
19400 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19401 : }
19402 : else
19403 : {
19404 : PyObject *retval;
19405 0 : PyBuffer_Release(&view6);
19406 : assert(view6.obj == NULL);
19407 0 : retval = PyObject_CallMethod(bytesio6, "truncate",
19408 : "l", (long) new_size);
19409 0 : if (retval == NULL)
19410 : {
19411 0 : Py_XDECREF(resultobj);
19412 : resultobj = NULL;
19413 : }
19414 : else
19415 : {
19416 0 : Py_DECREF(retval);
19417 :
19418 0 : retval = PyObject_CallMethod(bytesio6,
19419 : "getbuffer", NULL);
19420 0 : if (retval == NULL
19421 0 : || PyObject_GetBuffer(retval, &view6,
19422 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19423 : {
19424 0 : Py_XDECREF(resultobj);
19425 : resultobj = NULL;
19426 : }
19427 :
19428 0 : Py_XDECREF(retval);
19429 :
19430 0 : if (resultobj && view6.len
19431 : != new_size)
19432 : {
19433 0 : Py_XDECREF(resultobj);
19434 0 : resultobj = NULL;
19435 0 : PyErr_Format(PyExc_ValueError,
19436 : "Expected buffer of length %zu, got %zi",
19437 : new_size,
19438 : view6.len);
19439 : }
19440 : }
19441 : }
19442 : }
19443 0 : if (resultobj)
19444 0 : memcpy(view6.buf, new_data, new_size);
19445 : }
19446 :
19447 :
19448 :
19449 : }
19450 :
19451 : /* Free the temporary wrapper, if any. */
19452 0 : if (wrapper6)
19453 0 : gpgme_data_release(wrapper6);
19454 0 : Py_XDECREF (bytesio6);
19455 0 : if (have_view6 && view6.buf)
19456 0 : PyBuffer_Release(&view6);
19457 : }
19458 : return resultobj;
19459 : fail:
19460 : {
19461 0 : if (arg2) free(arg2);
19462 : }
19463 : {
19464 0 : Py_XDECREF(encodedInput3);
19465 : }
19466 : {
19467 : /* See whether we need to update the Python buffer. */
19468 : if (resultobj && wrapper5 && view5.buf)
19469 : {
19470 : int dirty;
19471 : char *new_data = NULL;
19472 : size_t new_size;
19473 :
19474 :
19475 : new_data = wrapper5->data.mem.buffer;
19476 : new_size = wrapper5->data.mem.length;
19477 : dirty = new_data != NULL;
19478 :
19479 :
19480 :
19481 :
19482 :
19483 :
19484 :
19485 : if (dirty)
19486 : {
19487 : /* The buffer is dirty. */
19488 : if (view5.readonly)
19489 : {
19490 : Py_XDECREF(resultobj);
19491 : resultobj = NULL;
19492 : PyErr_SetString(PyExc_ValueError,
19493 : "cannot update read-only buffer");
19494 : }
19495 :
19496 : /* See if we need to truncate the buffer. */
19497 : if (resultobj && view5.len != new_size)
19498 : {
19499 : if (bytesio5 == NULL)
19500 : {
19501 : Py_XDECREF(resultobj);
19502 : resultobj = NULL;
19503 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19504 : }
19505 : else
19506 : {
19507 : PyObject *retval;
19508 : PyBuffer_Release(&view5);
19509 : assert(view5.obj == NULL);
19510 : retval = PyObject_CallMethod(bytesio5, "truncate",
19511 : "l", (long) new_size);
19512 : if (retval == NULL)
19513 : {
19514 : Py_XDECREF(resultobj);
19515 : resultobj = NULL;
19516 : }
19517 : else
19518 : {
19519 : Py_DECREF(retval);
19520 :
19521 : retval = PyObject_CallMethod(bytesio5,
19522 : "getbuffer", NULL);
19523 : if (retval == NULL
19524 : || PyObject_GetBuffer(retval, &view5,
19525 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19526 : {
19527 : Py_XDECREF(resultobj);
19528 : resultobj = NULL;
19529 : }
19530 :
19531 : Py_XDECREF(retval);
19532 :
19533 : if (resultobj && view5.len
19534 : != new_size)
19535 : {
19536 : Py_XDECREF(resultobj);
19537 : resultobj = NULL;
19538 : PyErr_Format(PyExc_ValueError,
19539 : "Expected buffer of length %zu, got %zi",
19540 : new_size,
19541 : view5.len);
19542 : }
19543 : }
19544 : }
19545 : }
19546 : if (resultobj)
19547 : memcpy(view5.buf, new_data, new_size);
19548 : }
19549 :
19550 :
19551 :
19552 : }
19553 :
19554 : /* Free the temporary wrapper, if any. */
19555 0 : if (wrapper5)
19556 0 : gpgme_data_release(wrapper5);
19557 0 : Py_XDECREF (bytesio5);
19558 : if (have_view5 && view5.buf)
19559 : PyBuffer_Release(&view5);
19560 : }
19561 : {
19562 : /* See whether we need to update the Python buffer. */
19563 : if (resultobj && wrapper6 && view6.buf)
19564 : {
19565 : int dirty;
19566 : char *new_data = NULL;
19567 : size_t new_size;
19568 :
19569 :
19570 : new_data = wrapper6->data.mem.buffer;
19571 : new_size = wrapper6->data.mem.length;
19572 : dirty = new_data != NULL;
19573 :
19574 :
19575 :
19576 :
19577 :
19578 :
19579 :
19580 : if (dirty)
19581 : {
19582 : /* The buffer is dirty. */
19583 : if (view6.readonly)
19584 : {
19585 : Py_XDECREF(resultobj);
19586 : resultobj = NULL;
19587 : PyErr_SetString(PyExc_ValueError,
19588 : "cannot update read-only buffer");
19589 : }
19590 :
19591 : /* See if we need to truncate the buffer. */
19592 : if (resultobj && view6.len != new_size)
19593 : {
19594 : if (bytesio6 == NULL)
19595 : {
19596 : Py_XDECREF(resultobj);
19597 : resultobj = NULL;
19598 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19599 : }
19600 : else
19601 : {
19602 : PyObject *retval;
19603 : PyBuffer_Release(&view6);
19604 : assert(view6.obj == NULL);
19605 : retval = PyObject_CallMethod(bytesio6, "truncate",
19606 : "l", (long) new_size);
19607 : if (retval == NULL)
19608 : {
19609 : Py_XDECREF(resultobj);
19610 : resultobj = NULL;
19611 : }
19612 : else
19613 : {
19614 : Py_DECREF(retval);
19615 :
19616 : retval = PyObject_CallMethod(bytesio6,
19617 : "getbuffer", NULL);
19618 : if (retval == NULL
19619 : || PyObject_GetBuffer(retval, &view6,
19620 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19621 : {
19622 : Py_XDECREF(resultobj);
19623 : resultobj = NULL;
19624 : }
19625 :
19626 : Py_XDECREF(retval);
19627 :
19628 : if (resultobj && view6.len
19629 : != new_size)
19630 : {
19631 : Py_XDECREF(resultobj);
19632 : resultobj = NULL;
19633 : PyErr_Format(PyExc_ValueError,
19634 : "Expected buffer of length %zu, got %zi",
19635 : new_size,
19636 : view6.len);
19637 : }
19638 : }
19639 : }
19640 : }
19641 : if (resultobj)
19642 : memcpy(view6.buf, new_data, new_size);
19643 : }
19644 :
19645 :
19646 :
19647 : }
19648 :
19649 : /* Free the temporary wrapper, if any. */
19650 0 : if (wrapper6)
19651 0 : gpgme_data_release(wrapper6);
19652 0 : Py_XDECREF (bytesio6);
19653 : if (have_view6 && view6.buf)
19654 : PyBuffer_Release(&view6);
19655 : }
19656 : return NULL;
19657 : }
19658 :
19659 :
19660 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19661 0 : PyObject *resultobj = 0;
19662 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19663 0 : char *arg2 = (char *) 0 ;
19664 0 : void *argp1 = 0 ;
19665 0 : int res1 = 0 ;
19666 : int res2 ;
19667 0 : char *buf2 = 0 ;
19668 0 : int alloc2 = 0 ;
19669 0 : PyObject * obj0 = 0 ;
19670 0 : PyObject * obj1 = 0 ;
19671 :
19672 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_recipient_keyid_set",&obj0,&obj1)) SWIG_fail;
19673 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
19674 0 : if (!SWIG_IsOK(res1)) {
19675 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_keyid_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19676 : }
19677 0 : arg1 = (struct _gpgme_recipient *)(argp1);
19678 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19679 0 : if (!SWIG_IsOK(res2)) {
19680 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_recipient_keyid_set" "', argument " "2"" of type '" "char *""'");
19681 : }
19682 0 : arg2 = (char *)(buf2);
19683 : {
19684 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19685 0 : if (arg1->keyid) free((char*)arg1->keyid);
19686 0 : if (arg2) {
19687 0 : size_t size = strlen((const char *)(arg2)) + 1;
19688 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
19689 : } else {
19690 0 : arg1->keyid = 0;
19691 : }
19692 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19693 : }
19694 0 : resultobj = SWIG_Py_Void();
19695 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
19696 : return resultobj;
19697 : fail:
19698 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
19699 : return NULL;
19700 : }
19701 :
19702 :
19703 8 : SWIGINTERN PyObject *_wrap__gpgme_recipient_keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19704 8 : PyObject *resultobj = 0;
19705 8 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19706 8 : void *argp1 = 0 ;
19707 8 : int res1 = 0 ;
19708 8 : PyObject * obj0 = 0 ;
19709 8 : char *result = 0 ;
19710 :
19711 8 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_keyid_get",&obj0)) SWIG_fail;
19712 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
19713 8 : if (!SWIG_IsOK(res1)) {
19714 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_keyid_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19715 : }
19716 8 : arg1 = (struct _gpgme_recipient *)(argp1);
19717 : {
19718 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19719 8 : result = (char *) ((arg1)->keyid);
19720 8 : SWIG_PYTHON_THREAD_END_ALLOW;
19721 : }
19722 8 : resultobj = SWIG_FromCharPtr((const char *)result);
19723 8 : return resultobj;
19724 : fail:
19725 : return NULL;
19726 : }
19727 :
19728 :
19729 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient__keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19730 0 : PyObject *resultobj = 0;
19731 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19732 : char *arg2 ;
19733 0 : void *argp1 = 0 ;
19734 0 : int res1 = 0 ;
19735 : char temp2[16+1] ;
19736 : int res2 ;
19737 0 : PyObject * obj0 = 0 ;
19738 0 : PyObject * obj1 = 0 ;
19739 :
19740 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_recipient__keyid_set",&obj0,&obj1)) SWIG_fail;
19741 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
19742 0 : if (!SWIG_IsOK(res1)) {
19743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient__keyid_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19744 : }
19745 0 : arg1 = (struct _gpgme_recipient *)(argp1);
19746 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
19747 0 : if (!SWIG_IsOK(res2)) {
19748 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_recipient__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
19749 : }
19750 0 : arg2 = (char *)(temp2);
19751 : {
19752 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19753 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
19754 : else memset(arg1->_keyid,0,16+1*sizeof(char));
19755 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19756 : }
19757 0 : resultobj = SWIG_Py_Void();
19758 0 : return resultobj;
19759 : fail:
19760 : return NULL;
19761 : }
19762 :
19763 :
19764 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient__keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19765 0 : PyObject *resultobj = 0;
19766 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19767 0 : void *argp1 = 0 ;
19768 0 : int res1 = 0 ;
19769 0 : PyObject * obj0 = 0 ;
19770 0 : char *result = 0 ;
19771 :
19772 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient__keyid_get",&obj0)) SWIG_fail;
19773 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
19774 0 : if (!SWIG_IsOK(res1)) {
19775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient__keyid_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19776 : }
19777 0 : arg1 = (struct _gpgme_recipient *)(argp1);
19778 : {
19779 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19780 0 : result = (char *)(char *) ((arg1)->_keyid);
19781 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19782 : }
19783 : {
19784 0 : size_t size = SWIG_strnlen(result, 16+1);
19785 :
19786 :
19787 :
19788 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
19789 : }
19790 0 : return resultobj;
19791 : fail:
19792 : return NULL;
19793 : }
19794 :
19795 :
19796 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19797 0 : PyObject *resultobj = 0;
19798 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19799 : gpgme_pubkey_algo_t arg2 ;
19800 0 : void *argp1 = 0 ;
19801 0 : int res1 = 0 ;
19802 : int val2 ;
19803 0 : int ecode2 = 0 ;
19804 0 : PyObject * obj0 = 0 ;
19805 0 : PyObject * obj1 = 0 ;
19806 :
19807 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_recipient_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
19808 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
19809 0 : if (!SWIG_IsOK(res1)) {
19810 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19811 : }
19812 0 : arg1 = (struct _gpgme_recipient *)(argp1);
19813 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19814 0 : if (!SWIG_IsOK(ecode2)) {
19815 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_recipient_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
19816 : }
19817 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
19818 : {
19819 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19820 0 : if (arg1) (arg1)->pubkey_algo = arg2;
19821 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19822 : }
19823 0 : resultobj = SWIG_Py_Void();
19824 0 : return resultobj;
19825 : fail:
19826 : return NULL;
19827 : }
19828 :
19829 :
19830 8 : SWIGINTERN PyObject *_wrap__gpgme_recipient_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19831 8 : PyObject *resultobj = 0;
19832 8 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19833 8 : void *argp1 = 0 ;
19834 8 : int res1 = 0 ;
19835 8 : PyObject * obj0 = 0 ;
19836 : gpgme_pubkey_algo_t result;
19837 :
19838 8 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_pubkey_algo_get",&obj0)) SWIG_fail;
19839 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
19840 8 : if (!SWIG_IsOK(res1)) {
19841 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19842 : }
19843 8 : arg1 = (struct _gpgme_recipient *)(argp1);
19844 : {
19845 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19846 8 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
19847 8 : SWIG_PYTHON_THREAD_END_ALLOW;
19848 : }
19849 16 : resultobj = SWIG_From_int((int)(result));
19850 8 : return resultobj;
19851 : fail:
19852 : return NULL;
19853 : }
19854 :
19855 :
19856 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19857 0 : PyObject *resultobj = 0;
19858 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19859 : gpgme_error_t arg2 ;
19860 0 : void *argp1 = 0 ;
19861 0 : int res1 = 0 ;
19862 0 : PyObject * obj0 = 0 ;
19863 0 : PyObject * obj1 = 0 ;
19864 :
19865 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_recipient_status_set",&obj0,&obj1)) SWIG_fail;
19866 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
19867 0 : if (!SWIG_IsOK(res1)) {
19868 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_status_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19869 : }
19870 0 : arg1 = (struct _gpgme_recipient *)(argp1);
19871 : {
19872 0 : if (PyLong_Check(obj1))
19873 0 : arg2 = PyLong_AsLong(obj1);
19874 :
19875 : else if (PyInt_Check(obj1))
19876 : arg2 = PyInt_AsLong(obj1);
19877 :
19878 : else
19879 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
19880 : }
19881 : {
19882 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19883 0 : if (arg1) (arg1)->status = arg2;
19884 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19885 : }
19886 0 : resultobj = SWIG_Py_Void();
19887 0 : return resultobj;
19888 : fail:
19889 : return NULL;
19890 : }
19891 :
19892 :
19893 8 : SWIGINTERN PyObject *_wrap__gpgme_recipient_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19894 8 : PyObject *resultobj = 0;
19895 8 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19896 8 : void *argp1 = 0 ;
19897 8 : int res1 = 0 ;
19898 8 : PyObject * obj0 = 0 ;
19899 : gpgme_error_t result;
19900 :
19901 8 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_status_get",&obj0)) SWIG_fail;
19902 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
19903 8 : if (!SWIG_IsOK(res1)) {
19904 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_status_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19905 : }
19906 8 : arg1 = (struct _gpgme_recipient *)(argp1);
19907 : {
19908 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19909 8 : result = ((arg1)->status);
19910 8 : SWIG_PYTHON_THREAD_END_ALLOW;
19911 : }
19912 : {
19913 8 : resultobj = PyLong_FromLong(result);
19914 : }
19915 8 : return resultobj;
19916 : fail:
19917 : return NULL;
19918 : }
19919 :
19920 :
19921 0 : SWIGINTERN PyObject *_wrap_new__gpgme_recipient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19922 0 : PyObject *resultobj = 0;
19923 0 : struct _gpgme_recipient *result = 0 ;
19924 :
19925 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_recipient")) SWIG_fail;
19926 : {
19927 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19928 0 : result = (struct _gpgme_recipient *)calloc(1, sizeof(struct _gpgme_recipient));
19929 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19930 : }
19931 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_recipient, SWIG_POINTER_NEW | 0 );
19932 0 : return resultobj;
19933 : fail:
19934 : return NULL;
19935 : }
19936 :
19937 :
19938 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_recipient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19939 0 : PyObject *resultobj = 0;
19940 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
19941 0 : void *argp1 = 0 ;
19942 0 : int res1 = 0 ;
19943 0 : PyObject * obj0 = 0 ;
19944 :
19945 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_recipient",&obj0)) SWIG_fail;
19946 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, SWIG_POINTER_DISOWN | 0 );
19947 0 : if (!SWIG_IsOK(res1)) {
19948 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_recipient" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
19949 : }
19950 0 : arg1 = (struct _gpgme_recipient *)(argp1);
19951 : {
19952 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19953 0 : free((char *) arg1);
19954 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19955 : }
19956 0 : resultobj = SWIG_Py_Void();
19957 0 : return resultobj;
19958 : fail:
19959 : return NULL;
19960 : }
19961 :
19962 :
19963 29 : SWIGINTERN PyObject *_gpgme_recipient_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19964 : PyObject *obj;
19965 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
19966 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_recipient, SWIG_NewClientData(obj));
19967 29 : return SWIG_Py_Void();
19968 : }
19969 :
19970 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_unsupported_algorithm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19971 0 : PyObject *resultobj = 0;
19972 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
19973 0 : char *arg2 = (char *) 0 ;
19974 0 : void *argp1 = 0 ;
19975 0 : int res1 = 0 ;
19976 : int res2 ;
19977 0 : char *buf2 = 0 ;
19978 0 : int alloc2 = 0 ;
19979 0 : PyObject * obj0 = 0 ;
19980 0 : PyObject * obj1 = 0 ;
19981 :
19982 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_unsupported_algorithm_set",&obj0,&obj1)) SWIG_fail;
19983 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
19984 0 : if (!SWIG_IsOK(res1)) {
19985 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 *""'");
19986 : }
19987 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
19988 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19989 0 : if (!SWIG_IsOK(res2)) {
19990 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_unsupported_algorithm_set" "', argument " "2"" of type '" "char *""'");
19991 : }
19992 0 : arg2 = (char *)(buf2);
19993 : {
19994 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19995 0 : if (arg1->unsupported_algorithm) free((char*)arg1->unsupported_algorithm);
19996 0 : if (arg2) {
19997 0 : size_t size = strlen((const char *)(arg2)) + 1;
19998 0 : arg1->unsupported_algorithm = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
19999 : } else {
20000 0 : arg1->unsupported_algorithm = 0;
20001 : }
20002 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20003 : }
20004 0 : resultobj = SWIG_Py_Void();
20005 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20006 : return resultobj;
20007 : fail:
20008 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20009 : return NULL;
20010 : }
20011 :
20012 :
20013 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_unsupported_algorithm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20014 10 : PyObject *resultobj = 0;
20015 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20016 10 : void *argp1 = 0 ;
20017 10 : int res1 = 0 ;
20018 10 : PyObject * obj0 = 0 ;
20019 10 : char *result = 0 ;
20020 :
20021 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_unsupported_algorithm_get",&obj0)) SWIG_fail;
20022 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20023 10 : if (!SWIG_IsOK(res1)) {
20024 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 *""'");
20025 : }
20026 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20027 : {
20028 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20029 10 : result = (char *) ((arg1)->unsupported_algorithm);
20030 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20031 : }
20032 10 : resultobj = SWIG_FromCharPtr((const char *)result);
20033 10 : return resultobj;
20034 : fail:
20035 : return NULL;
20036 : }
20037 :
20038 :
20039 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_wrong_key_usage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20040 0 : PyObject *resultobj = 0;
20041 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20042 : unsigned int arg2 ;
20043 0 : void *argp1 = 0 ;
20044 0 : int res1 = 0 ;
20045 : unsigned int val2 ;
20046 0 : int ecode2 = 0 ;
20047 0 : PyObject * obj0 = 0 ;
20048 0 : PyObject * obj1 = 0 ;
20049 :
20050 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_wrong_key_usage_set",&obj0,&obj1)) SWIG_fail;
20051 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20052 0 : if (!SWIG_IsOK(res1)) {
20053 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 *""'");
20054 : }
20055 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20056 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20057 0 : if (!SWIG_IsOK(ecode2)) {
20058 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result_wrong_key_usage_set" "', argument " "2"" of type '" "unsigned int""'");
20059 : }
20060 0 : arg2 = (unsigned int)(val2);
20061 : {
20062 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20063 0 : if (arg1) (arg1)->wrong_key_usage = arg2;
20064 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20065 : }
20066 0 : resultobj = SWIG_Py_Void();
20067 0 : return resultobj;
20068 : fail:
20069 : return NULL;
20070 : }
20071 :
20072 :
20073 20 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_wrong_key_usage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20074 20 : PyObject *resultobj = 0;
20075 20 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20076 20 : void *argp1 = 0 ;
20077 20 : int res1 = 0 ;
20078 20 : PyObject * obj0 = 0 ;
20079 : unsigned int result;
20080 :
20081 20 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_wrong_key_usage_get",&obj0)) SWIG_fail;
20082 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20083 20 : if (!SWIG_IsOK(res1)) {
20084 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 *""'");
20085 : }
20086 20 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20087 : {
20088 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20089 20 : result = (unsigned int) ((arg1)->wrong_key_usage);
20090 20 : SWIG_PYTHON_THREAD_END_ALLOW;
20091 : }
20092 20 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
20093 20 : return resultobj;
20094 : fail:
20095 : return NULL;
20096 : }
20097 :
20098 :
20099 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_is_de_vs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20100 0 : PyObject *resultobj = 0;
20101 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20102 : unsigned int arg2 ;
20103 0 : void *argp1 = 0 ;
20104 0 : int res1 = 0 ;
20105 : unsigned int val2 ;
20106 0 : int ecode2 = 0 ;
20107 0 : PyObject * obj0 = 0 ;
20108 0 : PyObject * obj1 = 0 ;
20109 :
20110 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_is_de_vs_set",&obj0,&obj1)) SWIG_fail;
20111 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20112 0 : if (!SWIG_IsOK(res1)) {
20113 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_is_de_vs_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20114 : }
20115 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20116 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20117 0 : if (!SWIG_IsOK(ecode2)) {
20118 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result_is_de_vs_set" "', argument " "2"" of type '" "unsigned int""'");
20119 : }
20120 0 : arg2 = (unsigned int)(val2);
20121 : {
20122 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20123 0 : if (arg1) (arg1)->is_de_vs = arg2;
20124 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20125 : }
20126 0 : resultobj = SWIG_Py_Void();
20127 0 : return resultobj;
20128 : fail:
20129 : return NULL;
20130 : }
20131 :
20132 :
20133 20 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_is_de_vs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20134 20 : PyObject *resultobj = 0;
20135 20 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20136 20 : void *argp1 = 0 ;
20137 20 : int res1 = 0 ;
20138 20 : PyObject * obj0 = 0 ;
20139 : unsigned int result;
20140 :
20141 20 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_is_de_vs_get",&obj0)) SWIG_fail;
20142 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20143 20 : if (!SWIG_IsOK(res1)) {
20144 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_is_de_vs_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20145 : }
20146 20 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20147 : {
20148 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20149 20 : result = (unsigned int) ((arg1)->is_de_vs);
20150 20 : SWIG_PYTHON_THREAD_END_ALLOW;
20151 : }
20152 20 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
20153 20 : return resultobj;
20154 : fail:
20155 : return NULL;
20156 : }
20157 :
20158 :
20159 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_is_mime_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20160 0 : PyObject *resultobj = 0;
20161 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20162 : unsigned int arg2 ;
20163 0 : void *argp1 = 0 ;
20164 0 : int res1 = 0 ;
20165 : unsigned int val2 ;
20166 0 : int ecode2 = 0 ;
20167 0 : PyObject * obj0 = 0 ;
20168 0 : PyObject * obj1 = 0 ;
20169 :
20170 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_is_mime_set",&obj0,&obj1)) SWIG_fail;
20171 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20172 0 : if (!SWIG_IsOK(res1)) {
20173 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_is_mime_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20174 : }
20175 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20176 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20177 0 : if (!SWIG_IsOK(ecode2)) {
20178 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result_is_mime_set" "', argument " "2"" of type '" "unsigned int""'");
20179 : }
20180 0 : arg2 = (unsigned int)(val2);
20181 : {
20182 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20183 0 : if (arg1) (arg1)->is_mime = arg2;
20184 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20185 : }
20186 0 : resultobj = SWIG_Py_Void();
20187 0 : return resultobj;
20188 : fail:
20189 : return NULL;
20190 : }
20191 :
20192 :
20193 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_is_mime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20194 10 : PyObject *resultobj = 0;
20195 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20196 10 : void *argp1 = 0 ;
20197 10 : int res1 = 0 ;
20198 10 : PyObject * obj0 = 0 ;
20199 : unsigned int result;
20200 :
20201 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_is_mime_get",&obj0)) SWIG_fail;
20202 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20203 10 : if (!SWIG_IsOK(res1)) {
20204 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_is_mime_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20205 : }
20206 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20207 : {
20208 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20209 10 : result = (unsigned int) ((arg1)->is_mime);
20210 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20211 : }
20212 10 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
20213 10 : return resultobj;
20214 : fail:
20215 : return NULL;
20216 : }
20217 :
20218 :
20219 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_legacy_cipher_nomdc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20220 0 : PyObject *resultobj = 0;
20221 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20222 : unsigned int arg2 ;
20223 0 : void *argp1 = 0 ;
20224 0 : int res1 = 0 ;
20225 : unsigned int val2 ;
20226 0 : int ecode2 = 0 ;
20227 0 : PyObject * obj0 = 0 ;
20228 0 : PyObject * obj1 = 0 ;
20229 :
20230 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_legacy_cipher_nomdc_set",&obj0,&obj1)) SWIG_fail;
20231 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20232 0 : if (!SWIG_IsOK(res1)) {
20233 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_legacy_cipher_nomdc_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20234 : }
20235 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20236 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20237 0 : if (!SWIG_IsOK(ecode2)) {
20238 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result_legacy_cipher_nomdc_set" "', argument " "2"" of type '" "unsigned int""'");
20239 : }
20240 0 : arg2 = (unsigned int)(val2);
20241 : {
20242 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20243 0 : if (arg1) (arg1)->legacy_cipher_nomdc = arg2;
20244 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20245 : }
20246 0 : resultobj = SWIG_Py_Void();
20247 0 : return resultobj;
20248 : fail:
20249 : return NULL;
20250 : }
20251 :
20252 :
20253 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_legacy_cipher_nomdc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20254 10 : PyObject *resultobj = 0;
20255 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20256 10 : void *argp1 = 0 ;
20257 10 : int res1 = 0 ;
20258 10 : PyObject * obj0 = 0 ;
20259 : unsigned int result;
20260 :
20261 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_legacy_cipher_nomdc_get",&obj0)) SWIG_fail;
20262 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20263 10 : if (!SWIG_IsOK(res1)) {
20264 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_legacy_cipher_nomdc_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20265 : }
20266 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20267 : {
20268 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20269 10 : result = (unsigned int) ((arg1)->legacy_cipher_nomdc);
20270 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20271 : }
20272 10 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
20273 10 : return resultobj;
20274 : fail:
20275 : return NULL;
20276 : }
20277 :
20278 :
20279 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20280 0 : PyObject *resultobj = 0;
20281 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20282 : int arg2 ;
20283 0 : void *argp1 = 0 ;
20284 0 : int res1 = 0 ;
20285 : int val2 ;
20286 0 : int ecode2 = 0 ;
20287 0 : PyObject * obj0 = 0 ;
20288 0 : PyObject * obj1 = 0 ;
20289 :
20290 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result__unused_set",&obj0,&obj1)) SWIG_fail;
20291 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20292 0 : if (!SWIG_IsOK(res1)) {
20293 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20294 : }
20295 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20296 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
20297 0 : if (!SWIG_IsOK(ecode2)) {
20298 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result__unused_set" "', argument " "2"" of type '" "int""'");
20299 : }
20300 0 : arg2 = (int)(val2);
20301 : {
20302 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20303 0 : if (arg1) (arg1)->_unused = arg2;
20304 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20305 : }
20306 0 : resultobj = SWIG_Py_Void();
20307 0 : return resultobj;
20308 : fail:
20309 : return NULL;
20310 : }
20311 :
20312 :
20313 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20314 0 : PyObject *resultobj = 0;
20315 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20316 0 : void *argp1 = 0 ;
20317 0 : int res1 = 0 ;
20318 0 : PyObject * obj0 = 0 ;
20319 : int result;
20320 :
20321 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result__unused_get",&obj0)) SWIG_fail;
20322 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20323 0 : if (!SWIG_IsOK(res1)) {
20324 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20325 : }
20326 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20327 : {
20328 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20329 0 : result = (int) ((arg1)->_unused);
20330 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20331 : }
20332 0 : resultobj = SWIG_From_int((int)(result));
20333 0 : return resultobj;
20334 : fail:
20335 : return NULL;
20336 : }
20337 :
20338 :
20339 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_recipients_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20340 0 : PyObject *resultobj = 0;
20341 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20342 0 : gpgme_recipient_t arg2 = (gpgme_recipient_t) 0 ;
20343 0 : void *argp1 = 0 ;
20344 0 : int res1 = 0 ;
20345 0 : void *argp2 = 0 ;
20346 0 : int res2 = 0 ;
20347 0 : PyObject * obj0 = 0 ;
20348 0 : PyObject * obj1 = 0 ;
20349 :
20350 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_recipients_set",&obj0,&obj1)) SWIG_fail;
20351 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20352 0 : if (!SWIG_IsOK(res1)) {
20353 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_recipients_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20354 : }
20355 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20356 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_recipient, SWIG_POINTER_DISOWN | 0 );
20357 0 : if (!SWIG_IsOK(res2)) {
20358 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_recipients_set" "', argument " "2"" of type '" "gpgme_recipient_t""'");
20359 : }
20360 0 : arg2 = (gpgme_recipient_t)(argp2);
20361 : {
20362 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20363 0 : if (arg1) (arg1)->recipients = arg2;
20364 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20365 : }
20366 0 : resultobj = SWIG_Py_Void();
20367 0 : return resultobj;
20368 : fail:
20369 : return NULL;
20370 : }
20371 :
20372 :
20373 20 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_recipients_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20374 20 : PyObject *resultobj = 0;
20375 20 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20376 20 : void *argp1 = 0 ;
20377 20 : int res1 = 0 ;
20378 20 : PyObject * obj0 = 0 ;
20379 : gpgme_recipient_t result;
20380 :
20381 20 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_recipients_get",&obj0)) SWIG_fail;
20382 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20383 20 : if (!SWIG_IsOK(res1)) {
20384 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_recipients_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20385 : }
20386 20 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20387 : {
20388 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20389 20 : result = (gpgme_recipient_t) ((arg1)->recipients);
20390 20 : SWIG_PYTHON_THREAD_END_ALLOW;
20391 : }
20392 : {
20393 : int i;
20394 20 : int size = 0;
20395 : gpgme_recipient_t curr;
20396 36 : for (curr = result; curr != NULL; curr = curr->next) {
20397 16 : size++;
20398 : }
20399 20 : resultobj = PyList_New(size);
20400 36 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
20401 16 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_recipient, 0 );
20402 16 : PyList_SetItem(resultobj, i, o);
20403 : }
20404 : }
20405 : return resultobj;
20406 : fail:
20407 : return NULL;
20408 : }
20409 :
20410 :
20411 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_file_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20412 0 : PyObject *resultobj = 0;
20413 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20414 0 : char *arg2 = (char *) 0 ;
20415 0 : void *argp1 = 0 ;
20416 0 : int res1 = 0 ;
20417 : int res2 ;
20418 0 : char *buf2 = 0 ;
20419 0 : int alloc2 = 0 ;
20420 0 : PyObject * obj0 = 0 ;
20421 0 : PyObject * obj1 = 0 ;
20422 :
20423 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_file_name_set",&obj0,&obj1)) SWIG_fail;
20424 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20425 0 : if (!SWIG_IsOK(res1)) {
20426 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 *""'");
20427 : }
20428 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20429 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20430 0 : if (!SWIG_IsOK(res2)) {
20431 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_file_name_set" "', argument " "2"" of type '" "char *""'");
20432 : }
20433 0 : arg2 = (char *)(buf2);
20434 : {
20435 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20436 0 : if (arg1->file_name) free((char*)arg1->file_name);
20437 0 : if (arg2) {
20438 0 : size_t size = strlen((const char *)(arg2)) + 1;
20439 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
20440 : } else {
20441 0 : arg1->file_name = 0;
20442 : }
20443 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20444 : }
20445 0 : resultobj = SWIG_Py_Void();
20446 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20447 : return resultobj;
20448 : fail:
20449 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20450 : return NULL;
20451 : }
20452 :
20453 :
20454 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_file_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20455 10 : PyObject *resultobj = 0;
20456 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20457 10 : void *argp1 = 0 ;
20458 10 : int res1 = 0 ;
20459 10 : PyObject * obj0 = 0 ;
20460 10 : char *result = 0 ;
20461 :
20462 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_file_name_get",&obj0)) SWIG_fail;
20463 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20464 10 : if (!SWIG_IsOK(res1)) {
20465 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 *""'");
20466 : }
20467 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20468 : {
20469 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20470 10 : result = (char *) ((arg1)->file_name);
20471 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20472 : }
20473 10 : resultobj = SWIG_FromCharPtr((const char *)result);
20474 10 : return resultobj;
20475 : fail:
20476 : return NULL;
20477 : }
20478 :
20479 :
20480 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_session_key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20481 0 : PyObject *resultobj = 0;
20482 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20483 0 : char *arg2 = (char *) 0 ;
20484 0 : void *argp1 = 0 ;
20485 0 : int res1 = 0 ;
20486 : int res2 ;
20487 0 : char *buf2 = 0 ;
20488 0 : int alloc2 = 0 ;
20489 0 : PyObject * obj0 = 0 ;
20490 0 : PyObject * obj1 = 0 ;
20491 :
20492 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_session_key_set",&obj0,&obj1)) SWIG_fail;
20493 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20494 0 : if (!SWIG_IsOK(res1)) {
20495 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 *""'");
20496 : }
20497 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20498 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20499 0 : if (!SWIG_IsOK(res2)) {
20500 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_session_key_set" "', argument " "2"" of type '" "char *""'");
20501 : }
20502 0 : arg2 = (char *)(buf2);
20503 : {
20504 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20505 0 : if (arg1->session_key) free((char*)arg1->session_key);
20506 0 : if (arg2) {
20507 0 : size_t size = strlen((const char *)(arg2)) + 1;
20508 0 : arg1->session_key = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
20509 : } else {
20510 0 : arg1->session_key = 0;
20511 : }
20512 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20513 : }
20514 0 : resultobj = SWIG_Py_Void();
20515 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20516 : return resultobj;
20517 : fail:
20518 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20519 : return NULL;
20520 : }
20521 :
20522 :
20523 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_session_key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20524 10 : PyObject *resultobj = 0;
20525 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20526 10 : void *argp1 = 0 ;
20527 10 : int res1 = 0 ;
20528 10 : PyObject * obj0 = 0 ;
20529 10 : char *result = 0 ;
20530 :
20531 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_session_key_get",&obj0)) SWIG_fail;
20532 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20533 10 : if (!SWIG_IsOK(res1)) {
20534 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 *""'");
20535 : }
20536 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20537 : {
20538 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20539 10 : result = (char *) ((arg1)->session_key);
20540 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20541 : }
20542 10 : resultobj = SWIG_FromCharPtr((const char *)result);
20543 10 : return resultobj;
20544 : fail:
20545 : return NULL;
20546 : }
20547 :
20548 :
20549 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_symkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20550 0 : PyObject *resultobj = 0;
20551 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20552 0 : char *arg2 = (char *) 0 ;
20553 0 : void *argp1 = 0 ;
20554 0 : int res1 = 0 ;
20555 : int res2 ;
20556 0 : char *buf2 = 0 ;
20557 0 : int alloc2 = 0 ;
20558 0 : PyObject * obj0 = 0 ;
20559 0 : PyObject * obj1 = 0 ;
20560 :
20561 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_symkey_algo_set",&obj0,&obj1)) SWIG_fail;
20562 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20563 0 : if (!SWIG_IsOK(res1)) {
20564 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_symkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20565 : }
20566 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20567 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20568 0 : if (!SWIG_IsOK(res2)) {
20569 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_symkey_algo_set" "', argument " "2"" of type '" "char *""'");
20570 : }
20571 0 : arg2 = (char *)(buf2);
20572 : {
20573 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20574 0 : if (arg1->symkey_algo) free((char*)arg1->symkey_algo);
20575 0 : if (arg2) {
20576 0 : size_t size = strlen((const char *)(arg2)) + 1;
20577 0 : arg1->symkey_algo = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
20578 : } else {
20579 0 : arg1->symkey_algo = 0;
20580 : }
20581 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20582 : }
20583 0 : resultobj = SWIG_Py_Void();
20584 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20585 : return resultobj;
20586 : fail:
20587 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20588 : return NULL;
20589 : }
20590 :
20591 :
20592 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_symkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20593 10 : PyObject *resultobj = 0;
20594 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20595 10 : void *argp1 = 0 ;
20596 10 : int res1 = 0 ;
20597 10 : PyObject * obj0 = 0 ;
20598 10 : char *result = 0 ;
20599 :
20600 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_symkey_algo_get",&obj0)) SWIG_fail;
20601 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
20602 10 : if (!SWIG_IsOK(res1)) {
20603 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_symkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20604 : }
20605 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20606 : {
20607 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20608 10 : result = (char *) ((arg1)->symkey_algo);
20609 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20610 : }
20611 10 : resultobj = SWIG_FromCharPtr((const char *)result);
20612 10 : return resultobj;
20613 : fail:
20614 : return NULL;
20615 : }
20616 :
20617 :
20618 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_decrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20619 0 : PyObject *resultobj = 0;
20620 0 : struct _gpgme_op_decrypt_result *result = 0 ;
20621 :
20622 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_decrypt_result")) SWIG_fail;
20623 : {
20624 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20625 0 : result = (struct _gpgme_op_decrypt_result *)calloc(1, sizeof(struct _gpgme_op_decrypt_result));
20626 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20627 : }
20628 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_decrypt_result, SWIG_POINTER_NEW | 0 );
20629 0 : return resultobj;
20630 : fail:
20631 : return NULL;
20632 : }
20633 :
20634 :
20635 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_decrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20636 0 : PyObject *resultobj = 0;
20637 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
20638 0 : void *argp1 = 0 ;
20639 0 : int res1 = 0 ;
20640 0 : PyObject * obj0 = 0 ;
20641 :
20642 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_decrypt_result",&obj0)) SWIG_fail;
20643 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, SWIG_POINTER_DISOWN | 0 );
20644 0 : if (!SWIG_IsOK(res1)) {
20645 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_decrypt_result" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
20646 : }
20647 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
20648 : {
20649 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20650 0 : free((char *) arg1);
20651 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20652 : }
20653 0 : resultobj = SWIG_Py_Void();
20654 0 : return resultobj;
20655 : fail:
20656 : return NULL;
20657 : }
20658 :
20659 :
20660 29 : SWIGINTERN PyObject *_gpgme_op_decrypt_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20661 : PyObject *obj;
20662 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20663 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_decrypt_result, SWIG_NewClientData(obj));
20664 29 : return SWIG_Py_Void();
20665 : }
20666 :
20667 10 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20668 10 : PyObject *resultobj = 0;
20669 10 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
20670 10 : void *argp1 = 0 ;
20671 10 : int res1 = 0 ;
20672 10 : PyObject * obj0 = 0 ;
20673 : gpgme_decrypt_result_t result;
20674 :
20675 10 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_decrypt_result",&obj0)) SWIG_fail;
20676 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
20677 10 : if (!SWIG_IsOK(res1)) {
20678 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
20679 : }
20680 10 : arg1 = (gpgme_ctx_t)(argp1);
20681 : {
20682 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20683 10 : result = (gpgme_decrypt_result_t)gpgme_op_decrypt_result(arg1);
20684 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20685 : }
20686 : {
20687 : PyObject *fragile;
20688 10 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_decrypt_result,
20689 : 0 );
20690 10 : resultobj = _gpg_wrap_result(fragile, "DecryptResult");
20691 10 : Py_DECREF(fragile);
20692 : }
20693 : return resultobj;
20694 : fail:
20695 : return NULL;
20696 : }
20697 :
20698 :
20699 0 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20700 0 : PyObject *resultobj = 0;
20701 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
20702 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
20703 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
20704 0 : void *argp1 = 0 ;
20705 0 : int res1 = 0 ;
20706 0 : gpgme_data_t wrapper2 = NULL ;
20707 0 : PyObject *bytesio2 = NULL ;
20708 : Py_buffer view2 ;
20709 0 : int have_view2 = 0 ;
20710 0 : gpgme_data_t wrapper3 = NULL ;
20711 0 : PyObject *bytesio3 = NULL ;
20712 : Py_buffer view3 ;
20713 0 : int have_view3 = 0 ;
20714 0 : PyObject * obj0 = 0 ;
20715 0 : PyObject * obj1 = 0 ;
20716 0 : PyObject * obj2 = 0 ;
20717 : gpgme_error_t result;
20718 :
20719 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_start",&obj0,&obj1,&obj2)) SWIG_fail;
20720 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
20721 0 : if (!SWIG_IsOK(res1)) {
20722 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
20723 : }
20724 0 : arg1 = (gpgme_ctx_t)(argp1);
20725 : {
20726 : /* If we create a temporary wrapper2 object, we will store it in
20727 : wrapperN, where N is 2. Here in this fragment, SWIG will
20728 : automatically append 2. */
20729 0 : memset(&view2, 0, sizeof view2);
20730 0 : if (obj1 == Py_None)
20731 0 : arg2 = NULL;
20732 : else {
20733 : PyObject *pypointer;
20734 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
20735 : &bytesio2, &view2);
20736 0 : if (pypointer == NULL)
20737 : return NULL;
20738 0 : have_view2 = !! view2.obj;
20739 :
20740 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
20741 :
20742 : /* Following code is from swig's python.swg. */
20743 :
20744 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
20745 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20746 0 : Py_DECREF(pypointer);
20747 : return NULL;
20748 : }
20749 0 : Py_DECREF(pypointer);
20750 : }
20751 : }
20752 : {
20753 : /* If we create a temporary wrapper3 object, we will store it in
20754 : wrapperN, where N is 3. Here in this fragment, SWIG will
20755 : automatically append 3. */
20756 0 : memset(&view3, 0, sizeof view3);
20757 0 : if (obj2 == Py_None)
20758 0 : arg3 = NULL;
20759 : else {
20760 : PyObject *pypointer;
20761 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
20762 : &bytesio3, &view3);
20763 0 : if (pypointer == NULL)
20764 : return NULL;
20765 0 : have_view3 = !! view3.obj;
20766 :
20767 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
20768 :
20769 : /* Following code is from swig's python.swg. */
20770 :
20771 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
20772 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20773 0 : Py_DECREF(pypointer);
20774 : return NULL;
20775 : }
20776 0 : Py_DECREF(pypointer);
20777 : }
20778 : }
20779 : {
20780 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20781 0 : result = gpgme_op_decrypt_start(arg1,arg2,arg3);
20782 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20783 : }
20784 : {
20785 0 : resultobj = PyLong_FromLong(result);
20786 : }
20787 : {
20788 : /* See whether we need to update the Python buffer. */
20789 0 : if (resultobj && wrapper2 && view2.buf)
20790 : {
20791 : int dirty;
20792 0 : char *new_data = NULL;
20793 : size_t new_size;
20794 :
20795 :
20796 0 : new_data = wrapper2->data.mem.buffer;
20797 0 : new_size = wrapper2->data.mem.length;
20798 0 : dirty = new_data != NULL;
20799 :
20800 :
20801 :
20802 :
20803 :
20804 :
20805 :
20806 0 : if (dirty)
20807 : {
20808 : /* The buffer is dirty. */
20809 0 : if (view2.readonly)
20810 : {
20811 0 : Py_XDECREF(resultobj);
20812 0 : resultobj = NULL;
20813 0 : PyErr_SetString(PyExc_ValueError,
20814 : "cannot update read-only buffer");
20815 : }
20816 :
20817 : /* See if we need to truncate the buffer. */
20818 0 : if (resultobj && view2.len != new_size)
20819 : {
20820 0 : if (bytesio2 == NULL)
20821 : {
20822 0 : Py_XDECREF(resultobj);
20823 0 : resultobj = NULL;
20824 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20825 : }
20826 : else
20827 : {
20828 : PyObject *retval;
20829 0 : PyBuffer_Release(&view2);
20830 : assert(view2.obj == NULL);
20831 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
20832 : "l", (long) new_size);
20833 0 : if (retval == NULL)
20834 : {
20835 0 : Py_XDECREF(resultobj);
20836 : resultobj = NULL;
20837 : }
20838 : else
20839 : {
20840 0 : Py_DECREF(retval);
20841 :
20842 0 : retval = PyObject_CallMethod(bytesio2,
20843 : "getbuffer", NULL);
20844 0 : if (retval == NULL
20845 0 : || PyObject_GetBuffer(retval, &view2,
20846 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20847 : {
20848 0 : Py_XDECREF(resultobj);
20849 : resultobj = NULL;
20850 : }
20851 :
20852 0 : Py_XDECREF(retval);
20853 :
20854 0 : if (resultobj && view2.len
20855 : != new_size)
20856 : {
20857 0 : Py_XDECREF(resultobj);
20858 0 : resultobj = NULL;
20859 0 : PyErr_Format(PyExc_ValueError,
20860 : "Expected buffer of length %zu, got %zi",
20861 : new_size,
20862 : view2.len);
20863 : }
20864 : }
20865 : }
20866 : }
20867 0 : if (resultobj)
20868 0 : memcpy(view2.buf, new_data, new_size);
20869 : }
20870 :
20871 :
20872 :
20873 : }
20874 :
20875 : /* Free the temporary wrapper, if any. */
20876 0 : if (wrapper2)
20877 0 : gpgme_data_release(wrapper2);
20878 0 : Py_XDECREF (bytesio2);
20879 0 : if (have_view2 && view2.buf)
20880 0 : PyBuffer_Release(&view2);
20881 : }
20882 : {
20883 : /* See whether we need to update the Python buffer. */
20884 0 : if (resultobj && wrapper3 && view3.buf)
20885 : {
20886 : int dirty;
20887 0 : char *new_data = NULL;
20888 : size_t new_size;
20889 :
20890 :
20891 0 : new_data = wrapper3->data.mem.buffer;
20892 0 : new_size = wrapper3->data.mem.length;
20893 0 : dirty = new_data != NULL;
20894 :
20895 :
20896 :
20897 :
20898 :
20899 :
20900 :
20901 0 : if (dirty)
20902 : {
20903 : /* The buffer is dirty. */
20904 0 : if (view3.readonly)
20905 : {
20906 0 : Py_XDECREF(resultobj);
20907 0 : resultobj = NULL;
20908 0 : PyErr_SetString(PyExc_ValueError,
20909 : "cannot update read-only buffer");
20910 : }
20911 :
20912 : /* See if we need to truncate the buffer. */
20913 0 : if (resultobj && view3.len != new_size)
20914 : {
20915 0 : if (bytesio3 == NULL)
20916 : {
20917 0 : Py_XDECREF(resultobj);
20918 0 : resultobj = NULL;
20919 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20920 : }
20921 : else
20922 : {
20923 : PyObject *retval;
20924 0 : PyBuffer_Release(&view3);
20925 : assert(view3.obj == NULL);
20926 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
20927 : "l", (long) new_size);
20928 0 : if (retval == NULL)
20929 : {
20930 0 : Py_XDECREF(resultobj);
20931 : resultobj = NULL;
20932 : }
20933 : else
20934 : {
20935 0 : Py_DECREF(retval);
20936 :
20937 0 : retval = PyObject_CallMethod(bytesio3,
20938 : "getbuffer", NULL);
20939 0 : if (retval == NULL
20940 0 : || PyObject_GetBuffer(retval, &view3,
20941 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20942 : {
20943 0 : Py_XDECREF(resultobj);
20944 : resultobj = NULL;
20945 : }
20946 :
20947 0 : Py_XDECREF(retval);
20948 :
20949 0 : if (resultobj && view3.len
20950 : != new_size)
20951 : {
20952 0 : Py_XDECREF(resultobj);
20953 0 : resultobj = NULL;
20954 0 : PyErr_Format(PyExc_ValueError,
20955 : "Expected buffer of length %zu, got %zi",
20956 : new_size,
20957 : view3.len);
20958 : }
20959 : }
20960 : }
20961 : }
20962 0 : if (resultobj)
20963 0 : memcpy(view3.buf, new_data, new_size);
20964 : }
20965 :
20966 :
20967 :
20968 : }
20969 :
20970 : /* Free the temporary wrapper, if any. */
20971 0 : if (wrapper3)
20972 0 : gpgme_data_release(wrapper3);
20973 0 : Py_XDECREF (bytesio3);
20974 0 : if (have_view3 && view3.buf)
20975 0 : PyBuffer_Release(&view3);
20976 : }
20977 : return resultobj;
20978 : fail:
20979 : {
20980 : /* See whether we need to update the Python buffer. */
20981 : if (resultobj && wrapper2 && view2.buf)
20982 : {
20983 : int dirty;
20984 : char *new_data = NULL;
20985 : size_t new_size;
20986 :
20987 :
20988 : new_data = wrapper2->data.mem.buffer;
20989 : new_size = wrapper2->data.mem.length;
20990 : dirty = new_data != NULL;
20991 :
20992 :
20993 :
20994 :
20995 :
20996 :
20997 :
20998 : if (dirty)
20999 : {
21000 : /* The buffer is dirty. */
21001 : if (view2.readonly)
21002 : {
21003 : Py_XDECREF(resultobj);
21004 : resultobj = NULL;
21005 : PyErr_SetString(PyExc_ValueError,
21006 : "cannot update read-only buffer");
21007 : }
21008 :
21009 : /* See if we need to truncate the buffer. */
21010 : if (resultobj && view2.len != new_size)
21011 : {
21012 : if (bytesio2 == NULL)
21013 : {
21014 : Py_XDECREF(resultobj);
21015 : resultobj = NULL;
21016 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21017 : }
21018 : else
21019 : {
21020 : PyObject *retval;
21021 : PyBuffer_Release(&view2);
21022 : assert(view2.obj == NULL);
21023 : retval = PyObject_CallMethod(bytesio2, "truncate",
21024 : "l", (long) new_size);
21025 : if (retval == NULL)
21026 : {
21027 : Py_XDECREF(resultobj);
21028 : resultobj = NULL;
21029 : }
21030 : else
21031 : {
21032 : Py_DECREF(retval);
21033 :
21034 : retval = PyObject_CallMethod(bytesio2,
21035 : "getbuffer", NULL);
21036 : if (retval == NULL
21037 : || PyObject_GetBuffer(retval, &view2,
21038 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21039 : {
21040 : Py_XDECREF(resultobj);
21041 : resultobj = NULL;
21042 : }
21043 :
21044 : Py_XDECREF(retval);
21045 :
21046 : if (resultobj && view2.len
21047 : != new_size)
21048 : {
21049 : Py_XDECREF(resultobj);
21050 : resultobj = NULL;
21051 : PyErr_Format(PyExc_ValueError,
21052 : "Expected buffer of length %zu, got %zi",
21053 : new_size,
21054 : view2.len);
21055 : }
21056 : }
21057 : }
21058 : }
21059 : if (resultobj)
21060 : memcpy(view2.buf, new_data, new_size);
21061 : }
21062 :
21063 :
21064 :
21065 : }
21066 :
21067 : /* Free the temporary wrapper, if any. */
21068 0 : if (wrapper2)
21069 0 : gpgme_data_release(wrapper2);
21070 0 : Py_XDECREF (bytesio2);
21071 : if (have_view2 && view2.buf)
21072 : PyBuffer_Release(&view2);
21073 : }
21074 : {
21075 : /* See whether we need to update the Python buffer. */
21076 : if (resultobj && wrapper3 && view3.buf)
21077 : {
21078 : int dirty;
21079 : char *new_data = NULL;
21080 : size_t new_size;
21081 :
21082 :
21083 : new_data = wrapper3->data.mem.buffer;
21084 : new_size = wrapper3->data.mem.length;
21085 : dirty = new_data != NULL;
21086 :
21087 :
21088 :
21089 :
21090 :
21091 :
21092 :
21093 : if (dirty)
21094 : {
21095 : /* The buffer is dirty. */
21096 : if (view3.readonly)
21097 : {
21098 : Py_XDECREF(resultobj);
21099 : resultobj = NULL;
21100 : PyErr_SetString(PyExc_ValueError,
21101 : "cannot update read-only buffer");
21102 : }
21103 :
21104 : /* See if we need to truncate the buffer. */
21105 : if (resultobj && view3.len != new_size)
21106 : {
21107 : if (bytesio3 == NULL)
21108 : {
21109 : Py_XDECREF(resultobj);
21110 : resultobj = NULL;
21111 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21112 : }
21113 : else
21114 : {
21115 : PyObject *retval;
21116 : PyBuffer_Release(&view3);
21117 : assert(view3.obj == NULL);
21118 : retval = PyObject_CallMethod(bytesio3, "truncate",
21119 : "l", (long) new_size);
21120 : if (retval == NULL)
21121 : {
21122 : Py_XDECREF(resultobj);
21123 : resultobj = NULL;
21124 : }
21125 : else
21126 : {
21127 : Py_DECREF(retval);
21128 :
21129 : retval = PyObject_CallMethod(bytesio3,
21130 : "getbuffer", NULL);
21131 : if (retval == NULL
21132 : || PyObject_GetBuffer(retval, &view3,
21133 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21134 : {
21135 : Py_XDECREF(resultobj);
21136 : resultobj = NULL;
21137 : }
21138 :
21139 : Py_XDECREF(retval);
21140 :
21141 : if (resultobj && view3.len
21142 : != new_size)
21143 : {
21144 : Py_XDECREF(resultobj);
21145 : resultobj = NULL;
21146 : PyErr_Format(PyExc_ValueError,
21147 : "Expected buffer of length %zu, got %zi",
21148 : new_size,
21149 : view3.len);
21150 : }
21151 : }
21152 : }
21153 : }
21154 : if (resultobj)
21155 : memcpy(view3.buf, new_data, new_size);
21156 : }
21157 :
21158 :
21159 :
21160 : }
21161 :
21162 : /* Free the temporary wrapper, if any. */
21163 0 : if (wrapper3)
21164 0 : gpgme_data_release(wrapper3);
21165 0 : Py_XDECREF (bytesio3);
21166 : if (have_view3 && view3.buf)
21167 : PyBuffer_Release(&view3);
21168 : }
21169 : return NULL;
21170 : }
21171 :
21172 :
21173 4 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21174 4 : PyObject *resultobj = 0;
21175 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
21176 4 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
21177 4 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
21178 4 : void *argp1 = 0 ;
21179 4 : int res1 = 0 ;
21180 4 : gpgme_data_t wrapper2 = NULL ;
21181 4 : PyObject *bytesio2 = NULL ;
21182 : Py_buffer view2 ;
21183 4 : int have_view2 = 0 ;
21184 4 : gpgme_data_t wrapper3 = NULL ;
21185 4 : PyObject *bytesio3 = NULL ;
21186 : Py_buffer view3 ;
21187 4 : int have_view3 = 0 ;
21188 4 : PyObject * obj0 = 0 ;
21189 4 : PyObject * obj1 = 0 ;
21190 4 : PyObject * obj2 = 0 ;
21191 : gpgme_error_t result;
21192 :
21193 4 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt",&obj0,&obj1,&obj2)) SWIG_fail;
21194 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
21195 4 : if (!SWIG_IsOK(res1)) {
21196 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt" "', argument " "1"" of type '" "gpgme_ctx_t""'");
21197 : }
21198 4 : arg1 = (gpgme_ctx_t)(argp1);
21199 : {
21200 : /* If we create a temporary wrapper2 object, we will store it in
21201 : wrapperN, where N is 2. Here in this fragment, SWIG will
21202 : automatically append 2. */
21203 4 : memset(&view2, 0, sizeof view2);
21204 4 : if (obj1 == Py_None)
21205 0 : arg2 = NULL;
21206 : else {
21207 : PyObject *pypointer;
21208 4 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
21209 : &bytesio2, &view2);
21210 4 : if (pypointer == NULL)
21211 : return NULL;
21212 4 : have_view2 = !! view2.obj;
21213 :
21214 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
21215 :
21216 : /* Following code is from swig's python.swg. */
21217 :
21218 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
21219 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
21220 0 : Py_DECREF(pypointer);
21221 : return NULL;
21222 : }
21223 4 : Py_DECREF(pypointer);
21224 : }
21225 : }
21226 : {
21227 : /* If we create a temporary wrapper3 object, we will store it in
21228 : wrapperN, where N is 3. Here in this fragment, SWIG will
21229 : automatically append 3. */
21230 4 : memset(&view3, 0, sizeof view3);
21231 4 : if (obj2 == Py_None)
21232 0 : arg3 = NULL;
21233 : else {
21234 : PyObject *pypointer;
21235 4 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
21236 : &bytesio3, &view3);
21237 4 : if (pypointer == NULL)
21238 : return NULL;
21239 4 : have_view3 = !! view3.obj;
21240 :
21241 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
21242 :
21243 : /* Following code is from swig's python.swg. */
21244 :
21245 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
21246 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
21247 0 : Py_DECREF(pypointer);
21248 : return NULL;
21249 : }
21250 4 : Py_DECREF(pypointer);
21251 : }
21252 : }
21253 : {
21254 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21255 4 : result = gpgme_op_decrypt(arg1,arg2,arg3);
21256 4 : SWIG_PYTHON_THREAD_END_ALLOW;
21257 : }
21258 : {
21259 4 : resultobj = PyLong_FromLong(result);
21260 : }
21261 : {
21262 : /* See whether we need to update the Python buffer. */
21263 4 : if (resultobj && wrapper2 && view2.buf)
21264 : {
21265 : int dirty;
21266 0 : char *new_data = NULL;
21267 : size_t new_size;
21268 :
21269 :
21270 0 : new_data = wrapper2->data.mem.buffer;
21271 0 : new_size = wrapper2->data.mem.length;
21272 0 : dirty = new_data != NULL;
21273 :
21274 :
21275 :
21276 :
21277 :
21278 :
21279 :
21280 0 : if (dirty)
21281 : {
21282 : /* The buffer is dirty. */
21283 0 : if (view2.readonly)
21284 : {
21285 0 : Py_XDECREF(resultobj);
21286 0 : resultobj = NULL;
21287 0 : PyErr_SetString(PyExc_ValueError,
21288 : "cannot update read-only buffer");
21289 : }
21290 :
21291 : /* See if we need to truncate the buffer. */
21292 0 : if (resultobj && view2.len != new_size)
21293 : {
21294 0 : if (bytesio2 == NULL)
21295 : {
21296 0 : Py_XDECREF(resultobj);
21297 0 : resultobj = NULL;
21298 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21299 : }
21300 : else
21301 : {
21302 : PyObject *retval;
21303 0 : PyBuffer_Release(&view2);
21304 : assert(view2.obj == NULL);
21305 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
21306 : "l", (long) new_size);
21307 0 : if (retval == NULL)
21308 : {
21309 0 : Py_XDECREF(resultobj);
21310 : resultobj = NULL;
21311 : }
21312 : else
21313 : {
21314 0 : Py_DECREF(retval);
21315 :
21316 0 : retval = PyObject_CallMethod(bytesio2,
21317 : "getbuffer", NULL);
21318 0 : if (retval == NULL
21319 0 : || PyObject_GetBuffer(retval, &view2,
21320 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21321 : {
21322 0 : Py_XDECREF(resultobj);
21323 : resultobj = NULL;
21324 : }
21325 :
21326 0 : Py_XDECREF(retval);
21327 :
21328 0 : if (resultobj && view2.len
21329 : != new_size)
21330 : {
21331 0 : Py_XDECREF(resultobj);
21332 0 : resultobj = NULL;
21333 0 : PyErr_Format(PyExc_ValueError,
21334 : "Expected buffer of length %zu, got %zi",
21335 : new_size,
21336 : view2.len);
21337 : }
21338 : }
21339 : }
21340 : }
21341 0 : if (resultobj)
21342 0 : memcpy(view2.buf, new_data, new_size);
21343 : }
21344 :
21345 :
21346 :
21347 : }
21348 :
21349 : /* Free the temporary wrapper, if any. */
21350 4 : if (wrapper2)
21351 0 : gpgme_data_release(wrapper2);
21352 4 : Py_XDECREF (bytesio2);
21353 4 : if (have_view2 && view2.buf)
21354 0 : PyBuffer_Release(&view2);
21355 : }
21356 : {
21357 : /* See whether we need to update the Python buffer. */
21358 4 : if (resultobj && wrapper3 && view3.buf)
21359 : {
21360 : int dirty;
21361 0 : char *new_data = NULL;
21362 : size_t new_size;
21363 :
21364 :
21365 0 : new_data = wrapper3->data.mem.buffer;
21366 0 : new_size = wrapper3->data.mem.length;
21367 0 : dirty = new_data != NULL;
21368 :
21369 :
21370 :
21371 :
21372 :
21373 :
21374 :
21375 0 : if (dirty)
21376 : {
21377 : /* The buffer is dirty. */
21378 0 : if (view3.readonly)
21379 : {
21380 0 : Py_XDECREF(resultobj);
21381 0 : resultobj = NULL;
21382 0 : PyErr_SetString(PyExc_ValueError,
21383 : "cannot update read-only buffer");
21384 : }
21385 :
21386 : /* See if we need to truncate the buffer. */
21387 0 : if (resultobj && view3.len != new_size)
21388 : {
21389 0 : if (bytesio3 == NULL)
21390 : {
21391 0 : Py_XDECREF(resultobj);
21392 0 : resultobj = NULL;
21393 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21394 : }
21395 : else
21396 : {
21397 : PyObject *retval;
21398 0 : PyBuffer_Release(&view3);
21399 : assert(view3.obj == NULL);
21400 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
21401 : "l", (long) new_size);
21402 0 : if (retval == NULL)
21403 : {
21404 0 : Py_XDECREF(resultobj);
21405 : resultobj = NULL;
21406 : }
21407 : else
21408 : {
21409 0 : Py_DECREF(retval);
21410 :
21411 0 : retval = PyObject_CallMethod(bytesio3,
21412 : "getbuffer", NULL);
21413 0 : if (retval == NULL
21414 0 : || PyObject_GetBuffer(retval, &view3,
21415 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21416 : {
21417 0 : Py_XDECREF(resultobj);
21418 : resultobj = NULL;
21419 : }
21420 :
21421 0 : Py_XDECREF(retval);
21422 :
21423 0 : if (resultobj && view3.len
21424 : != new_size)
21425 : {
21426 0 : Py_XDECREF(resultobj);
21427 0 : resultobj = NULL;
21428 0 : PyErr_Format(PyExc_ValueError,
21429 : "Expected buffer of length %zu, got %zi",
21430 : new_size,
21431 : view3.len);
21432 : }
21433 : }
21434 : }
21435 : }
21436 0 : if (resultobj)
21437 0 : memcpy(view3.buf, new_data, new_size);
21438 : }
21439 :
21440 :
21441 :
21442 : }
21443 :
21444 : /* Free the temporary wrapper, if any. */
21445 4 : if (wrapper3)
21446 0 : gpgme_data_release(wrapper3);
21447 4 : Py_XDECREF (bytesio3);
21448 4 : if (have_view3 && view3.buf)
21449 0 : PyBuffer_Release(&view3);
21450 : }
21451 : return resultobj;
21452 : fail:
21453 : {
21454 : /* See whether we need to update the Python buffer. */
21455 : if (resultobj && wrapper2 && view2.buf)
21456 : {
21457 : int dirty;
21458 : char *new_data = NULL;
21459 : size_t new_size;
21460 :
21461 :
21462 : new_data = wrapper2->data.mem.buffer;
21463 : new_size = wrapper2->data.mem.length;
21464 : dirty = new_data != NULL;
21465 :
21466 :
21467 :
21468 :
21469 :
21470 :
21471 :
21472 : if (dirty)
21473 : {
21474 : /* The buffer is dirty. */
21475 : if (view2.readonly)
21476 : {
21477 : Py_XDECREF(resultobj);
21478 : resultobj = NULL;
21479 : PyErr_SetString(PyExc_ValueError,
21480 : "cannot update read-only buffer");
21481 : }
21482 :
21483 : /* See if we need to truncate the buffer. */
21484 : if (resultobj && view2.len != new_size)
21485 : {
21486 : if (bytesio2 == NULL)
21487 : {
21488 : Py_XDECREF(resultobj);
21489 : resultobj = NULL;
21490 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21491 : }
21492 : else
21493 : {
21494 : PyObject *retval;
21495 : PyBuffer_Release(&view2);
21496 : assert(view2.obj == NULL);
21497 : retval = PyObject_CallMethod(bytesio2, "truncate",
21498 : "l", (long) new_size);
21499 : if (retval == NULL)
21500 : {
21501 : Py_XDECREF(resultobj);
21502 : resultobj = NULL;
21503 : }
21504 : else
21505 : {
21506 : Py_DECREF(retval);
21507 :
21508 : retval = PyObject_CallMethod(bytesio2,
21509 : "getbuffer", NULL);
21510 : if (retval == NULL
21511 : || PyObject_GetBuffer(retval, &view2,
21512 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21513 : {
21514 : Py_XDECREF(resultobj);
21515 : resultobj = NULL;
21516 : }
21517 :
21518 : Py_XDECREF(retval);
21519 :
21520 : if (resultobj && view2.len
21521 : != new_size)
21522 : {
21523 : Py_XDECREF(resultobj);
21524 : resultobj = NULL;
21525 : PyErr_Format(PyExc_ValueError,
21526 : "Expected buffer of length %zu, got %zi",
21527 : new_size,
21528 : view2.len);
21529 : }
21530 : }
21531 : }
21532 : }
21533 : if (resultobj)
21534 : memcpy(view2.buf, new_data, new_size);
21535 : }
21536 :
21537 :
21538 :
21539 : }
21540 :
21541 : /* Free the temporary wrapper, if any. */
21542 0 : if (wrapper2)
21543 0 : gpgme_data_release(wrapper2);
21544 0 : Py_XDECREF (bytesio2);
21545 : if (have_view2 && view2.buf)
21546 : PyBuffer_Release(&view2);
21547 : }
21548 : {
21549 : /* See whether we need to update the Python buffer. */
21550 : if (resultobj && wrapper3 && view3.buf)
21551 : {
21552 : int dirty;
21553 : char *new_data = NULL;
21554 : size_t new_size;
21555 :
21556 :
21557 : new_data = wrapper3->data.mem.buffer;
21558 : new_size = wrapper3->data.mem.length;
21559 : dirty = new_data != NULL;
21560 :
21561 :
21562 :
21563 :
21564 :
21565 :
21566 :
21567 : if (dirty)
21568 : {
21569 : /* The buffer is dirty. */
21570 : if (view3.readonly)
21571 : {
21572 : Py_XDECREF(resultobj);
21573 : resultobj = NULL;
21574 : PyErr_SetString(PyExc_ValueError,
21575 : "cannot update read-only buffer");
21576 : }
21577 :
21578 : /* See if we need to truncate the buffer. */
21579 : if (resultobj && view3.len != new_size)
21580 : {
21581 : if (bytesio3 == NULL)
21582 : {
21583 : Py_XDECREF(resultobj);
21584 : resultobj = NULL;
21585 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21586 : }
21587 : else
21588 : {
21589 : PyObject *retval;
21590 : PyBuffer_Release(&view3);
21591 : assert(view3.obj == NULL);
21592 : retval = PyObject_CallMethod(bytesio3, "truncate",
21593 : "l", (long) new_size);
21594 : if (retval == NULL)
21595 : {
21596 : Py_XDECREF(resultobj);
21597 : resultobj = NULL;
21598 : }
21599 : else
21600 : {
21601 : Py_DECREF(retval);
21602 :
21603 : retval = PyObject_CallMethod(bytesio3,
21604 : "getbuffer", NULL);
21605 : if (retval == NULL
21606 : || PyObject_GetBuffer(retval, &view3,
21607 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21608 : {
21609 : Py_XDECREF(resultobj);
21610 : resultobj = NULL;
21611 : }
21612 :
21613 : Py_XDECREF(retval);
21614 :
21615 : if (resultobj && view3.len
21616 : != new_size)
21617 : {
21618 : Py_XDECREF(resultobj);
21619 : resultobj = NULL;
21620 : PyErr_Format(PyExc_ValueError,
21621 : "Expected buffer of length %zu, got %zi",
21622 : new_size,
21623 : view3.len);
21624 : }
21625 : }
21626 : }
21627 : }
21628 : if (resultobj)
21629 : memcpy(view3.buf, new_data, new_size);
21630 : }
21631 :
21632 :
21633 :
21634 : }
21635 :
21636 : /* Free the temporary wrapper, if any. */
21637 0 : if (wrapper3)
21638 0 : gpgme_data_release(wrapper3);
21639 0 : Py_XDECREF (bytesio3);
21640 : if (have_view3 && view3.buf)
21641 : PyBuffer_Release(&view3);
21642 : }
21643 : return NULL;
21644 : }
21645 :
21646 :
21647 0 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_verify_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21648 0 : PyObject *resultobj = 0;
21649 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
21650 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
21651 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
21652 0 : void *argp1 = 0 ;
21653 0 : int res1 = 0 ;
21654 0 : gpgme_data_t wrapper2 = NULL ;
21655 0 : PyObject *bytesio2 = NULL ;
21656 : Py_buffer view2 ;
21657 0 : int have_view2 = 0 ;
21658 0 : gpgme_data_t wrapper3 = NULL ;
21659 0 : PyObject *bytesio3 = NULL ;
21660 : Py_buffer view3 ;
21661 0 : int have_view3 = 0 ;
21662 0 : PyObject * obj0 = 0 ;
21663 0 : PyObject * obj1 = 0 ;
21664 0 : PyObject * obj2 = 0 ;
21665 : gpgme_error_t result;
21666 :
21667 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_verify_start",&obj0,&obj1,&obj2)) SWIG_fail;
21668 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
21669 0 : if (!SWIG_IsOK(res1)) {
21670 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_verify_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
21671 : }
21672 0 : arg1 = (gpgme_ctx_t)(argp1);
21673 : {
21674 : /* If we create a temporary wrapper2 object, we will store it in
21675 : wrapperN, where N is 2. Here in this fragment, SWIG will
21676 : automatically append 2. */
21677 0 : memset(&view2, 0, sizeof view2);
21678 0 : if (obj1 == Py_None)
21679 0 : arg2 = NULL;
21680 : else {
21681 : PyObject *pypointer;
21682 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
21683 : &bytesio2, &view2);
21684 0 : if (pypointer == NULL)
21685 : return NULL;
21686 0 : have_view2 = !! view2.obj;
21687 :
21688 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
21689 :
21690 : /* Following code is from swig's python.swg. */
21691 :
21692 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
21693 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
21694 0 : Py_DECREF(pypointer);
21695 : return NULL;
21696 : }
21697 0 : Py_DECREF(pypointer);
21698 : }
21699 : }
21700 : {
21701 : /* If we create a temporary wrapper3 object, we will store it in
21702 : wrapperN, where N is 3. Here in this fragment, SWIG will
21703 : automatically append 3. */
21704 0 : memset(&view3, 0, sizeof view3);
21705 0 : if (obj2 == Py_None)
21706 0 : arg3 = NULL;
21707 : else {
21708 : PyObject *pypointer;
21709 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
21710 : &bytesio3, &view3);
21711 0 : if (pypointer == NULL)
21712 : return NULL;
21713 0 : have_view3 = !! view3.obj;
21714 :
21715 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
21716 :
21717 : /* Following code is from swig's python.swg. */
21718 :
21719 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
21720 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
21721 0 : Py_DECREF(pypointer);
21722 : return NULL;
21723 : }
21724 0 : Py_DECREF(pypointer);
21725 : }
21726 : }
21727 : {
21728 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21729 0 : result = gpgme_op_decrypt_verify_start(arg1,arg2,arg3);
21730 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21731 : }
21732 : {
21733 0 : resultobj = PyLong_FromLong(result);
21734 : }
21735 : {
21736 : /* See whether we need to update the Python buffer. */
21737 0 : if (resultobj && wrapper2 && view2.buf)
21738 : {
21739 : int dirty;
21740 0 : char *new_data = NULL;
21741 : size_t new_size;
21742 :
21743 :
21744 0 : new_data = wrapper2->data.mem.buffer;
21745 0 : new_size = wrapper2->data.mem.length;
21746 0 : dirty = new_data != NULL;
21747 :
21748 :
21749 :
21750 :
21751 :
21752 :
21753 :
21754 0 : if (dirty)
21755 : {
21756 : /* The buffer is dirty. */
21757 0 : if (view2.readonly)
21758 : {
21759 0 : Py_XDECREF(resultobj);
21760 0 : resultobj = NULL;
21761 0 : PyErr_SetString(PyExc_ValueError,
21762 : "cannot update read-only buffer");
21763 : }
21764 :
21765 : /* See if we need to truncate the buffer. */
21766 0 : if (resultobj && view2.len != new_size)
21767 : {
21768 0 : if (bytesio2 == NULL)
21769 : {
21770 0 : Py_XDECREF(resultobj);
21771 0 : resultobj = NULL;
21772 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21773 : }
21774 : else
21775 : {
21776 : PyObject *retval;
21777 0 : PyBuffer_Release(&view2);
21778 : assert(view2.obj == NULL);
21779 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
21780 : "l", (long) new_size);
21781 0 : if (retval == NULL)
21782 : {
21783 0 : Py_XDECREF(resultobj);
21784 : resultobj = NULL;
21785 : }
21786 : else
21787 : {
21788 0 : Py_DECREF(retval);
21789 :
21790 0 : retval = PyObject_CallMethod(bytesio2,
21791 : "getbuffer", NULL);
21792 0 : if (retval == NULL
21793 0 : || PyObject_GetBuffer(retval, &view2,
21794 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21795 : {
21796 0 : Py_XDECREF(resultobj);
21797 : resultobj = NULL;
21798 : }
21799 :
21800 0 : Py_XDECREF(retval);
21801 :
21802 0 : if (resultobj && view2.len
21803 : != new_size)
21804 : {
21805 0 : Py_XDECREF(resultobj);
21806 0 : resultobj = NULL;
21807 0 : PyErr_Format(PyExc_ValueError,
21808 : "Expected buffer of length %zu, got %zi",
21809 : new_size,
21810 : view2.len);
21811 : }
21812 : }
21813 : }
21814 : }
21815 0 : if (resultobj)
21816 0 : memcpy(view2.buf, new_data, new_size);
21817 : }
21818 :
21819 :
21820 :
21821 : }
21822 :
21823 : /* Free the temporary wrapper, if any. */
21824 0 : if (wrapper2)
21825 0 : gpgme_data_release(wrapper2);
21826 0 : Py_XDECREF (bytesio2);
21827 0 : if (have_view2 && view2.buf)
21828 0 : PyBuffer_Release(&view2);
21829 : }
21830 : {
21831 : /* See whether we need to update the Python buffer. */
21832 0 : if (resultobj && wrapper3 && view3.buf)
21833 : {
21834 : int dirty;
21835 0 : char *new_data = NULL;
21836 : size_t new_size;
21837 :
21838 :
21839 0 : new_data = wrapper3->data.mem.buffer;
21840 0 : new_size = wrapper3->data.mem.length;
21841 0 : dirty = new_data != NULL;
21842 :
21843 :
21844 :
21845 :
21846 :
21847 :
21848 :
21849 0 : if (dirty)
21850 : {
21851 : /* The buffer is dirty. */
21852 0 : if (view3.readonly)
21853 : {
21854 0 : Py_XDECREF(resultobj);
21855 0 : resultobj = NULL;
21856 0 : PyErr_SetString(PyExc_ValueError,
21857 : "cannot update read-only buffer");
21858 : }
21859 :
21860 : /* See if we need to truncate the buffer. */
21861 0 : if (resultobj && view3.len != new_size)
21862 : {
21863 0 : if (bytesio3 == NULL)
21864 : {
21865 0 : Py_XDECREF(resultobj);
21866 0 : resultobj = NULL;
21867 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21868 : }
21869 : else
21870 : {
21871 : PyObject *retval;
21872 0 : PyBuffer_Release(&view3);
21873 : assert(view3.obj == NULL);
21874 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
21875 : "l", (long) new_size);
21876 0 : if (retval == NULL)
21877 : {
21878 0 : Py_XDECREF(resultobj);
21879 : resultobj = NULL;
21880 : }
21881 : else
21882 : {
21883 0 : Py_DECREF(retval);
21884 :
21885 0 : retval = PyObject_CallMethod(bytesio3,
21886 : "getbuffer", NULL);
21887 0 : if (retval == NULL
21888 0 : || PyObject_GetBuffer(retval, &view3,
21889 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21890 : {
21891 0 : Py_XDECREF(resultobj);
21892 : resultobj = NULL;
21893 : }
21894 :
21895 0 : Py_XDECREF(retval);
21896 :
21897 0 : if (resultobj && view3.len
21898 : != new_size)
21899 : {
21900 0 : Py_XDECREF(resultobj);
21901 0 : resultobj = NULL;
21902 0 : PyErr_Format(PyExc_ValueError,
21903 : "Expected buffer of length %zu, got %zi",
21904 : new_size,
21905 : view3.len);
21906 : }
21907 : }
21908 : }
21909 : }
21910 0 : if (resultobj)
21911 0 : memcpy(view3.buf, new_data, new_size);
21912 : }
21913 :
21914 :
21915 :
21916 : }
21917 :
21918 : /* Free the temporary wrapper, if any. */
21919 0 : if (wrapper3)
21920 0 : gpgme_data_release(wrapper3);
21921 0 : Py_XDECREF (bytesio3);
21922 0 : if (have_view3 && view3.buf)
21923 0 : PyBuffer_Release(&view3);
21924 : }
21925 : return resultobj;
21926 : fail:
21927 : {
21928 : /* See whether we need to update the Python buffer. */
21929 : if (resultobj && wrapper2 && view2.buf)
21930 : {
21931 : int dirty;
21932 : char *new_data = NULL;
21933 : size_t new_size;
21934 :
21935 :
21936 : new_data = wrapper2->data.mem.buffer;
21937 : new_size = wrapper2->data.mem.length;
21938 : dirty = new_data != NULL;
21939 :
21940 :
21941 :
21942 :
21943 :
21944 :
21945 :
21946 : if (dirty)
21947 : {
21948 : /* The buffer is dirty. */
21949 : if (view2.readonly)
21950 : {
21951 : Py_XDECREF(resultobj);
21952 : resultobj = NULL;
21953 : PyErr_SetString(PyExc_ValueError,
21954 : "cannot update read-only buffer");
21955 : }
21956 :
21957 : /* See if we need to truncate the buffer. */
21958 : if (resultobj && view2.len != new_size)
21959 : {
21960 : if (bytesio2 == NULL)
21961 : {
21962 : Py_XDECREF(resultobj);
21963 : resultobj = NULL;
21964 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21965 : }
21966 : else
21967 : {
21968 : PyObject *retval;
21969 : PyBuffer_Release(&view2);
21970 : assert(view2.obj == NULL);
21971 : retval = PyObject_CallMethod(bytesio2, "truncate",
21972 : "l", (long) new_size);
21973 : if (retval == NULL)
21974 : {
21975 : Py_XDECREF(resultobj);
21976 : resultobj = NULL;
21977 : }
21978 : else
21979 : {
21980 : Py_DECREF(retval);
21981 :
21982 : retval = PyObject_CallMethod(bytesio2,
21983 : "getbuffer", NULL);
21984 : if (retval == NULL
21985 : || PyObject_GetBuffer(retval, &view2,
21986 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21987 : {
21988 : Py_XDECREF(resultobj);
21989 : resultobj = NULL;
21990 : }
21991 :
21992 : Py_XDECREF(retval);
21993 :
21994 : if (resultobj && view2.len
21995 : != new_size)
21996 : {
21997 : Py_XDECREF(resultobj);
21998 : resultobj = NULL;
21999 : PyErr_Format(PyExc_ValueError,
22000 : "Expected buffer of length %zu, got %zi",
22001 : new_size,
22002 : view2.len);
22003 : }
22004 : }
22005 : }
22006 : }
22007 : if (resultobj)
22008 : memcpy(view2.buf, new_data, new_size);
22009 : }
22010 :
22011 :
22012 :
22013 : }
22014 :
22015 : /* Free the temporary wrapper, if any. */
22016 0 : if (wrapper2)
22017 0 : gpgme_data_release(wrapper2);
22018 0 : Py_XDECREF (bytesio2);
22019 : if (have_view2 && view2.buf)
22020 : PyBuffer_Release(&view2);
22021 : }
22022 : {
22023 : /* See whether we need to update the Python buffer. */
22024 : if (resultobj && wrapper3 && view3.buf)
22025 : {
22026 : int dirty;
22027 : char *new_data = NULL;
22028 : size_t new_size;
22029 :
22030 :
22031 : new_data = wrapper3->data.mem.buffer;
22032 : new_size = wrapper3->data.mem.length;
22033 : dirty = new_data != NULL;
22034 :
22035 :
22036 :
22037 :
22038 :
22039 :
22040 :
22041 : if (dirty)
22042 : {
22043 : /* The buffer is dirty. */
22044 : if (view3.readonly)
22045 : {
22046 : Py_XDECREF(resultobj);
22047 : resultobj = NULL;
22048 : PyErr_SetString(PyExc_ValueError,
22049 : "cannot update read-only buffer");
22050 : }
22051 :
22052 : /* See if we need to truncate the buffer. */
22053 : if (resultobj && view3.len != new_size)
22054 : {
22055 : if (bytesio3 == NULL)
22056 : {
22057 : Py_XDECREF(resultobj);
22058 : resultobj = NULL;
22059 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22060 : }
22061 : else
22062 : {
22063 : PyObject *retval;
22064 : PyBuffer_Release(&view3);
22065 : assert(view3.obj == NULL);
22066 : retval = PyObject_CallMethod(bytesio3, "truncate",
22067 : "l", (long) new_size);
22068 : if (retval == NULL)
22069 : {
22070 : Py_XDECREF(resultobj);
22071 : resultobj = NULL;
22072 : }
22073 : else
22074 : {
22075 : Py_DECREF(retval);
22076 :
22077 : retval = PyObject_CallMethod(bytesio3,
22078 : "getbuffer", NULL);
22079 : if (retval == NULL
22080 : || PyObject_GetBuffer(retval, &view3,
22081 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22082 : {
22083 : Py_XDECREF(resultobj);
22084 : resultobj = NULL;
22085 : }
22086 :
22087 : Py_XDECREF(retval);
22088 :
22089 : if (resultobj && view3.len
22090 : != new_size)
22091 : {
22092 : Py_XDECREF(resultobj);
22093 : resultobj = NULL;
22094 : PyErr_Format(PyExc_ValueError,
22095 : "Expected buffer of length %zu, got %zi",
22096 : new_size,
22097 : view3.len);
22098 : }
22099 : }
22100 : }
22101 : }
22102 : if (resultobj)
22103 : memcpy(view3.buf, new_data, new_size);
22104 : }
22105 :
22106 :
22107 :
22108 : }
22109 :
22110 : /* Free the temporary wrapper, if any. */
22111 0 : if (wrapper3)
22112 0 : gpgme_data_release(wrapper3);
22113 0 : Py_XDECREF (bytesio3);
22114 : if (have_view3 && view3.buf)
22115 : PyBuffer_Release(&view3);
22116 : }
22117 : return NULL;
22118 : }
22119 :
22120 :
22121 8 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22122 8 : PyObject *resultobj = 0;
22123 8 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
22124 8 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
22125 8 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
22126 8 : void *argp1 = 0 ;
22127 8 : int res1 = 0 ;
22128 8 : gpgme_data_t wrapper2 = NULL ;
22129 8 : PyObject *bytesio2 = NULL ;
22130 : Py_buffer view2 ;
22131 8 : int have_view2 = 0 ;
22132 8 : gpgme_data_t wrapper3 = NULL ;
22133 8 : PyObject *bytesio3 = NULL ;
22134 : Py_buffer view3 ;
22135 8 : int have_view3 = 0 ;
22136 8 : PyObject * obj0 = 0 ;
22137 8 : PyObject * obj1 = 0 ;
22138 8 : PyObject * obj2 = 0 ;
22139 : gpgme_error_t result;
22140 :
22141 8 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_verify",&obj0,&obj1,&obj2)) SWIG_fail;
22142 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
22143 8 : if (!SWIG_IsOK(res1)) {
22144 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_verify" "', argument " "1"" of type '" "gpgme_ctx_t""'");
22145 : }
22146 8 : arg1 = (gpgme_ctx_t)(argp1);
22147 : {
22148 : /* If we create a temporary wrapper2 object, we will store it in
22149 : wrapperN, where N is 2. Here in this fragment, SWIG will
22150 : automatically append 2. */
22151 8 : memset(&view2, 0, sizeof view2);
22152 8 : if (obj1 == Py_None)
22153 0 : arg2 = NULL;
22154 : else {
22155 : PyObject *pypointer;
22156 8 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
22157 : &bytesio2, &view2);
22158 8 : if (pypointer == NULL)
22159 : return NULL;
22160 8 : have_view2 = !! view2.obj;
22161 :
22162 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
22163 :
22164 : /* Following code is from swig's python.swg. */
22165 :
22166 8 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
22167 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22168 0 : Py_DECREF(pypointer);
22169 : return NULL;
22170 : }
22171 8 : Py_DECREF(pypointer);
22172 : }
22173 : }
22174 : {
22175 : /* If we create a temporary wrapper3 object, we will store it in
22176 : wrapperN, where N is 3. Here in this fragment, SWIG will
22177 : automatically append 3. */
22178 8 : memset(&view3, 0, sizeof view3);
22179 8 : if (obj2 == Py_None)
22180 0 : arg3 = NULL;
22181 : else {
22182 : PyObject *pypointer;
22183 8 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
22184 : &bytesio3, &view3);
22185 8 : if (pypointer == NULL)
22186 : return NULL;
22187 8 : have_view3 = !! view3.obj;
22188 :
22189 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
22190 :
22191 : /* Following code is from swig's python.swg. */
22192 :
22193 8 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
22194 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22195 0 : Py_DECREF(pypointer);
22196 : return NULL;
22197 : }
22198 8 : Py_DECREF(pypointer);
22199 : }
22200 : }
22201 : {
22202 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22203 8 : result = gpgme_op_decrypt_verify(arg1,arg2,arg3);
22204 8 : SWIG_PYTHON_THREAD_END_ALLOW;
22205 : }
22206 : {
22207 8 : resultobj = PyLong_FromLong(result);
22208 : }
22209 : {
22210 : /* See whether we need to update the Python buffer. */
22211 8 : if (resultobj && wrapper2 && view2.buf)
22212 : {
22213 : int dirty;
22214 4 : char *new_data = NULL;
22215 : size_t new_size;
22216 :
22217 :
22218 4 : new_data = wrapper2->data.mem.buffer;
22219 4 : new_size = wrapper2->data.mem.length;
22220 4 : dirty = new_data != NULL;
22221 :
22222 :
22223 :
22224 :
22225 :
22226 :
22227 :
22228 4 : if (dirty)
22229 : {
22230 : /* The buffer is dirty. */
22231 0 : if (view2.readonly)
22232 : {
22233 0 : Py_XDECREF(resultobj);
22234 0 : resultobj = NULL;
22235 0 : PyErr_SetString(PyExc_ValueError,
22236 : "cannot update read-only buffer");
22237 : }
22238 :
22239 : /* See if we need to truncate the buffer. */
22240 0 : if (resultobj && view2.len != new_size)
22241 : {
22242 0 : if (bytesio2 == NULL)
22243 : {
22244 0 : Py_XDECREF(resultobj);
22245 0 : resultobj = NULL;
22246 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22247 : }
22248 : else
22249 : {
22250 : PyObject *retval;
22251 0 : PyBuffer_Release(&view2);
22252 : assert(view2.obj == NULL);
22253 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
22254 : "l", (long) new_size);
22255 0 : if (retval == NULL)
22256 : {
22257 0 : Py_XDECREF(resultobj);
22258 : resultobj = NULL;
22259 : }
22260 : else
22261 : {
22262 0 : Py_DECREF(retval);
22263 :
22264 0 : retval = PyObject_CallMethod(bytesio2,
22265 : "getbuffer", NULL);
22266 0 : if (retval == NULL
22267 0 : || PyObject_GetBuffer(retval, &view2,
22268 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22269 : {
22270 0 : Py_XDECREF(resultobj);
22271 : resultobj = NULL;
22272 : }
22273 :
22274 0 : Py_XDECREF(retval);
22275 :
22276 0 : if (resultobj && view2.len
22277 : != new_size)
22278 : {
22279 0 : Py_XDECREF(resultobj);
22280 0 : resultobj = NULL;
22281 0 : PyErr_Format(PyExc_ValueError,
22282 : "Expected buffer of length %zu, got %zi",
22283 : new_size,
22284 : view2.len);
22285 : }
22286 : }
22287 : }
22288 : }
22289 0 : if (resultobj)
22290 0 : memcpy(view2.buf, new_data, new_size);
22291 : }
22292 :
22293 :
22294 :
22295 : }
22296 :
22297 : /* Free the temporary wrapper, if any. */
22298 8 : if (wrapper2)
22299 7 : gpgme_data_release(wrapper2);
22300 8 : Py_XDECREF (bytesio2);
22301 8 : if (have_view2 && view2.buf)
22302 4 : PyBuffer_Release(&view2);
22303 : }
22304 : {
22305 : /* See whether we need to update the Python buffer. */
22306 8 : if (resultobj && wrapper3 && view3.buf)
22307 : {
22308 : int dirty;
22309 0 : char *new_data = NULL;
22310 : size_t new_size;
22311 :
22312 :
22313 0 : new_data = wrapper3->data.mem.buffer;
22314 0 : new_size = wrapper3->data.mem.length;
22315 0 : dirty = new_data != NULL;
22316 :
22317 :
22318 :
22319 :
22320 :
22321 :
22322 :
22323 0 : if (dirty)
22324 : {
22325 : /* The buffer is dirty. */
22326 0 : if (view3.readonly)
22327 : {
22328 0 : Py_XDECREF(resultobj);
22329 0 : resultobj = NULL;
22330 0 : PyErr_SetString(PyExc_ValueError,
22331 : "cannot update read-only buffer");
22332 : }
22333 :
22334 : /* See if we need to truncate the buffer. */
22335 0 : if (resultobj && view3.len != new_size)
22336 : {
22337 0 : if (bytesio3 == NULL)
22338 : {
22339 0 : Py_XDECREF(resultobj);
22340 0 : resultobj = NULL;
22341 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22342 : }
22343 : else
22344 : {
22345 : PyObject *retval;
22346 0 : PyBuffer_Release(&view3);
22347 : assert(view3.obj == NULL);
22348 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
22349 : "l", (long) new_size);
22350 0 : if (retval == NULL)
22351 : {
22352 0 : Py_XDECREF(resultobj);
22353 : resultobj = NULL;
22354 : }
22355 : else
22356 : {
22357 0 : Py_DECREF(retval);
22358 :
22359 0 : retval = PyObject_CallMethod(bytesio3,
22360 : "getbuffer", NULL);
22361 0 : if (retval == NULL
22362 0 : || PyObject_GetBuffer(retval, &view3,
22363 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22364 : {
22365 0 : Py_XDECREF(resultobj);
22366 : resultobj = NULL;
22367 : }
22368 :
22369 0 : Py_XDECREF(retval);
22370 :
22371 0 : if (resultobj && view3.len
22372 : != new_size)
22373 : {
22374 0 : Py_XDECREF(resultobj);
22375 0 : resultobj = NULL;
22376 0 : PyErr_Format(PyExc_ValueError,
22377 : "Expected buffer of length %zu, got %zi",
22378 : new_size,
22379 : view3.len);
22380 : }
22381 : }
22382 : }
22383 : }
22384 0 : if (resultobj)
22385 0 : memcpy(view3.buf, new_data, new_size);
22386 : }
22387 :
22388 :
22389 :
22390 : }
22391 :
22392 : /* Free the temporary wrapper, if any. */
22393 8 : if (wrapper3)
22394 0 : gpgme_data_release(wrapper3);
22395 8 : Py_XDECREF (bytesio3);
22396 8 : if (have_view3 && view3.buf)
22397 0 : PyBuffer_Release(&view3);
22398 : }
22399 : return resultobj;
22400 : fail:
22401 : {
22402 : /* See whether we need to update the Python buffer. */
22403 : if (resultobj && wrapper2 && view2.buf)
22404 : {
22405 : int dirty;
22406 : char *new_data = NULL;
22407 : size_t new_size;
22408 :
22409 :
22410 : new_data = wrapper2->data.mem.buffer;
22411 : new_size = wrapper2->data.mem.length;
22412 : dirty = new_data != NULL;
22413 :
22414 :
22415 :
22416 :
22417 :
22418 :
22419 :
22420 : if (dirty)
22421 : {
22422 : /* The buffer is dirty. */
22423 : if (view2.readonly)
22424 : {
22425 : Py_XDECREF(resultobj);
22426 : resultobj = NULL;
22427 : PyErr_SetString(PyExc_ValueError,
22428 : "cannot update read-only buffer");
22429 : }
22430 :
22431 : /* See if we need to truncate the buffer. */
22432 : if (resultobj && view2.len != new_size)
22433 : {
22434 : if (bytesio2 == NULL)
22435 : {
22436 : Py_XDECREF(resultobj);
22437 : resultobj = NULL;
22438 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22439 : }
22440 : else
22441 : {
22442 : PyObject *retval;
22443 : PyBuffer_Release(&view2);
22444 : assert(view2.obj == NULL);
22445 : retval = PyObject_CallMethod(bytesio2, "truncate",
22446 : "l", (long) new_size);
22447 : if (retval == NULL)
22448 : {
22449 : Py_XDECREF(resultobj);
22450 : resultobj = NULL;
22451 : }
22452 : else
22453 : {
22454 : Py_DECREF(retval);
22455 :
22456 : retval = PyObject_CallMethod(bytesio2,
22457 : "getbuffer", NULL);
22458 : if (retval == NULL
22459 : || PyObject_GetBuffer(retval, &view2,
22460 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22461 : {
22462 : Py_XDECREF(resultobj);
22463 : resultobj = NULL;
22464 : }
22465 :
22466 : Py_XDECREF(retval);
22467 :
22468 : if (resultobj && view2.len
22469 : != new_size)
22470 : {
22471 : Py_XDECREF(resultobj);
22472 : resultobj = NULL;
22473 : PyErr_Format(PyExc_ValueError,
22474 : "Expected buffer of length %zu, got %zi",
22475 : new_size,
22476 : view2.len);
22477 : }
22478 : }
22479 : }
22480 : }
22481 : if (resultobj)
22482 : memcpy(view2.buf, new_data, new_size);
22483 : }
22484 :
22485 :
22486 :
22487 : }
22488 :
22489 : /* Free the temporary wrapper, if any. */
22490 0 : if (wrapper2)
22491 0 : gpgme_data_release(wrapper2);
22492 0 : Py_XDECREF (bytesio2);
22493 : if (have_view2 && view2.buf)
22494 : PyBuffer_Release(&view2);
22495 : }
22496 : {
22497 : /* See whether we need to update the Python buffer. */
22498 : if (resultobj && wrapper3 && view3.buf)
22499 : {
22500 : int dirty;
22501 : char *new_data = NULL;
22502 : size_t new_size;
22503 :
22504 :
22505 : new_data = wrapper3->data.mem.buffer;
22506 : new_size = wrapper3->data.mem.length;
22507 : dirty = new_data != NULL;
22508 :
22509 :
22510 :
22511 :
22512 :
22513 :
22514 :
22515 : if (dirty)
22516 : {
22517 : /* The buffer is dirty. */
22518 : if (view3.readonly)
22519 : {
22520 : Py_XDECREF(resultobj);
22521 : resultobj = NULL;
22522 : PyErr_SetString(PyExc_ValueError,
22523 : "cannot update read-only buffer");
22524 : }
22525 :
22526 : /* See if we need to truncate the buffer. */
22527 : if (resultobj && view3.len != new_size)
22528 : {
22529 : if (bytesio3 == NULL)
22530 : {
22531 : Py_XDECREF(resultobj);
22532 : resultobj = NULL;
22533 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22534 : }
22535 : else
22536 : {
22537 : PyObject *retval;
22538 : PyBuffer_Release(&view3);
22539 : assert(view3.obj == NULL);
22540 : retval = PyObject_CallMethod(bytesio3, "truncate",
22541 : "l", (long) new_size);
22542 : if (retval == NULL)
22543 : {
22544 : Py_XDECREF(resultobj);
22545 : resultobj = NULL;
22546 : }
22547 : else
22548 : {
22549 : Py_DECREF(retval);
22550 :
22551 : retval = PyObject_CallMethod(bytesio3,
22552 : "getbuffer", NULL);
22553 : if (retval == NULL
22554 : || PyObject_GetBuffer(retval, &view3,
22555 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22556 : {
22557 : Py_XDECREF(resultobj);
22558 : resultobj = NULL;
22559 : }
22560 :
22561 : Py_XDECREF(retval);
22562 :
22563 : if (resultobj && view3.len
22564 : != new_size)
22565 : {
22566 : Py_XDECREF(resultobj);
22567 : resultobj = NULL;
22568 : PyErr_Format(PyExc_ValueError,
22569 : "Expected buffer of length %zu, got %zi",
22570 : new_size,
22571 : view3.len);
22572 : }
22573 : }
22574 : }
22575 : }
22576 : if (resultobj)
22577 : memcpy(view3.buf, new_data, new_size);
22578 : }
22579 :
22580 :
22581 :
22582 : }
22583 :
22584 : /* Free the temporary wrapper, if any. */
22585 0 : if (wrapper3)
22586 0 : gpgme_data_release(wrapper3);
22587 0 : Py_XDECREF (bytesio3);
22588 : if (have_view3 && view3.buf)
22589 : PyBuffer_Release(&view3);
22590 : }
22591 : return NULL;
22592 : }
22593 :
22594 :
22595 0 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_ext_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22596 0 : PyObject *resultobj = 0;
22597 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
22598 : gpgme_decrypt_flags_t arg2 ;
22599 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
22600 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
22601 0 : void *argp1 = 0 ;
22602 0 : int res1 = 0 ;
22603 : int val2 ;
22604 0 : int ecode2 = 0 ;
22605 0 : gpgme_data_t wrapper3 = NULL ;
22606 0 : PyObject *bytesio3 = NULL ;
22607 : Py_buffer view3 ;
22608 0 : int have_view3 = 0 ;
22609 0 : gpgme_data_t wrapper4 = NULL ;
22610 0 : PyObject *bytesio4 = NULL ;
22611 : Py_buffer view4 ;
22612 0 : int have_view4 = 0 ;
22613 0 : PyObject * obj0 = 0 ;
22614 0 : PyObject * obj1 = 0 ;
22615 0 : PyObject * obj2 = 0 ;
22616 0 : PyObject * obj3 = 0 ;
22617 : gpgme_error_t result;
22618 :
22619 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_decrypt_ext_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22620 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
22621 0 : if (!SWIG_IsOK(res1)) {
22622 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
22623 : }
22624 0 : arg1 = (gpgme_ctx_t)(argp1);
22625 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22626 0 : if (!SWIG_IsOK(ecode2)) {
22627 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_op_decrypt_ext_start" "', argument " "2"" of type '" "gpgme_decrypt_flags_t""'");
22628 : }
22629 0 : arg2 = (gpgme_decrypt_flags_t)(val2);
22630 : {
22631 : /* If we create a temporary wrapper3 object, we will store it in
22632 : wrapperN, where N is 3. Here in this fragment, SWIG will
22633 : automatically append 3. */
22634 0 : memset(&view3, 0, sizeof view3);
22635 0 : if (obj2 == Py_None)
22636 0 : arg3 = NULL;
22637 : else {
22638 : PyObject *pypointer;
22639 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
22640 : &bytesio3, &view3);
22641 0 : if (pypointer == NULL)
22642 : return NULL;
22643 0 : have_view3 = !! view3.obj;
22644 :
22645 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
22646 :
22647 : /* Following code is from swig's python.swg. */
22648 :
22649 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
22650 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22651 0 : Py_DECREF(pypointer);
22652 : return NULL;
22653 : }
22654 0 : Py_DECREF(pypointer);
22655 : }
22656 : }
22657 : {
22658 : /* If we create a temporary wrapper4 object, we will store it in
22659 : wrapperN, where N is 4. Here in this fragment, SWIG will
22660 : automatically append 4. */
22661 0 : memset(&view4, 0, sizeof view4);
22662 0 : if (obj3 == Py_None)
22663 0 : arg4 = NULL;
22664 : else {
22665 : PyObject *pypointer;
22666 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
22667 : &bytesio4, &view4);
22668 0 : if (pypointer == NULL)
22669 : return NULL;
22670 0 : have_view4 = !! view4.obj;
22671 :
22672 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
22673 :
22674 : /* Following code is from swig's python.swg. */
22675 :
22676 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
22677 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22678 0 : Py_DECREF(pypointer);
22679 : return NULL;
22680 : }
22681 0 : Py_DECREF(pypointer);
22682 : }
22683 : }
22684 : {
22685 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22686 0 : result = gpgme_op_decrypt_ext_start(arg1,arg2,arg3,arg4);
22687 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22688 : }
22689 : {
22690 0 : resultobj = PyLong_FromLong(result);
22691 : }
22692 : {
22693 : /* See whether we need to update the Python buffer. */
22694 0 : if (resultobj && wrapper3 && view3.buf)
22695 : {
22696 : int dirty;
22697 0 : char *new_data = NULL;
22698 : size_t new_size;
22699 :
22700 :
22701 0 : new_data = wrapper3->data.mem.buffer;
22702 0 : new_size = wrapper3->data.mem.length;
22703 0 : dirty = new_data != NULL;
22704 :
22705 :
22706 :
22707 :
22708 :
22709 :
22710 :
22711 0 : if (dirty)
22712 : {
22713 : /* The buffer is dirty. */
22714 0 : if (view3.readonly)
22715 : {
22716 0 : Py_XDECREF(resultobj);
22717 0 : resultobj = NULL;
22718 0 : PyErr_SetString(PyExc_ValueError,
22719 : "cannot update read-only buffer");
22720 : }
22721 :
22722 : /* See if we need to truncate the buffer. */
22723 0 : if (resultobj && view3.len != new_size)
22724 : {
22725 0 : if (bytesio3 == NULL)
22726 : {
22727 0 : Py_XDECREF(resultobj);
22728 0 : resultobj = NULL;
22729 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22730 : }
22731 : else
22732 : {
22733 : PyObject *retval;
22734 0 : PyBuffer_Release(&view3);
22735 : assert(view3.obj == NULL);
22736 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
22737 : "l", (long) new_size);
22738 0 : if (retval == NULL)
22739 : {
22740 0 : Py_XDECREF(resultobj);
22741 : resultobj = NULL;
22742 : }
22743 : else
22744 : {
22745 0 : Py_DECREF(retval);
22746 :
22747 0 : retval = PyObject_CallMethod(bytesio3,
22748 : "getbuffer", NULL);
22749 0 : if (retval == NULL
22750 0 : || PyObject_GetBuffer(retval, &view3,
22751 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22752 : {
22753 0 : Py_XDECREF(resultobj);
22754 : resultobj = NULL;
22755 : }
22756 :
22757 0 : Py_XDECREF(retval);
22758 :
22759 0 : if (resultobj && view3.len
22760 : != new_size)
22761 : {
22762 0 : Py_XDECREF(resultobj);
22763 0 : resultobj = NULL;
22764 0 : PyErr_Format(PyExc_ValueError,
22765 : "Expected buffer of length %zu, got %zi",
22766 : new_size,
22767 : view3.len);
22768 : }
22769 : }
22770 : }
22771 : }
22772 0 : if (resultobj)
22773 0 : memcpy(view3.buf, new_data, new_size);
22774 : }
22775 :
22776 :
22777 :
22778 : }
22779 :
22780 : /* Free the temporary wrapper, if any. */
22781 0 : if (wrapper3)
22782 0 : gpgme_data_release(wrapper3);
22783 0 : Py_XDECREF (bytesio3);
22784 0 : if (have_view3 && view3.buf)
22785 0 : PyBuffer_Release(&view3);
22786 : }
22787 : {
22788 : /* See whether we need to update the Python buffer. */
22789 0 : if (resultobj && wrapper4 && view4.buf)
22790 : {
22791 : int dirty;
22792 0 : char *new_data = NULL;
22793 : size_t new_size;
22794 :
22795 :
22796 0 : new_data = wrapper4->data.mem.buffer;
22797 0 : new_size = wrapper4->data.mem.length;
22798 0 : dirty = new_data != NULL;
22799 :
22800 :
22801 :
22802 :
22803 :
22804 :
22805 :
22806 0 : if (dirty)
22807 : {
22808 : /* The buffer is dirty. */
22809 0 : if (view4.readonly)
22810 : {
22811 0 : Py_XDECREF(resultobj);
22812 0 : resultobj = NULL;
22813 0 : PyErr_SetString(PyExc_ValueError,
22814 : "cannot update read-only buffer");
22815 : }
22816 :
22817 : /* See if we need to truncate the buffer. */
22818 0 : if (resultobj && view4.len != new_size)
22819 : {
22820 0 : if (bytesio4 == NULL)
22821 : {
22822 0 : Py_XDECREF(resultobj);
22823 0 : resultobj = NULL;
22824 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22825 : }
22826 : else
22827 : {
22828 : PyObject *retval;
22829 0 : PyBuffer_Release(&view4);
22830 : assert(view4.obj == NULL);
22831 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
22832 : "l", (long) new_size);
22833 0 : if (retval == NULL)
22834 : {
22835 0 : Py_XDECREF(resultobj);
22836 : resultobj = NULL;
22837 : }
22838 : else
22839 : {
22840 0 : Py_DECREF(retval);
22841 :
22842 0 : retval = PyObject_CallMethod(bytesio4,
22843 : "getbuffer", NULL);
22844 0 : if (retval == NULL
22845 0 : || PyObject_GetBuffer(retval, &view4,
22846 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22847 : {
22848 0 : Py_XDECREF(resultobj);
22849 : resultobj = NULL;
22850 : }
22851 :
22852 0 : Py_XDECREF(retval);
22853 :
22854 0 : if (resultobj && view4.len
22855 : != new_size)
22856 : {
22857 0 : Py_XDECREF(resultobj);
22858 0 : resultobj = NULL;
22859 0 : PyErr_Format(PyExc_ValueError,
22860 : "Expected buffer of length %zu, got %zi",
22861 : new_size,
22862 : view4.len);
22863 : }
22864 : }
22865 : }
22866 : }
22867 0 : if (resultobj)
22868 0 : memcpy(view4.buf, new_data, new_size);
22869 : }
22870 :
22871 :
22872 :
22873 : }
22874 :
22875 : /* Free the temporary wrapper, if any. */
22876 0 : if (wrapper4)
22877 0 : gpgme_data_release(wrapper4);
22878 0 : Py_XDECREF (bytesio4);
22879 0 : if (have_view4 && view4.buf)
22880 0 : PyBuffer_Release(&view4);
22881 : }
22882 : return resultobj;
22883 : fail:
22884 : {
22885 : /* See whether we need to update the Python buffer. */
22886 : if (resultobj && wrapper3 && view3.buf)
22887 : {
22888 : int dirty;
22889 : char *new_data = NULL;
22890 : size_t new_size;
22891 :
22892 :
22893 : new_data = wrapper3->data.mem.buffer;
22894 : new_size = wrapper3->data.mem.length;
22895 : dirty = new_data != NULL;
22896 :
22897 :
22898 :
22899 :
22900 :
22901 :
22902 :
22903 : if (dirty)
22904 : {
22905 : /* The buffer is dirty. */
22906 : if (view3.readonly)
22907 : {
22908 : Py_XDECREF(resultobj);
22909 : resultobj = NULL;
22910 : PyErr_SetString(PyExc_ValueError,
22911 : "cannot update read-only buffer");
22912 : }
22913 :
22914 : /* See if we need to truncate the buffer. */
22915 : if (resultobj && view3.len != new_size)
22916 : {
22917 : if (bytesio3 == NULL)
22918 : {
22919 : Py_XDECREF(resultobj);
22920 : resultobj = NULL;
22921 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22922 : }
22923 : else
22924 : {
22925 : PyObject *retval;
22926 : PyBuffer_Release(&view3);
22927 : assert(view3.obj == NULL);
22928 : retval = PyObject_CallMethod(bytesio3, "truncate",
22929 : "l", (long) new_size);
22930 : if (retval == NULL)
22931 : {
22932 : Py_XDECREF(resultobj);
22933 : resultobj = NULL;
22934 : }
22935 : else
22936 : {
22937 : Py_DECREF(retval);
22938 :
22939 : retval = PyObject_CallMethod(bytesio3,
22940 : "getbuffer", NULL);
22941 : if (retval == NULL
22942 : || PyObject_GetBuffer(retval, &view3,
22943 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22944 : {
22945 : Py_XDECREF(resultobj);
22946 : resultobj = NULL;
22947 : }
22948 :
22949 : Py_XDECREF(retval);
22950 :
22951 : if (resultobj && view3.len
22952 : != new_size)
22953 : {
22954 : Py_XDECREF(resultobj);
22955 : resultobj = NULL;
22956 : PyErr_Format(PyExc_ValueError,
22957 : "Expected buffer of length %zu, got %zi",
22958 : new_size,
22959 : view3.len);
22960 : }
22961 : }
22962 : }
22963 : }
22964 : if (resultobj)
22965 : memcpy(view3.buf, new_data, new_size);
22966 : }
22967 :
22968 :
22969 :
22970 : }
22971 :
22972 : /* Free the temporary wrapper, if any. */
22973 0 : if (wrapper3)
22974 0 : gpgme_data_release(wrapper3);
22975 0 : Py_XDECREF (bytesio3);
22976 : if (have_view3 && view3.buf)
22977 : PyBuffer_Release(&view3);
22978 : }
22979 : {
22980 : /* See whether we need to update the Python buffer. */
22981 : if (resultobj && wrapper4 && view4.buf)
22982 : {
22983 : int dirty;
22984 : char *new_data = NULL;
22985 : size_t new_size;
22986 :
22987 :
22988 : new_data = wrapper4->data.mem.buffer;
22989 : new_size = wrapper4->data.mem.length;
22990 : dirty = new_data != NULL;
22991 :
22992 :
22993 :
22994 :
22995 :
22996 :
22997 :
22998 : if (dirty)
22999 : {
23000 : /* The buffer is dirty. */
23001 : if (view4.readonly)
23002 : {
23003 : Py_XDECREF(resultobj);
23004 : resultobj = NULL;
23005 : PyErr_SetString(PyExc_ValueError,
23006 : "cannot update read-only buffer");
23007 : }
23008 :
23009 : /* See if we need to truncate the buffer. */
23010 : if (resultobj && view4.len != new_size)
23011 : {
23012 : if (bytesio4 == NULL)
23013 : {
23014 : Py_XDECREF(resultobj);
23015 : resultobj = NULL;
23016 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23017 : }
23018 : else
23019 : {
23020 : PyObject *retval;
23021 : PyBuffer_Release(&view4);
23022 : assert(view4.obj == NULL);
23023 : retval = PyObject_CallMethod(bytesio4, "truncate",
23024 : "l", (long) new_size);
23025 : if (retval == NULL)
23026 : {
23027 : Py_XDECREF(resultobj);
23028 : resultobj = NULL;
23029 : }
23030 : else
23031 : {
23032 : Py_DECREF(retval);
23033 :
23034 : retval = PyObject_CallMethod(bytesio4,
23035 : "getbuffer", NULL);
23036 : if (retval == NULL
23037 : || PyObject_GetBuffer(retval, &view4,
23038 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23039 : {
23040 : Py_XDECREF(resultobj);
23041 : resultobj = NULL;
23042 : }
23043 :
23044 : Py_XDECREF(retval);
23045 :
23046 : if (resultobj && view4.len
23047 : != new_size)
23048 : {
23049 : Py_XDECREF(resultobj);
23050 : resultobj = NULL;
23051 : PyErr_Format(PyExc_ValueError,
23052 : "Expected buffer of length %zu, got %zi",
23053 : new_size,
23054 : view4.len);
23055 : }
23056 : }
23057 : }
23058 : }
23059 : if (resultobj)
23060 : memcpy(view4.buf, new_data, new_size);
23061 : }
23062 :
23063 :
23064 :
23065 : }
23066 :
23067 : /* Free the temporary wrapper, if any. */
23068 0 : if (wrapper4)
23069 0 : gpgme_data_release(wrapper4);
23070 0 : Py_XDECREF (bytesio4);
23071 : if (have_view4 && view4.buf)
23072 : PyBuffer_Release(&view4);
23073 : }
23074 : return NULL;
23075 : }
23076 :
23077 :
23078 0 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23079 0 : PyObject *resultobj = 0;
23080 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
23081 : gpgme_decrypt_flags_t arg2 ;
23082 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
23083 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
23084 0 : void *argp1 = 0 ;
23085 0 : int res1 = 0 ;
23086 : int val2 ;
23087 0 : int ecode2 = 0 ;
23088 0 : gpgme_data_t wrapper3 = NULL ;
23089 0 : PyObject *bytesio3 = NULL ;
23090 : Py_buffer view3 ;
23091 0 : int have_view3 = 0 ;
23092 0 : gpgme_data_t wrapper4 = NULL ;
23093 0 : PyObject *bytesio4 = NULL ;
23094 : Py_buffer view4 ;
23095 0 : int have_view4 = 0 ;
23096 0 : PyObject * obj0 = 0 ;
23097 0 : PyObject * obj1 = 0 ;
23098 0 : PyObject * obj2 = 0 ;
23099 0 : PyObject * obj3 = 0 ;
23100 : gpgme_error_t result;
23101 :
23102 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_decrypt_ext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23103 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
23104 0 : if (!SWIG_IsOK(res1)) {
23105 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
23106 : }
23107 0 : arg1 = (gpgme_ctx_t)(argp1);
23108 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23109 0 : if (!SWIG_IsOK(ecode2)) {
23110 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_op_decrypt_ext" "', argument " "2"" of type '" "gpgme_decrypt_flags_t""'");
23111 : }
23112 0 : arg2 = (gpgme_decrypt_flags_t)(val2);
23113 : {
23114 : /* If we create a temporary wrapper3 object, we will store it in
23115 : wrapperN, where N is 3. Here in this fragment, SWIG will
23116 : automatically append 3. */
23117 0 : memset(&view3, 0, sizeof view3);
23118 0 : if (obj2 == Py_None)
23119 0 : arg3 = NULL;
23120 : else {
23121 : PyObject *pypointer;
23122 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
23123 : &bytesio3, &view3);
23124 0 : if (pypointer == NULL)
23125 : return NULL;
23126 0 : have_view3 = !! view3.obj;
23127 :
23128 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
23129 :
23130 : /* Following code is from swig's python.swg. */
23131 :
23132 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
23133 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23134 0 : Py_DECREF(pypointer);
23135 : return NULL;
23136 : }
23137 0 : Py_DECREF(pypointer);
23138 : }
23139 : }
23140 : {
23141 : /* If we create a temporary wrapper4 object, we will store it in
23142 : wrapperN, where N is 4. Here in this fragment, SWIG will
23143 : automatically append 4. */
23144 0 : memset(&view4, 0, sizeof view4);
23145 0 : if (obj3 == Py_None)
23146 0 : arg4 = NULL;
23147 : else {
23148 : PyObject *pypointer;
23149 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
23150 : &bytesio4, &view4);
23151 0 : if (pypointer == NULL)
23152 : return NULL;
23153 0 : have_view4 = !! view4.obj;
23154 :
23155 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
23156 :
23157 : /* Following code is from swig's python.swg. */
23158 :
23159 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
23160 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23161 0 : Py_DECREF(pypointer);
23162 : return NULL;
23163 : }
23164 0 : Py_DECREF(pypointer);
23165 : }
23166 : }
23167 : {
23168 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23169 0 : result = gpgme_op_decrypt_ext(arg1,arg2,arg3,arg4);
23170 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23171 : }
23172 : {
23173 0 : resultobj = PyLong_FromLong(result);
23174 : }
23175 : {
23176 : /* See whether we need to update the Python buffer. */
23177 0 : if (resultobj && wrapper3 && view3.buf)
23178 : {
23179 : int dirty;
23180 0 : char *new_data = NULL;
23181 : size_t new_size;
23182 :
23183 :
23184 0 : new_data = wrapper3->data.mem.buffer;
23185 0 : new_size = wrapper3->data.mem.length;
23186 0 : dirty = new_data != NULL;
23187 :
23188 :
23189 :
23190 :
23191 :
23192 :
23193 :
23194 0 : if (dirty)
23195 : {
23196 : /* The buffer is dirty. */
23197 0 : if (view3.readonly)
23198 : {
23199 0 : Py_XDECREF(resultobj);
23200 0 : resultobj = NULL;
23201 0 : PyErr_SetString(PyExc_ValueError,
23202 : "cannot update read-only buffer");
23203 : }
23204 :
23205 : /* See if we need to truncate the buffer. */
23206 0 : if (resultobj && view3.len != new_size)
23207 : {
23208 0 : if (bytesio3 == NULL)
23209 : {
23210 0 : Py_XDECREF(resultobj);
23211 0 : resultobj = NULL;
23212 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23213 : }
23214 : else
23215 : {
23216 : PyObject *retval;
23217 0 : PyBuffer_Release(&view3);
23218 : assert(view3.obj == NULL);
23219 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
23220 : "l", (long) new_size);
23221 0 : if (retval == NULL)
23222 : {
23223 0 : Py_XDECREF(resultobj);
23224 : resultobj = NULL;
23225 : }
23226 : else
23227 : {
23228 0 : Py_DECREF(retval);
23229 :
23230 0 : retval = PyObject_CallMethod(bytesio3,
23231 : "getbuffer", NULL);
23232 0 : if (retval == NULL
23233 0 : || PyObject_GetBuffer(retval, &view3,
23234 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23235 : {
23236 0 : Py_XDECREF(resultobj);
23237 : resultobj = NULL;
23238 : }
23239 :
23240 0 : Py_XDECREF(retval);
23241 :
23242 0 : if (resultobj && view3.len
23243 : != new_size)
23244 : {
23245 0 : Py_XDECREF(resultobj);
23246 0 : resultobj = NULL;
23247 0 : PyErr_Format(PyExc_ValueError,
23248 : "Expected buffer of length %zu, got %zi",
23249 : new_size,
23250 : view3.len);
23251 : }
23252 : }
23253 : }
23254 : }
23255 0 : if (resultobj)
23256 0 : memcpy(view3.buf, new_data, new_size);
23257 : }
23258 :
23259 :
23260 :
23261 : }
23262 :
23263 : /* Free the temporary wrapper, if any. */
23264 0 : if (wrapper3)
23265 0 : gpgme_data_release(wrapper3);
23266 0 : Py_XDECREF (bytesio3);
23267 0 : if (have_view3 && view3.buf)
23268 0 : PyBuffer_Release(&view3);
23269 : }
23270 : {
23271 : /* See whether we need to update the Python buffer. */
23272 0 : if (resultobj && wrapper4 && view4.buf)
23273 : {
23274 : int dirty;
23275 0 : char *new_data = NULL;
23276 : size_t new_size;
23277 :
23278 :
23279 0 : new_data = wrapper4->data.mem.buffer;
23280 0 : new_size = wrapper4->data.mem.length;
23281 0 : dirty = new_data != NULL;
23282 :
23283 :
23284 :
23285 :
23286 :
23287 :
23288 :
23289 0 : if (dirty)
23290 : {
23291 : /* The buffer is dirty. */
23292 0 : if (view4.readonly)
23293 : {
23294 0 : Py_XDECREF(resultobj);
23295 0 : resultobj = NULL;
23296 0 : PyErr_SetString(PyExc_ValueError,
23297 : "cannot update read-only buffer");
23298 : }
23299 :
23300 : /* See if we need to truncate the buffer. */
23301 0 : if (resultobj && view4.len != new_size)
23302 : {
23303 0 : if (bytesio4 == NULL)
23304 : {
23305 0 : Py_XDECREF(resultobj);
23306 0 : resultobj = NULL;
23307 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23308 : }
23309 : else
23310 : {
23311 : PyObject *retval;
23312 0 : PyBuffer_Release(&view4);
23313 : assert(view4.obj == NULL);
23314 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
23315 : "l", (long) new_size);
23316 0 : if (retval == NULL)
23317 : {
23318 0 : Py_XDECREF(resultobj);
23319 : resultobj = NULL;
23320 : }
23321 : else
23322 : {
23323 0 : Py_DECREF(retval);
23324 :
23325 0 : retval = PyObject_CallMethod(bytesio4,
23326 : "getbuffer", NULL);
23327 0 : if (retval == NULL
23328 0 : || PyObject_GetBuffer(retval, &view4,
23329 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23330 : {
23331 0 : Py_XDECREF(resultobj);
23332 : resultobj = NULL;
23333 : }
23334 :
23335 0 : Py_XDECREF(retval);
23336 :
23337 0 : if (resultobj && view4.len
23338 : != new_size)
23339 : {
23340 0 : Py_XDECREF(resultobj);
23341 0 : resultobj = NULL;
23342 0 : PyErr_Format(PyExc_ValueError,
23343 : "Expected buffer of length %zu, got %zi",
23344 : new_size,
23345 : view4.len);
23346 : }
23347 : }
23348 : }
23349 : }
23350 0 : if (resultobj)
23351 0 : memcpy(view4.buf, new_data, new_size);
23352 : }
23353 :
23354 :
23355 :
23356 : }
23357 :
23358 : /* Free the temporary wrapper, if any. */
23359 0 : if (wrapper4)
23360 0 : gpgme_data_release(wrapper4);
23361 0 : Py_XDECREF (bytesio4);
23362 0 : if (have_view4 && view4.buf)
23363 0 : PyBuffer_Release(&view4);
23364 : }
23365 : return resultobj;
23366 : fail:
23367 : {
23368 : /* See whether we need to update the Python buffer. */
23369 : if (resultobj && wrapper3 && view3.buf)
23370 : {
23371 : int dirty;
23372 : char *new_data = NULL;
23373 : size_t new_size;
23374 :
23375 :
23376 : new_data = wrapper3->data.mem.buffer;
23377 : new_size = wrapper3->data.mem.length;
23378 : dirty = new_data != NULL;
23379 :
23380 :
23381 :
23382 :
23383 :
23384 :
23385 :
23386 : if (dirty)
23387 : {
23388 : /* The buffer is dirty. */
23389 : if (view3.readonly)
23390 : {
23391 : Py_XDECREF(resultobj);
23392 : resultobj = NULL;
23393 : PyErr_SetString(PyExc_ValueError,
23394 : "cannot update read-only buffer");
23395 : }
23396 :
23397 : /* See if we need to truncate the buffer. */
23398 : if (resultobj && view3.len != new_size)
23399 : {
23400 : if (bytesio3 == NULL)
23401 : {
23402 : Py_XDECREF(resultobj);
23403 : resultobj = NULL;
23404 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23405 : }
23406 : else
23407 : {
23408 : PyObject *retval;
23409 : PyBuffer_Release(&view3);
23410 : assert(view3.obj == NULL);
23411 : retval = PyObject_CallMethod(bytesio3, "truncate",
23412 : "l", (long) new_size);
23413 : if (retval == NULL)
23414 : {
23415 : Py_XDECREF(resultobj);
23416 : resultobj = NULL;
23417 : }
23418 : else
23419 : {
23420 : Py_DECREF(retval);
23421 :
23422 : retval = PyObject_CallMethod(bytesio3,
23423 : "getbuffer", NULL);
23424 : if (retval == NULL
23425 : || PyObject_GetBuffer(retval, &view3,
23426 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23427 : {
23428 : Py_XDECREF(resultobj);
23429 : resultobj = NULL;
23430 : }
23431 :
23432 : Py_XDECREF(retval);
23433 :
23434 : if (resultobj && view3.len
23435 : != new_size)
23436 : {
23437 : Py_XDECREF(resultobj);
23438 : resultobj = NULL;
23439 : PyErr_Format(PyExc_ValueError,
23440 : "Expected buffer of length %zu, got %zi",
23441 : new_size,
23442 : view3.len);
23443 : }
23444 : }
23445 : }
23446 : }
23447 : if (resultobj)
23448 : memcpy(view3.buf, new_data, new_size);
23449 : }
23450 :
23451 :
23452 :
23453 : }
23454 :
23455 : /* Free the temporary wrapper, if any. */
23456 0 : if (wrapper3)
23457 0 : gpgme_data_release(wrapper3);
23458 0 : Py_XDECREF (bytesio3);
23459 : if (have_view3 && view3.buf)
23460 : PyBuffer_Release(&view3);
23461 : }
23462 : {
23463 : /* See whether we need to update the Python buffer. */
23464 : if (resultobj && wrapper4 && view4.buf)
23465 : {
23466 : int dirty;
23467 : char *new_data = NULL;
23468 : size_t new_size;
23469 :
23470 :
23471 : new_data = wrapper4->data.mem.buffer;
23472 : new_size = wrapper4->data.mem.length;
23473 : dirty = new_data != NULL;
23474 :
23475 :
23476 :
23477 :
23478 :
23479 :
23480 :
23481 : if (dirty)
23482 : {
23483 : /* The buffer is dirty. */
23484 : if (view4.readonly)
23485 : {
23486 : Py_XDECREF(resultobj);
23487 : resultobj = NULL;
23488 : PyErr_SetString(PyExc_ValueError,
23489 : "cannot update read-only buffer");
23490 : }
23491 :
23492 : /* See if we need to truncate the buffer. */
23493 : if (resultobj && view4.len != new_size)
23494 : {
23495 : if (bytesio4 == NULL)
23496 : {
23497 : Py_XDECREF(resultobj);
23498 : resultobj = NULL;
23499 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23500 : }
23501 : else
23502 : {
23503 : PyObject *retval;
23504 : PyBuffer_Release(&view4);
23505 : assert(view4.obj == NULL);
23506 : retval = PyObject_CallMethod(bytesio4, "truncate",
23507 : "l", (long) new_size);
23508 : if (retval == NULL)
23509 : {
23510 : Py_XDECREF(resultobj);
23511 : resultobj = NULL;
23512 : }
23513 : else
23514 : {
23515 : Py_DECREF(retval);
23516 :
23517 : retval = PyObject_CallMethod(bytesio4,
23518 : "getbuffer", NULL);
23519 : if (retval == NULL
23520 : || PyObject_GetBuffer(retval, &view4,
23521 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23522 : {
23523 : Py_XDECREF(resultobj);
23524 : resultobj = NULL;
23525 : }
23526 :
23527 : Py_XDECREF(retval);
23528 :
23529 : if (resultobj && view4.len
23530 : != new_size)
23531 : {
23532 : Py_XDECREF(resultobj);
23533 : resultobj = NULL;
23534 : PyErr_Format(PyExc_ValueError,
23535 : "Expected buffer of length %zu, got %zi",
23536 : new_size,
23537 : view4.len);
23538 : }
23539 : }
23540 : }
23541 : }
23542 : if (resultobj)
23543 : memcpy(view4.buf, new_data, new_size);
23544 : }
23545 :
23546 :
23547 :
23548 : }
23549 :
23550 : /* Free the temporary wrapper, if any. */
23551 0 : if (wrapper4)
23552 0 : gpgme_data_release(wrapper4);
23553 0 : Py_XDECREF (bytesio4);
23554 : if (have_view4 && view4.buf)
23555 : PyBuffer_Release(&view4);
23556 : }
23557 : return NULL;
23558 : }
23559 :
23560 :
23561 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23562 0 : PyObject *resultobj = 0;
23563 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23564 : gpgme_sig_mode_t arg2 ;
23565 0 : void *argp1 = 0 ;
23566 0 : int res1 = 0 ;
23567 : int val2 ;
23568 0 : int ecode2 = 0 ;
23569 0 : PyObject * obj0 = 0 ;
23570 0 : PyObject * obj1 = 0 ;
23571 :
23572 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_type_set",&obj0,&obj1)) SWIG_fail;
23573 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23574 0 : if (!SWIG_IsOK(res1)) {
23575 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_type_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23576 : }
23577 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23578 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23579 0 : if (!SWIG_IsOK(ecode2)) {
23580 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_type_set" "', argument " "2"" of type '" "gpgme_sig_mode_t""'");
23581 : }
23582 0 : arg2 = (gpgme_sig_mode_t)(val2);
23583 : {
23584 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23585 0 : if (arg1) (arg1)->type = arg2;
23586 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23587 : }
23588 0 : resultobj = SWIG_Py_Void();
23589 0 : return resultobj;
23590 : fail:
23591 : return NULL;
23592 : }
23593 :
23594 :
23595 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23596 25 : PyObject *resultobj = 0;
23597 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23598 25 : void *argp1 = 0 ;
23599 25 : int res1 = 0 ;
23600 25 : PyObject * obj0 = 0 ;
23601 : gpgme_sig_mode_t result;
23602 :
23603 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_type_get",&obj0)) SWIG_fail;
23604 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23605 25 : if (!SWIG_IsOK(res1)) {
23606 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_type_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23607 : }
23608 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
23609 : {
23610 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23611 25 : result = (gpgme_sig_mode_t) ((arg1)->type);
23612 25 : SWIG_PYTHON_THREAD_END_ALLOW;
23613 : }
23614 50 : resultobj = SWIG_From_int((int)(result));
23615 25 : return resultobj;
23616 : fail:
23617 : return NULL;
23618 : }
23619 :
23620 :
23621 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 0 : PyObject *resultobj = 0;
23623 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23624 : gpgme_pubkey_algo_t arg2 ;
23625 0 : void *argp1 = 0 ;
23626 0 : int res1 = 0 ;
23627 : int val2 ;
23628 0 : int ecode2 = 0 ;
23629 0 : PyObject * obj0 = 0 ;
23630 0 : PyObject * obj1 = 0 ;
23631 :
23632 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
23633 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23634 0 : if (!SWIG_IsOK(res1)) {
23635 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23636 : }
23637 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23638 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23639 0 : if (!SWIG_IsOK(ecode2)) {
23640 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
23641 : }
23642 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
23643 : {
23644 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23645 0 : if (arg1) (arg1)->pubkey_algo = arg2;
23646 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23647 : }
23648 0 : resultobj = SWIG_Py_Void();
23649 0 : return resultobj;
23650 : fail:
23651 : return NULL;
23652 : }
23653 :
23654 :
23655 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23656 25 : PyObject *resultobj = 0;
23657 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23658 25 : void *argp1 = 0 ;
23659 25 : int res1 = 0 ;
23660 25 : PyObject * obj0 = 0 ;
23661 : gpgme_pubkey_algo_t result;
23662 :
23663 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_pubkey_algo_get",&obj0)) SWIG_fail;
23664 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23665 25 : if (!SWIG_IsOK(res1)) {
23666 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23667 : }
23668 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
23669 : {
23670 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23671 25 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
23672 25 : SWIG_PYTHON_THREAD_END_ALLOW;
23673 : }
23674 50 : resultobj = SWIG_From_int((int)(result));
23675 25 : return resultobj;
23676 : fail:
23677 : return NULL;
23678 : }
23679 :
23680 :
23681 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_hash_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23682 0 : PyObject *resultobj = 0;
23683 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23684 : gpgme_hash_algo_t arg2 ;
23685 0 : void *argp1 = 0 ;
23686 0 : int res1 = 0 ;
23687 : int val2 ;
23688 0 : int ecode2 = 0 ;
23689 0 : PyObject * obj0 = 0 ;
23690 0 : PyObject * obj1 = 0 ;
23691 :
23692 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_hash_algo_set",&obj0,&obj1)) SWIG_fail;
23693 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23694 0 : if (!SWIG_IsOK(res1)) {
23695 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_hash_algo_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23696 : }
23697 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23698 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23699 0 : if (!SWIG_IsOK(ecode2)) {
23700 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_hash_algo_set" "', argument " "2"" of type '" "gpgme_hash_algo_t""'");
23701 : }
23702 0 : arg2 = (gpgme_hash_algo_t)(val2);
23703 : {
23704 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23705 0 : if (arg1) (arg1)->hash_algo = arg2;
23706 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23707 : }
23708 0 : resultobj = SWIG_Py_Void();
23709 0 : return resultobj;
23710 : fail:
23711 : return NULL;
23712 : }
23713 :
23714 :
23715 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_hash_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23716 25 : PyObject *resultobj = 0;
23717 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23718 25 : void *argp1 = 0 ;
23719 25 : int res1 = 0 ;
23720 25 : PyObject * obj0 = 0 ;
23721 : gpgme_hash_algo_t result;
23722 :
23723 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_hash_algo_get",&obj0)) SWIG_fail;
23724 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23725 25 : if (!SWIG_IsOK(res1)) {
23726 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_hash_algo_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23727 : }
23728 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
23729 : {
23730 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23731 25 : result = (gpgme_hash_algo_t) ((arg1)->hash_algo);
23732 25 : SWIG_PYTHON_THREAD_END_ALLOW;
23733 : }
23734 50 : resultobj = SWIG_From_int((int)(result));
23735 25 : return resultobj;
23736 : fail:
23737 : return NULL;
23738 : }
23739 :
23740 :
23741 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature__obsolete_class_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 0 : PyObject *resultobj = 0;
23743 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23744 : unsigned long arg2 ;
23745 0 : void *argp1 = 0 ;
23746 0 : int res1 = 0 ;
23747 : unsigned long val2 ;
23748 0 : int ecode2 = 0 ;
23749 0 : PyObject * obj0 = 0 ;
23750 0 : PyObject * obj1 = 0 ;
23751 :
23752 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature__obsolete_class_set",&obj0,&obj1)) SWIG_fail;
23753 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23754 0 : if (!SWIG_IsOK(res1)) {
23755 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature__obsolete_class_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23756 : }
23757 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23758 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
23759 0 : if (!SWIG_IsOK(ecode2)) {
23760 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature__obsolete_class_set" "', argument " "2"" of type '" "unsigned long""'");
23761 : }
23762 0 : arg2 = (unsigned long)(val2);
23763 : {
23764 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23765 0 : if (arg1) (arg1)->_obsolete_class = arg2;
23766 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23767 : }
23768 0 : resultobj = SWIG_Py_Void();
23769 0 : return resultobj;
23770 : fail:
23771 : return NULL;
23772 : }
23773 :
23774 :
23775 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature__obsolete_class_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23776 0 : PyObject *resultobj = 0;
23777 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23778 0 : void *argp1 = 0 ;
23779 0 : int res1 = 0 ;
23780 0 : PyObject * obj0 = 0 ;
23781 : unsigned long result;
23782 :
23783 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature__obsolete_class_get",&obj0)) SWIG_fail;
23784 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23785 0 : if (!SWIG_IsOK(res1)) {
23786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature__obsolete_class_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23787 : }
23788 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23789 : {
23790 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23791 0 : result = (unsigned long) ((arg1)->_obsolete_class);
23792 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23793 : }
23794 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
23795 0 : return resultobj;
23796 : fail:
23797 : return NULL;
23798 : }
23799 :
23800 :
23801 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23802 0 : PyObject *resultobj = 0;
23803 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23804 : long arg2 ;
23805 0 : void *argp1 = 0 ;
23806 0 : int res1 = 0 ;
23807 : long val2 ;
23808 0 : int ecode2 = 0 ;
23809 0 : PyObject * obj0 = 0 ;
23810 0 : PyObject * obj1 = 0 ;
23811 :
23812 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_timestamp_set",&obj0,&obj1)) SWIG_fail;
23813 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23814 0 : if (!SWIG_IsOK(res1)) {
23815 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23816 : }
23817 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23818 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
23819 0 : if (!SWIG_IsOK(ecode2)) {
23820 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_timestamp_set" "', argument " "2"" of type '" "long""'");
23821 : }
23822 0 : arg2 = (long)(val2);
23823 : {
23824 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23825 0 : if (arg1) (arg1)->timestamp = arg2;
23826 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23827 : }
23828 0 : resultobj = SWIG_Py_Void();
23829 0 : return resultobj;
23830 : fail:
23831 : return NULL;
23832 : }
23833 :
23834 :
23835 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23836 25 : PyObject *resultobj = 0;
23837 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23838 25 : void *argp1 = 0 ;
23839 25 : int res1 = 0 ;
23840 25 : PyObject * obj0 = 0 ;
23841 : long result;
23842 :
23843 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_timestamp_get",&obj0)) SWIG_fail;
23844 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23845 25 : if (!SWIG_IsOK(res1)) {
23846 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23847 : }
23848 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
23849 : {
23850 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23851 25 : result = (long) ((arg1)->timestamp);
23852 25 : SWIG_PYTHON_THREAD_END_ALLOW;
23853 : }
23854 25 : resultobj = SWIG_From_long((long)(result));
23855 25 : return resultobj;
23856 : fail:
23857 : return NULL;
23858 : }
23859 :
23860 :
23861 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23862 0 : PyObject *resultobj = 0;
23863 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23864 0 : char *arg2 = (char *) 0 ;
23865 0 : void *argp1 = 0 ;
23866 0 : int res1 = 0 ;
23867 : int res2 ;
23868 0 : char *buf2 = 0 ;
23869 0 : int alloc2 = 0 ;
23870 0 : PyObject * obj0 = 0 ;
23871 0 : PyObject * obj1 = 0 ;
23872 :
23873 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_fpr_set",&obj0,&obj1)) SWIG_fail;
23874 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23875 0 : if (!SWIG_IsOK(res1)) {
23876 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_fpr_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23877 : }
23878 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23879 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23880 0 : if (!SWIG_IsOK(res2)) {
23881 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_new_signature_fpr_set" "', argument " "2"" of type '" "char *""'");
23882 : }
23883 0 : arg2 = (char *)(buf2);
23884 : {
23885 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23886 0 : if (arg1->fpr) free((char*)arg1->fpr);
23887 0 : if (arg2) {
23888 0 : size_t size = strlen((const char *)(arg2)) + 1;
23889 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
23890 : } else {
23891 0 : arg1->fpr = 0;
23892 : }
23893 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23894 : }
23895 0 : resultobj = SWIG_Py_Void();
23896 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
23897 : return resultobj;
23898 : fail:
23899 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
23900 : return NULL;
23901 : }
23902 :
23903 :
23904 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23905 25 : PyObject *resultobj = 0;
23906 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23907 25 : void *argp1 = 0 ;
23908 25 : int res1 = 0 ;
23909 25 : PyObject * obj0 = 0 ;
23910 25 : char *result = 0 ;
23911 :
23912 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_fpr_get",&obj0)) SWIG_fail;
23913 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23914 25 : if (!SWIG_IsOK(res1)) {
23915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_fpr_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23916 : }
23917 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
23918 : {
23919 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23920 25 : result = (char *) ((arg1)->fpr);
23921 25 : SWIG_PYTHON_THREAD_END_ALLOW;
23922 : }
23923 25 : resultobj = SWIG_FromCharPtr((const char *)result);
23924 25 : return resultobj;
23925 : fail:
23926 : return NULL;
23927 : }
23928 :
23929 :
23930 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature__obsolete_class_2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23931 0 : PyObject *resultobj = 0;
23932 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23933 : unsigned int arg2 ;
23934 0 : void *argp1 = 0 ;
23935 0 : int res1 = 0 ;
23936 : unsigned int val2 ;
23937 0 : int ecode2 = 0 ;
23938 0 : PyObject * obj0 = 0 ;
23939 0 : PyObject * obj1 = 0 ;
23940 :
23941 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature__obsolete_class_2_set",&obj0,&obj1)) SWIG_fail;
23942 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23943 0 : if (!SWIG_IsOK(res1)) {
23944 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature__obsolete_class_2_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23945 : }
23946 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23947 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23948 0 : if (!SWIG_IsOK(ecode2)) {
23949 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature__obsolete_class_2_set" "', argument " "2"" of type '" "unsigned int""'");
23950 : }
23951 0 : arg2 = (unsigned int)(val2);
23952 : {
23953 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23954 0 : if (arg1) (arg1)->_obsolete_class_2 = arg2;
23955 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23956 : }
23957 0 : resultobj = SWIG_Py_Void();
23958 0 : return resultobj;
23959 : fail:
23960 : return NULL;
23961 : }
23962 :
23963 :
23964 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature__obsolete_class_2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23965 0 : PyObject *resultobj = 0;
23966 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23967 0 : void *argp1 = 0 ;
23968 0 : int res1 = 0 ;
23969 0 : PyObject * obj0 = 0 ;
23970 : unsigned int result;
23971 :
23972 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature__obsolete_class_2_get",&obj0)) SWIG_fail;
23973 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
23974 0 : if (!SWIG_IsOK(res1)) {
23975 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature__obsolete_class_2_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
23976 : }
23977 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
23978 : {
23979 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23980 0 : result = (unsigned int) ((arg1)->_obsolete_class_2);
23981 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23982 : }
23983 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
23984 0 : return resultobj;
23985 : fail:
23986 : return NULL;
23987 : }
23988 :
23989 :
23990 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_sig_class_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23991 0 : PyObject *resultobj = 0;
23992 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
23993 : unsigned int arg2 ;
23994 0 : void *argp1 = 0 ;
23995 0 : int res1 = 0 ;
23996 : unsigned int val2 ;
23997 0 : int ecode2 = 0 ;
23998 0 : PyObject * obj0 = 0 ;
23999 0 : PyObject * obj1 = 0 ;
24000 :
24001 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_sig_class_set",&obj0,&obj1)) SWIG_fail;
24002 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
24003 0 : if (!SWIG_IsOK(res1)) {
24004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_sig_class_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
24005 : }
24006 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
24007 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24008 0 : if (!SWIG_IsOK(ecode2)) {
24009 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_sig_class_set" "', argument " "2"" of type '" "unsigned int""'");
24010 : }
24011 0 : arg2 = (unsigned int)(val2);
24012 : {
24013 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24014 0 : if (arg1) (arg1)->sig_class = arg2;
24015 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24016 : }
24017 0 : resultobj = SWIG_Py_Void();
24018 0 : return resultobj;
24019 : fail:
24020 : return NULL;
24021 : }
24022 :
24023 :
24024 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_sig_class_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24025 25 : PyObject *resultobj = 0;
24026 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
24027 25 : void *argp1 = 0 ;
24028 25 : int res1 = 0 ;
24029 25 : PyObject * obj0 = 0 ;
24030 : unsigned int result;
24031 :
24032 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_sig_class_get",&obj0)) SWIG_fail;
24033 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
24034 25 : if (!SWIG_IsOK(res1)) {
24035 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_sig_class_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
24036 : }
24037 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
24038 : {
24039 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24040 25 : result = (unsigned int) ((arg1)->sig_class);
24041 25 : SWIG_PYTHON_THREAD_END_ALLOW;
24042 : }
24043 25 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
24044 25 : return resultobj;
24045 : fail:
24046 : return NULL;
24047 : }
24048 :
24049 :
24050 0 : SWIGINTERN PyObject *_wrap_new__gpgme_new_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24051 0 : PyObject *resultobj = 0;
24052 0 : struct _gpgme_new_signature *result = 0 ;
24053 :
24054 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_new_signature")) SWIG_fail;
24055 : {
24056 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24057 0 : result = (struct _gpgme_new_signature *)calloc(1, sizeof(struct _gpgme_new_signature));
24058 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24059 : }
24060 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_new_signature, SWIG_POINTER_NEW | 0 );
24061 0 : return resultobj;
24062 : fail:
24063 : return NULL;
24064 : }
24065 :
24066 :
24067 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_new_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24068 0 : PyObject *resultobj = 0;
24069 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
24070 0 : void *argp1 = 0 ;
24071 0 : int res1 = 0 ;
24072 0 : PyObject * obj0 = 0 ;
24073 :
24074 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_new_signature",&obj0)) SWIG_fail;
24075 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, SWIG_POINTER_DISOWN | 0 );
24076 0 : if (!SWIG_IsOK(res1)) {
24077 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_new_signature" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
24078 : }
24079 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
24080 : {
24081 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24082 0 : free((char *) arg1);
24083 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24084 : }
24085 0 : resultobj = SWIG_Py_Void();
24086 0 : return resultobj;
24087 : fail:
24088 : return NULL;
24089 : }
24090 :
24091 :
24092 29 : SWIGINTERN PyObject *_gpgme_new_signature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24093 : PyObject *obj;
24094 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24095 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_new_signature, SWIG_NewClientData(obj));
24096 29 : return SWIG_Py_Void();
24097 : }
24098 :
24099 0 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_invalid_signers_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24100 0 : PyObject *resultobj = 0;
24101 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
24102 0 : gpgme_invalid_key_t arg2 = (gpgme_invalid_key_t) 0 ;
24103 0 : void *argp1 = 0 ;
24104 0 : int res1 = 0 ;
24105 0 : void *argp2 = 0 ;
24106 0 : int res2 = 0 ;
24107 0 : PyObject * obj0 = 0 ;
24108 0 : PyObject * obj1 = 0 ;
24109 :
24110 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_sign_result_invalid_signers_set",&obj0,&obj1)) SWIG_fail;
24111 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
24112 0 : if (!SWIG_IsOK(res1)) {
24113 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 *""'");
24114 : }
24115 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
24116 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
24117 0 : if (!SWIG_IsOK(res2)) {
24118 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_sign_result_invalid_signers_set" "', argument " "2"" of type '" "gpgme_invalid_key_t""'");
24119 : }
24120 0 : arg2 = (gpgme_invalid_key_t)(argp2);
24121 : {
24122 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24123 0 : if (arg1) (arg1)->invalid_signers = arg2;
24124 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24125 : }
24126 0 : resultobj = SWIG_Py_Void();
24127 0 : return resultobj;
24128 : fail:
24129 : return NULL;
24130 : }
24131 :
24132 :
24133 44 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_invalid_signers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24134 44 : PyObject *resultobj = 0;
24135 44 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
24136 44 : void *argp1 = 0 ;
24137 44 : int res1 = 0 ;
24138 44 : PyObject * obj0 = 0 ;
24139 : gpgme_invalid_key_t result;
24140 :
24141 44 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_sign_result_invalid_signers_get",&obj0)) SWIG_fail;
24142 44 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
24143 44 : if (!SWIG_IsOK(res1)) {
24144 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 *""'");
24145 : }
24146 44 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
24147 : {
24148 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24149 44 : result = (gpgme_invalid_key_t) ((arg1)->invalid_signers);
24150 44 : SWIG_PYTHON_THREAD_END_ALLOW;
24151 : }
24152 : {
24153 : int i;
24154 44 : int size = 0;
24155 : gpgme_invalid_key_t curr;
24156 50 : for (curr = result; curr != NULL; curr = curr->next) {
24157 6 : size++;
24158 : }
24159 44 : resultobj = PyList_New(size);
24160 50 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
24161 6 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_invalid_key, 0 );
24162 6 : PyList_SetItem(resultobj, i, o);
24163 : }
24164 : }
24165 : return resultobj;
24166 : fail:
24167 : return NULL;
24168 : }
24169 :
24170 :
24171 0 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_signatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24172 0 : PyObject *resultobj = 0;
24173 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
24174 0 : gpgme_new_signature_t arg2 = (gpgme_new_signature_t) 0 ;
24175 0 : void *argp1 = 0 ;
24176 0 : int res1 = 0 ;
24177 0 : void *argp2 = 0 ;
24178 0 : int res2 = 0 ;
24179 0 : PyObject * obj0 = 0 ;
24180 0 : PyObject * obj1 = 0 ;
24181 :
24182 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_sign_result_signatures_set",&obj0,&obj1)) SWIG_fail;
24183 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
24184 0 : if (!SWIG_IsOK(res1)) {
24185 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_signatures_set" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
24186 : }
24187 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
24188 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_new_signature, SWIG_POINTER_DISOWN | 0 );
24189 0 : if (!SWIG_IsOK(res2)) {
24190 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_sign_result_signatures_set" "', argument " "2"" of type '" "gpgme_new_signature_t""'");
24191 : }
24192 0 : arg2 = (gpgme_new_signature_t)(argp2);
24193 : {
24194 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24195 0 : if (arg1) (arg1)->signatures = arg2;
24196 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24197 : }
24198 0 : resultobj = SWIG_Py_Void();
24199 0 : return resultobj;
24200 : fail:
24201 : return NULL;
24202 : }
24203 :
24204 :
24205 44 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_signatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24206 44 : PyObject *resultobj = 0;
24207 44 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
24208 44 : void *argp1 = 0 ;
24209 44 : int res1 = 0 ;
24210 44 : PyObject * obj0 = 0 ;
24211 : gpgme_new_signature_t result;
24212 :
24213 44 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_sign_result_signatures_get",&obj0)) SWIG_fail;
24214 44 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
24215 44 : if (!SWIG_IsOK(res1)) {
24216 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_signatures_get" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
24217 : }
24218 44 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
24219 : {
24220 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24221 44 : result = (gpgme_new_signature_t) ((arg1)->signatures);
24222 44 : SWIG_PYTHON_THREAD_END_ALLOW;
24223 : }
24224 : {
24225 : int i;
24226 44 : int size = 0;
24227 : gpgme_new_signature_t curr;
24228 94 : for (curr = result; curr != NULL; curr = curr->next) {
24229 50 : size++;
24230 : }
24231 44 : resultobj = PyList_New(size);
24232 94 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
24233 50 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_new_signature, 0 );
24234 50 : PyList_SetItem(resultobj, i, o);
24235 : }
24236 : }
24237 : return resultobj;
24238 : fail:
24239 : return NULL;
24240 : }
24241 :
24242 :
24243 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_sign_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24244 0 : PyObject *resultobj = 0;
24245 0 : struct _gpgme_op_sign_result *result = 0 ;
24246 :
24247 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_sign_result")) SWIG_fail;
24248 : {
24249 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24250 0 : result = (struct _gpgme_op_sign_result *)calloc(1, sizeof(struct _gpgme_op_sign_result));
24251 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24252 : }
24253 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_sign_result, SWIG_POINTER_NEW | 0 );
24254 0 : return resultobj;
24255 : fail:
24256 : return NULL;
24257 : }
24258 :
24259 :
24260 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_sign_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24261 0 : PyObject *resultobj = 0;
24262 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
24263 0 : void *argp1 = 0 ;
24264 0 : int res1 = 0 ;
24265 0 : PyObject * obj0 = 0 ;
24266 :
24267 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_sign_result",&obj0)) SWIG_fail;
24268 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, SWIG_POINTER_DISOWN | 0 );
24269 0 : if (!SWIG_IsOK(res1)) {
24270 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_sign_result" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
24271 : }
24272 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
24273 : {
24274 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24275 0 : free((char *) arg1);
24276 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24277 : }
24278 0 : resultobj = SWIG_Py_Void();
24279 0 : return resultobj;
24280 : fail:
24281 : return NULL;
24282 : }
24283 :
24284 :
24285 29 : SWIGINTERN PyObject *_gpgme_op_sign_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24286 : PyObject *obj;
24287 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24288 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_sign_result, SWIG_NewClientData(obj));
24289 29 : return SWIG_Py_Void();
24290 : }
24291 :
24292 22 : SWIGINTERN PyObject *_wrap_gpgme_op_sign_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24293 22 : PyObject *resultobj = 0;
24294 22 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
24295 22 : void *argp1 = 0 ;
24296 22 : int res1 = 0 ;
24297 22 : PyObject * obj0 = 0 ;
24298 : gpgme_sign_result_t result;
24299 :
24300 22 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_sign_result",&obj0)) SWIG_fail;
24301 22 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
24302 22 : if (!SWIG_IsOK(res1)) {
24303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
24304 : }
24305 22 : arg1 = (gpgme_ctx_t)(argp1);
24306 : {
24307 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24308 22 : result = (gpgme_sign_result_t)gpgme_op_sign_result(arg1);
24309 22 : SWIG_PYTHON_THREAD_END_ALLOW;
24310 : }
24311 : {
24312 : PyObject *fragile;
24313 22 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_sign_result,
24314 : 0 );
24315 22 : resultobj = _gpg_wrap_result(fragile, "SignResult");
24316 22 : Py_DECREF(fragile);
24317 : }
24318 : return resultobj;
24319 : fail:
24320 : return NULL;
24321 : }
24322 :
24323 :
24324 0 : SWIGINTERN PyObject *_wrap_gpgme_op_sign_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 0 : PyObject *resultobj = 0;
24326 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
24327 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
24328 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
24329 : gpgme_sig_mode_t arg4 ;
24330 0 : void *argp1 = 0 ;
24331 0 : int res1 = 0 ;
24332 0 : gpgme_data_t wrapper2 = NULL ;
24333 0 : PyObject *bytesio2 = NULL ;
24334 : Py_buffer view2 ;
24335 0 : int have_view2 = 0 ;
24336 0 : gpgme_data_t wrapper3 = NULL ;
24337 0 : PyObject *bytesio3 = NULL ;
24338 : Py_buffer view3 ;
24339 0 : int have_view3 = 0 ;
24340 : int val4 ;
24341 0 : int ecode4 = 0 ;
24342 0 : PyObject * obj0 = 0 ;
24343 0 : PyObject * obj1 = 0 ;
24344 0 : PyObject * obj2 = 0 ;
24345 0 : PyObject * obj3 = 0 ;
24346 : gpgme_error_t result;
24347 :
24348 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_sign_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24349 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
24350 0 : if (!SWIG_IsOK(res1)) {
24351 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
24352 : }
24353 0 : arg1 = (gpgme_ctx_t)(argp1);
24354 : {
24355 : /* If we create a temporary wrapper2 object, we will store it in
24356 : wrapperN, where N is 2. Here in this fragment, SWIG will
24357 : automatically append 2. */
24358 0 : memset(&view2, 0, sizeof view2);
24359 0 : if (obj1 == Py_None)
24360 0 : arg2 = NULL;
24361 : else {
24362 : PyObject *pypointer;
24363 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
24364 : &bytesio2, &view2);
24365 0 : if (pypointer == NULL)
24366 : return NULL;
24367 0 : have_view2 = !! view2.obj;
24368 :
24369 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
24370 :
24371 : /* Following code is from swig's python.swg. */
24372 :
24373 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
24374 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24375 0 : Py_DECREF(pypointer);
24376 : return NULL;
24377 : }
24378 0 : Py_DECREF(pypointer);
24379 : }
24380 : }
24381 : {
24382 : /* If we create a temporary wrapper3 object, we will store it in
24383 : wrapperN, where N is 3. Here in this fragment, SWIG will
24384 : automatically append 3. */
24385 0 : memset(&view3, 0, sizeof view3);
24386 0 : if (obj2 == Py_None)
24387 0 : arg3 = NULL;
24388 : else {
24389 : PyObject *pypointer;
24390 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
24391 : &bytesio3, &view3);
24392 0 : if (pypointer == NULL)
24393 : return NULL;
24394 0 : have_view3 = !! view3.obj;
24395 :
24396 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
24397 :
24398 : /* Following code is from swig's python.swg. */
24399 :
24400 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
24401 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24402 0 : Py_DECREF(pypointer);
24403 : return NULL;
24404 : }
24405 0 : Py_DECREF(pypointer);
24406 : }
24407 : }
24408 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
24409 0 : if (!SWIG_IsOK(ecode4)) {
24410 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_sign_start" "', argument " "4"" of type '" "gpgme_sig_mode_t""'");
24411 : }
24412 0 : arg4 = (gpgme_sig_mode_t)(val4);
24413 : {
24414 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24415 0 : result = gpgme_op_sign_start(arg1,arg2,arg3,arg4);
24416 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24417 : }
24418 : {
24419 0 : resultobj = PyLong_FromLong(result);
24420 : }
24421 : {
24422 : /* See whether we need to update the Python buffer. */
24423 0 : if (resultobj && wrapper2 && view2.buf)
24424 : {
24425 : int dirty;
24426 0 : char *new_data = NULL;
24427 : size_t new_size;
24428 :
24429 :
24430 0 : new_data = wrapper2->data.mem.buffer;
24431 0 : new_size = wrapper2->data.mem.length;
24432 0 : dirty = new_data != NULL;
24433 :
24434 :
24435 :
24436 :
24437 :
24438 :
24439 :
24440 0 : if (dirty)
24441 : {
24442 : /* The buffer is dirty. */
24443 0 : if (view2.readonly)
24444 : {
24445 0 : Py_XDECREF(resultobj);
24446 0 : resultobj = NULL;
24447 0 : PyErr_SetString(PyExc_ValueError,
24448 : "cannot update read-only buffer");
24449 : }
24450 :
24451 : /* See if we need to truncate the buffer. */
24452 0 : if (resultobj && view2.len != new_size)
24453 : {
24454 0 : if (bytesio2 == NULL)
24455 : {
24456 0 : Py_XDECREF(resultobj);
24457 0 : resultobj = NULL;
24458 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24459 : }
24460 : else
24461 : {
24462 : PyObject *retval;
24463 0 : PyBuffer_Release(&view2);
24464 : assert(view2.obj == NULL);
24465 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
24466 : "l", (long) new_size);
24467 0 : if (retval == NULL)
24468 : {
24469 0 : Py_XDECREF(resultobj);
24470 : resultobj = NULL;
24471 : }
24472 : else
24473 : {
24474 0 : Py_DECREF(retval);
24475 :
24476 0 : retval = PyObject_CallMethod(bytesio2,
24477 : "getbuffer", NULL);
24478 0 : if (retval == NULL
24479 0 : || PyObject_GetBuffer(retval, &view2,
24480 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24481 : {
24482 0 : Py_XDECREF(resultobj);
24483 : resultobj = NULL;
24484 : }
24485 :
24486 0 : Py_XDECREF(retval);
24487 :
24488 0 : if (resultobj && view2.len
24489 : != new_size)
24490 : {
24491 0 : Py_XDECREF(resultobj);
24492 0 : resultobj = NULL;
24493 0 : PyErr_Format(PyExc_ValueError,
24494 : "Expected buffer of length %zu, got %zi",
24495 : new_size,
24496 : view2.len);
24497 : }
24498 : }
24499 : }
24500 : }
24501 0 : if (resultobj)
24502 0 : memcpy(view2.buf, new_data, new_size);
24503 : }
24504 :
24505 :
24506 :
24507 : }
24508 :
24509 : /* Free the temporary wrapper, if any. */
24510 0 : if (wrapper2)
24511 0 : gpgme_data_release(wrapper2);
24512 0 : Py_XDECREF (bytesio2);
24513 0 : if (have_view2 && view2.buf)
24514 0 : PyBuffer_Release(&view2);
24515 : }
24516 : {
24517 : /* See whether we need to update the Python buffer. */
24518 0 : if (resultobj && wrapper3 && view3.buf)
24519 : {
24520 : int dirty;
24521 0 : char *new_data = NULL;
24522 : size_t new_size;
24523 :
24524 :
24525 0 : new_data = wrapper3->data.mem.buffer;
24526 0 : new_size = wrapper3->data.mem.length;
24527 0 : dirty = new_data != NULL;
24528 :
24529 :
24530 :
24531 :
24532 :
24533 :
24534 :
24535 0 : if (dirty)
24536 : {
24537 : /* The buffer is dirty. */
24538 0 : if (view3.readonly)
24539 : {
24540 0 : Py_XDECREF(resultobj);
24541 0 : resultobj = NULL;
24542 0 : PyErr_SetString(PyExc_ValueError,
24543 : "cannot update read-only buffer");
24544 : }
24545 :
24546 : /* See if we need to truncate the buffer. */
24547 0 : if (resultobj && view3.len != new_size)
24548 : {
24549 0 : if (bytesio3 == NULL)
24550 : {
24551 0 : Py_XDECREF(resultobj);
24552 0 : resultobj = NULL;
24553 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24554 : }
24555 : else
24556 : {
24557 : PyObject *retval;
24558 0 : PyBuffer_Release(&view3);
24559 : assert(view3.obj == NULL);
24560 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
24561 : "l", (long) new_size);
24562 0 : if (retval == NULL)
24563 : {
24564 0 : Py_XDECREF(resultobj);
24565 : resultobj = NULL;
24566 : }
24567 : else
24568 : {
24569 0 : Py_DECREF(retval);
24570 :
24571 0 : retval = PyObject_CallMethod(bytesio3,
24572 : "getbuffer", NULL);
24573 0 : if (retval == NULL
24574 0 : || PyObject_GetBuffer(retval, &view3,
24575 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24576 : {
24577 0 : Py_XDECREF(resultobj);
24578 : resultobj = NULL;
24579 : }
24580 :
24581 0 : Py_XDECREF(retval);
24582 :
24583 0 : if (resultobj && view3.len
24584 : != new_size)
24585 : {
24586 0 : Py_XDECREF(resultobj);
24587 0 : resultobj = NULL;
24588 0 : PyErr_Format(PyExc_ValueError,
24589 : "Expected buffer of length %zu, got %zi",
24590 : new_size,
24591 : view3.len);
24592 : }
24593 : }
24594 : }
24595 : }
24596 0 : if (resultobj)
24597 0 : memcpy(view3.buf, new_data, new_size);
24598 : }
24599 :
24600 :
24601 :
24602 : }
24603 :
24604 : /* Free the temporary wrapper, if any. */
24605 0 : if (wrapper3)
24606 0 : gpgme_data_release(wrapper3);
24607 0 : Py_XDECREF (bytesio3);
24608 0 : if (have_view3 && view3.buf)
24609 0 : PyBuffer_Release(&view3);
24610 : }
24611 : return resultobj;
24612 : fail:
24613 : {
24614 : /* See whether we need to update the Python buffer. */
24615 : if (resultobj && wrapper2 && view2.buf)
24616 : {
24617 : int dirty;
24618 : char *new_data = NULL;
24619 : size_t new_size;
24620 :
24621 :
24622 : new_data = wrapper2->data.mem.buffer;
24623 : new_size = wrapper2->data.mem.length;
24624 : dirty = new_data != NULL;
24625 :
24626 :
24627 :
24628 :
24629 :
24630 :
24631 :
24632 : if (dirty)
24633 : {
24634 : /* The buffer is dirty. */
24635 : if (view2.readonly)
24636 : {
24637 : Py_XDECREF(resultobj);
24638 : resultobj = NULL;
24639 : PyErr_SetString(PyExc_ValueError,
24640 : "cannot update read-only buffer");
24641 : }
24642 :
24643 : /* See if we need to truncate the buffer. */
24644 : if (resultobj && view2.len != new_size)
24645 : {
24646 : if (bytesio2 == NULL)
24647 : {
24648 : Py_XDECREF(resultobj);
24649 : resultobj = NULL;
24650 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24651 : }
24652 : else
24653 : {
24654 : PyObject *retval;
24655 : PyBuffer_Release(&view2);
24656 : assert(view2.obj == NULL);
24657 : retval = PyObject_CallMethod(bytesio2, "truncate",
24658 : "l", (long) new_size);
24659 : if (retval == NULL)
24660 : {
24661 : Py_XDECREF(resultobj);
24662 : resultobj = NULL;
24663 : }
24664 : else
24665 : {
24666 : Py_DECREF(retval);
24667 :
24668 : retval = PyObject_CallMethod(bytesio2,
24669 : "getbuffer", NULL);
24670 : if (retval == NULL
24671 : || PyObject_GetBuffer(retval, &view2,
24672 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24673 : {
24674 : Py_XDECREF(resultobj);
24675 : resultobj = NULL;
24676 : }
24677 :
24678 : Py_XDECREF(retval);
24679 :
24680 : if (resultobj && view2.len
24681 : != new_size)
24682 : {
24683 : Py_XDECREF(resultobj);
24684 : resultobj = NULL;
24685 : PyErr_Format(PyExc_ValueError,
24686 : "Expected buffer of length %zu, got %zi",
24687 : new_size,
24688 : view2.len);
24689 : }
24690 : }
24691 : }
24692 : }
24693 : if (resultobj)
24694 : memcpy(view2.buf, new_data, new_size);
24695 : }
24696 :
24697 :
24698 :
24699 : }
24700 :
24701 : /* Free the temporary wrapper, if any. */
24702 0 : if (wrapper2)
24703 0 : gpgme_data_release(wrapper2);
24704 0 : Py_XDECREF (bytesio2);
24705 0 : if (have_view2 && view2.buf)
24706 0 : PyBuffer_Release(&view2);
24707 : }
24708 : {
24709 : /* See whether we need to update the Python buffer. */
24710 : if (resultobj && wrapper3 && view3.buf)
24711 : {
24712 : int dirty;
24713 : char *new_data = NULL;
24714 : size_t new_size;
24715 :
24716 :
24717 : new_data = wrapper3->data.mem.buffer;
24718 : new_size = wrapper3->data.mem.length;
24719 : dirty = new_data != NULL;
24720 :
24721 :
24722 :
24723 :
24724 :
24725 :
24726 :
24727 : if (dirty)
24728 : {
24729 : /* The buffer is dirty. */
24730 : if (view3.readonly)
24731 : {
24732 : Py_XDECREF(resultobj);
24733 : resultobj = NULL;
24734 : PyErr_SetString(PyExc_ValueError,
24735 : "cannot update read-only buffer");
24736 : }
24737 :
24738 : /* See if we need to truncate the buffer. */
24739 : if (resultobj && view3.len != new_size)
24740 : {
24741 : if (bytesio3 == NULL)
24742 : {
24743 : Py_XDECREF(resultobj);
24744 : resultobj = NULL;
24745 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24746 : }
24747 : else
24748 : {
24749 : PyObject *retval;
24750 : PyBuffer_Release(&view3);
24751 : assert(view3.obj == NULL);
24752 : retval = PyObject_CallMethod(bytesio3, "truncate",
24753 : "l", (long) new_size);
24754 : if (retval == NULL)
24755 : {
24756 : Py_XDECREF(resultobj);
24757 : resultobj = NULL;
24758 : }
24759 : else
24760 : {
24761 : Py_DECREF(retval);
24762 :
24763 : retval = PyObject_CallMethod(bytesio3,
24764 : "getbuffer", NULL);
24765 : if (retval == NULL
24766 : || PyObject_GetBuffer(retval, &view3,
24767 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24768 : {
24769 : Py_XDECREF(resultobj);
24770 : resultobj = NULL;
24771 : }
24772 :
24773 : Py_XDECREF(retval);
24774 :
24775 : if (resultobj && view3.len
24776 : != new_size)
24777 : {
24778 : Py_XDECREF(resultobj);
24779 : resultobj = NULL;
24780 : PyErr_Format(PyExc_ValueError,
24781 : "Expected buffer of length %zu, got %zi",
24782 : new_size,
24783 : view3.len);
24784 : }
24785 : }
24786 : }
24787 : }
24788 : if (resultobj)
24789 : memcpy(view3.buf, new_data, new_size);
24790 : }
24791 :
24792 :
24793 :
24794 : }
24795 :
24796 : /* Free the temporary wrapper, if any. */
24797 0 : if (wrapper3)
24798 0 : gpgme_data_release(wrapper3);
24799 0 : Py_XDECREF (bytesio3);
24800 0 : if (have_view3 && view3.buf)
24801 0 : PyBuffer_Release(&view3);
24802 : }
24803 : return NULL;
24804 : }
24805 :
24806 :
24807 17 : SWIGINTERN PyObject *_wrap_gpgme_op_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24808 17 : PyObject *resultobj = 0;
24809 17 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
24810 17 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
24811 17 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
24812 : gpgme_sig_mode_t arg4 ;
24813 17 : void *argp1 = 0 ;
24814 17 : int res1 = 0 ;
24815 17 : gpgme_data_t wrapper2 = NULL ;
24816 17 : PyObject *bytesio2 = NULL ;
24817 : Py_buffer view2 ;
24818 17 : int have_view2 = 0 ;
24819 17 : gpgme_data_t wrapper3 = NULL ;
24820 17 : PyObject *bytesio3 = NULL ;
24821 : Py_buffer view3 ;
24822 17 : int have_view3 = 0 ;
24823 : int val4 ;
24824 17 : int ecode4 = 0 ;
24825 17 : PyObject * obj0 = 0 ;
24826 17 : PyObject * obj1 = 0 ;
24827 17 : PyObject * obj2 = 0 ;
24828 17 : PyObject * obj3 = 0 ;
24829 : gpgme_error_t result;
24830 :
24831 17 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_sign",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24832 17 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
24833 17 : if (!SWIG_IsOK(res1)) {
24834 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign" "', argument " "1"" of type '" "gpgme_ctx_t""'");
24835 : }
24836 17 : arg1 = (gpgme_ctx_t)(argp1);
24837 : {
24838 : /* If we create a temporary wrapper2 object, we will store it in
24839 : wrapperN, where N is 2. Here in this fragment, SWIG will
24840 : automatically append 2. */
24841 17 : memset(&view2, 0, sizeof view2);
24842 17 : if (obj1 == Py_None)
24843 0 : arg2 = NULL;
24844 : else {
24845 : PyObject *pypointer;
24846 17 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
24847 : &bytesio2, &view2);
24848 17 : if (pypointer == NULL)
24849 : return NULL;
24850 17 : have_view2 = !! view2.obj;
24851 :
24852 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
24853 :
24854 : /* Following code is from swig's python.swg. */
24855 :
24856 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
24857 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24858 0 : Py_DECREF(pypointer);
24859 : return NULL;
24860 : }
24861 17 : Py_DECREF(pypointer);
24862 : }
24863 : }
24864 : {
24865 : /* If we create a temporary wrapper3 object, we will store it in
24866 : wrapperN, where N is 3. Here in this fragment, SWIG will
24867 : automatically append 3. */
24868 17 : memset(&view3, 0, sizeof view3);
24869 17 : if (obj2 == Py_None)
24870 0 : arg3 = NULL;
24871 : else {
24872 : PyObject *pypointer;
24873 17 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
24874 : &bytesio3, &view3);
24875 17 : if (pypointer == NULL)
24876 : return NULL;
24877 17 : have_view3 = !! view3.obj;
24878 :
24879 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
24880 :
24881 : /* Following code is from swig's python.swg. */
24882 :
24883 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
24884 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24885 0 : Py_DECREF(pypointer);
24886 : return NULL;
24887 : }
24888 17 : Py_DECREF(pypointer);
24889 : }
24890 : }
24891 34 : ecode4 = SWIG_AsVal_int(obj3, &val4);
24892 17 : if (!SWIG_IsOK(ecode4)) {
24893 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_sign" "', argument " "4"" of type '" "gpgme_sig_mode_t""'");
24894 : }
24895 17 : arg4 = (gpgme_sig_mode_t)(val4);
24896 : {
24897 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24898 17 : result = gpgme_op_sign(arg1,arg2,arg3,arg4);
24899 17 : SWIG_PYTHON_THREAD_END_ALLOW;
24900 : }
24901 : {
24902 17 : resultobj = PyLong_FromLong(result);
24903 : }
24904 : {
24905 : /* See whether we need to update the Python buffer. */
24906 17 : if (resultobj && wrapper2 && view2.buf)
24907 : {
24908 : int dirty;
24909 9 : char *new_data = NULL;
24910 : size_t new_size;
24911 :
24912 :
24913 9 : new_data = wrapper2->data.mem.buffer;
24914 9 : new_size = wrapper2->data.mem.length;
24915 9 : dirty = new_data != NULL;
24916 :
24917 :
24918 :
24919 :
24920 :
24921 :
24922 :
24923 9 : if (dirty)
24924 : {
24925 : /* The buffer is dirty. */
24926 0 : if (view2.readonly)
24927 : {
24928 0 : Py_XDECREF(resultobj);
24929 0 : resultobj = NULL;
24930 0 : PyErr_SetString(PyExc_ValueError,
24931 : "cannot update read-only buffer");
24932 : }
24933 :
24934 : /* See if we need to truncate the buffer. */
24935 0 : if (resultobj && view2.len != new_size)
24936 : {
24937 0 : if (bytesio2 == NULL)
24938 : {
24939 0 : Py_XDECREF(resultobj);
24940 0 : resultobj = NULL;
24941 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24942 : }
24943 : else
24944 : {
24945 : PyObject *retval;
24946 0 : PyBuffer_Release(&view2);
24947 : assert(view2.obj == NULL);
24948 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
24949 : "l", (long) new_size);
24950 0 : if (retval == NULL)
24951 : {
24952 0 : Py_XDECREF(resultobj);
24953 : resultobj = NULL;
24954 : }
24955 : else
24956 : {
24957 0 : Py_DECREF(retval);
24958 :
24959 0 : retval = PyObject_CallMethod(bytesio2,
24960 : "getbuffer", NULL);
24961 0 : if (retval == NULL
24962 0 : || PyObject_GetBuffer(retval, &view2,
24963 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24964 : {
24965 0 : Py_XDECREF(resultobj);
24966 : resultobj = NULL;
24967 : }
24968 :
24969 0 : Py_XDECREF(retval);
24970 :
24971 0 : if (resultobj && view2.len
24972 : != new_size)
24973 : {
24974 0 : Py_XDECREF(resultobj);
24975 0 : resultobj = NULL;
24976 0 : PyErr_Format(PyExc_ValueError,
24977 : "Expected buffer of length %zu, got %zi",
24978 : new_size,
24979 : view2.len);
24980 : }
24981 : }
24982 : }
24983 : }
24984 0 : if (resultobj)
24985 0 : memcpy(view2.buf, new_data, new_size);
24986 : }
24987 :
24988 :
24989 :
24990 : }
24991 :
24992 : /* Free the temporary wrapper, if any. */
24993 17 : if (wrapper2)
24994 10 : gpgme_data_release(wrapper2);
24995 17 : Py_XDECREF (bytesio2);
24996 17 : if (have_view2 && view2.buf)
24997 9 : PyBuffer_Release(&view2);
24998 : }
24999 : {
25000 : /* See whether we need to update the Python buffer. */
25001 17 : if (resultobj && wrapper3 && view3.buf)
25002 : {
25003 : int dirty;
25004 1 : char *new_data = NULL;
25005 : size_t new_size;
25006 :
25007 :
25008 1 : new_data = wrapper3->data.mem.buffer;
25009 1 : new_size = wrapper3->data.mem.length;
25010 1 : dirty = new_data != NULL;
25011 :
25012 :
25013 :
25014 :
25015 :
25016 :
25017 :
25018 1 : if (dirty)
25019 : {
25020 : /* The buffer is dirty. */
25021 1 : if (view3.readonly)
25022 : {
25023 0 : Py_XDECREF(resultobj);
25024 0 : resultobj = NULL;
25025 0 : PyErr_SetString(PyExc_ValueError,
25026 : "cannot update read-only buffer");
25027 : }
25028 :
25029 : /* See if we need to truncate the buffer. */
25030 1 : if (resultobj && view3.len != new_size)
25031 : {
25032 0 : if (bytesio3 == NULL)
25033 : {
25034 0 : Py_XDECREF(resultobj);
25035 0 : resultobj = NULL;
25036 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25037 : }
25038 : else
25039 : {
25040 : PyObject *retval;
25041 0 : PyBuffer_Release(&view3);
25042 : assert(view3.obj == NULL);
25043 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
25044 : "l", (long) new_size);
25045 0 : if (retval == NULL)
25046 : {
25047 0 : Py_XDECREF(resultobj);
25048 : resultobj = NULL;
25049 : }
25050 : else
25051 : {
25052 0 : Py_DECREF(retval);
25053 :
25054 0 : retval = PyObject_CallMethod(bytesio3,
25055 : "getbuffer", NULL);
25056 0 : if (retval == NULL
25057 0 : || PyObject_GetBuffer(retval, &view3,
25058 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25059 : {
25060 0 : Py_XDECREF(resultobj);
25061 : resultobj = NULL;
25062 : }
25063 :
25064 0 : Py_XDECREF(retval);
25065 :
25066 0 : if (resultobj && view3.len
25067 : != new_size)
25068 : {
25069 0 : Py_XDECREF(resultobj);
25070 0 : resultobj = NULL;
25071 0 : PyErr_Format(PyExc_ValueError,
25072 : "Expected buffer of length %zu, got %zi",
25073 : new_size,
25074 : view3.len);
25075 : }
25076 : }
25077 : }
25078 : }
25079 1 : if (resultobj)
25080 1 : memcpy(view3.buf, new_data, new_size);
25081 : }
25082 :
25083 :
25084 :
25085 : }
25086 :
25087 : /* Free the temporary wrapper, if any. */
25088 17 : if (wrapper3)
25089 2 : gpgme_data_release(wrapper3);
25090 17 : Py_XDECREF (bytesio3);
25091 17 : if (have_view3 && view3.buf)
25092 1 : PyBuffer_Release(&view3);
25093 : }
25094 : return resultobj;
25095 : fail:
25096 : {
25097 : /* See whether we need to update the Python buffer. */
25098 : if (resultobj && wrapper2 && view2.buf)
25099 : {
25100 : int dirty;
25101 : char *new_data = NULL;
25102 : size_t new_size;
25103 :
25104 :
25105 : new_data = wrapper2->data.mem.buffer;
25106 : new_size = wrapper2->data.mem.length;
25107 : dirty = new_data != NULL;
25108 :
25109 :
25110 :
25111 :
25112 :
25113 :
25114 :
25115 : if (dirty)
25116 : {
25117 : /* The buffer is dirty. */
25118 : if (view2.readonly)
25119 : {
25120 : Py_XDECREF(resultobj);
25121 : resultobj = NULL;
25122 : PyErr_SetString(PyExc_ValueError,
25123 : "cannot update read-only buffer");
25124 : }
25125 :
25126 : /* See if we need to truncate the buffer. */
25127 : if (resultobj && view2.len != new_size)
25128 : {
25129 : if (bytesio2 == NULL)
25130 : {
25131 : Py_XDECREF(resultobj);
25132 : resultobj = NULL;
25133 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25134 : }
25135 : else
25136 : {
25137 : PyObject *retval;
25138 : PyBuffer_Release(&view2);
25139 : assert(view2.obj == NULL);
25140 : retval = PyObject_CallMethod(bytesio2, "truncate",
25141 : "l", (long) new_size);
25142 : if (retval == NULL)
25143 : {
25144 : Py_XDECREF(resultobj);
25145 : resultobj = NULL;
25146 : }
25147 : else
25148 : {
25149 : Py_DECREF(retval);
25150 :
25151 : retval = PyObject_CallMethod(bytesio2,
25152 : "getbuffer", NULL);
25153 : if (retval == NULL
25154 : || PyObject_GetBuffer(retval, &view2,
25155 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25156 : {
25157 : Py_XDECREF(resultobj);
25158 : resultobj = NULL;
25159 : }
25160 :
25161 : Py_XDECREF(retval);
25162 :
25163 : if (resultobj && view2.len
25164 : != new_size)
25165 : {
25166 : Py_XDECREF(resultobj);
25167 : resultobj = NULL;
25168 : PyErr_Format(PyExc_ValueError,
25169 : "Expected buffer of length %zu, got %zi",
25170 : new_size,
25171 : view2.len);
25172 : }
25173 : }
25174 : }
25175 : }
25176 : if (resultobj)
25177 : memcpy(view2.buf, new_data, new_size);
25178 : }
25179 :
25180 :
25181 :
25182 : }
25183 :
25184 : /* Free the temporary wrapper, if any. */
25185 0 : if (wrapper2)
25186 0 : gpgme_data_release(wrapper2);
25187 0 : Py_XDECREF (bytesio2);
25188 0 : if (have_view2 && view2.buf)
25189 0 : PyBuffer_Release(&view2);
25190 : }
25191 : {
25192 : /* See whether we need to update the Python buffer. */
25193 : if (resultobj && wrapper3 && view3.buf)
25194 : {
25195 : int dirty;
25196 : char *new_data = NULL;
25197 : size_t new_size;
25198 :
25199 :
25200 : new_data = wrapper3->data.mem.buffer;
25201 : new_size = wrapper3->data.mem.length;
25202 : dirty = new_data != NULL;
25203 :
25204 :
25205 :
25206 :
25207 :
25208 :
25209 :
25210 : if (dirty)
25211 : {
25212 : /* The buffer is dirty. */
25213 : if (view3.readonly)
25214 : {
25215 : Py_XDECREF(resultobj);
25216 : resultobj = NULL;
25217 : PyErr_SetString(PyExc_ValueError,
25218 : "cannot update read-only buffer");
25219 : }
25220 :
25221 : /* See if we need to truncate the buffer. */
25222 : if (resultobj && view3.len != new_size)
25223 : {
25224 : if (bytesio3 == NULL)
25225 : {
25226 : Py_XDECREF(resultobj);
25227 : resultobj = NULL;
25228 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25229 : }
25230 : else
25231 : {
25232 : PyObject *retval;
25233 : PyBuffer_Release(&view3);
25234 : assert(view3.obj == NULL);
25235 : retval = PyObject_CallMethod(bytesio3, "truncate",
25236 : "l", (long) new_size);
25237 : if (retval == NULL)
25238 : {
25239 : Py_XDECREF(resultobj);
25240 : resultobj = NULL;
25241 : }
25242 : else
25243 : {
25244 : Py_DECREF(retval);
25245 :
25246 : retval = PyObject_CallMethod(bytesio3,
25247 : "getbuffer", NULL);
25248 : if (retval == NULL
25249 : || PyObject_GetBuffer(retval, &view3,
25250 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25251 : {
25252 : Py_XDECREF(resultobj);
25253 : resultobj = NULL;
25254 : }
25255 :
25256 : Py_XDECREF(retval);
25257 :
25258 : if (resultobj && view3.len
25259 : != new_size)
25260 : {
25261 : Py_XDECREF(resultobj);
25262 : resultobj = NULL;
25263 : PyErr_Format(PyExc_ValueError,
25264 : "Expected buffer of length %zu, got %zi",
25265 : new_size,
25266 : view3.len);
25267 : }
25268 : }
25269 : }
25270 : }
25271 : if (resultobj)
25272 : memcpy(view3.buf, new_data, new_size);
25273 : }
25274 :
25275 :
25276 :
25277 : }
25278 :
25279 : /* Free the temporary wrapper, if any. */
25280 0 : if (wrapper3)
25281 0 : gpgme_data_release(wrapper3);
25282 0 : Py_XDECREF (bytesio3);
25283 0 : if (have_view3 && view3.buf)
25284 0 : PyBuffer_Release(&view3);
25285 : }
25286 : return NULL;
25287 : }
25288 :
25289 :
25290 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_summary_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25291 0 : PyObject *resultobj = 0;
25292 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25293 : gpgme_sigsum_t arg2 ;
25294 0 : void *argp1 = 0 ;
25295 0 : int res1 = 0 ;
25296 : int val2 ;
25297 0 : int ecode2 = 0 ;
25298 0 : PyObject * obj0 = 0 ;
25299 0 : PyObject * obj1 = 0 ;
25300 :
25301 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_summary_set",&obj0,&obj1)) SWIG_fail;
25302 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25303 0 : if (!SWIG_IsOK(res1)) {
25304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_summary_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25305 : }
25306 0 : arg1 = (struct _gpgme_signature *)(argp1);
25307 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25308 0 : if (!SWIG_IsOK(ecode2)) {
25309 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_summary_set" "', argument " "2"" of type '" "gpgme_sigsum_t""'");
25310 : }
25311 0 : arg2 = (gpgme_sigsum_t)(val2);
25312 : {
25313 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25314 0 : if (arg1) (arg1)->summary = arg2;
25315 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25316 : }
25317 0 : resultobj = SWIG_Py_Void();
25318 0 : return resultobj;
25319 : fail:
25320 : return NULL;
25321 : }
25322 :
25323 :
25324 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_summary_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25325 16 : PyObject *resultobj = 0;
25326 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25327 16 : void *argp1 = 0 ;
25328 16 : int res1 = 0 ;
25329 16 : PyObject * obj0 = 0 ;
25330 : gpgme_sigsum_t result;
25331 :
25332 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_summary_get",&obj0)) SWIG_fail;
25333 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25334 16 : if (!SWIG_IsOK(res1)) {
25335 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_summary_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25336 : }
25337 16 : arg1 = (struct _gpgme_signature *)(argp1);
25338 : {
25339 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25340 16 : result = (gpgme_sigsum_t) ((arg1)->summary);
25341 16 : SWIG_PYTHON_THREAD_END_ALLOW;
25342 : }
25343 32 : resultobj = SWIG_From_int((int)(result));
25344 16 : return resultobj;
25345 : fail:
25346 : return NULL;
25347 : }
25348 :
25349 :
25350 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25351 0 : PyObject *resultobj = 0;
25352 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25353 0 : char *arg2 = (char *) 0 ;
25354 0 : void *argp1 = 0 ;
25355 0 : int res1 = 0 ;
25356 : int res2 ;
25357 0 : char *buf2 = 0 ;
25358 0 : int alloc2 = 0 ;
25359 0 : PyObject * obj0 = 0 ;
25360 0 : PyObject * obj1 = 0 ;
25361 :
25362 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_fpr_set",&obj0,&obj1)) SWIG_fail;
25363 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25364 0 : if (!SWIG_IsOK(res1)) {
25365 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_fpr_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25366 : }
25367 0 : arg1 = (struct _gpgme_signature *)(argp1);
25368 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25369 0 : if (!SWIG_IsOK(res2)) {
25370 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_fpr_set" "', argument " "2"" of type '" "char *""'");
25371 : }
25372 0 : arg2 = (char *)(buf2);
25373 : {
25374 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25375 0 : if (arg1->fpr) free((char*)arg1->fpr);
25376 0 : if (arg2) {
25377 0 : size_t size = strlen((const char *)(arg2)) + 1;
25378 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
25379 : } else {
25380 0 : arg1->fpr = 0;
25381 : }
25382 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25383 : }
25384 0 : resultobj = SWIG_Py_Void();
25385 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
25386 : return resultobj;
25387 : fail:
25388 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
25389 : return NULL;
25390 : }
25391 :
25392 :
25393 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25394 16 : PyObject *resultobj = 0;
25395 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25396 16 : void *argp1 = 0 ;
25397 16 : int res1 = 0 ;
25398 16 : PyObject * obj0 = 0 ;
25399 16 : char *result = 0 ;
25400 :
25401 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_fpr_get",&obj0)) SWIG_fail;
25402 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25403 16 : if (!SWIG_IsOK(res1)) {
25404 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_fpr_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25405 : }
25406 16 : arg1 = (struct _gpgme_signature *)(argp1);
25407 : {
25408 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25409 16 : result = (char *) ((arg1)->fpr);
25410 16 : SWIG_PYTHON_THREAD_END_ALLOW;
25411 : }
25412 16 : resultobj = SWIG_FromCharPtr((const char *)result);
25413 16 : return resultobj;
25414 : fail:
25415 : return NULL;
25416 : }
25417 :
25418 :
25419 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25420 0 : PyObject *resultobj = 0;
25421 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25422 : gpgme_error_t arg2 ;
25423 0 : void *argp1 = 0 ;
25424 0 : int res1 = 0 ;
25425 0 : PyObject * obj0 = 0 ;
25426 0 : PyObject * obj1 = 0 ;
25427 :
25428 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_status_set",&obj0,&obj1)) SWIG_fail;
25429 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25430 0 : if (!SWIG_IsOK(res1)) {
25431 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_status_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25432 : }
25433 0 : arg1 = (struct _gpgme_signature *)(argp1);
25434 : {
25435 0 : if (PyLong_Check(obj1))
25436 0 : arg2 = PyLong_AsLong(obj1);
25437 :
25438 : else if (PyInt_Check(obj1))
25439 : arg2 = PyInt_AsLong(obj1);
25440 :
25441 : else
25442 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
25443 : }
25444 : {
25445 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25446 0 : if (arg1) (arg1)->status = arg2;
25447 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25448 : }
25449 0 : resultobj = SWIG_Py_Void();
25450 0 : return resultobj;
25451 : fail:
25452 : return NULL;
25453 : }
25454 :
25455 :
25456 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25457 16 : PyObject *resultobj = 0;
25458 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25459 16 : void *argp1 = 0 ;
25460 16 : int res1 = 0 ;
25461 16 : PyObject * obj0 = 0 ;
25462 : gpgme_error_t result;
25463 :
25464 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_status_get",&obj0)) SWIG_fail;
25465 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25466 16 : if (!SWIG_IsOK(res1)) {
25467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_status_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25468 : }
25469 16 : arg1 = (struct _gpgme_signature *)(argp1);
25470 : {
25471 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25472 16 : result = ((arg1)->status);
25473 16 : SWIG_PYTHON_THREAD_END_ALLOW;
25474 : }
25475 : {
25476 16 : resultobj = PyLong_FromLong(result);
25477 : }
25478 16 : return resultobj;
25479 : fail:
25480 : return NULL;
25481 : }
25482 :
25483 :
25484 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_notations_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25485 0 : PyObject *resultobj = 0;
25486 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25487 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
25488 0 : void *argp1 = 0 ;
25489 0 : int res1 = 0 ;
25490 0 : void *argp2 = 0 ;
25491 0 : int res2 = 0 ;
25492 0 : PyObject * obj0 = 0 ;
25493 0 : PyObject * obj1 = 0 ;
25494 :
25495 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_notations_set",&obj0,&obj1)) SWIG_fail;
25496 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25497 0 : if (!SWIG_IsOK(res1)) {
25498 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_notations_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25499 : }
25500 0 : arg1 = (struct _gpgme_signature *)(argp1);
25501 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
25502 0 : if (!SWIG_IsOK(res2)) {
25503 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_notations_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
25504 : }
25505 0 : arg2 = (gpgme_sig_notation_t)(argp2);
25506 : {
25507 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25508 0 : if (arg1) (arg1)->notations = arg2;
25509 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25510 : }
25511 0 : resultobj = SWIG_Py_Void();
25512 0 : return resultobj;
25513 : fail:
25514 : return NULL;
25515 : }
25516 :
25517 :
25518 32 : SWIGINTERN PyObject *_wrap__gpgme_signature_notations_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25519 32 : PyObject *resultobj = 0;
25520 32 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25521 32 : void *argp1 = 0 ;
25522 32 : int res1 = 0 ;
25523 32 : PyObject * obj0 = 0 ;
25524 : gpgme_sig_notation_t result;
25525 :
25526 32 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_notations_get",&obj0)) SWIG_fail;
25527 32 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25528 32 : if (!SWIG_IsOK(res1)) {
25529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_notations_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25530 : }
25531 32 : arg1 = (struct _gpgme_signature *)(argp1);
25532 : {
25533 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25534 32 : result = (gpgme_sig_notation_t) ((arg1)->notations);
25535 32 : SWIG_PYTHON_THREAD_END_ALLOW;
25536 : }
25537 : {
25538 : int i;
25539 32 : int size = 0;
25540 : gpgme_sig_notation_t curr;
25541 62 : for (curr = result; curr != NULL; curr = curr->next) {
25542 30 : size++;
25543 : }
25544 32 : resultobj = PyList_New(size);
25545 62 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
25546 30 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
25547 30 : PyList_SetItem(resultobj, i, o);
25548 : }
25549 : }
25550 : return resultobj;
25551 : fail:
25552 : return NULL;
25553 : }
25554 :
25555 :
25556 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557 0 : PyObject *resultobj = 0;
25558 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25559 : unsigned long arg2 ;
25560 0 : void *argp1 = 0 ;
25561 0 : int res1 = 0 ;
25562 : unsigned long val2 ;
25563 0 : int ecode2 = 0 ;
25564 0 : PyObject * obj0 = 0 ;
25565 0 : PyObject * obj1 = 0 ;
25566 :
25567 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_timestamp_set",&obj0,&obj1)) SWIG_fail;
25568 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25569 0 : if (!SWIG_IsOK(res1)) {
25570 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25571 : }
25572 0 : arg1 = (struct _gpgme_signature *)(argp1);
25573 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
25574 0 : if (!SWIG_IsOK(ecode2)) {
25575 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_timestamp_set" "', argument " "2"" of type '" "unsigned long""'");
25576 : }
25577 0 : arg2 = (unsigned long)(val2);
25578 : {
25579 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25580 0 : if (arg1) (arg1)->timestamp = arg2;
25581 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25582 : }
25583 0 : resultobj = SWIG_Py_Void();
25584 0 : return resultobj;
25585 : fail:
25586 : return NULL;
25587 : }
25588 :
25589 :
25590 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25591 16 : PyObject *resultobj = 0;
25592 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25593 16 : void *argp1 = 0 ;
25594 16 : int res1 = 0 ;
25595 16 : PyObject * obj0 = 0 ;
25596 : unsigned long result;
25597 :
25598 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_timestamp_get",&obj0)) SWIG_fail;
25599 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25600 16 : if (!SWIG_IsOK(res1)) {
25601 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25602 : }
25603 16 : arg1 = (struct _gpgme_signature *)(argp1);
25604 : {
25605 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25606 16 : result = (unsigned long) ((arg1)->timestamp);
25607 16 : SWIG_PYTHON_THREAD_END_ALLOW;
25608 : }
25609 16 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
25610 16 : return resultobj;
25611 : fail:
25612 : return NULL;
25613 : }
25614 :
25615 :
25616 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_exp_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25617 0 : PyObject *resultobj = 0;
25618 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25619 : unsigned long arg2 ;
25620 0 : void *argp1 = 0 ;
25621 0 : int res1 = 0 ;
25622 : unsigned long val2 ;
25623 0 : int ecode2 = 0 ;
25624 0 : PyObject * obj0 = 0 ;
25625 0 : PyObject * obj1 = 0 ;
25626 :
25627 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_exp_timestamp_set",&obj0,&obj1)) SWIG_fail;
25628 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25629 0 : if (!SWIG_IsOK(res1)) {
25630 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_exp_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25631 : }
25632 0 : arg1 = (struct _gpgme_signature *)(argp1);
25633 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
25634 0 : if (!SWIG_IsOK(ecode2)) {
25635 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_exp_timestamp_set" "', argument " "2"" of type '" "unsigned long""'");
25636 : }
25637 0 : arg2 = (unsigned long)(val2);
25638 : {
25639 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25640 0 : if (arg1) (arg1)->exp_timestamp = arg2;
25641 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25642 : }
25643 0 : resultobj = SWIG_Py_Void();
25644 0 : return resultobj;
25645 : fail:
25646 : return NULL;
25647 : }
25648 :
25649 :
25650 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_exp_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25651 16 : PyObject *resultobj = 0;
25652 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25653 16 : void *argp1 = 0 ;
25654 16 : int res1 = 0 ;
25655 16 : PyObject * obj0 = 0 ;
25656 : unsigned long result;
25657 :
25658 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_exp_timestamp_get",&obj0)) SWIG_fail;
25659 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25660 16 : if (!SWIG_IsOK(res1)) {
25661 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_exp_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25662 : }
25663 16 : arg1 = (struct _gpgme_signature *)(argp1);
25664 : {
25665 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25666 16 : result = (unsigned long) ((arg1)->exp_timestamp);
25667 16 : SWIG_PYTHON_THREAD_END_ALLOW;
25668 : }
25669 16 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
25670 16 : return resultobj;
25671 : fail:
25672 : return NULL;
25673 : }
25674 :
25675 :
25676 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_wrong_key_usage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25677 0 : PyObject *resultobj = 0;
25678 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25679 : unsigned int arg2 ;
25680 0 : void *argp1 = 0 ;
25681 0 : int res1 = 0 ;
25682 : unsigned int val2 ;
25683 0 : int ecode2 = 0 ;
25684 0 : PyObject * obj0 = 0 ;
25685 0 : PyObject * obj1 = 0 ;
25686 :
25687 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_wrong_key_usage_set",&obj0,&obj1)) SWIG_fail;
25688 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25689 0 : if (!SWIG_IsOK(res1)) {
25690 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_wrong_key_usage_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25691 : }
25692 0 : arg1 = (struct _gpgme_signature *)(argp1);
25693 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
25694 0 : if (!SWIG_IsOK(ecode2)) {
25695 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_wrong_key_usage_set" "', argument " "2"" of type '" "unsigned int""'");
25696 : }
25697 0 : arg2 = (unsigned int)(val2);
25698 : {
25699 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25700 0 : if (arg1) (arg1)->wrong_key_usage = arg2;
25701 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25702 : }
25703 0 : resultobj = SWIG_Py_Void();
25704 0 : return resultobj;
25705 : fail:
25706 : return NULL;
25707 : }
25708 :
25709 :
25710 32 : SWIGINTERN PyObject *_wrap__gpgme_signature_wrong_key_usage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25711 32 : PyObject *resultobj = 0;
25712 32 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25713 32 : void *argp1 = 0 ;
25714 32 : int res1 = 0 ;
25715 32 : PyObject * obj0 = 0 ;
25716 : unsigned int result;
25717 :
25718 32 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_wrong_key_usage_get",&obj0)) SWIG_fail;
25719 32 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25720 32 : if (!SWIG_IsOK(res1)) {
25721 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_wrong_key_usage_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25722 : }
25723 32 : arg1 = (struct _gpgme_signature *)(argp1);
25724 : {
25725 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25726 32 : result = (unsigned int) ((arg1)->wrong_key_usage);
25727 32 : SWIG_PYTHON_THREAD_END_ALLOW;
25728 : }
25729 32 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
25730 32 : return resultobj;
25731 : fail:
25732 : return NULL;
25733 : }
25734 :
25735 :
25736 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_trust_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25737 0 : PyObject *resultobj = 0;
25738 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25739 : unsigned int arg2 ;
25740 0 : void *argp1 = 0 ;
25741 0 : int res1 = 0 ;
25742 : unsigned int val2 ;
25743 0 : int ecode2 = 0 ;
25744 0 : PyObject * obj0 = 0 ;
25745 0 : PyObject * obj1 = 0 ;
25746 :
25747 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_pka_trust_set",&obj0,&obj1)) SWIG_fail;
25748 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25749 0 : if (!SWIG_IsOK(res1)) {
25750 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_trust_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25751 : }
25752 0 : arg1 = (struct _gpgme_signature *)(argp1);
25753 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
25754 0 : if (!SWIG_IsOK(ecode2)) {
25755 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_pka_trust_set" "', argument " "2"" of type '" "unsigned int""'");
25756 : }
25757 0 : arg2 = (unsigned int)(val2);
25758 : {
25759 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25760 0 : if (arg1) (arg1)->pka_trust = arg2;
25761 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25762 : }
25763 0 : resultobj = SWIG_Py_Void();
25764 0 : return resultobj;
25765 : fail:
25766 : return NULL;
25767 : }
25768 :
25769 :
25770 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_trust_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25771 16 : PyObject *resultobj = 0;
25772 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25773 16 : void *argp1 = 0 ;
25774 16 : int res1 = 0 ;
25775 16 : PyObject * obj0 = 0 ;
25776 : unsigned int result;
25777 :
25778 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pka_trust_get",&obj0)) SWIG_fail;
25779 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25780 16 : if (!SWIG_IsOK(res1)) {
25781 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_trust_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25782 : }
25783 16 : arg1 = (struct _gpgme_signature *)(argp1);
25784 : {
25785 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25786 16 : result = (unsigned int) ((arg1)->pka_trust);
25787 16 : SWIG_PYTHON_THREAD_END_ALLOW;
25788 : }
25789 16 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
25790 16 : return resultobj;
25791 : fail:
25792 : return NULL;
25793 : }
25794 :
25795 :
25796 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_chain_model_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25797 0 : PyObject *resultobj = 0;
25798 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25799 : unsigned int arg2 ;
25800 0 : void *argp1 = 0 ;
25801 0 : int res1 = 0 ;
25802 : unsigned int val2 ;
25803 0 : int ecode2 = 0 ;
25804 0 : PyObject * obj0 = 0 ;
25805 0 : PyObject * obj1 = 0 ;
25806 :
25807 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_chain_model_set",&obj0,&obj1)) SWIG_fail;
25808 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25809 0 : if (!SWIG_IsOK(res1)) {
25810 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_chain_model_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25811 : }
25812 0 : arg1 = (struct _gpgme_signature *)(argp1);
25813 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
25814 0 : if (!SWIG_IsOK(ecode2)) {
25815 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_chain_model_set" "', argument " "2"" of type '" "unsigned int""'");
25816 : }
25817 0 : arg2 = (unsigned int)(val2);
25818 : {
25819 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25820 0 : if (arg1) (arg1)->chain_model = arg2;
25821 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25822 : }
25823 0 : resultobj = SWIG_Py_Void();
25824 0 : return resultobj;
25825 : fail:
25826 : return NULL;
25827 : }
25828 :
25829 :
25830 32 : SWIGINTERN PyObject *_wrap__gpgme_signature_chain_model_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25831 32 : PyObject *resultobj = 0;
25832 32 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25833 32 : void *argp1 = 0 ;
25834 32 : int res1 = 0 ;
25835 32 : PyObject * obj0 = 0 ;
25836 : unsigned int result;
25837 :
25838 32 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_chain_model_get",&obj0)) SWIG_fail;
25839 32 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25840 32 : if (!SWIG_IsOK(res1)) {
25841 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_chain_model_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25842 : }
25843 32 : arg1 = (struct _gpgme_signature *)(argp1);
25844 : {
25845 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25846 32 : result = (unsigned int) ((arg1)->chain_model);
25847 32 : SWIG_PYTHON_THREAD_END_ALLOW;
25848 : }
25849 32 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
25850 32 : return resultobj;
25851 : fail:
25852 : return NULL;
25853 : }
25854 :
25855 :
25856 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_is_de_vs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25857 0 : PyObject *resultobj = 0;
25858 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25859 : unsigned int arg2 ;
25860 0 : void *argp1 = 0 ;
25861 0 : int res1 = 0 ;
25862 : unsigned int val2 ;
25863 0 : int ecode2 = 0 ;
25864 0 : PyObject * obj0 = 0 ;
25865 0 : PyObject * obj1 = 0 ;
25866 :
25867 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_is_de_vs_set",&obj0,&obj1)) SWIG_fail;
25868 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25869 0 : if (!SWIG_IsOK(res1)) {
25870 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_is_de_vs_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25871 : }
25872 0 : arg1 = (struct _gpgme_signature *)(argp1);
25873 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
25874 0 : if (!SWIG_IsOK(ecode2)) {
25875 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_is_de_vs_set" "', argument " "2"" of type '" "unsigned int""'");
25876 : }
25877 0 : arg2 = (unsigned int)(val2);
25878 : {
25879 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25880 0 : if (arg1) (arg1)->is_de_vs = arg2;
25881 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25882 : }
25883 0 : resultobj = SWIG_Py_Void();
25884 0 : return resultobj;
25885 : fail:
25886 : return NULL;
25887 : }
25888 :
25889 :
25890 32 : SWIGINTERN PyObject *_wrap__gpgme_signature_is_de_vs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25891 32 : PyObject *resultobj = 0;
25892 32 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25893 32 : void *argp1 = 0 ;
25894 32 : int res1 = 0 ;
25895 32 : PyObject * obj0 = 0 ;
25896 : unsigned int result;
25897 :
25898 32 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_is_de_vs_get",&obj0)) SWIG_fail;
25899 32 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25900 32 : if (!SWIG_IsOK(res1)) {
25901 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_is_de_vs_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25902 : }
25903 32 : arg1 = (struct _gpgme_signature *)(argp1);
25904 : {
25905 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25906 32 : result = (unsigned int) ((arg1)->is_de_vs);
25907 32 : SWIG_PYTHON_THREAD_END_ALLOW;
25908 : }
25909 32 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
25910 32 : return resultobj;
25911 : fail:
25912 : return NULL;
25913 : }
25914 :
25915 :
25916 0 : SWIGINTERN PyObject *_wrap__gpgme_signature__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25917 0 : PyObject *resultobj = 0;
25918 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25919 : int arg2 ;
25920 0 : void *argp1 = 0 ;
25921 0 : int res1 = 0 ;
25922 : int val2 ;
25923 0 : int ecode2 = 0 ;
25924 0 : PyObject * obj0 = 0 ;
25925 0 : PyObject * obj1 = 0 ;
25926 :
25927 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature__unused_set",&obj0,&obj1)) SWIG_fail;
25928 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25929 0 : if (!SWIG_IsOK(res1)) {
25930 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature__unused_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25931 : }
25932 0 : arg1 = (struct _gpgme_signature *)(argp1);
25933 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25934 0 : if (!SWIG_IsOK(ecode2)) {
25935 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature__unused_set" "', argument " "2"" of type '" "int""'");
25936 : }
25937 0 : arg2 = (int)(val2);
25938 : {
25939 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25940 0 : if (arg1) (arg1)->_unused = arg2;
25941 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25942 : }
25943 0 : resultobj = SWIG_Py_Void();
25944 0 : return resultobj;
25945 : fail:
25946 : return NULL;
25947 : }
25948 :
25949 :
25950 0 : SWIGINTERN PyObject *_wrap__gpgme_signature__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25951 0 : PyObject *resultobj = 0;
25952 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25953 0 : void *argp1 = 0 ;
25954 0 : int res1 = 0 ;
25955 0 : PyObject * obj0 = 0 ;
25956 : int result;
25957 :
25958 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature__unused_get",&obj0)) SWIG_fail;
25959 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25960 0 : if (!SWIG_IsOK(res1)) {
25961 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature__unused_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25962 : }
25963 0 : arg1 = (struct _gpgme_signature *)(argp1);
25964 : {
25965 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25966 0 : result = (int) ((arg1)->_unused);
25967 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25968 : }
25969 0 : resultobj = SWIG_From_int((int)(result));
25970 0 : return resultobj;
25971 : fail:
25972 : return NULL;
25973 : }
25974 :
25975 :
25976 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25977 0 : PyObject *resultobj = 0;
25978 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
25979 : gpgme_validity_t arg2 ;
25980 0 : void *argp1 = 0 ;
25981 0 : int res1 = 0 ;
25982 : int val2 ;
25983 0 : int ecode2 = 0 ;
25984 0 : PyObject * obj0 = 0 ;
25985 0 : PyObject * obj1 = 0 ;
25986 :
25987 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_validity_set",&obj0,&obj1)) SWIG_fail;
25988 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
25989 0 : if (!SWIG_IsOK(res1)) {
25990 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
25991 : }
25992 0 : arg1 = (struct _gpgme_signature *)(argp1);
25993 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25994 0 : if (!SWIG_IsOK(ecode2)) {
25995 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_validity_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
25996 : }
25997 0 : arg2 = (gpgme_validity_t)(val2);
25998 : {
25999 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26000 0 : if (arg1) (arg1)->validity = arg2;
26001 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26002 : }
26003 0 : resultobj = SWIG_Py_Void();
26004 0 : return resultobj;
26005 : fail:
26006 : return NULL;
26007 : }
26008 :
26009 :
26010 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26011 16 : PyObject *resultobj = 0;
26012 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26013 16 : void *argp1 = 0 ;
26014 16 : int res1 = 0 ;
26015 16 : PyObject * obj0 = 0 ;
26016 : gpgme_validity_t result;
26017 :
26018 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_validity_get",&obj0)) SWIG_fail;
26019 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26020 16 : if (!SWIG_IsOK(res1)) {
26021 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26022 : }
26023 16 : arg1 = (struct _gpgme_signature *)(argp1);
26024 : {
26025 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26026 16 : result = (gpgme_validity_t) ((arg1)->validity);
26027 16 : SWIG_PYTHON_THREAD_END_ALLOW;
26028 : }
26029 32 : resultobj = SWIG_From_int((int)(result));
26030 16 : return resultobj;
26031 : fail:
26032 : return NULL;
26033 : }
26034 :
26035 :
26036 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_reason_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26037 0 : PyObject *resultobj = 0;
26038 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26039 : gpgme_error_t arg2 ;
26040 0 : void *argp1 = 0 ;
26041 0 : int res1 = 0 ;
26042 0 : PyObject * obj0 = 0 ;
26043 0 : PyObject * obj1 = 0 ;
26044 :
26045 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_validity_reason_set",&obj0,&obj1)) SWIG_fail;
26046 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26047 0 : if (!SWIG_IsOK(res1)) {
26048 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_reason_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26049 : }
26050 0 : arg1 = (struct _gpgme_signature *)(argp1);
26051 : {
26052 0 : if (PyLong_Check(obj1))
26053 0 : arg2 = PyLong_AsLong(obj1);
26054 :
26055 : else if (PyInt_Check(obj1))
26056 : arg2 = PyInt_AsLong(obj1);
26057 :
26058 : else
26059 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
26060 : }
26061 : {
26062 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26063 0 : if (arg1) (arg1)->validity_reason = arg2;
26064 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26065 : }
26066 0 : resultobj = SWIG_Py_Void();
26067 0 : return resultobj;
26068 : fail:
26069 : return NULL;
26070 : }
26071 :
26072 :
26073 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_reason_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26074 16 : PyObject *resultobj = 0;
26075 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26076 16 : void *argp1 = 0 ;
26077 16 : int res1 = 0 ;
26078 16 : PyObject * obj0 = 0 ;
26079 : gpgme_error_t result;
26080 :
26081 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_validity_reason_get",&obj0)) SWIG_fail;
26082 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26083 16 : if (!SWIG_IsOK(res1)) {
26084 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_reason_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26085 : }
26086 16 : arg1 = (struct _gpgme_signature *)(argp1);
26087 : {
26088 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26089 16 : result = ((arg1)->validity_reason);
26090 16 : SWIG_PYTHON_THREAD_END_ALLOW;
26091 : }
26092 : {
26093 16 : resultobj = PyLong_FromLong(result);
26094 : }
26095 16 : return resultobj;
26096 : fail:
26097 : return NULL;
26098 : }
26099 :
26100 :
26101 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26102 0 : PyObject *resultobj = 0;
26103 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26104 : gpgme_pubkey_algo_t arg2 ;
26105 0 : void *argp1 = 0 ;
26106 0 : int res1 = 0 ;
26107 : int val2 ;
26108 0 : int ecode2 = 0 ;
26109 0 : PyObject * obj0 = 0 ;
26110 0 : PyObject * obj1 = 0 ;
26111 :
26112 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
26113 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26114 0 : if (!SWIG_IsOK(res1)) {
26115 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26116 : }
26117 0 : arg1 = (struct _gpgme_signature *)(argp1);
26118 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
26119 0 : if (!SWIG_IsOK(ecode2)) {
26120 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
26121 : }
26122 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
26123 : {
26124 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26125 0 : if (arg1) (arg1)->pubkey_algo = arg2;
26126 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26127 : }
26128 0 : resultobj = SWIG_Py_Void();
26129 0 : return resultobj;
26130 : fail:
26131 : return NULL;
26132 : }
26133 :
26134 :
26135 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26136 16 : PyObject *resultobj = 0;
26137 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26138 16 : void *argp1 = 0 ;
26139 16 : int res1 = 0 ;
26140 16 : PyObject * obj0 = 0 ;
26141 : gpgme_pubkey_algo_t result;
26142 :
26143 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pubkey_algo_get",&obj0)) SWIG_fail;
26144 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26145 16 : if (!SWIG_IsOK(res1)) {
26146 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26147 : }
26148 16 : arg1 = (struct _gpgme_signature *)(argp1);
26149 : {
26150 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26151 16 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
26152 16 : SWIG_PYTHON_THREAD_END_ALLOW;
26153 : }
26154 32 : resultobj = SWIG_From_int((int)(result));
26155 16 : return resultobj;
26156 : fail:
26157 : return NULL;
26158 : }
26159 :
26160 :
26161 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_hash_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26162 0 : PyObject *resultobj = 0;
26163 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26164 : gpgme_hash_algo_t arg2 ;
26165 0 : void *argp1 = 0 ;
26166 0 : int res1 = 0 ;
26167 : int val2 ;
26168 0 : int ecode2 = 0 ;
26169 0 : PyObject * obj0 = 0 ;
26170 0 : PyObject * obj1 = 0 ;
26171 :
26172 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_hash_algo_set",&obj0,&obj1)) SWIG_fail;
26173 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26174 0 : if (!SWIG_IsOK(res1)) {
26175 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_hash_algo_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26176 : }
26177 0 : arg1 = (struct _gpgme_signature *)(argp1);
26178 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
26179 0 : if (!SWIG_IsOK(ecode2)) {
26180 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_hash_algo_set" "', argument " "2"" of type '" "gpgme_hash_algo_t""'");
26181 : }
26182 0 : arg2 = (gpgme_hash_algo_t)(val2);
26183 : {
26184 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26185 0 : if (arg1) (arg1)->hash_algo = arg2;
26186 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26187 : }
26188 0 : resultobj = SWIG_Py_Void();
26189 0 : return resultobj;
26190 : fail:
26191 : return NULL;
26192 : }
26193 :
26194 :
26195 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_hash_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26196 16 : PyObject *resultobj = 0;
26197 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26198 16 : void *argp1 = 0 ;
26199 16 : int res1 = 0 ;
26200 16 : PyObject * obj0 = 0 ;
26201 : gpgme_hash_algo_t result;
26202 :
26203 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_hash_algo_get",&obj0)) SWIG_fail;
26204 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26205 16 : if (!SWIG_IsOK(res1)) {
26206 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_hash_algo_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26207 : }
26208 16 : arg1 = (struct _gpgme_signature *)(argp1);
26209 : {
26210 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26211 16 : result = (gpgme_hash_algo_t) ((arg1)->hash_algo);
26212 16 : SWIG_PYTHON_THREAD_END_ALLOW;
26213 : }
26214 32 : resultobj = SWIG_From_int((int)(result));
26215 16 : return resultobj;
26216 : fail:
26217 : return NULL;
26218 : }
26219 :
26220 :
26221 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_address_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 0 : PyObject *resultobj = 0;
26223 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26224 0 : char *arg2 = (char *) 0 ;
26225 0 : void *argp1 = 0 ;
26226 0 : int res1 = 0 ;
26227 : int res2 ;
26228 0 : char *buf2 = 0 ;
26229 0 : int alloc2 = 0 ;
26230 0 : PyObject * obj0 = 0 ;
26231 0 : PyObject * obj1 = 0 ;
26232 :
26233 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_pka_address_set",&obj0,&obj1)) SWIG_fail;
26234 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26235 0 : if (!SWIG_IsOK(res1)) {
26236 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_address_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26237 : }
26238 0 : arg1 = (struct _gpgme_signature *)(argp1);
26239 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26240 0 : if (!SWIG_IsOK(res2)) {
26241 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_pka_address_set" "', argument " "2"" of type '" "char *""'");
26242 : }
26243 0 : arg2 = (char *)(buf2);
26244 : {
26245 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26246 0 : if (arg1->pka_address) free((char*)arg1->pka_address);
26247 0 : if (arg2) {
26248 0 : size_t size = strlen((const char *)(arg2)) + 1;
26249 0 : arg1->pka_address = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
26250 : } else {
26251 0 : arg1->pka_address = 0;
26252 : }
26253 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26254 : }
26255 0 : resultobj = SWIG_Py_Void();
26256 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26257 : return resultobj;
26258 : fail:
26259 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26260 : return NULL;
26261 : }
26262 :
26263 :
26264 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_address_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26265 16 : PyObject *resultobj = 0;
26266 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26267 16 : void *argp1 = 0 ;
26268 16 : int res1 = 0 ;
26269 16 : PyObject * obj0 = 0 ;
26270 16 : char *result = 0 ;
26271 :
26272 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pka_address_get",&obj0)) SWIG_fail;
26273 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26274 16 : if (!SWIG_IsOK(res1)) {
26275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_address_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26276 : }
26277 16 : arg1 = (struct _gpgme_signature *)(argp1);
26278 : {
26279 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26280 16 : result = (char *) ((arg1)->pka_address);
26281 16 : SWIG_PYTHON_THREAD_END_ALLOW;
26282 : }
26283 16 : resultobj = SWIG_FromCharPtr((const char *)result);
26284 16 : return resultobj;
26285 : fail:
26286 : return NULL;
26287 : }
26288 :
26289 :
26290 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26291 0 : PyObject *resultobj = 0;
26292 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26293 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
26294 0 : void *argp1 = 0 ;
26295 0 : int res1 = 0 ;
26296 0 : void *argp2 = 0 ;
26297 0 : int res2 = 0 ;
26298 0 : PyObject * obj0 = 0 ;
26299 0 : PyObject * obj1 = 0 ;
26300 :
26301 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_key_set",&obj0,&obj1)) SWIG_fail;
26302 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26303 0 : if (!SWIG_IsOK(res1)) {
26304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_key_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26305 : }
26306 0 : arg1 = (struct _gpgme_signature *)(argp1);
26307 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, SWIG_POINTER_DISOWN | 0 );
26308 0 : if (!SWIG_IsOK(res2)) {
26309 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_key_set" "', argument " "2"" of type '" "gpgme_key_t""'");
26310 : }
26311 0 : arg2 = (gpgme_key_t)(argp2);
26312 : {
26313 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26314 0 : if (arg1) (arg1)->key = arg2;
26315 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26316 : }
26317 0 : resultobj = SWIG_Py_Void();
26318 0 : return resultobj;
26319 : fail:
26320 : return NULL;
26321 : }
26322 :
26323 :
26324 16 : SWIGINTERN PyObject *_wrap__gpgme_signature_key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26325 16 : PyObject *resultobj = 0;
26326 16 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26327 16 : void *argp1 = 0 ;
26328 16 : int res1 = 0 ;
26329 16 : PyObject * obj0 = 0 ;
26330 : gpgme_key_t result;
26331 :
26332 16 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_key_get",&obj0)) SWIG_fail;
26333 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
26334 16 : if (!SWIG_IsOK(res1)) {
26335 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_key_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26336 : }
26337 16 : arg1 = (struct _gpgme_signature *)(argp1);
26338 : {
26339 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26340 16 : result = (gpgme_key_t) ((arg1)->key);
26341 16 : SWIG_PYTHON_THREAD_END_ALLOW;
26342 : }
26343 16 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
26344 16 : return resultobj;
26345 : fail:
26346 : return NULL;
26347 : }
26348 :
26349 :
26350 0 : SWIGINTERN PyObject *_wrap_new__gpgme_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26351 0 : PyObject *resultobj = 0;
26352 0 : struct _gpgme_signature *result = 0 ;
26353 :
26354 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_signature")) SWIG_fail;
26355 : {
26356 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26357 0 : result = (struct _gpgme_signature *)calloc(1, sizeof(struct _gpgme_signature));
26358 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26359 : }
26360 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_signature, SWIG_POINTER_NEW | 0 );
26361 0 : return resultobj;
26362 : fail:
26363 : return NULL;
26364 : }
26365 :
26366 :
26367 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26368 0 : PyObject *resultobj = 0;
26369 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
26370 0 : void *argp1 = 0 ;
26371 0 : int res1 = 0 ;
26372 0 : PyObject * obj0 = 0 ;
26373 :
26374 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_signature",&obj0)) SWIG_fail;
26375 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, SWIG_POINTER_DISOWN | 0 );
26376 0 : if (!SWIG_IsOK(res1)) {
26377 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_signature" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
26378 : }
26379 0 : arg1 = (struct _gpgme_signature *)(argp1);
26380 : {
26381 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26382 0 : free((char *) arg1);
26383 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26384 : }
26385 0 : resultobj = SWIG_Py_Void();
26386 0 : return resultobj;
26387 : fail:
26388 : return NULL;
26389 : }
26390 :
26391 :
26392 29 : SWIGINTERN PyObject *_gpgme_signature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26393 : PyObject *obj;
26394 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
26395 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_signature, SWIG_NewClientData(obj));
26396 29 : return SWIG_Py_Void();
26397 : }
26398 :
26399 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_signatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26400 0 : PyObject *resultobj = 0;
26401 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26402 0 : gpgme_signature_t arg2 = (gpgme_signature_t) 0 ;
26403 0 : void *argp1 = 0 ;
26404 0 : int res1 = 0 ;
26405 0 : void *argp2 = 0 ;
26406 0 : int res2 = 0 ;
26407 0 : PyObject * obj0 = 0 ;
26408 0 : PyObject * obj1 = 0 ;
26409 :
26410 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_verify_result_signatures_set",&obj0,&obj1)) SWIG_fail;
26411 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
26412 0 : if (!SWIG_IsOK(res1)) {
26413 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_signatures_set" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
26414 : }
26415 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26416 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_signature, SWIG_POINTER_DISOWN | 0 );
26417 0 : if (!SWIG_IsOK(res2)) {
26418 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_verify_result_signatures_set" "', argument " "2"" of type '" "gpgme_signature_t""'");
26419 : }
26420 0 : arg2 = (gpgme_signature_t)(argp2);
26421 : {
26422 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26423 0 : if (arg1) (arg1)->signatures = arg2;
26424 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26425 : }
26426 0 : resultobj = SWIG_Py_Void();
26427 0 : return resultobj;
26428 : fail:
26429 : return NULL;
26430 : }
26431 :
26432 :
26433 40 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_signatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26434 40 : PyObject *resultobj = 0;
26435 40 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26436 40 : void *argp1 = 0 ;
26437 40 : int res1 = 0 ;
26438 40 : PyObject * obj0 = 0 ;
26439 : gpgme_signature_t result;
26440 :
26441 40 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_verify_result_signatures_get",&obj0)) SWIG_fail;
26442 40 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
26443 40 : if (!SWIG_IsOK(res1)) {
26444 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_signatures_get" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
26445 : }
26446 40 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26447 : {
26448 40 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26449 40 : result = (gpgme_signature_t) ((arg1)->signatures);
26450 40 : SWIG_PYTHON_THREAD_END_ALLOW;
26451 : }
26452 : {
26453 : int i;
26454 40 : int size = 0;
26455 : gpgme_signature_t curr;
26456 72 : for (curr = result; curr != NULL; curr = curr->next) {
26457 32 : size++;
26458 : }
26459 40 : resultobj = PyList_New(size);
26460 72 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
26461 32 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_signature, 0 );
26462 32 : PyList_SetItem(resultobj, i, o);
26463 : }
26464 : }
26465 : return resultobj;
26466 : fail:
26467 : return NULL;
26468 : }
26469 :
26470 :
26471 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_file_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26472 0 : PyObject *resultobj = 0;
26473 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26474 0 : char *arg2 = (char *) 0 ;
26475 0 : void *argp1 = 0 ;
26476 0 : int res1 = 0 ;
26477 : int res2 ;
26478 0 : char *buf2 = 0 ;
26479 0 : int alloc2 = 0 ;
26480 0 : PyObject * obj0 = 0 ;
26481 0 : PyObject * obj1 = 0 ;
26482 :
26483 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_verify_result_file_name_set",&obj0,&obj1)) SWIG_fail;
26484 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
26485 0 : if (!SWIG_IsOK(res1)) {
26486 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 *""'");
26487 : }
26488 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26489 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26490 0 : if (!SWIG_IsOK(res2)) {
26491 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_verify_result_file_name_set" "', argument " "2"" of type '" "char *""'");
26492 : }
26493 0 : arg2 = (char *)(buf2);
26494 : {
26495 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26496 0 : if (arg1->file_name) free((char*)arg1->file_name);
26497 0 : if (arg2) {
26498 0 : size_t size = strlen((const char *)(arg2)) + 1;
26499 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
26500 : } else {
26501 0 : arg1->file_name = 0;
26502 : }
26503 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26504 : }
26505 0 : resultobj = SWIG_Py_Void();
26506 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26507 : return resultobj;
26508 : fail:
26509 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26510 : return NULL;
26511 : }
26512 :
26513 :
26514 20 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_file_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26515 20 : PyObject *resultobj = 0;
26516 20 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26517 20 : void *argp1 = 0 ;
26518 20 : int res1 = 0 ;
26519 20 : PyObject * obj0 = 0 ;
26520 20 : char *result = 0 ;
26521 :
26522 20 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_verify_result_file_name_get",&obj0)) SWIG_fail;
26523 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
26524 20 : if (!SWIG_IsOK(res1)) {
26525 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 *""'");
26526 : }
26527 20 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26528 : {
26529 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26530 20 : result = (char *) ((arg1)->file_name);
26531 20 : SWIG_PYTHON_THREAD_END_ALLOW;
26532 : }
26533 20 : resultobj = SWIG_FromCharPtr((const char *)result);
26534 20 : return resultobj;
26535 : fail:
26536 : return NULL;
26537 : }
26538 :
26539 :
26540 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_is_mime_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26541 0 : PyObject *resultobj = 0;
26542 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26543 : unsigned int arg2 ;
26544 0 : void *argp1 = 0 ;
26545 0 : int res1 = 0 ;
26546 : unsigned int val2 ;
26547 0 : int ecode2 = 0 ;
26548 0 : PyObject * obj0 = 0 ;
26549 0 : PyObject * obj1 = 0 ;
26550 :
26551 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_verify_result_is_mime_set",&obj0,&obj1)) SWIG_fail;
26552 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
26553 0 : if (!SWIG_IsOK(res1)) {
26554 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_is_mime_set" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
26555 : }
26556 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26557 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
26558 0 : if (!SWIG_IsOK(ecode2)) {
26559 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_verify_result_is_mime_set" "', argument " "2"" of type '" "unsigned int""'");
26560 : }
26561 0 : arg2 = (unsigned int)(val2);
26562 : {
26563 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26564 0 : if (arg1) (arg1)->is_mime = arg2;
26565 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26566 : }
26567 0 : resultobj = SWIG_Py_Void();
26568 0 : return resultobj;
26569 : fail:
26570 : return NULL;
26571 : }
26572 :
26573 :
26574 20 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_is_mime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26575 20 : PyObject *resultobj = 0;
26576 20 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26577 20 : void *argp1 = 0 ;
26578 20 : int res1 = 0 ;
26579 20 : PyObject * obj0 = 0 ;
26580 : unsigned int result;
26581 :
26582 20 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_verify_result_is_mime_get",&obj0)) SWIG_fail;
26583 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
26584 20 : if (!SWIG_IsOK(res1)) {
26585 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_is_mime_get" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
26586 : }
26587 20 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26588 : {
26589 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26590 20 : result = (unsigned int) ((arg1)->is_mime);
26591 20 : SWIG_PYTHON_THREAD_END_ALLOW;
26592 : }
26593 20 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
26594 20 : return resultobj;
26595 : fail:
26596 : return NULL;
26597 : }
26598 :
26599 :
26600 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26601 0 : PyObject *resultobj = 0;
26602 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26603 : unsigned int arg2 ;
26604 0 : void *argp1 = 0 ;
26605 0 : int res1 = 0 ;
26606 : unsigned int val2 ;
26607 0 : int ecode2 = 0 ;
26608 0 : PyObject * obj0 = 0 ;
26609 0 : PyObject * obj1 = 0 ;
26610 :
26611 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_verify_result__unused_set",&obj0,&obj1)) SWIG_fail;
26612 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
26613 0 : if (!SWIG_IsOK(res1)) {
26614 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
26615 : }
26616 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26617 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
26618 0 : if (!SWIG_IsOK(ecode2)) {
26619 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_verify_result__unused_set" "', argument " "2"" of type '" "unsigned int""'");
26620 : }
26621 0 : arg2 = (unsigned int)(val2);
26622 : {
26623 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26624 0 : if (arg1) (arg1)->_unused = arg2;
26625 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26626 : }
26627 0 : resultobj = SWIG_Py_Void();
26628 0 : return resultobj;
26629 : fail:
26630 : return NULL;
26631 : }
26632 :
26633 :
26634 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26635 0 : PyObject *resultobj = 0;
26636 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26637 0 : void *argp1 = 0 ;
26638 0 : int res1 = 0 ;
26639 0 : PyObject * obj0 = 0 ;
26640 : unsigned int result;
26641 :
26642 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_verify_result__unused_get",&obj0)) SWIG_fail;
26643 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
26644 0 : if (!SWIG_IsOK(res1)) {
26645 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
26646 : }
26647 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26648 : {
26649 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26650 0 : result = (unsigned int) ((arg1)->_unused);
26651 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26652 : }
26653 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
26654 0 : return resultobj;
26655 : fail:
26656 : return NULL;
26657 : }
26658 :
26659 :
26660 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_verify_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26661 0 : PyObject *resultobj = 0;
26662 0 : struct _gpgme_op_verify_result *result = 0 ;
26663 :
26664 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_verify_result")) SWIG_fail;
26665 : {
26666 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26667 0 : result = (struct _gpgme_op_verify_result *)calloc(1, sizeof(struct _gpgme_op_verify_result));
26668 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26669 : }
26670 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_verify_result, SWIG_POINTER_NEW | 0 );
26671 0 : return resultobj;
26672 : fail:
26673 : return NULL;
26674 : }
26675 :
26676 :
26677 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_verify_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26678 0 : PyObject *resultobj = 0;
26679 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
26680 0 : void *argp1 = 0 ;
26681 0 : int res1 = 0 ;
26682 0 : PyObject * obj0 = 0 ;
26683 :
26684 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_verify_result",&obj0)) SWIG_fail;
26685 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, SWIG_POINTER_DISOWN | 0 );
26686 0 : if (!SWIG_IsOK(res1)) {
26687 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_verify_result" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
26688 : }
26689 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
26690 : {
26691 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26692 0 : free((char *) arg1);
26693 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26694 : }
26695 0 : resultobj = SWIG_Py_Void();
26696 0 : return resultobj;
26697 : fail:
26698 : return NULL;
26699 : }
26700 :
26701 :
26702 29 : SWIGINTERN PyObject *_gpgme_op_verify_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26703 : PyObject *obj;
26704 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
26705 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_verify_result, SWIG_NewClientData(obj));
26706 29 : return SWIG_Py_Void();
26707 : }
26708 :
26709 20 : SWIGINTERN PyObject *_wrap_gpgme_op_verify_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26710 20 : PyObject *resultobj = 0;
26711 20 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26712 20 : void *argp1 = 0 ;
26713 20 : int res1 = 0 ;
26714 20 : PyObject * obj0 = 0 ;
26715 : gpgme_verify_result_t result;
26716 :
26717 20 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_verify_result",&obj0)) SWIG_fail;
26718 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26719 20 : if (!SWIG_IsOK(res1)) {
26720 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26721 : }
26722 20 : arg1 = (gpgme_ctx_t)(argp1);
26723 : {
26724 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26725 20 : result = (gpgme_verify_result_t)gpgme_op_verify_result(arg1);
26726 20 : SWIG_PYTHON_THREAD_END_ALLOW;
26727 : }
26728 : {
26729 : PyObject *fragile;
26730 20 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_verify_result,
26731 : 0 );
26732 20 : resultobj = _gpg_wrap_result(fragile, "VerifyResult");
26733 20 : Py_DECREF(fragile);
26734 : }
26735 : return resultobj;
26736 : fail:
26737 : return NULL;
26738 : }
26739 :
26740 :
26741 1 : SWIGINTERN PyObject *_wrap_gpgme_op_verify_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26742 1 : PyObject *resultobj = 0;
26743 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26744 1 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
26745 1 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
26746 1 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
26747 1 : void *argp1 = 0 ;
26748 1 : int res1 = 0 ;
26749 1 : gpgme_data_t wrapper2 = NULL ;
26750 1 : PyObject *bytesio2 = NULL ;
26751 : Py_buffer view2 ;
26752 1 : int have_view2 = 0 ;
26753 1 : gpgme_data_t wrapper3 = NULL ;
26754 1 : PyObject *bytesio3 = NULL ;
26755 : Py_buffer view3 ;
26756 1 : int have_view3 = 0 ;
26757 1 : gpgme_data_t wrapper4 = NULL ;
26758 1 : PyObject *bytesio4 = NULL ;
26759 : Py_buffer view4 ;
26760 1 : int have_view4 = 0 ;
26761 1 : PyObject * obj0 = 0 ;
26762 1 : PyObject * obj1 = 0 ;
26763 1 : PyObject * obj2 = 0 ;
26764 1 : PyObject * obj3 = 0 ;
26765 : gpgme_error_t result;
26766 :
26767 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_verify_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26768 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26769 1 : if (!SWIG_IsOK(res1)) {
26770 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26771 : }
26772 1 : arg1 = (gpgme_ctx_t)(argp1);
26773 : {
26774 : /* If we create a temporary wrapper2 object, we will store it in
26775 : wrapperN, where N is 2. Here in this fragment, SWIG will
26776 : automatically append 2. */
26777 1 : memset(&view2, 0, sizeof view2);
26778 1 : if (obj1 == Py_None)
26779 0 : arg2 = NULL;
26780 : else {
26781 : PyObject *pypointer;
26782 1 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
26783 : &bytesio2, &view2);
26784 1 : if (pypointer == NULL)
26785 : return NULL;
26786 1 : have_view2 = !! view2.obj;
26787 :
26788 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
26789 :
26790 : /* Following code is from swig's python.swg. */
26791 :
26792 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
26793 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26794 0 : Py_DECREF(pypointer);
26795 : return NULL;
26796 : }
26797 1 : Py_DECREF(pypointer);
26798 : }
26799 : }
26800 : {
26801 : /* If we create a temporary wrapper3 object, we will store it in
26802 : wrapperN, where N is 3. Here in this fragment, SWIG will
26803 : automatically append 3. */
26804 1 : memset(&view3, 0, sizeof view3);
26805 1 : if (obj2 == Py_None)
26806 1 : arg3 = NULL;
26807 : else {
26808 : PyObject *pypointer;
26809 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
26810 : &bytesio3, &view3);
26811 0 : if (pypointer == NULL)
26812 : return NULL;
26813 0 : have_view3 = !! view3.obj;
26814 :
26815 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
26816 :
26817 : /* Following code is from swig's python.swg. */
26818 :
26819 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
26820 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26821 0 : Py_DECREF(pypointer);
26822 : return NULL;
26823 : }
26824 0 : Py_DECREF(pypointer);
26825 : }
26826 : }
26827 : {
26828 : /* If we create a temporary wrapper4 object, we will store it in
26829 : wrapperN, where N is 4. Here in this fragment, SWIG will
26830 : automatically append 4. */
26831 1 : memset(&view4, 0, sizeof view4);
26832 1 : if (obj3 == Py_None)
26833 0 : arg4 = NULL;
26834 : else {
26835 : PyObject *pypointer;
26836 1 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
26837 : &bytesio4, &view4);
26838 1 : if (pypointer == NULL)
26839 : return NULL;
26840 1 : have_view4 = !! view4.obj;
26841 :
26842 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
26843 :
26844 : /* Following code is from swig's python.swg. */
26845 :
26846 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
26847 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26848 0 : Py_DECREF(pypointer);
26849 : return NULL;
26850 : }
26851 1 : Py_DECREF(pypointer);
26852 : }
26853 : }
26854 : {
26855 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26856 1 : result = gpgme_op_verify_start(arg1,arg2,arg3,arg4);
26857 1 : SWIG_PYTHON_THREAD_END_ALLOW;
26858 : }
26859 : {
26860 1 : resultobj = PyLong_FromLong(result);
26861 : }
26862 : {
26863 : /* See whether we need to update the Python buffer. */
26864 1 : if (resultobj && wrapper2 && view2.buf)
26865 : {
26866 : int dirty;
26867 0 : char *new_data = NULL;
26868 : size_t new_size;
26869 :
26870 :
26871 0 : new_data = wrapper2->data.mem.buffer;
26872 0 : new_size = wrapper2->data.mem.length;
26873 0 : dirty = new_data != NULL;
26874 :
26875 :
26876 :
26877 :
26878 :
26879 :
26880 :
26881 0 : if (dirty)
26882 : {
26883 : /* The buffer is dirty. */
26884 0 : if (view2.readonly)
26885 : {
26886 0 : Py_XDECREF(resultobj);
26887 0 : resultobj = NULL;
26888 0 : PyErr_SetString(PyExc_ValueError,
26889 : "cannot update read-only buffer");
26890 : }
26891 :
26892 : /* See if we need to truncate the buffer. */
26893 0 : if (resultobj && view2.len != new_size)
26894 : {
26895 0 : if (bytesio2 == NULL)
26896 : {
26897 0 : Py_XDECREF(resultobj);
26898 0 : resultobj = NULL;
26899 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26900 : }
26901 : else
26902 : {
26903 : PyObject *retval;
26904 0 : PyBuffer_Release(&view2);
26905 : assert(view2.obj == NULL);
26906 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
26907 : "l", (long) new_size);
26908 0 : if (retval == NULL)
26909 : {
26910 0 : Py_XDECREF(resultobj);
26911 : resultobj = NULL;
26912 : }
26913 : else
26914 : {
26915 0 : Py_DECREF(retval);
26916 :
26917 0 : retval = PyObject_CallMethod(bytesio2,
26918 : "getbuffer", NULL);
26919 0 : if (retval == NULL
26920 0 : || PyObject_GetBuffer(retval, &view2,
26921 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26922 : {
26923 0 : Py_XDECREF(resultobj);
26924 : resultobj = NULL;
26925 : }
26926 :
26927 0 : Py_XDECREF(retval);
26928 :
26929 0 : if (resultobj && view2.len
26930 : != new_size)
26931 : {
26932 0 : Py_XDECREF(resultobj);
26933 0 : resultobj = NULL;
26934 0 : PyErr_Format(PyExc_ValueError,
26935 : "Expected buffer of length %zu, got %zi",
26936 : new_size,
26937 : view2.len);
26938 : }
26939 : }
26940 : }
26941 : }
26942 0 : if (resultobj)
26943 0 : memcpy(view2.buf, new_data, new_size);
26944 : }
26945 :
26946 :
26947 :
26948 : }
26949 :
26950 : /* Free the temporary wrapper, if any. */
26951 1 : if (wrapper2)
26952 0 : gpgme_data_release(wrapper2);
26953 1 : Py_XDECREF (bytesio2);
26954 1 : if (have_view2 && view2.buf)
26955 0 : PyBuffer_Release(&view2);
26956 : }
26957 : {
26958 : /* See whether we need to update the Python buffer. */
26959 1 : if (resultobj && wrapper3 && view3.buf)
26960 : {
26961 : int dirty;
26962 0 : char *new_data = NULL;
26963 : size_t new_size;
26964 :
26965 :
26966 0 : new_data = wrapper3->data.mem.buffer;
26967 0 : new_size = wrapper3->data.mem.length;
26968 0 : dirty = new_data != NULL;
26969 :
26970 :
26971 :
26972 :
26973 :
26974 :
26975 :
26976 0 : if (dirty)
26977 : {
26978 : /* The buffer is dirty. */
26979 0 : if (view3.readonly)
26980 : {
26981 0 : Py_XDECREF(resultobj);
26982 0 : resultobj = NULL;
26983 0 : PyErr_SetString(PyExc_ValueError,
26984 : "cannot update read-only buffer");
26985 : }
26986 :
26987 : /* See if we need to truncate the buffer. */
26988 0 : if (resultobj && view3.len != new_size)
26989 : {
26990 0 : if (bytesio3 == NULL)
26991 : {
26992 0 : Py_XDECREF(resultobj);
26993 0 : resultobj = NULL;
26994 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26995 : }
26996 : else
26997 : {
26998 : PyObject *retval;
26999 0 : PyBuffer_Release(&view3);
27000 : assert(view3.obj == NULL);
27001 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
27002 : "l", (long) new_size);
27003 0 : if (retval == NULL)
27004 : {
27005 0 : Py_XDECREF(resultobj);
27006 : resultobj = NULL;
27007 : }
27008 : else
27009 : {
27010 0 : Py_DECREF(retval);
27011 :
27012 0 : retval = PyObject_CallMethod(bytesio3,
27013 : "getbuffer", NULL);
27014 0 : if (retval == NULL
27015 0 : || PyObject_GetBuffer(retval, &view3,
27016 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27017 : {
27018 0 : Py_XDECREF(resultobj);
27019 : resultobj = NULL;
27020 : }
27021 :
27022 0 : Py_XDECREF(retval);
27023 :
27024 0 : if (resultobj && view3.len
27025 : != new_size)
27026 : {
27027 0 : Py_XDECREF(resultobj);
27028 0 : resultobj = NULL;
27029 0 : PyErr_Format(PyExc_ValueError,
27030 : "Expected buffer of length %zu, got %zi",
27031 : new_size,
27032 : view3.len);
27033 : }
27034 : }
27035 : }
27036 : }
27037 0 : if (resultobj)
27038 0 : memcpy(view3.buf, new_data, new_size);
27039 : }
27040 :
27041 :
27042 :
27043 : }
27044 :
27045 : /* Free the temporary wrapper, if any. */
27046 1 : if (wrapper3)
27047 0 : gpgme_data_release(wrapper3);
27048 1 : Py_XDECREF (bytesio3);
27049 1 : if (have_view3 && view3.buf)
27050 0 : PyBuffer_Release(&view3);
27051 : }
27052 : {
27053 : /* See whether we need to update the Python buffer. */
27054 1 : if (resultobj && wrapper4 && view4.buf)
27055 : {
27056 : int dirty;
27057 0 : char *new_data = NULL;
27058 : size_t new_size;
27059 :
27060 :
27061 0 : new_data = wrapper4->data.mem.buffer;
27062 0 : new_size = wrapper4->data.mem.length;
27063 0 : dirty = new_data != NULL;
27064 :
27065 :
27066 :
27067 :
27068 :
27069 :
27070 :
27071 0 : if (dirty)
27072 : {
27073 : /* The buffer is dirty. */
27074 0 : if (view4.readonly)
27075 : {
27076 0 : Py_XDECREF(resultobj);
27077 0 : resultobj = NULL;
27078 0 : PyErr_SetString(PyExc_ValueError,
27079 : "cannot update read-only buffer");
27080 : }
27081 :
27082 : /* See if we need to truncate the buffer. */
27083 0 : if (resultobj && view4.len != new_size)
27084 : {
27085 0 : if (bytesio4 == NULL)
27086 : {
27087 0 : Py_XDECREF(resultobj);
27088 0 : resultobj = NULL;
27089 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27090 : }
27091 : else
27092 : {
27093 : PyObject *retval;
27094 0 : PyBuffer_Release(&view4);
27095 : assert(view4.obj == NULL);
27096 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
27097 : "l", (long) new_size);
27098 0 : if (retval == NULL)
27099 : {
27100 0 : Py_XDECREF(resultobj);
27101 : resultobj = NULL;
27102 : }
27103 : else
27104 : {
27105 0 : Py_DECREF(retval);
27106 :
27107 0 : retval = PyObject_CallMethod(bytesio4,
27108 : "getbuffer", NULL);
27109 0 : if (retval == NULL
27110 0 : || PyObject_GetBuffer(retval, &view4,
27111 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27112 : {
27113 0 : Py_XDECREF(resultobj);
27114 : resultobj = NULL;
27115 : }
27116 :
27117 0 : Py_XDECREF(retval);
27118 :
27119 0 : if (resultobj && view4.len
27120 : != new_size)
27121 : {
27122 0 : Py_XDECREF(resultobj);
27123 0 : resultobj = NULL;
27124 0 : PyErr_Format(PyExc_ValueError,
27125 : "Expected buffer of length %zu, got %zi",
27126 : new_size,
27127 : view4.len);
27128 : }
27129 : }
27130 : }
27131 : }
27132 0 : if (resultobj)
27133 0 : memcpy(view4.buf, new_data, new_size);
27134 : }
27135 :
27136 :
27137 :
27138 : }
27139 :
27140 : /* Free the temporary wrapper, if any. */
27141 1 : if (wrapper4)
27142 0 : gpgme_data_release(wrapper4);
27143 1 : Py_XDECREF (bytesio4);
27144 1 : if (have_view4 && view4.buf)
27145 0 : PyBuffer_Release(&view4);
27146 : }
27147 : return resultobj;
27148 : fail:
27149 : {
27150 : /* See whether we need to update the Python buffer. */
27151 : if (resultobj && wrapper2 && view2.buf)
27152 : {
27153 : int dirty;
27154 : char *new_data = NULL;
27155 : size_t new_size;
27156 :
27157 :
27158 : new_data = wrapper2->data.mem.buffer;
27159 : new_size = wrapper2->data.mem.length;
27160 : dirty = new_data != NULL;
27161 :
27162 :
27163 :
27164 :
27165 :
27166 :
27167 :
27168 : if (dirty)
27169 : {
27170 : /* The buffer is dirty. */
27171 : if (view2.readonly)
27172 : {
27173 : Py_XDECREF(resultobj);
27174 : resultobj = NULL;
27175 : PyErr_SetString(PyExc_ValueError,
27176 : "cannot update read-only buffer");
27177 : }
27178 :
27179 : /* See if we need to truncate the buffer. */
27180 : if (resultobj && view2.len != new_size)
27181 : {
27182 : if (bytesio2 == NULL)
27183 : {
27184 : Py_XDECREF(resultobj);
27185 : resultobj = NULL;
27186 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27187 : }
27188 : else
27189 : {
27190 : PyObject *retval;
27191 : PyBuffer_Release(&view2);
27192 : assert(view2.obj == NULL);
27193 : retval = PyObject_CallMethod(bytesio2, "truncate",
27194 : "l", (long) new_size);
27195 : if (retval == NULL)
27196 : {
27197 : Py_XDECREF(resultobj);
27198 : resultobj = NULL;
27199 : }
27200 : else
27201 : {
27202 : Py_DECREF(retval);
27203 :
27204 : retval = PyObject_CallMethod(bytesio2,
27205 : "getbuffer", NULL);
27206 : if (retval == NULL
27207 : || PyObject_GetBuffer(retval, &view2,
27208 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27209 : {
27210 : Py_XDECREF(resultobj);
27211 : resultobj = NULL;
27212 : }
27213 :
27214 : Py_XDECREF(retval);
27215 :
27216 : if (resultobj && view2.len
27217 : != new_size)
27218 : {
27219 : Py_XDECREF(resultobj);
27220 : resultobj = NULL;
27221 : PyErr_Format(PyExc_ValueError,
27222 : "Expected buffer of length %zu, got %zi",
27223 : new_size,
27224 : view2.len);
27225 : }
27226 : }
27227 : }
27228 : }
27229 : if (resultobj)
27230 : memcpy(view2.buf, new_data, new_size);
27231 : }
27232 :
27233 :
27234 :
27235 : }
27236 :
27237 : /* Free the temporary wrapper, if any. */
27238 0 : if (wrapper2)
27239 0 : gpgme_data_release(wrapper2);
27240 0 : Py_XDECREF (bytesio2);
27241 : if (have_view2 && view2.buf)
27242 : PyBuffer_Release(&view2);
27243 : }
27244 : {
27245 : /* See whether we need to update the Python buffer. */
27246 : if (resultobj && wrapper3 && view3.buf)
27247 : {
27248 : int dirty;
27249 : char *new_data = NULL;
27250 : size_t new_size;
27251 :
27252 :
27253 : new_data = wrapper3->data.mem.buffer;
27254 : new_size = wrapper3->data.mem.length;
27255 : dirty = new_data != NULL;
27256 :
27257 :
27258 :
27259 :
27260 :
27261 :
27262 :
27263 : if (dirty)
27264 : {
27265 : /* The buffer is dirty. */
27266 : if (view3.readonly)
27267 : {
27268 : Py_XDECREF(resultobj);
27269 : resultobj = NULL;
27270 : PyErr_SetString(PyExc_ValueError,
27271 : "cannot update read-only buffer");
27272 : }
27273 :
27274 : /* See if we need to truncate the buffer. */
27275 : if (resultobj && view3.len != new_size)
27276 : {
27277 : if (bytesio3 == NULL)
27278 : {
27279 : Py_XDECREF(resultobj);
27280 : resultobj = NULL;
27281 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27282 : }
27283 : else
27284 : {
27285 : PyObject *retval;
27286 : PyBuffer_Release(&view3);
27287 : assert(view3.obj == NULL);
27288 : retval = PyObject_CallMethod(bytesio3, "truncate",
27289 : "l", (long) new_size);
27290 : if (retval == NULL)
27291 : {
27292 : Py_XDECREF(resultobj);
27293 : resultobj = NULL;
27294 : }
27295 : else
27296 : {
27297 : Py_DECREF(retval);
27298 :
27299 : retval = PyObject_CallMethod(bytesio3,
27300 : "getbuffer", NULL);
27301 : if (retval == NULL
27302 : || PyObject_GetBuffer(retval, &view3,
27303 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27304 : {
27305 : Py_XDECREF(resultobj);
27306 : resultobj = NULL;
27307 : }
27308 :
27309 : Py_XDECREF(retval);
27310 :
27311 : if (resultobj && view3.len
27312 : != new_size)
27313 : {
27314 : Py_XDECREF(resultobj);
27315 : resultobj = NULL;
27316 : PyErr_Format(PyExc_ValueError,
27317 : "Expected buffer of length %zu, got %zi",
27318 : new_size,
27319 : view3.len);
27320 : }
27321 : }
27322 : }
27323 : }
27324 : if (resultobj)
27325 : memcpy(view3.buf, new_data, new_size);
27326 : }
27327 :
27328 :
27329 :
27330 : }
27331 :
27332 : /* Free the temporary wrapper, if any. */
27333 0 : if (wrapper3)
27334 0 : gpgme_data_release(wrapper3);
27335 0 : Py_XDECREF (bytesio3);
27336 : if (have_view3 && view3.buf)
27337 : PyBuffer_Release(&view3);
27338 : }
27339 : {
27340 : /* See whether we need to update the Python buffer. */
27341 : if (resultobj && wrapper4 && view4.buf)
27342 : {
27343 : int dirty;
27344 : char *new_data = NULL;
27345 : size_t new_size;
27346 :
27347 :
27348 : new_data = wrapper4->data.mem.buffer;
27349 : new_size = wrapper4->data.mem.length;
27350 : dirty = new_data != NULL;
27351 :
27352 :
27353 :
27354 :
27355 :
27356 :
27357 :
27358 : if (dirty)
27359 : {
27360 : /* The buffer is dirty. */
27361 : if (view4.readonly)
27362 : {
27363 : Py_XDECREF(resultobj);
27364 : resultobj = NULL;
27365 : PyErr_SetString(PyExc_ValueError,
27366 : "cannot update read-only buffer");
27367 : }
27368 :
27369 : /* See if we need to truncate the buffer. */
27370 : if (resultobj && view4.len != new_size)
27371 : {
27372 : if (bytesio4 == NULL)
27373 : {
27374 : Py_XDECREF(resultobj);
27375 : resultobj = NULL;
27376 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27377 : }
27378 : else
27379 : {
27380 : PyObject *retval;
27381 : PyBuffer_Release(&view4);
27382 : assert(view4.obj == NULL);
27383 : retval = PyObject_CallMethod(bytesio4, "truncate",
27384 : "l", (long) new_size);
27385 : if (retval == NULL)
27386 : {
27387 : Py_XDECREF(resultobj);
27388 : resultobj = NULL;
27389 : }
27390 : else
27391 : {
27392 : Py_DECREF(retval);
27393 :
27394 : retval = PyObject_CallMethod(bytesio4,
27395 : "getbuffer", NULL);
27396 : if (retval == NULL
27397 : || PyObject_GetBuffer(retval, &view4,
27398 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27399 : {
27400 : Py_XDECREF(resultobj);
27401 : resultobj = NULL;
27402 : }
27403 :
27404 : Py_XDECREF(retval);
27405 :
27406 : if (resultobj && view4.len
27407 : != new_size)
27408 : {
27409 : Py_XDECREF(resultobj);
27410 : resultobj = NULL;
27411 : PyErr_Format(PyExc_ValueError,
27412 : "Expected buffer of length %zu, got %zi",
27413 : new_size,
27414 : view4.len);
27415 : }
27416 : }
27417 : }
27418 : }
27419 : if (resultobj)
27420 : memcpy(view4.buf, new_data, new_size);
27421 : }
27422 :
27423 :
27424 :
27425 : }
27426 :
27427 : /* Free the temporary wrapper, if any. */
27428 0 : if (wrapper4)
27429 0 : gpgme_data_release(wrapper4);
27430 0 : Py_XDECREF (bytesio4);
27431 : if (have_view4 && view4.buf)
27432 : PyBuffer_Release(&view4);
27433 : }
27434 : return NULL;
27435 : }
27436 :
27437 :
27438 13 : SWIGINTERN PyObject *_wrap_gpgme_op_verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27439 13 : PyObject *resultobj = 0;
27440 13 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27441 13 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
27442 13 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
27443 13 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
27444 13 : void *argp1 = 0 ;
27445 13 : int res1 = 0 ;
27446 13 : gpgme_data_t wrapper2 = NULL ;
27447 13 : PyObject *bytesio2 = NULL ;
27448 : Py_buffer view2 ;
27449 13 : int have_view2 = 0 ;
27450 13 : gpgme_data_t wrapper3 = NULL ;
27451 13 : PyObject *bytesio3 = NULL ;
27452 : Py_buffer view3 ;
27453 13 : int have_view3 = 0 ;
27454 13 : gpgme_data_t wrapper4 = NULL ;
27455 13 : PyObject *bytesio4 = NULL ;
27456 : Py_buffer view4 ;
27457 13 : int have_view4 = 0 ;
27458 13 : PyObject * obj0 = 0 ;
27459 13 : PyObject * obj1 = 0 ;
27460 13 : PyObject * obj2 = 0 ;
27461 13 : PyObject * obj3 = 0 ;
27462 : gpgme_error_t result;
27463 :
27464 13 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_verify",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27465 13 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27466 13 : if (!SWIG_IsOK(res1)) {
27467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27468 : }
27469 13 : arg1 = (gpgme_ctx_t)(argp1);
27470 : {
27471 : /* If we create a temporary wrapper2 object, we will store it in
27472 : wrapperN, where N is 2. Here in this fragment, SWIG will
27473 : automatically append 2. */
27474 13 : memset(&view2, 0, sizeof view2);
27475 13 : if (obj1 == Py_None)
27476 0 : arg2 = NULL;
27477 : else {
27478 : PyObject *pypointer;
27479 13 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
27480 : &bytesio2, &view2);
27481 13 : if (pypointer == NULL)
27482 : return NULL;
27483 13 : have_view2 = !! view2.obj;
27484 :
27485 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
27486 :
27487 : /* Following code is from swig's python.swg. */
27488 :
27489 13 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
27490 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
27491 0 : Py_DECREF(pypointer);
27492 : return NULL;
27493 : }
27494 13 : Py_DECREF(pypointer);
27495 : }
27496 : }
27497 : {
27498 : /* If we create a temporary wrapper3 object, we will store it in
27499 : wrapperN, where N is 3. Here in this fragment, SWIG will
27500 : automatically append 3. */
27501 13 : memset(&view3, 0, sizeof view3);
27502 13 : if (obj2 == Py_None)
27503 7 : arg3 = NULL;
27504 : else {
27505 : PyObject *pypointer;
27506 6 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
27507 : &bytesio3, &view3);
27508 6 : if (pypointer == NULL)
27509 : return NULL;
27510 6 : have_view3 = !! view3.obj;
27511 :
27512 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
27513 :
27514 : /* Following code is from swig's python.swg. */
27515 :
27516 6 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
27517 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
27518 0 : Py_DECREF(pypointer);
27519 : return NULL;
27520 : }
27521 6 : Py_DECREF(pypointer);
27522 : }
27523 : }
27524 : {
27525 : /* If we create a temporary wrapper4 object, we will store it in
27526 : wrapperN, where N is 4. Here in this fragment, SWIG will
27527 : automatically append 4. */
27528 13 : memset(&view4, 0, sizeof view4);
27529 13 : if (obj3 == Py_None)
27530 6 : arg4 = NULL;
27531 : else {
27532 : PyObject *pypointer;
27533 7 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
27534 : &bytesio4, &view4);
27535 7 : if (pypointer == NULL)
27536 : return NULL;
27537 7 : have_view4 = !! view4.obj;
27538 :
27539 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
27540 :
27541 : /* Following code is from swig's python.swg. */
27542 :
27543 7 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
27544 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
27545 0 : Py_DECREF(pypointer);
27546 : return NULL;
27547 : }
27548 7 : Py_DECREF(pypointer);
27549 : }
27550 : }
27551 : {
27552 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27553 13 : result = gpgme_op_verify(arg1,arg2,arg3,arg4);
27554 13 : SWIG_PYTHON_THREAD_END_ALLOW;
27555 : }
27556 : {
27557 13 : resultobj = PyLong_FromLong(result);
27558 : }
27559 : {
27560 : /* See whether we need to update the Python buffer. */
27561 13 : if (resultobj && wrapper2 && view2.buf)
27562 : {
27563 : int dirty;
27564 7 : char *new_data = NULL;
27565 : size_t new_size;
27566 :
27567 :
27568 7 : new_data = wrapper2->data.mem.buffer;
27569 7 : new_size = wrapper2->data.mem.length;
27570 7 : dirty = new_data != NULL;
27571 :
27572 :
27573 :
27574 :
27575 :
27576 :
27577 :
27578 7 : if (dirty)
27579 : {
27580 : /* The buffer is dirty. */
27581 0 : if (view2.readonly)
27582 : {
27583 0 : Py_XDECREF(resultobj);
27584 0 : resultobj = NULL;
27585 0 : PyErr_SetString(PyExc_ValueError,
27586 : "cannot update read-only buffer");
27587 : }
27588 :
27589 : /* See if we need to truncate the buffer. */
27590 0 : if (resultobj && view2.len != new_size)
27591 : {
27592 0 : if (bytesio2 == NULL)
27593 : {
27594 0 : Py_XDECREF(resultobj);
27595 0 : resultobj = NULL;
27596 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27597 : }
27598 : else
27599 : {
27600 : PyObject *retval;
27601 0 : PyBuffer_Release(&view2);
27602 : assert(view2.obj == NULL);
27603 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
27604 : "l", (long) new_size);
27605 0 : if (retval == NULL)
27606 : {
27607 0 : Py_XDECREF(resultobj);
27608 : resultobj = NULL;
27609 : }
27610 : else
27611 : {
27612 0 : Py_DECREF(retval);
27613 :
27614 0 : retval = PyObject_CallMethod(bytesio2,
27615 : "getbuffer", NULL);
27616 0 : if (retval == NULL
27617 0 : || PyObject_GetBuffer(retval, &view2,
27618 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27619 : {
27620 0 : Py_XDECREF(resultobj);
27621 : resultobj = NULL;
27622 : }
27623 :
27624 0 : Py_XDECREF(retval);
27625 :
27626 0 : if (resultobj && view2.len
27627 : != new_size)
27628 : {
27629 0 : Py_XDECREF(resultobj);
27630 0 : resultobj = NULL;
27631 0 : PyErr_Format(PyExc_ValueError,
27632 : "Expected buffer of length %zu, got %zi",
27633 : new_size,
27634 : view2.len);
27635 : }
27636 : }
27637 : }
27638 : }
27639 0 : if (resultobj)
27640 0 : memcpy(view2.buf, new_data, new_size);
27641 : }
27642 :
27643 :
27644 :
27645 : }
27646 :
27647 : /* Free the temporary wrapper, if any. */
27648 13 : if (wrapper2)
27649 8 : gpgme_data_release(wrapper2);
27650 13 : Py_XDECREF (bytesio2);
27651 13 : if (have_view2 && view2.buf)
27652 7 : PyBuffer_Release(&view2);
27653 : }
27654 : {
27655 : /* See whether we need to update the Python buffer. */
27656 13 : if (resultobj && wrapper3 && view3.buf)
27657 : {
27658 : int dirty;
27659 4 : char *new_data = NULL;
27660 : size_t new_size;
27661 :
27662 :
27663 4 : new_data = wrapper3->data.mem.buffer;
27664 4 : new_size = wrapper3->data.mem.length;
27665 4 : dirty = new_data != NULL;
27666 :
27667 :
27668 :
27669 :
27670 :
27671 :
27672 :
27673 4 : if (dirty)
27674 : {
27675 : /* The buffer is dirty. */
27676 0 : if (view3.readonly)
27677 : {
27678 0 : Py_XDECREF(resultobj);
27679 0 : resultobj = NULL;
27680 0 : PyErr_SetString(PyExc_ValueError,
27681 : "cannot update read-only buffer");
27682 : }
27683 :
27684 : /* See if we need to truncate the buffer. */
27685 0 : if (resultobj && view3.len != new_size)
27686 : {
27687 0 : if (bytesio3 == NULL)
27688 : {
27689 0 : Py_XDECREF(resultobj);
27690 0 : resultobj = NULL;
27691 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27692 : }
27693 : else
27694 : {
27695 : PyObject *retval;
27696 0 : PyBuffer_Release(&view3);
27697 : assert(view3.obj == NULL);
27698 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
27699 : "l", (long) new_size);
27700 0 : if (retval == NULL)
27701 : {
27702 0 : Py_XDECREF(resultobj);
27703 : resultobj = NULL;
27704 : }
27705 : else
27706 : {
27707 0 : Py_DECREF(retval);
27708 :
27709 0 : retval = PyObject_CallMethod(bytesio3,
27710 : "getbuffer", NULL);
27711 0 : if (retval == NULL
27712 0 : || PyObject_GetBuffer(retval, &view3,
27713 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27714 : {
27715 0 : Py_XDECREF(resultobj);
27716 : resultobj = NULL;
27717 : }
27718 :
27719 0 : Py_XDECREF(retval);
27720 :
27721 0 : if (resultobj && view3.len
27722 : != new_size)
27723 : {
27724 0 : Py_XDECREF(resultobj);
27725 0 : resultobj = NULL;
27726 0 : PyErr_Format(PyExc_ValueError,
27727 : "Expected buffer of length %zu, got %zi",
27728 : new_size,
27729 : view3.len);
27730 : }
27731 : }
27732 : }
27733 : }
27734 0 : if (resultobj)
27735 0 : memcpy(view3.buf, new_data, new_size);
27736 : }
27737 :
27738 :
27739 :
27740 : }
27741 :
27742 : /* Free the temporary wrapper, if any. */
27743 13 : if (wrapper3)
27744 4 : gpgme_data_release(wrapper3);
27745 13 : Py_XDECREF (bytesio3);
27746 13 : if (have_view3 && view3.buf)
27747 4 : PyBuffer_Release(&view3);
27748 : }
27749 : {
27750 : /* See whether we need to update the Python buffer. */
27751 13 : if (resultobj && wrapper4 && view4.buf)
27752 : {
27753 : int dirty;
27754 0 : char *new_data = NULL;
27755 : size_t new_size;
27756 :
27757 :
27758 0 : new_data = wrapper4->data.mem.buffer;
27759 0 : new_size = wrapper4->data.mem.length;
27760 0 : dirty = new_data != NULL;
27761 :
27762 :
27763 :
27764 :
27765 :
27766 :
27767 :
27768 0 : if (dirty)
27769 : {
27770 : /* The buffer is dirty. */
27771 0 : if (view4.readonly)
27772 : {
27773 0 : Py_XDECREF(resultobj);
27774 0 : resultobj = NULL;
27775 0 : PyErr_SetString(PyExc_ValueError,
27776 : "cannot update read-only buffer");
27777 : }
27778 :
27779 : /* See if we need to truncate the buffer. */
27780 0 : if (resultobj && view4.len != new_size)
27781 : {
27782 0 : if (bytesio4 == NULL)
27783 : {
27784 0 : Py_XDECREF(resultobj);
27785 0 : resultobj = NULL;
27786 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27787 : }
27788 : else
27789 : {
27790 : PyObject *retval;
27791 0 : PyBuffer_Release(&view4);
27792 : assert(view4.obj == NULL);
27793 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
27794 : "l", (long) new_size);
27795 0 : if (retval == NULL)
27796 : {
27797 0 : Py_XDECREF(resultobj);
27798 : resultobj = NULL;
27799 : }
27800 : else
27801 : {
27802 0 : Py_DECREF(retval);
27803 :
27804 0 : retval = PyObject_CallMethod(bytesio4,
27805 : "getbuffer", NULL);
27806 0 : if (retval == NULL
27807 0 : || PyObject_GetBuffer(retval, &view4,
27808 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27809 : {
27810 0 : Py_XDECREF(resultobj);
27811 : resultobj = NULL;
27812 : }
27813 :
27814 0 : Py_XDECREF(retval);
27815 :
27816 0 : if (resultobj && view4.len
27817 : != new_size)
27818 : {
27819 0 : Py_XDECREF(resultobj);
27820 0 : resultobj = NULL;
27821 0 : PyErr_Format(PyExc_ValueError,
27822 : "Expected buffer of length %zu, got %zi",
27823 : new_size,
27824 : view4.len);
27825 : }
27826 : }
27827 : }
27828 : }
27829 0 : if (resultobj)
27830 0 : memcpy(view4.buf, new_data, new_size);
27831 : }
27832 :
27833 :
27834 :
27835 : }
27836 :
27837 : /* Free the temporary wrapper, if any. */
27838 13 : if (wrapper4)
27839 1 : gpgme_data_release(wrapper4);
27840 13 : Py_XDECREF (bytesio4);
27841 13 : if (have_view4 && view4.buf)
27842 0 : PyBuffer_Release(&view4);
27843 : }
27844 : return resultobj;
27845 : fail:
27846 : {
27847 : /* See whether we need to update the Python buffer. */
27848 : if (resultobj && wrapper2 && view2.buf)
27849 : {
27850 : int dirty;
27851 : char *new_data = NULL;
27852 : size_t new_size;
27853 :
27854 :
27855 : new_data = wrapper2->data.mem.buffer;
27856 : new_size = wrapper2->data.mem.length;
27857 : dirty = new_data != NULL;
27858 :
27859 :
27860 :
27861 :
27862 :
27863 :
27864 :
27865 : if (dirty)
27866 : {
27867 : /* The buffer is dirty. */
27868 : if (view2.readonly)
27869 : {
27870 : Py_XDECREF(resultobj);
27871 : resultobj = NULL;
27872 : PyErr_SetString(PyExc_ValueError,
27873 : "cannot update read-only buffer");
27874 : }
27875 :
27876 : /* See if we need to truncate the buffer. */
27877 : if (resultobj && view2.len != new_size)
27878 : {
27879 : if (bytesio2 == NULL)
27880 : {
27881 : Py_XDECREF(resultobj);
27882 : resultobj = NULL;
27883 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27884 : }
27885 : else
27886 : {
27887 : PyObject *retval;
27888 : PyBuffer_Release(&view2);
27889 : assert(view2.obj == NULL);
27890 : retval = PyObject_CallMethod(bytesio2, "truncate",
27891 : "l", (long) new_size);
27892 : if (retval == NULL)
27893 : {
27894 : Py_XDECREF(resultobj);
27895 : resultobj = NULL;
27896 : }
27897 : else
27898 : {
27899 : Py_DECREF(retval);
27900 :
27901 : retval = PyObject_CallMethod(bytesio2,
27902 : "getbuffer", NULL);
27903 : if (retval == NULL
27904 : || PyObject_GetBuffer(retval, &view2,
27905 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27906 : {
27907 : Py_XDECREF(resultobj);
27908 : resultobj = NULL;
27909 : }
27910 :
27911 : Py_XDECREF(retval);
27912 :
27913 : if (resultobj && view2.len
27914 : != new_size)
27915 : {
27916 : Py_XDECREF(resultobj);
27917 : resultobj = NULL;
27918 : PyErr_Format(PyExc_ValueError,
27919 : "Expected buffer of length %zu, got %zi",
27920 : new_size,
27921 : view2.len);
27922 : }
27923 : }
27924 : }
27925 : }
27926 : if (resultobj)
27927 : memcpy(view2.buf, new_data, new_size);
27928 : }
27929 :
27930 :
27931 :
27932 : }
27933 :
27934 : /* Free the temporary wrapper, if any. */
27935 0 : if (wrapper2)
27936 0 : gpgme_data_release(wrapper2);
27937 0 : Py_XDECREF (bytesio2);
27938 : if (have_view2 && view2.buf)
27939 : PyBuffer_Release(&view2);
27940 : }
27941 : {
27942 : /* See whether we need to update the Python buffer. */
27943 : if (resultobj && wrapper3 && view3.buf)
27944 : {
27945 : int dirty;
27946 : char *new_data = NULL;
27947 : size_t new_size;
27948 :
27949 :
27950 : new_data = wrapper3->data.mem.buffer;
27951 : new_size = wrapper3->data.mem.length;
27952 : dirty = new_data != NULL;
27953 :
27954 :
27955 :
27956 :
27957 :
27958 :
27959 :
27960 : if (dirty)
27961 : {
27962 : /* The buffer is dirty. */
27963 : if (view3.readonly)
27964 : {
27965 : Py_XDECREF(resultobj);
27966 : resultobj = NULL;
27967 : PyErr_SetString(PyExc_ValueError,
27968 : "cannot update read-only buffer");
27969 : }
27970 :
27971 : /* See if we need to truncate the buffer. */
27972 : if (resultobj && view3.len != new_size)
27973 : {
27974 : if (bytesio3 == NULL)
27975 : {
27976 : Py_XDECREF(resultobj);
27977 : resultobj = NULL;
27978 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27979 : }
27980 : else
27981 : {
27982 : PyObject *retval;
27983 : PyBuffer_Release(&view3);
27984 : assert(view3.obj == NULL);
27985 : retval = PyObject_CallMethod(bytesio3, "truncate",
27986 : "l", (long) new_size);
27987 : if (retval == NULL)
27988 : {
27989 : Py_XDECREF(resultobj);
27990 : resultobj = NULL;
27991 : }
27992 : else
27993 : {
27994 : Py_DECREF(retval);
27995 :
27996 : retval = PyObject_CallMethod(bytesio3,
27997 : "getbuffer", NULL);
27998 : if (retval == NULL
27999 : || PyObject_GetBuffer(retval, &view3,
28000 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
28001 : {
28002 : Py_XDECREF(resultobj);
28003 : resultobj = NULL;
28004 : }
28005 :
28006 : Py_XDECREF(retval);
28007 :
28008 : if (resultobj && view3.len
28009 : != new_size)
28010 : {
28011 : Py_XDECREF(resultobj);
28012 : resultobj = NULL;
28013 : PyErr_Format(PyExc_ValueError,
28014 : "Expected buffer of length %zu, got %zi",
28015 : new_size,
28016 : view3.len);
28017 : }
28018 : }
28019 : }
28020 : }
28021 : if (resultobj)
28022 : memcpy(view3.buf, new_data, new_size);
28023 : }
28024 :
28025 :
28026 :
28027 : }
28028 :
28029 : /* Free the temporary wrapper, if any. */
28030 0 : if (wrapper3)
28031 0 : gpgme_data_release(wrapper3);
28032 0 : Py_XDECREF (bytesio3);
28033 : if (have_view3 && view3.buf)
28034 : PyBuffer_Release(&view3);
28035 : }
28036 : {
28037 : /* See whether we need to update the Python buffer. */
28038 : if (resultobj && wrapper4 && view4.buf)
28039 : {
28040 : int dirty;
28041 : char *new_data = NULL;
28042 : size_t new_size;
28043 :
28044 :
28045 : new_data = wrapper4->data.mem.buffer;
28046 : new_size = wrapper4->data.mem.length;
28047 : dirty = new_data != NULL;
28048 :
28049 :
28050 :
28051 :
28052 :
28053 :
28054 :
28055 : if (dirty)
28056 : {
28057 : /* The buffer is dirty. */
28058 : if (view4.readonly)
28059 : {
28060 : Py_XDECREF(resultobj);
28061 : resultobj = NULL;
28062 : PyErr_SetString(PyExc_ValueError,
28063 : "cannot update read-only buffer");
28064 : }
28065 :
28066 : /* See if we need to truncate the buffer. */
28067 : if (resultobj && view4.len != new_size)
28068 : {
28069 : if (bytesio4 == NULL)
28070 : {
28071 : Py_XDECREF(resultobj);
28072 : resultobj = NULL;
28073 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
28074 : }
28075 : else
28076 : {
28077 : PyObject *retval;
28078 : PyBuffer_Release(&view4);
28079 : assert(view4.obj == NULL);
28080 : retval = PyObject_CallMethod(bytesio4, "truncate",
28081 : "l", (long) new_size);
28082 : if (retval == NULL)
28083 : {
28084 : Py_XDECREF(resultobj);
28085 : resultobj = NULL;
28086 : }
28087 : else
28088 : {
28089 : Py_DECREF(retval);
28090 :
28091 : retval = PyObject_CallMethod(bytesio4,
28092 : "getbuffer", NULL);
28093 : if (retval == NULL
28094 : || PyObject_GetBuffer(retval, &view4,
28095 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
28096 : {
28097 : Py_XDECREF(resultobj);
28098 : resultobj = NULL;
28099 : }
28100 :
28101 : Py_XDECREF(retval);
28102 :
28103 : if (resultobj && view4.len
28104 : != new_size)
28105 : {
28106 : Py_XDECREF(resultobj);
28107 : resultobj = NULL;
28108 : PyErr_Format(PyExc_ValueError,
28109 : "Expected buffer of length %zu, got %zi",
28110 : new_size,
28111 : view4.len);
28112 : }
28113 : }
28114 : }
28115 : }
28116 : if (resultobj)
28117 : memcpy(view4.buf, new_data, new_size);
28118 : }
28119 :
28120 :
28121 :
28122 : }
28123 :
28124 : /* Free the temporary wrapper, if any. */
28125 0 : if (wrapper4)
28126 0 : gpgme_data_release(wrapper4);
28127 0 : Py_XDECREF (bytesio4);
28128 : if (have_view4 && view4.buf)
28129 : PyBuffer_Release(&view4);
28130 : }
28131 : return NULL;
28132 : }
28133 :
28134 :
28135 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28136 0 : PyObject *resultobj = 0;
28137 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
28138 0 : char *arg2 = (char *) 0 ;
28139 0 : void *argp1 = 0 ;
28140 0 : int res1 = 0 ;
28141 : int res2 ;
28142 0 : char *buf2 = 0 ;
28143 0 : int alloc2 = 0 ;
28144 0 : PyObject * obj0 = 0 ;
28145 0 : PyObject * obj1 = 0 ;
28146 :
28147 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_import_status_fpr_set",&obj0,&obj1)) SWIG_fail;
28148 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
28149 0 : if (!SWIG_IsOK(res1)) {
28150 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_fpr_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
28151 : }
28152 0 : arg1 = (struct _gpgme_import_status *)(argp1);
28153 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28154 0 : if (!SWIG_IsOK(res2)) {
28155 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_import_status_fpr_set" "', argument " "2"" of type '" "char *""'");
28156 : }
28157 0 : arg2 = (char *)(buf2);
28158 : {
28159 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28160 0 : if (arg1->fpr) free((char*)arg1->fpr);
28161 0 : if (arg2) {
28162 0 : size_t size = strlen((const char *)(arg2)) + 1;
28163 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
28164 : } else {
28165 0 : arg1->fpr = 0;
28166 : }
28167 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28168 : }
28169 0 : resultobj = SWIG_Py_Void();
28170 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28171 : return resultobj;
28172 : fail:
28173 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28174 : return NULL;
28175 : }
28176 :
28177 :
28178 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28179 3 : PyObject *resultobj = 0;
28180 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
28181 3 : void *argp1 = 0 ;
28182 3 : int res1 = 0 ;
28183 3 : PyObject * obj0 = 0 ;
28184 3 : char *result = 0 ;
28185 :
28186 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_fpr_get",&obj0)) SWIG_fail;
28187 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
28188 3 : if (!SWIG_IsOK(res1)) {
28189 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_fpr_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
28190 : }
28191 3 : arg1 = (struct _gpgme_import_status *)(argp1);
28192 : {
28193 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28194 3 : result = (char *) ((arg1)->fpr);
28195 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28196 : }
28197 3 : resultobj = SWIG_FromCharPtr((const char *)result);
28198 3 : return resultobj;
28199 : fail:
28200 : return NULL;
28201 : }
28202 :
28203 :
28204 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_result_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28205 0 : PyObject *resultobj = 0;
28206 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
28207 : gpgme_error_t arg2 ;
28208 0 : void *argp1 = 0 ;
28209 0 : int res1 = 0 ;
28210 0 : PyObject * obj0 = 0 ;
28211 0 : PyObject * obj1 = 0 ;
28212 :
28213 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_import_status_result_set",&obj0,&obj1)) SWIG_fail;
28214 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
28215 0 : if (!SWIG_IsOK(res1)) {
28216 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_result_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
28217 : }
28218 0 : arg1 = (struct _gpgme_import_status *)(argp1);
28219 : {
28220 0 : if (PyLong_Check(obj1))
28221 0 : arg2 = PyLong_AsLong(obj1);
28222 :
28223 : else if (PyInt_Check(obj1))
28224 : arg2 = PyInt_AsLong(obj1);
28225 :
28226 : else
28227 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
28228 : }
28229 : {
28230 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28231 0 : if (arg1) (arg1)->result = arg2;
28232 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28233 : }
28234 0 : resultobj = SWIG_Py_Void();
28235 0 : return resultobj;
28236 : fail:
28237 : return NULL;
28238 : }
28239 :
28240 :
28241 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_result_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28242 3 : PyObject *resultobj = 0;
28243 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
28244 3 : void *argp1 = 0 ;
28245 3 : int res1 = 0 ;
28246 3 : PyObject * obj0 = 0 ;
28247 : gpgme_error_t result;
28248 :
28249 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_result_get",&obj0)) SWIG_fail;
28250 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
28251 3 : if (!SWIG_IsOK(res1)) {
28252 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_result_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
28253 : }
28254 3 : arg1 = (struct _gpgme_import_status *)(argp1);
28255 : {
28256 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28257 3 : result = ((arg1)->result);
28258 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28259 : }
28260 : {
28261 3 : resultobj = PyLong_FromLong(result);
28262 : }
28263 3 : return resultobj;
28264 : fail:
28265 : return NULL;
28266 : }
28267 :
28268 :
28269 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28270 0 : PyObject *resultobj = 0;
28271 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
28272 : unsigned int arg2 ;
28273 0 : void *argp1 = 0 ;
28274 0 : int res1 = 0 ;
28275 : unsigned int val2 ;
28276 0 : int ecode2 = 0 ;
28277 0 : PyObject * obj0 = 0 ;
28278 0 : PyObject * obj1 = 0 ;
28279 :
28280 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_import_status_status_set",&obj0,&obj1)) SWIG_fail;
28281 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
28282 0 : if (!SWIG_IsOK(res1)) {
28283 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_status_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
28284 : }
28285 0 : arg1 = (struct _gpgme_import_status *)(argp1);
28286 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
28287 0 : if (!SWIG_IsOK(ecode2)) {
28288 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_import_status_status_set" "', argument " "2"" of type '" "unsigned int""'");
28289 : }
28290 0 : arg2 = (unsigned int)(val2);
28291 : {
28292 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28293 0 : if (arg1) (arg1)->status = arg2;
28294 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28295 : }
28296 0 : resultobj = SWIG_Py_Void();
28297 0 : return resultobj;
28298 : fail:
28299 : return NULL;
28300 : }
28301 :
28302 :
28303 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28304 3 : PyObject *resultobj = 0;
28305 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
28306 3 : void *argp1 = 0 ;
28307 3 : int res1 = 0 ;
28308 3 : PyObject * obj0 = 0 ;
28309 : unsigned int result;
28310 :
28311 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_status_get",&obj0)) SWIG_fail;
28312 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
28313 3 : if (!SWIG_IsOK(res1)) {
28314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_status_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
28315 : }
28316 3 : arg1 = (struct _gpgme_import_status *)(argp1);
28317 : {
28318 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28319 3 : result = (unsigned int) ((arg1)->status);
28320 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28321 : }
28322 3 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
28323 3 : return resultobj;
28324 : fail:
28325 : return NULL;
28326 : }
28327 :
28328 :
28329 0 : SWIGINTERN PyObject *_wrap_new__gpgme_import_status(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28330 0 : PyObject *resultobj = 0;
28331 0 : struct _gpgme_import_status *result = 0 ;
28332 :
28333 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_import_status")) SWIG_fail;
28334 : {
28335 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28336 0 : result = (struct _gpgme_import_status *)calloc(1, sizeof(struct _gpgme_import_status));
28337 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28338 : }
28339 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_import_status, SWIG_POINTER_NEW | 0 );
28340 0 : return resultobj;
28341 : fail:
28342 : return NULL;
28343 : }
28344 :
28345 :
28346 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_import_status(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28347 0 : PyObject *resultobj = 0;
28348 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
28349 0 : void *argp1 = 0 ;
28350 0 : int res1 = 0 ;
28351 0 : PyObject * obj0 = 0 ;
28352 :
28353 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_import_status",&obj0)) SWIG_fail;
28354 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, SWIG_POINTER_DISOWN | 0 );
28355 0 : if (!SWIG_IsOK(res1)) {
28356 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_import_status" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
28357 : }
28358 0 : arg1 = (struct _gpgme_import_status *)(argp1);
28359 : {
28360 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28361 0 : free((char *) arg1);
28362 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28363 : }
28364 0 : resultobj = SWIG_Py_Void();
28365 0 : return resultobj;
28366 : fail:
28367 : return NULL;
28368 : }
28369 :
28370 :
28371 29 : SWIGINTERN PyObject *_gpgme_import_status_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28372 : PyObject *obj;
28373 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
28374 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_import_status, SWIG_NewClientData(obj));
28375 29 : return SWIG_Py_Void();
28376 : }
28377 :
28378 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_considered_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28379 0 : PyObject *resultobj = 0;
28380 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28381 : int arg2 ;
28382 0 : void *argp1 = 0 ;
28383 0 : int res1 = 0 ;
28384 : int val2 ;
28385 0 : int ecode2 = 0 ;
28386 0 : PyObject * obj0 = 0 ;
28387 0 : PyObject * obj1 = 0 ;
28388 :
28389 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_considered_set",&obj0,&obj1)) SWIG_fail;
28390 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28391 0 : if (!SWIG_IsOK(res1)) {
28392 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_considered_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
28393 : }
28394 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28395 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28396 0 : if (!SWIG_IsOK(ecode2)) {
28397 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_considered_set" "', argument " "2"" of type '" "int""'");
28398 : }
28399 0 : arg2 = (int)(val2);
28400 : {
28401 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28402 0 : if (arg1) (arg1)->considered = arg2;
28403 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28404 : }
28405 0 : resultobj = SWIG_Py_Void();
28406 0 : return resultobj;
28407 : fail:
28408 : return NULL;
28409 : }
28410 :
28411 :
28412 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_considered_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28413 3 : PyObject *resultobj = 0;
28414 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28415 3 : void *argp1 = 0 ;
28416 3 : int res1 = 0 ;
28417 3 : PyObject * obj0 = 0 ;
28418 : int result;
28419 :
28420 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_considered_get",&obj0)) SWIG_fail;
28421 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28422 3 : if (!SWIG_IsOK(res1)) {
28423 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_considered_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
28424 : }
28425 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28426 : {
28427 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28428 3 : result = (int) ((arg1)->considered);
28429 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28430 : }
28431 3 : resultobj = SWIG_From_int((int)(result));
28432 3 : return resultobj;
28433 : fail:
28434 : return NULL;
28435 : }
28436 :
28437 :
28438 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_no_user_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28439 0 : PyObject *resultobj = 0;
28440 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28441 : int arg2 ;
28442 0 : void *argp1 = 0 ;
28443 0 : int res1 = 0 ;
28444 : int val2 ;
28445 0 : int ecode2 = 0 ;
28446 0 : PyObject * obj0 = 0 ;
28447 0 : PyObject * obj1 = 0 ;
28448 :
28449 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_no_user_id_set",&obj0,&obj1)) SWIG_fail;
28450 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28451 0 : if (!SWIG_IsOK(res1)) {
28452 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 *""'");
28453 : }
28454 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28455 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28456 0 : if (!SWIG_IsOK(ecode2)) {
28457 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_no_user_id_set" "', argument " "2"" of type '" "int""'");
28458 : }
28459 0 : arg2 = (int)(val2);
28460 : {
28461 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28462 0 : if (arg1) (arg1)->no_user_id = arg2;
28463 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28464 : }
28465 0 : resultobj = SWIG_Py_Void();
28466 0 : return resultobj;
28467 : fail:
28468 : return NULL;
28469 : }
28470 :
28471 :
28472 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_no_user_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28473 3 : PyObject *resultobj = 0;
28474 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28475 3 : void *argp1 = 0 ;
28476 3 : int res1 = 0 ;
28477 3 : PyObject * obj0 = 0 ;
28478 : int result;
28479 :
28480 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_no_user_id_get",&obj0)) SWIG_fail;
28481 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28482 3 : if (!SWIG_IsOK(res1)) {
28483 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 *""'");
28484 : }
28485 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28486 : {
28487 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28488 3 : result = (int) ((arg1)->no_user_id);
28489 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28490 : }
28491 3 : resultobj = SWIG_From_int((int)(result));
28492 3 : return resultobj;
28493 : fail:
28494 : return NULL;
28495 : }
28496 :
28497 :
28498 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28499 0 : PyObject *resultobj = 0;
28500 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28501 : int arg2 ;
28502 0 : void *argp1 = 0 ;
28503 0 : int res1 = 0 ;
28504 : int val2 ;
28505 0 : int ecode2 = 0 ;
28506 0 : PyObject * obj0 = 0 ;
28507 0 : PyObject * obj1 = 0 ;
28508 :
28509 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_imported_set",&obj0,&obj1)) SWIG_fail;
28510 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28511 0 : if (!SWIG_IsOK(res1)) {
28512 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
28513 : }
28514 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28515 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28516 0 : if (!SWIG_IsOK(ecode2)) {
28517 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_imported_set" "', argument " "2"" of type '" "int""'");
28518 : }
28519 0 : arg2 = (int)(val2);
28520 : {
28521 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28522 0 : if (arg1) (arg1)->imported = arg2;
28523 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28524 : }
28525 0 : resultobj = SWIG_Py_Void();
28526 0 : return resultobj;
28527 : fail:
28528 : return NULL;
28529 : }
28530 :
28531 :
28532 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28533 3 : PyObject *resultobj = 0;
28534 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28535 3 : void *argp1 = 0 ;
28536 3 : int res1 = 0 ;
28537 3 : PyObject * obj0 = 0 ;
28538 : int result;
28539 :
28540 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imported_get",&obj0)) SWIG_fail;
28541 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28542 3 : if (!SWIG_IsOK(res1)) {
28543 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
28544 : }
28545 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28546 : {
28547 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28548 3 : result = (int) ((arg1)->imported);
28549 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28550 : }
28551 3 : resultobj = SWIG_From_int((int)(result));
28552 3 : return resultobj;
28553 : fail:
28554 : return NULL;
28555 : }
28556 :
28557 :
28558 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_rsa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 0 : PyObject *resultobj = 0;
28560 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28561 : int arg2 ;
28562 0 : void *argp1 = 0 ;
28563 0 : int res1 = 0 ;
28564 : int val2 ;
28565 0 : int ecode2 = 0 ;
28566 0 : PyObject * obj0 = 0 ;
28567 0 : PyObject * obj1 = 0 ;
28568 :
28569 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_imported_rsa_set",&obj0,&obj1)) SWIG_fail;
28570 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28571 0 : if (!SWIG_IsOK(res1)) {
28572 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 *""'");
28573 : }
28574 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28575 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28576 0 : if (!SWIG_IsOK(ecode2)) {
28577 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_imported_rsa_set" "', argument " "2"" of type '" "int""'");
28578 : }
28579 0 : arg2 = (int)(val2);
28580 : {
28581 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28582 0 : if (arg1) (arg1)->imported_rsa = arg2;
28583 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28584 : }
28585 0 : resultobj = SWIG_Py_Void();
28586 0 : return resultobj;
28587 : fail:
28588 : return NULL;
28589 : }
28590 :
28591 :
28592 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_rsa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28593 3 : PyObject *resultobj = 0;
28594 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28595 3 : void *argp1 = 0 ;
28596 3 : int res1 = 0 ;
28597 3 : PyObject * obj0 = 0 ;
28598 : int result;
28599 :
28600 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imported_rsa_get",&obj0)) SWIG_fail;
28601 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28602 3 : if (!SWIG_IsOK(res1)) {
28603 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 *""'");
28604 : }
28605 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28606 : {
28607 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28608 3 : result = (int) ((arg1)->imported_rsa);
28609 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28610 : }
28611 3 : resultobj = SWIG_From_int((int)(result));
28612 3 : return resultobj;
28613 : fail:
28614 : return NULL;
28615 : }
28616 :
28617 :
28618 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_unchanged_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28619 0 : PyObject *resultobj = 0;
28620 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28621 : int arg2 ;
28622 0 : void *argp1 = 0 ;
28623 0 : int res1 = 0 ;
28624 : int val2 ;
28625 0 : int ecode2 = 0 ;
28626 0 : PyObject * obj0 = 0 ;
28627 0 : PyObject * obj1 = 0 ;
28628 :
28629 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_unchanged_set",&obj0,&obj1)) SWIG_fail;
28630 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28631 0 : if (!SWIG_IsOK(res1)) {
28632 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_unchanged_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
28633 : }
28634 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28635 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28636 0 : if (!SWIG_IsOK(ecode2)) {
28637 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_unchanged_set" "', argument " "2"" of type '" "int""'");
28638 : }
28639 0 : arg2 = (int)(val2);
28640 : {
28641 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28642 0 : if (arg1) (arg1)->unchanged = arg2;
28643 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28644 : }
28645 0 : resultobj = SWIG_Py_Void();
28646 0 : return resultobj;
28647 : fail:
28648 : return NULL;
28649 : }
28650 :
28651 :
28652 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_unchanged_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28653 3 : PyObject *resultobj = 0;
28654 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28655 3 : void *argp1 = 0 ;
28656 3 : int res1 = 0 ;
28657 3 : PyObject * obj0 = 0 ;
28658 : int result;
28659 :
28660 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_unchanged_get",&obj0)) SWIG_fail;
28661 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28662 3 : if (!SWIG_IsOK(res1)) {
28663 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_unchanged_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
28664 : }
28665 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28666 : {
28667 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28668 3 : result = (int) ((arg1)->unchanged);
28669 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28670 : }
28671 3 : resultobj = SWIG_From_int((int)(result));
28672 3 : return resultobj;
28673 : fail:
28674 : return NULL;
28675 : }
28676 :
28677 :
28678 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_user_ids_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28679 0 : PyObject *resultobj = 0;
28680 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28681 : int arg2 ;
28682 0 : void *argp1 = 0 ;
28683 0 : int res1 = 0 ;
28684 : int val2 ;
28685 0 : int ecode2 = 0 ;
28686 0 : PyObject * obj0 = 0 ;
28687 0 : PyObject * obj1 = 0 ;
28688 :
28689 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_new_user_ids_set",&obj0,&obj1)) SWIG_fail;
28690 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28691 0 : if (!SWIG_IsOK(res1)) {
28692 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 *""'");
28693 : }
28694 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28695 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28696 0 : if (!SWIG_IsOK(ecode2)) {
28697 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_user_ids_set" "', argument " "2"" of type '" "int""'");
28698 : }
28699 0 : arg2 = (int)(val2);
28700 : {
28701 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28702 0 : if (arg1) (arg1)->new_user_ids = arg2;
28703 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28704 : }
28705 0 : resultobj = SWIG_Py_Void();
28706 0 : return resultobj;
28707 : fail:
28708 : return NULL;
28709 : }
28710 :
28711 :
28712 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_user_ids_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28713 3 : PyObject *resultobj = 0;
28714 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28715 3 : void *argp1 = 0 ;
28716 3 : int res1 = 0 ;
28717 3 : PyObject * obj0 = 0 ;
28718 : int result;
28719 :
28720 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_user_ids_get",&obj0)) SWIG_fail;
28721 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28722 3 : if (!SWIG_IsOK(res1)) {
28723 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 *""'");
28724 : }
28725 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28726 : {
28727 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28728 3 : result = (int) ((arg1)->new_user_ids);
28729 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28730 : }
28731 3 : resultobj = SWIG_From_int((int)(result));
28732 3 : return resultobj;
28733 : fail:
28734 : return NULL;
28735 : }
28736 :
28737 :
28738 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_sub_keys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28739 0 : PyObject *resultobj = 0;
28740 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28741 : int arg2 ;
28742 0 : void *argp1 = 0 ;
28743 0 : int res1 = 0 ;
28744 : int val2 ;
28745 0 : int ecode2 = 0 ;
28746 0 : PyObject * obj0 = 0 ;
28747 0 : PyObject * obj1 = 0 ;
28748 :
28749 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_new_sub_keys_set",&obj0,&obj1)) SWIG_fail;
28750 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28751 0 : if (!SWIG_IsOK(res1)) {
28752 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 *""'");
28753 : }
28754 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28755 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28756 0 : if (!SWIG_IsOK(ecode2)) {
28757 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_sub_keys_set" "', argument " "2"" of type '" "int""'");
28758 : }
28759 0 : arg2 = (int)(val2);
28760 : {
28761 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28762 0 : if (arg1) (arg1)->new_sub_keys = arg2;
28763 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28764 : }
28765 0 : resultobj = SWIG_Py_Void();
28766 0 : return resultobj;
28767 : fail:
28768 : return NULL;
28769 : }
28770 :
28771 :
28772 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_sub_keys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28773 3 : PyObject *resultobj = 0;
28774 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28775 3 : void *argp1 = 0 ;
28776 3 : int res1 = 0 ;
28777 3 : PyObject * obj0 = 0 ;
28778 : int result;
28779 :
28780 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_sub_keys_get",&obj0)) SWIG_fail;
28781 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28782 3 : if (!SWIG_IsOK(res1)) {
28783 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 *""'");
28784 : }
28785 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28786 : {
28787 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28788 3 : result = (int) ((arg1)->new_sub_keys);
28789 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28790 : }
28791 3 : resultobj = SWIG_From_int((int)(result));
28792 3 : return resultobj;
28793 : fail:
28794 : return NULL;
28795 : }
28796 :
28797 :
28798 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_signatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28799 0 : PyObject *resultobj = 0;
28800 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28801 : int arg2 ;
28802 0 : void *argp1 = 0 ;
28803 0 : int res1 = 0 ;
28804 : int val2 ;
28805 0 : int ecode2 = 0 ;
28806 0 : PyObject * obj0 = 0 ;
28807 0 : PyObject * obj1 = 0 ;
28808 :
28809 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_new_signatures_set",&obj0,&obj1)) SWIG_fail;
28810 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28811 0 : if (!SWIG_IsOK(res1)) {
28812 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 *""'");
28813 : }
28814 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28815 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28816 0 : if (!SWIG_IsOK(ecode2)) {
28817 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_signatures_set" "', argument " "2"" of type '" "int""'");
28818 : }
28819 0 : arg2 = (int)(val2);
28820 : {
28821 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28822 0 : if (arg1) (arg1)->new_signatures = arg2;
28823 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28824 : }
28825 0 : resultobj = SWIG_Py_Void();
28826 0 : return resultobj;
28827 : fail:
28828 : return NULL;
28829 : }
28830 :
28831 :
28832 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_signatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28833 3 : PyObject *resultobj = 0;
28834 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28835 3 : void *argp1 = 0 ;
28836 3 : int res1 = 0 ;
28837 3 : PyObject * obj0 = 0 ;
28838 : int result;
28839 :
28840 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_signatures_get",&obj0)) SWIG_fail;
28841 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28842 3 : if (!SWIG_IsOK(res1)) {
28843 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 *""'");
28844 : }
28845 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28846 : {
28847 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28848 3 : result = (int) ((arg1)->new_signatures);
28849 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28850 : }
28851 3 : resultobj = SWIG_From_int((int)(result));
28852 3 : return resultobj;
28853 : fail:
28854 : return NULL;
28855 : }
28856 :
28857 :
28858 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_revocations_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28859 0 : PyObject *resultobj = 0;
28860 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28861 : int arg2 ;
28862 0 : void *argp1 = 0 ;
28863 0 : int res1 = 0 ;
28864 : int val2 ;
28865 0 : int ecode2 = 0 ;
28866 0 : PyObject * obj0 = 0 ;
28867 0 : PyObject * obj1 = 0 ;
28868 :
28869 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_new_revocations_set",&obj0,&obj1)) SWIG_fail;
28870 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28871 0 : if (!SWIG_IsOK(res1)) {
28872 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 *""'");
28873 : }
28874 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28875 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28876 0 : if (!SWIG_IsOK(ecode2)) {
28877 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_revocations_set" "', argument " "2"" of type '" "int""'");
28878 : }
28879 0 : arg2 = (int)(val2);
28880 : {
28881 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28882 0 : if (arg1) (arg1)->new_revocations = arg2;
28883 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28884 : }
28885 0 : resultobj = SWIG_Py_Void();
28886 0 : return resultobj;
28887 : fail:
28888 : return NULL;
28889 : }
28890 :
28891 :
28892 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_revocations_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28893 3 : PyObject *resultobj = 0;
28894 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28895 3 : void *argp1 = 0 ;
28896 3 : int res1 = 0 ;
28897 3 : PyObject * obj0 = 0 ;
28898 : int result;
28899 :
28900 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_revocations_get",&obj0)) SWIG_fail;
28901 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28902 3 : if (!SWIG_IsOK(res1)) {
28903 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 *""'");
28904 : }
28905 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28906 : {
28907 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28908 3 : result = (int) ((arg1)->new_revocations);
28909 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28910 : }
28911 3 : resultobj = SWIG_From_int((int)(result));
28912 3 : return resultobj;
28913 : fail:
28914 : return NULL;
28915 : }
28916 :
28917 :
28918 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_read_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28919 0 : PyObject *resultobj = 0;
28920 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28921 : int arg2 ;
28922 0 : void *argp1 = 0 ;
28923 0 : int res1 = 0 ;
28924 : int val2 ;
28925 0 : int ecode2 = 0 ;
28926 0 : PyObject * obj0 = 0 ;
28927 0 : PyObject * obj1 = 0 ;
28928 :
28929 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_secret_read_set",&obj0,&obj1)) SWIG_fail;
28930 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28931 0 : if (!SWIG_IsOK(res1)) {
28932 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 *""'");
28933 : }
28934 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28935 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28936 0 : if (!SWIG_IsOK(ecode2)) {
28937 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_read_set" "', argument " "2"" of type '" "int""'");
28938 : }
28939 0 : arg2 = (int)(val2);
28940 : {
28941 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28942 0 : if (arg1) (arg1)->secret_read = arg2;
28943 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28944 : }
28945 0 : resultobj = SWIG_Py_Void();
28946 0 : return resultobj;
28947 : fail:
28948 : return NULL;
28949 : }
28950 :
28951 :
28952 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_read_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28953 3 : PyObject *resultobj = 0;
28954 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28955 3 : void *argp1 = 0 ;
28956 3 : int res1 = 0 ;
28957 3 : PyObject * obj0 = 0 ;
28958 : int result;
28959 :
28960 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_read_get",&obj0)) SWIG_fail;
28961 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28962 3 : if (!SWIG_IsOK(res1)) {
28963 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 *""'");
28964 : }
28965 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28966 : {
28967 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28968 3 : result = (int) ((arg1)->secret_read);
28969 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28970 : }
28971 3 : resultobj = SWIG_From_int((int)(result));
28972 3 : return resultobj;
28973 : fail:
28974 : return NULL;
28975 : }
28976 :
28977 :
28978 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_imported_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28979 0 : PyObject *resultobj = 0;
28980 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
28981 : int arg2 ;
28982 0 : void *argp1 = 0 ;
28983 0 : int res1 = 0 ;
28984 : int val2 ;
28985 0 : int ecode2 = 0 ;
28986 0 : PyObject * obj0 = 0 ;
28987 0 : PyObject * obj1 = 0 ;
28988 :
28989 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_secret_imported_set",&obj0,&obj1)) SWIG_fail;
28990 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
28991 0 : if (!SWIG_IsOK(res1)) {
28992 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 *""'");
28993 : }
28994 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
28995 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28996 0 : if (!SWIG_IsOK(ecode2)) {
28997 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_imported_set" "', argument " "2"" of type '" "int""'");
28998 : }
28999 0 : arg2 = (int)(val2);
29000 : {
29001 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29002 0 : if (arg1) (arg1)->secret_imported = arg2;
29003 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29004 : }
29005 0 : resultobj = SWIG_Py_Void();
29006 0 : return resultobj;
29007 : fail:
29008 : return NULL;
29009 : }
29010 :
29011 :
29012 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_imported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29013 3 : PyObject *resultobj = 0;
29014 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29015 3 : void *argp1 = 0 ;
29016 3 : int res1 = 0 ;
29017 3 : PyObject * obj0 = 0 ;
29018 : int result;
29019 :
29020 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_imported_get",&obj0)) SWIG_fail;
29021 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29022 3 : if (!SWIG_IsOK(res1)) {
29023 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 *""'");
29024 : }
29025 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29026 : {
29027 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29028 3 : result = (int) ((arg1)->secret_imported);
29029 3 : SWIG_PYTHON_THREAD_END_ALLOW;
29030 : }
29031 3 : resultobj = SWIG_From_int((int)(result));
29032 3 : return resultobj;
29033 : fail:
29034 : return NULL;
29035 : }
29036 :
29037 :
29038 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_unchanged_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29039 0 : PyObject *resultobj = 0;
29040 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29041 : int arg2 ;
29042 0 : void *argp1 = 0 ;
29043 0 : int res1 = 0 ;
29044 : int val2 ;
29045 0 : int ecode2 = 0 ;
29046 0 : PyObject * obj0 = 0 ;
29047 0 : PyObject * obj1 = 0 ;
29048 :
29049 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_secret_unchanged_set",&obj0,&obj1)) SWIG_fail;
29050 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29051 0 : if (!SWIG_IsOK(res1)) {
29052 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 *""'");
29053 : }
29054 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29055 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
29056 0 : if (!SWIG_IsOK(ecode2)) {
29057 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_unchanged_set" "', argument " "2"" of type '" "int""'");
29058 : }
29059 0 : arg2 = (int)(val2);
29060 : {
29061 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29062 0 : if (arg1) (arg1)->secret_unchanged = arg2;
29063 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29064 : }
29065 0 : resultobj = SWIG_Py_Void();
29066 0 : return resultobj;
29067 : fail:
29068 : return NULL;
29069 : }
29070 :
29071 :
29072 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_unchanged_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29073 3 : PyObject *resultobj = 0;
29074 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29075 3 : void *argp1 = 0 ;
29076 3 : int res1 = 0 ;
29077 3 : PyObject * obj0 = 0 ;
29078 : int result;
29079 :
29080 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_unchanged_get",&obj0)) SWIG_fail;
29081 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29082 3 : if (!SWIG_IsOK(res1)) {
29083 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 *""'");
29084 : }
29085 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29086 : {
29087 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29088 3 : result = (int) ((arg1)->secret_unchanged);
29089 3 : SWIG_PYTHON_THREAD_END_ALLOW;
29090 : }
29091 3 : resultobj = SWIG_From_int((int)(result));
29092 3 : return resultobj;
29093 : fail:
29094 : return NULL;
29095 : }
29096 :
29097 :
29098 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_skipped_new_keys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29099 0 : PyObject *resultobj = 0;
29100 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29101 : int arg2 ;
29102 0 : void *argp1 = 0 ;
29103 0 : int res1 = 0 ;
29104 : int val2 ;
29105 0 : int ecode2 = 0 ;
29106 0 : PyObject * obj0 = 0 ;
29107 0 : PyObject * obj1 = 0 ;
29108 :
29109 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_skipped_new_keys_set",&obj0,&obj1)) SWIG_fail;
29110 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29111 0 : if (!SWIG_IsOK(res1)) {
29112 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 *""'");
29113 : }
29114 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29115 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
29116 0 : if (!SWIG_IsOK(ecode2)) {
29117 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_skipped_new_keys_set" "', argument " "2"" of type '" "int""'");
29118 : }
29119 0 : arg2 = (int)(val2);
29120 : {
29121 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29122 0 : if (arg1) (arg1)->skipped_new_keys = arg2;
29123 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29124 : }
29125 0 : resultobj = SWIG_Py_Void();
29126 0 : return resultobj;
29127 : fail:
29128 : return NULL;
29129 : }
29130 :
29131 :
29132 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_skipped_new_keys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29133 3 : PyObject *resultobj = 0;
29134 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29135 3 : void *argp1 = 0 ;
29136 3 : int res1 = 0 ;
29137 3 : PyObject * obj0 = 0 ;
29138 : int result;
29139 :
29140 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_skipped_new_keys_get",&obj0)) SWIG_fail;
29141 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29142 3 : if (!SWIG_IsOK(res1)) {
29143 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 *""'");
29144 : }
29145 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29146 : {
29147 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29148 3 : result = (int) ((arg1)->skipped_new_keys);
29149 3 : SWIG_PYTHON_THREAD_END_ALLOW;
29150 : }
29151 3 : resultobj = SWIG_From_int((int)(result));
29152 3 : return resultobj;
29153 : fail:
29154 : return NULL;
29155 : }
29156 :
29157 :
29158 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_not_imported_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29159 0 : PyObject *resultobj = 0;
29160 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29161 : int arg2 ;
29162 0 : void *argp1 = 0 ;
29163 0 : int res1 = 0 ;
29164 : int val2 ;
29165 0 : int ecode2 = 0 ;
29166 0 : PyObject * obj0 = 0 ;
29167 0 : PyObject * obj1 = 0 ;
29168 :
29169 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_not_imported_set",&obj0,&obj1)) SWIG_fail;
29170 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29171 0 : if (!SWIG_IsOK(res1)) {
29172 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 *""'");
29173 : }
29174 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29175 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
29176 0 : if (!SWIG_IsOK(ecode2)) {
29177 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_not_imported_set" "', argument " "2"" of type '" "int""'");
29178 : }
29179 0 : arg2 = (int)(val2);
29180 : {
29181 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29182 0 : if (arg1) (arg1)->not_imported = arg2;
29183 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29184 : }
29185 0 : resultobj = SWIG_Py_Void();
29186 0 : return resultobj;
29187 : fail:
29188 : return NULL;
29189 : }
29190 :
29191 :
29192 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_not_imported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29193 3 : PyObject *resultobj = 0;
29194 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29195 3 : void *argp1 = 0 ;
29196 3 : int res1 = 0 ;
29197 3 : PyObject * obj0 = 0 ;
29198 : int result;
29199 :
29200 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_not_imported_get",&obj0)) SWIG_fail;
29201 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29202 3 : if (!SWIG_IsOK(res1)) {
29203 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 *""'");
29204 : }
29205 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29206 : {
29207 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29208 3 : result = (int) ((arg1)->not_imported);
29209 3 : SWIG_PYTHON_THREAD_END_ALLOW;
29210 : }
29211 3 : resultobj = SWIG_From_int((int)(result));
29212 3 : return resultobj;
29213 : fail:
29214 : return NULL;
29215 : }
29216 :
29217 :
29218 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imports_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29219 0 : PyObject *resultobj = 0;
29220 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29221 0 : gpgme_import_status_t arg2 = (gpgme_import_status_t) 0 ;
29222 0 : void *argp1 = 0 ;
29223 0 : int res1 = 0 ;
29224 0 : void *argp2 = 0 ;
29225 0 : int res2 = 0 ;
29226 0 : PyObject * obj0 = 0 ;
29227 0 : PyObject * obj1 = 0 ;
29228 :
29229 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_imports_set",&obj0,&obj1)) SWIG_fail;
29230 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29231 0 : if (!SWIG_IsOK(res1)) {
29232 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imports_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
29233 : }
29234 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29235 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_import_status, SWIG_POINTER_DISOWN | 0 );
29236 0 : if (!SWIG_IsOK(res2)) {
29237 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_import_result_imports_set" "', argument " "2"" of type '" "gpgme_import_status_t""'");
29238 : }
29239 0 : arg2 = (gpgme_import_status_t)(argp2);
29240 : {
29241 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29242 0 : if (arg1) (arg1)->imports = arg2;
29243 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29244 : }
29245 0 : resultobj = SWIG_Py_Void();
29246 0 : return resultobj;
29247 : fail:
29248 : return NULL;
29249 : }
29250 :
29251 :
29252 6 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imports_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29253 6 : PyObject *resultobj = 0;
29254 6 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29255 6 : void *argp1 = 0 ;
29256 6 : int res1 = 0 ;
29257 6 : PyObject * obj0 = 0 ;
29258 : gpgme_import_status_t result;
29259 :
29260 6 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imports_get",&obj0)) SWIG_fail;
29261 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29262 6 : if (!SWIG_IsOK(res1)) {
29263 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imports_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
29264 : }
29265 6 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29266 : {
29267 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29268 6 : result = (gpgme_import_status_t) ((arg1)->imports);
29269 6 : SWIG_PYTHON_THREAD_END_ALLOW;
29270 : }
29271 : {
29272 : int i;
29273 6 : int size = 0;
29274 : gpgme_import_status_t curr;
29275 12 : for (curr = result; curr != NULL; curr = curr->next) {
29276 6 : size++;
29277 : }
29278 6 : resultobj = PyList_New(size);
29279 12 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
29280 6 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_import_status, 0 );
29281 6 : PyList_SetItem(resultobj, i, o);
29282 : }
29283 : }
29284 : return resultobj;
29285 : fail:
29286 : return NULL;
29287 : }
29288 :
29289 :
29290 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_skipped_v3_keys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29291 0 : PyObject *resultobj = 0;
29292 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29293 : int arg2 ;
29294 0 : void *argp1 = 0 ;
29295 0 : int res1 = 0 ;
29296 : int val2 ;
29297 0 : int ecode2 = 0 ;
29298 0 : PyObject * obj0 = 0 ;
29299 0 : PyObject * obj1 = 0 ;
29300 :
29301 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_skipped_v3_keys_set",&obj0,&obj1)) SWIG_fail;
29302 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29303 0 : if (!SWIG_IsOK(res1)) {
29304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_skipped_v3_keys_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
29305 : }
29306 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29307 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
29308 0 : if (!SWIG_IsOK(ecode2)) {
29309 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_skipped_v3_keys_set" "', argument " "2"" of type '" "int""'");
29310 : }
29311 0 : arg2 = (int)(val2);
29312 : {
29313 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29314 0 : if (arg1) (arg1)->skipped_v3_keys = arg2;
29315 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29316 : }
29317 0 : resultobj = SWIG_Py_Void();
29318 0 : return resultobj;
29319 : fail:
29320 : return NULL;
29321 : }
29322 :
29323 :
29324 3 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_skipped_v3_keys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29325 3 : PyObject *resultobj = 0;
29326 3 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29327 3 : void *argp1 = 0 ;
29328 3 : int res1 = 0 ;
29329 3 : PyObject * obj0 = 0 ;
29330 : int result;
29331 :
29332 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_skipped_v3_keys_get",&obj0)) SWIG_fail;
29333 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
29334 3 : if (!SWIG_IsOK(res1)) {
29335 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_skipped_v3_keys_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
29336 : }
29337 3 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29338 : {
29339 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29340 3 : result = (int) ((arg1)->skipped_v3_keys);
29341 3 : SWIG_PYTHON_THREAD_END_ALLOW;
29342 : }
29343 3 : resultobj = SWIG_From_int((int)(result));
29344 3 : return resultobj;
29345 : fail:
29346 : return NULL;
29347 : }
29348 :
29349 :
29350 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_import_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29351 0 : PyObject *resultobj = 0;
29352 0 : struct _gpgme_op_import_result *result = 0 ;
29353 :
29354 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_import_result")) SWIG_fail;
29355 : {
29356 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29357 0 : result = (struct _gpgme_op_import_result *)calloc(1, sizeof(struct _gpgme_op_import_result));
29358 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29359 : }
29360 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_import_result, SWIG_POINTER_NEW | 0 );
29361 0 : return resultobj;
29362 : fail:
29363 : return NULL;
29364 : }
29365 :
29366 :
29367 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_import_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29368 0 : PyObject *resultobj = 0;
29369 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
29370 0 : void *argp1 = 0 ;
29371 0 : int res1 = 0 ;
29372 0 : PyObject * obj0 = 0 ;
29373 :
29374 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_import_result",&obj0)) SWIG_fail;
29375 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, SWIG_POINTER_DISOWN | 0 );
29376 0 : if (!SWIG_IsOK(res1)) {
29377 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_import_result" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
29378 : }
29379 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
29380 : {
29381 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29382 0 : free((char *) arg1);
29383 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29384 : }
29385 0 : resultobj = SWIG_Py_Void();
29386 0 : return resultobj;
29387 : fail:
29388 : return NULL;
29389 : }
29390 :
29391 :
29392 29 : SWIGINTERN PyObject *_gpgme_op_import_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29393 : PyObject *obj;
29394 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
29395 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_import_result, SWIG_NewClientData(obj));
29396 29 : return SWIG_Py_Void();
29397 : }
29398 :
29399 3 : SWIGINTERN PyObject *_wrap_gpgme_op_import_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29400 3 : PyObject *resultobj = 0;
29401 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29402 3 : void *argp1 = 0 ;
29403 3 : int res1 = 0 ;
29404 3 : PyObject * obj0 = 0 ;
29405 : gpgme_import_result_t result;
29406 :
29407 3 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_import_result",&obj0)) SWIG_fail;
29408 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29409 3 : if (!SWIG_IsOK(res1)) {
29410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29411 : }
29412 3 : arg1 = (gpgme_ctx_t)(argp1);
29413 : {
29414 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29415 3 : result = (gpgme_import_result_t)gpgme_op_import_result(arg1);
29416 3 : SWIG_PYTHON_THREAD_END_ALLOW;
29417 : }
29418 : {
29419 : PyObject *fragile;
29420 3 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_import_result,
29421 : 0 );
29422 3 : resultobj = _gpg_wrap_result(fragile, "ImportResult");
29423 3 : Py_DECREF(fragile);
29424 : }
29425 : return resultobj;
29426 : fail:
29427 : return NULL;
29428 : }
29429 :
29430 :
29431 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29432 0 : PyObject *resultobj = 0;
29433 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29434 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
29435 0 : void *argp1 = 0 ;
29436 0 : int res1 = 0 ;
29437 0 : gpgme_data_t wrapper2 = NULL ;
29438 0 : PyObject *bytesio2 = NULL ;
29439 : Py_buffer view2 ;
29440 0 : int have_view2 = 0 ;
29441 0 : PyObject * obj0 = 0 ;
29442 0 : PyObject * obj1 = 0 ;
29443 : gpgme_error_t result;
29444 :
29445 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_start",&obj0,&obj1)) SWIG_fail;
29446 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29447 0 : if (!SWIG_IsOK(res1)) {
29448 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29449 : }
29450 0 : arg1 = (gpgme_ctx_t)(argp1);
29451 : {
29452 : /* If we create a temporary wrapper2 object, we will store it in
29453 : wrapperN, where N is 2. Here in this fragment, SWIG will
29454 : automatically append 2. */
29455 0 : memset(&view2, 0, sizeof view2);
29456 0 : if (obj1 == Py_None)
29457 0 : arg2 = NULL;
29458 : else {
29459 : PyObject *pypointer;
29460 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
29461 : &bytesio2, &view2);
29462 0 : if (pypointer == NULL)
29463 : return NULL;
29464 0 : have_view2 = !! view2.obj;
29465 :
29466 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
29467 :
29468 : /* Following code is from swig's python.swg. */
29469 :
29470 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
29471 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
29472 0 : Py_DECREF(pypointer);
29473 : return NULL;
29474 : }
29475 0 : Py_DECREF(pypointer);
29476 : }
29477 : }
29478 : {
29479 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29480 0 : result = gpgme_op_import_start(arg1,arg2);
29481 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29482 : }
29483 : {
29484 0 : resultobj = PyLong_FromLong(result);
29485 : }
29486 : {
29487 : /* See whether we need to update the Python buffer. */
29488 0 : if (resultobj && wrapper2 && view2.buf)
29489 : {
29490 : int dirty;
29491 0 : char *new_data = NULL;
29492 : size_t new_size;
29493 :
29494 :
29495 0 : new_data = wrapper2->data.mem.buffer;
29496 0 : new_size = wrapper2->data.mem.length;
29497 0 : dirty = new_data != NULL;
29498 :
29499 :
29500 :
29501 :
29502 :
29503 :
29504 :
29505 0 : if (dirty)
29506 : {
29507 : /* The buffer is dirty. */
29508 0 : if (view2.readonly)
29509 : {
29510 0 : Py_XDECREF(resultobj);
29511 0 : resultobj = NULL;
29512 0 : PyErr_SetString(PyExc_ValueError,
29513 : "cannot update read-only buffer");
29514 : }
29515 :
29516 : /* See if we need to truncate the buffer. */
29517 0 : if (resultobj && view2.len != new_size)
29518 : {
29519 0 : if (bytesio2 == NULL)
29520 : {
29521 0 : Py_XDECREF(resultobj);
29522 0 : resultobj = NULL;
29523 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29524 : }
29525 : else
29526 : {
29527 : PyObject *retval;
29528 0 : PyBuffer_Release(&view2);
29529 : assert(view2.obj == NULL);
29530 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
29531 : "l", (long) new_size);
29532 0 : if (retval == NULL)
29533 : {
29534 0 : Py_XDECREF(resultobj);
29535 : resultobj = NULL;
29536 : }
29537 : else
29538 : {
29539 0 : Py_DECREF(retval);
29540 :
29541 0 : retval = PyObject_CallMethod(bytesio2,
29542 : "getbuffer", NULL);
29543 0 : if (retval == NULL
29544 0 : || PyObject_GetBuffer(retval, &view2,
29545 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29546 : {
29547 0 : Py_XDECREF(resultobj);
29548 : resultobj = NULL;
29549 : }
29550 :
29551 0 : Py_XDECREF(retval);
29552 :
29553 0 : if (resultobj && view2.len
29554 : != new_size)
29555 : {
29556 0 : Py_XDECREF(resultobj);
29557 0 : resultobj = NULL;
29558 0 : PyErr_Format(PyExc_ValueError,
29559 : "Expected buffer of length %zu, got %zi",
29560 : new_size,
29561 : view2.len);
29562 : }
29563 : }
29564 : }
29565 : }
29566 0 : if (resultobj)
29567 0 : memcpy(view2.buf, new_data, new_size);
29568 : }
29569 :
29570 :
29571 :
29572 : }
29573 :
29574 : /* Free the temporary wrapper, if any. */
29575 0 : if (wrapper2)
29576 0 : gpgme_data_release(wrapper2);
29577 0 : Py_XDECREF (bytesio2);
29578 0 : if (have_view2 && view2.buf)
29579 0 : PyBuffer_Release(&view2);
29580 : }
29581 : return resultobj;
29582 : fail:
29583 : {
29584 : /* See whether we need to update the Python buffer. */
29585 : if (resultobj && wrapper2 && view2.buf)
29586 : {
29587 : int dirty;
29588 : char *new_data = NULL;
29589 : size_t new_size;
29590 :
29591 :
29592 : new_data = wrapper2->data.mem.buffer;
29593 : new_size = wrapper2->data.mem.length;
29594 : dirty = new_data != NULL;
29595 :
29596 :
29597 :
29598 :
29599 :
29600 :
29601 :
29602 : if (dirty)
29603 : {
29604 : /* The buffer is dirty. */
29605 : if (view2.readonly)
29606 : {
29607 : Py_XDECREF(resultobj);
29608 : resultobj = NULL;
29609 : PyErr_SetString(PyExc_ValueError,
29610 : "cannot update read-only buffer");
29611 : }
29612 :
29613 : /* See if we need to truncate the buffer. */
29614 : if (resultobj && view2.len != new_size)
29615 : {
29616 : if (bytesio2 == NULL)
29617 : {
29618 : Py_XDECREF(resultobj);
29619 : resultobj = NULL;
29620 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29621 : }
29622 : else
29623 : {
29624 : PyObject *retval;
29625 : PyBuffer_Release(&view2);
29626 : assert(view2.obj == NULL);
29627 : retval = PyObject_CallMethod(bytesio2, "truncate",
29628 : "l", (long) new_size);
29629 : if (retval == NULL)
29630 : {
29631 : Py_XDECREF(resultobj);
29632 : resultobj = NULL;
29633 : }
29634 : else
29635 : {
29636 : Py_DECREF(retval);
29637 :
29638 : retval = PyObject_CallMethod(bytesio2,
29639 : "getbuffer", NULL);
29640 : if (retval == NULL
29641 : || PyObject_GetBuffer(retval, &view2,
29642 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29643 : {
29644 : Py_XDECREF(resultobj);
29645 : resultobj = NULL;
29646 : }
29647 :
29648 : Py_XDECREF(retval);
29649 :
29650 : if (resultobj && view2.len
29651 : != new_size)
29652 : {
29653 : Py_XDECREF(resultobj);
29654 : resultobj = NULL;
29655 : PyErr_Format(PyExc_ValueError,
29656 : "Expected buffer of length %zu, got %zi",
29657 : new_size,
29658 : view2.len);
29659 : }
29660 : }
29661 : }
29662 : }
29663 : if (resultobj)
29664 : memcpy(view2.buf, new_data, new_size);
29665 : }
29666 :
29667 :
29668 :
29669 : }
29670 :
29671 : /* Free the temporary wrapper, if any. */
29672 0 : if (wrapper2)
29673 0 : gpgme_data_release(wrapper2);
29674 0 : Py_XDECREF (bytesio2);
29675 : if (have_view2 && view2.buf)
29676 : PyBuffer_Release(&view2);
29677 : }
29678 : return NULL;
29679 : }
29680 :
29681 :
29682 5 : SWIGINTERN PyObject *_wrap_gpgme_op_import(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29683 5 : PyObject *resultobj = 0;
29684 5 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29685 5 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
29686 5 : void *argp1 = 0 ;
29687 5 : int res1 = 0 ;
29688 5 : gpgme_data_t wrapper2 = NULL ;
29689 5 : PyObject *bytesio2 = NULL ;
29690 : Py_buffer view2 ;
29691 5 : int have_view2 = 0 ;
29692 5 : PyObject * obj0 = 0 ;
29693 5 : PyObject * obj1 = 0 ;
29694 : gpgme_error_t result;
29695 :
29696 5 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import",&obj0,&obj1)) SWIG_fail;
29697 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29698 5 : if (!SWIG_IsOK(res1)) {
29699 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29700 : }
29701 5 : arg1 = (gpgme_ctx_t)(argp1);
29702 : {
29703 : /* If we create a temporary wrapper2 object, we will store it in
29704 : wrapperN, where N is 2. Here in this fragment, SWIG will
29705 : automatically append 2. */
29706 5 : memset(&view2, 0, sizeof view2);
29707 5 : if (obj1 == Py_None)
29708 0 : arg2 = NULL;
29709 : else {
29710 : PyObject *pypointer;
29711 5 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
29712 : &bytesio2, &view2);
29713 5 : if (pypointer == NULL)
29714 : return NULL;
29715 5 : have_view2 = !! view2.obj;
29716 :
29717 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
29718 :
29719 : /* Following code is from swig's python.swg. */
29720 :
29721 5 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
29722 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
29723 0 : Py_DECREF(pypointer);
29724 : return NULL;
29725 : }
29726 5 : Py_DECREF(pypointer);
29727 : }
29728 : }
29729 : {
29730 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29731 5 : result = gpgme_op_import(arg1,arg2);
29732 5 : SWIG_PYTHON_THREAD_END_ALLOW;
29733 : }
29734 : {
29735 5 : resultobj = PyLong_FromLong(result);
29736 : }
29737 : {
29738 : /* See whether we need to update the Python buffer. */
29739 5 : if (resultobj && wrapper2 && view2.buf)
29740 : {
29741 : int dirty;
29742 3 : char *new_data = NULL;
29743 : size_t new_size;
29744 :
29745 :
29746 3 : new_data = wrapper2->data.mem.buffer;
29747 3 : new_size = wrapper2->data.mem.length;
29748 3 : dirty = new_data != NULL;
29749 :
29750 :
29751 :
29752 :
29753 :
29754 :
29755 :
29756 3 : if (dirty)
29757 : {
29758 : /* The buffer is dirty. */
29759 0 : if (view2.readonly)
29760 : {
29761 0 : Py_XDECREF(resultobj);
29762 0 : resultobj = NULL;
29763 0 : PyErr_SetString(PyExc_ValueError,
29764 : "cannot update read-only buffer");
29765 : }
29766 :
29767 : /* See if we need to truncate the buffer. */
29768 0 : if (resultobj && view2.len != new_size)
29769 : {
29770 0 : if (bytesio2 == NULL)
29771 : {
29772 0 : Py_XDECREF(resultobj);
29773 0 : resultobj = NULL;
29774 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29775 : }
29776 : else
29777 : {
29778 : PyObject *retval;
29779 0 : PyBuffer_Release(&view2);
29780 : assert(view2.obj == NULL);
29781 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
29782 : "l", (long) new_size);
29783 0 : if (retval == NULL)
29784 : {
29785 0 : Py_XDECREF(resultobj);
29786 : resultobj = NULL;
29787 : }
29788 : else
29789 : {
29790 0 : Py_DECREF(retval);
29791 :
29792 0 : retval = PyObject_CallMethod(bytesio2,
29793 : "getbuffer", NULL);
29794 0 : if (retval == NULL
29795 0 : || PyObject_GetBuffer(retval, &view2,
29796 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29797 : {
29798 0 : Py_XDECREF(resultobj);
29799 : resultobj = NULL;
29800 : }
29801 :
29802 0 : Py_XDECREF(retval);
29803 :
29804 0 : if (resultobj && view2.len
29805 : != new_size)
29806 : {
29807 0 : Py_XDECREF(resultobj);
29808 0 : resultobj = NULL;
29809 0 : PyErr_Format(PyExc_ValueError,
29810 : "Expected buffer of length %zu, got %zi",
29811 : new_size,
29812 : view2.len);
29813 : }
29814 : }
29815 : }
29816 : }
29817 0 : if (resultobj)
29818 0 : memcpy(view2.buf, new_data, new_size);
29819 : }
29820 :
29821 :
29822 :
29823 : }
29824 :
29825 : /* Free the temporary wrapper, if any. */
29826 5 : if (wrapper2)
29827 5 : gpgme_data_release(wrapper2);
29828 5 : Py_XDECREF (bytesio2);
29829 5 : if (have_view2 && view2.buf)
29830 3 : PyBuffer_Release(&view2);
29831 : }
29832 : return resultobj;
29833 : fail:
29834 : {
29835 : /* See whether we need to update the Python buffer. */
29836 : if (resultobj && wrapper2 && view2.buf)
29837 : {
29838 : int dirty;
29839 : char *new_data = NULL;
29840 : size_t new_size;
29841 :
29842 :
29843 : new_data = wrapper2->data.mem.buffer;
29844 : new_size = wrapper2->data.mem.length;
29845 : dirty = new_data != NULL;
29846 :
29847 :
29848 :
29849 :
29850 :
29851 :
29852 :
29853 : if (dirty)
29854 : {
29855 : /* The buffer is dirty. */
29856 : if (view2.readonly)
29857 : {
29858 : Py_XDECREF(resultobj);
29859 : resultobj = NULL;
29860 : PyErr_SetString(PyExc_ValueError,
29861 : "cannot update read-only buffer");
29862 : }
29863 :
29864 : /* See if we need to truncate the buffer. */
29865 : if (resultobj && view2.len != new_size)
29866 : {
29867 : if (bytesio2 == NULL)
29868 : {
29869 : Py_XDECREF(resultobj);
29870 : resultobj = NULL;
29871 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29872 : }
29873 : else
29874 : {
29875 : PyObject *retval;
29876 : PyBuffer_Release(&view2);
29877 : assert(view2.obj == NULL);
29878 : retval = PyObject_CallMethod(bytesio2, "truncate",
29879 : "l", (long) new_size);
29880 : if (retval == NULL)
29881 : {
29882 : Py_XDECREF(resultobj);
29883 : resultobj = NULL;
29884 : }
29885 : else
29886 : {
29887 : Py_DECREF(retval);
29888 :
29889 : retval = PyObject_CallMethod(bytesio2,
29890 : "getbuffer", NULL);
29891 : if (retval == NULL
29892 : || PyObject_GetBuffer(retval, &view2,
29893 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29894 : {
29895 : Py_XDECREF(resultobj);
29896 : resultobj = NULL;
29897 : }
29898 :
29899 : Py_XDECREF(retval);
29900 :
29901 : if (resultobj && view2.len
29902 : != new_size)
29903 : {
29904 : Py_XDECREF(resultobj);
29905 : resultobj = NULL;
29906 : PyErr_Format(PyExc_ValueError,
29907 : "Expected buffer of length %zu, got %zi",
29908 : new_size,
29909 : view2.len);
29910 : }
29911 : }
29912 : }
29913 : }
29914 : if (resultobj)
29915 : memcpy(view2.buf, new_data, new_size);
29916 : }
29917 :
29918 :
29919 :
29920 : }
29921 :
29922 : /* Free the temporary wrapper, if any. */
29923 0 : if (wrapper2)
29924 0 : gpgme_data_release(wrapper2);
29925 0 : Py_XDECREF (bytesio2);
29926 : if (have_view2 && view2.buf)
29927 : PyBuffer_Release(&view2);
29928 : }
29929 : return NULL;
29930 : }
29931 :
29932 :
29933 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_keys_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29934 0 : PyObject *resultobj = 0;
29935 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29936 : gpgme_key_t *arg2 ;
29937 0 : void *argp1 = 0 ;
29938 0 : int res1 = 0 ;
29939 0 : PyObject * obj0 = 0 ;
29940 0 : PyObject * obj1 = 0 ;
29941 : gpgme_error_t result;
29942 :
29943 : {
29944 0 : arg2 = NULL;
29945 : }
29946 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_keys_start",&obj0,&obj1)) SWIG_fail;
29947 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29948 0 : if (!SWIG_IsOK(res1)) {
29949 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_keys_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29950 : }
29951 0 : arg1 = (gpgme_ctx_t)(argp1);
29952 : {
29953 0 : int i, numb = 0;
29954 0 : if (!PySequence_Check(obj1)) {
29955 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
29956 : 2);
29957 0 : return NULL;
29958 : }
29959 0 : if((numb = PySequence_Length(obj1)) != 0) {
29960 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
29961 0 : for(i=0; i<numb; i++) {
29962 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
29963 :
29964 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
29965 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
29966 :
29967 : /* Following code is from swig's python.swg. */
29968 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
29969 0 : Py_DECREF(pypointer);
29970 0 : PyErr_Format(PyExc_TypeError,
29971 : "arg %d: list must contain only gpgme_key_ts, got %s "
29972 : "at position %d",
29973 0 : 2, pypointer->ob_type->tp_name, i);
29974 0 : free(arg2);
29975 0 : return NULL;
29976 : }
29977 0 : Py_DECREF(pypointer);
29978 : }
29979 0 : arg2[numb] = NULL;
29980 : }
29981 : }
29982 : {
29983 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29984 0 : result = gpgme_op_import_keys_start(arg1,arg2);
29985 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29986 : }
29987 : {
29988 0 : resultobj = PyLong_FromLong(result);
29989 : }
29990 : {
29991 0 : if (arg2) free(arg2);
29992 : }
29993 : return resultobj;
29994 : fail:
29995 : {
29996 : if (arg2) free(arg2);
29997 : }
29998 : return NULL;
29999 : }
30000 :
30001 :
30002 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30003 0 : PyObject *resultobj = 0;
30004 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30005 : gpgme_key_t *arg2 ;
30006 0 : void *argp1 = 0 ;
30007 0 : int res1 = 0 ;
30008 0 : PyObject * obj0 = 0 ;
30009 0 : PyObject * obj1 = 0 ;
30010 : gpgme_error_t result;
30011 :
30012 : {
30013 0 : arg2 = NULL;
30014 : }
30015 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_keys",&obj0,&obj1)) SWIG_fail;
30016 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30017 0 : if (!SWIG_IsOK(res1)) {
30018 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_keys" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30019 : }
30020 0 : arg1 = (gpgme_ctx_t)(argp1);
30021 : {
30022 0 : int i, numb = 0;
30023 0 : if (!PySequence_Check(obj1)) {
30024 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
30025 : 2);
30026 0 : return NULL;
30027 : }
30028 0 : if((numb = PySequence_Length(obj1)) != 0) {
30029 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
30030 0 : for(i=0; i<numb; i++) {
30031 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
30032 :
30033 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
30034 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
30035 :
30036 : /* Following code is from swig's python.swg. */
30037 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
30038 0 : Py_DECREF(pypointer);
30039 0 : PyErr_Format(PyExc_TypeError,
30040 : "arg %d: list must contain only gpgme_key_ts, got %s "
30041 : "at position %d",
30042 0 : 2, pypointer->ob_type->tp_name, i);
30043 0 : free(arg2);
30044 0 : return NULL;
30045 : }
30046 0 : Py_DECREF(pypointer);
30047 : }
30048 0 : arg2[numb] = NULL;
30049 : }
30050 : }
30051 : {
30052 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30053 0 : result = gpgme_op_import_keys(arg1,arg2);
30054 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30055 : }
30056 : {
30057 0 : resultobj = PyLong_FromLong(result);
30058 : }
30059 : {
30060 0 : if (arg2) free(arg2);
30061 : }
30062 : return resultobj;
30063 : fail:
30064 : {
30065 : if (arg2) free(arg2);
30066 : }
30067 : return NULL;
30068 : }
30069 :
30070 :
30071 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30072 0 : PyObject *resultobj = 0;
30073 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30074 0 : char *arg2 = (char *) 0 ;
30075 : gpgme_export_mode_t arg3 ;
30076 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
30077 0 : void *argp1 = 0 ;
30078 0 : int res1 = 0 ;
30079 0 : PyObject *encodedInput2 = NULL ;
30080 : unsigned int val3 ;
30081 0 : int ecode3 = 0 ;
30082 0 : gpgme_data_t wrapper4 = NULL ;
30083 0 : PyObject *bytesio4 = NULL ;
30084 : Py_buffer view4 ;
30085 0 : int have_view4 = 0 ;
30086 0 : PyObject * obj0 = 0 ;
30087 0 : PyObject * obj1 = 0 ;
30088 0 : PyObject * obj2 = 0 ;
30089 0 : PyObject * obj3 = 0 ;
30090 : gpgme_error_t result;
30091 :
30092 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30093 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30094 0 : if (!SWIG_IsOK(res1)) {
30095 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30096 : }
30097 0 : arg1 = (gpgme_ctx_t)(argp1);
30098 : {
30099 0 : if (obj1 == Py_None)
30100 : arg2 = NULL;
30101 0 : else if (PyUnicode_Check(obj1))
30102 : {
30103 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
30104 0 : if (encodedInput2 == NULL)
30105 : return NULL;
30106 0 : arg2 = PyBytes_AsString(encodedInput2);
30107 : }
30108 0 : else if (PyBytes_Check(obj1))
30109 0 : arg2 = PyBytes_AsString(obj1);
30110 : else {
30111 0 : PyErr_Format(PyExc_TypeError,
30112 : "arg %d: expected str, bytes, or None, got %s",
30113 : 2, obj1->ob_type->tp_name);
30114 0 : return NULL;
30115 : }
30116 : }
30117 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
30118 0 : if (!SWIG_IsOK(ecode3)) {
30119 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
30120 : }
30121 0 : arg3 = (gpgme_export_mode_t)(val3);
30122 : {
30123 : /* If we create a temporary wrapper4 object, we will store it in
30124 : wrapperN, where N is 4. Here in this fragment, SWIG will
30125 : automatically append 4. */
30126 0 : memset(&view4, 0, sizeof view4);
30127 0 : if (obj3 == Py_None)
30128 0 : arg4 = NULL;
30129 : else {
30130 : PyObject *pypointer;
30131 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
30132 : &bytesio4, &view4);
30133 0 : if (pypointer == NULL)
30134 : return NULL;
30135 0 : have_view4 = !! view4.obj;
30136 :
30137 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
30138 :
30139 : /* Following code is from swig's python.swg. */
30140 :
30141 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
30142 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
30143 0 : Py_DECREF(pypointer);
30144 : return NULL;
30145 : }
30146 0 : Py_DECREF(pypointer);
30147 : }
30148 : }
30149 : {
30150 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30151 0 : result = gpgme_op_export_start(arg1,(char const *)arg2,arg3,arg4);
30152 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30153 : }
30154 : {
30155 0 : resultobj = PyLong_FromLong(result);
30156 : }
30157 : {
30158 0 : Py_XDECREF(encodedInput2);
30159 : }
30160 : {
30161 : /* See whether we need to update the Python buffer. */
30162 0 : if (resultobj && wrapper4 && view4.buf)
30163 : {
30164 : int dirty;
30165 0 : char *new_data = NULL;
30166 : size_t new_size;
30167 :
30168 :
30169 0 : new_data = wrapper4->data.mem.buffer;
30170 0 : new_size = wrapper4->data.mem.length;
30171 0 : dirty = new_data != NULL;
30172 :
30173 :
30174 :
30175 :
30176 :
30177 :
30178 :
30179 0 : if (dirty)
30180 : {
30181 : /* The buffer is dirty. */
30182 0 : if (view4.readonly)
30183 : {
30184 0 : Py_XDECREF(resultobj);
30185 0 : resultobj = NULL;
30186 0 : PyErr_SetString(PyExc_ValueError,
30187 : "cannot update read-only buffer");
30188 : }
30189 :
30190 : /* See if we need to truncate the buffer. */
30191 0 : if (resultobj && view4.len != new_size)
30192 : {
30193 0 : if (bytesio4 == NULL)
30194 : {
30195 0 : Py_XDECREF(resultobj);
30196 0 : resultobj = NULL;
30197 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
30198 : }
30199 : else
30200 : {
30201 : PyObject *retval;
30202 0 : PyBuffer_Release(&view4);
30203 : assert(view4.obj == NULL);
30204 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
30205 : "l", (long) new_size);
30206 0 : if (retval == NULL)
30207 : {
30208 0 : Py_XDECREF(resultobj);
30209 : resultobj = NULL;
30210 : }
30211 : else
30212 : {
30213 0 : Py_DECREF(retval);
30214 :
30215 0 : retval = PyObject_CallMethod(bytesio4,
30216 : "getbuffer", NULL);
30217 0 : if (retval == NULL
30218 0 : || PyObject_GetBuffer(retval, &view4,
30219 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
30220 : {
30221 0 : Py_XDECREF(resultobj);
30222 : resultobj = NULL;
30223 : }
30224 :
30225 0 : Py_XDECREF(retval);
30226 :
30227 0 : if (resultobj && view4.len
30228 : != new_size)
30229 : {
30230 0 : Py_XDECREF(resultobj);
30231 0 : resultobj = NULL;
30232 0 : PyErr_Format(PyExc_ValueError,
30233 : "Expected buffer of length %zu, got %zi",
30234 : new_size,
30235 : view4.len);
30236 : }
30237 : }
30238 : }
30239 : }
30240 0 : if (resultobj)
30241 0 : memcpy(view4.buf, new_data, new_size);
30242 : }
30243 :
30244 :
30245 :
30246 : }
30247 :
30248 : /* Free the temporary wrapper, if any. */
30249 0 : if (wrapper4)
30250 0 : gpgme_data_release(wrapper4);
30251 0 : Py_XDECREF (bytesio4);
30252 0 : if (have_view4 && view4.buf)
30253 0 : PyBuffer_Release(&view4);
30254 : }
30255 : return resultobj;
30256 : fail:
30257 : {
30258 0 : Py_XDECREF(encodedInput2);
30259 : }
30260 : {
30261 : /* See whether we need to update the Python buffer. */
30262 : if (resultobj && wrapper4 && view4.buf)
30263 : {
30264 : int dirty;
30265 : char *new_data = NULL;
30266 : size_t new_size;
30267 :
30268 :
30269 : new_data = wrapper4->data.mem.buffer;
30270 : new_size = wrapper4->data.mem.length;
30271 : dirty = new_data != NULL;
30272 :
30273 :
30274 :
30275 :
30276 :
30277 :
30278 :
30279 : if (dirty)
30280 : {
30281 : /* The buffer is dirty. */
30282 : if (view4.readonly)
30283 : {
30284 : Py_XDECREF(resultobj);
30285 : resultobj = NULL;
30286 : PyErr_SetString(PyExc_ValueError,
30287 : "cannot update read-only buffer");
30288 : }
30289 :
30290 : /* See if we need to truncate the buffer. */
30291 : if (resultobj && view4.len != new_size)
30292 : {
30293 : if (bytesio4 == NULL)
30294 : {
30295 : Py_XDECREF(resultobj);
30296 : resultobj = NULL;
30297 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
30298 : }
30299 : else
30300 : {
30301 : PyObject *retval;
30302 : PyBuffer_Release(&view4);
30303 : assert(view4.obj == NULL);
30304 : retval = PyObject_CallMethod(bytesio4, "truncate",
30305 : "l", (long) new_size);
30306 : if (retval == NULL)
30307 : {
30308 : Py_XDECREF(resultobj);
30309 : resultobj = NULL;
30310 : }
30311 : else
30312 : {
30313 : Py_DECREF(retval);
30314 :
30315 : retval = PyObject_CallMethod(bytesio4,
30316 : "getbuffer", NULL);
30317 : if (retval == NULL
30318 : || PyObject_GetBuffer(retval, &view4,
30319 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
30320 : {
30321 : Py_XDECREF(resultobj);
30322 : resultobj = NULL;
30323 : }
30324 :
30325 : Py_XDECREF(retval);
30326 :
30327 : if (resultobj && view4.len
30328 : != new_size)
30329 : {
30330 : Py_XDECREF(resultobj);
30331 : resultobj = NULL;
30332 : PyErr_Format(PyExc_ValueError,
30333 : "Expected buffer of length %zu, got %zi",
30334 : new_size,
30335 : view4.len);
30336 : }
30337 : }
30338 : }
30339 : }
30340 : if (resultobj)
30341 : memcpy(view4.buf, new_data, new_size);
30342 : }
30343 :
30344 :
30345 :
30346 : }
30347 :
30348 : /* Free the temporary wrapper, if any. */
30349 0 : if (wrapper4)
30350 0 : gpgme_data_release(wrapper4);
30351 0 : Py_XDECREF (bytesio4);
30352 : if (have_view4 && view4.buf)
30353 : PyBuffer_Release(&view4);
30354 : }
30355 : return NULL;
30356 : }
30357 :
30358 :
30359 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30360 0 : PyObject *resultobj = 0;
30361 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30362 0 : char *arg2 = (char *) 0 ;
30363 : gpgme_export_mode_t arg3 ;
30364 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
30365 0 : void *argp1 = 0 ;
30366 0 : int res1 = 0 ;
30367 0 : PyObject *encodedInput2 = NULL ;
30368 : unsigned int val3 ;
30369 0 : int ecode3 = 0 ;
30370 0 : gpgme_data_t wrapper4 = NULL ;
30371 0 : PyObject *bytesio4 = NULL ;
30372 : Py_buffer view4 ;
30373 0 : int have_view4 = 0 ;
30374 0 : PyObject * obj0 = 0 ;
30375 0 : PyObject * obj1 = 0 ;
30376 0 : PyObject * obj2 = 0 ;
30377 0 : PyObject * obj3 = 0 ;
30378 : gpgme_error_t result;
30379 :
30380 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30381 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30382 0 : if (!SWIG_IsOK(res1)) {
30383 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30384 : }
30385 0 : arg1 = (gpgme_ctx_t)(argp1);
30386 : {
30387 0 : if (obj1 == Py_None)
30388 : arg2 = NULL;
30389 0 : else if (PyUnicode_Check(obj1))
30390 : {
30391 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
30392 0 : if (encodedInput2 == NULL)
30393 : return NULL;
30394 0 : arg2 = PyBytes_AsString(encodedInput2);
30395 : }
30396 0 : else if (PyBytes_Check(obj1))
30397 0 : arg2 = PyBytes_AsString(obj1);
30398 : else {
30399 0 : PyErr_Format(PyExc_TypeError,
30400 : "arg %d: expected str, bytes, or None, got %s",
30401 : 2, obj1->ob_type->tp_name);
30402 0 : return NULL;
30403 : }
30404 : }
30405 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
30406 0 : if (!SWIG_IsOK(ecode3)) {
30407 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
30408 : }
30409 0 : arg3 = (gpgme_export_mode_t)(val3);
30410 : {
30411 : /* If we create a temporary wrapper4 object, we will store it in
30412 : wrapperN, where N is 4. Here in this fragment, SWIG will
30413 : automatically append 4. */
30414 0 : memset(&view4, 0, sizeof view4);
30415 0 : if (obj3 == Py_None)
30416 0 : arg4 = NULL;
30417 : else {
30418 : PyObject *pypointer;
30419 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
30420 : &bytesio4, &view4);
30421 0 : if (pypointer == NULL)
30422 : return NULL;
30423 0 : have_view4 = !! view4.obj;
30424 :
30425 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
30426 :
30427 : /* Following code is from swig's python.swg. */
30428 :
30429 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
30430 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
30431 0 : Py_DECREF(pypointer);
30432 : return NULL;
30433 : }
30434 0 : Py_DECREF(pypointer);
30435 : }
30436 : }
30437 : {
30438 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30439 0 : result = gpgme_op_export(arg1,(char const *)arg2,arg3,arg4);
30440 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30441 : }
30442 : {
30443 0 : resultobj = PyLong_FromLong(result);
30444 : }
30445 : {
30446 0 : Py_XDECREF(encodedInput2);
30447 : }
30448 : {
30449 : /* See whether we need to update the Python buffer. */
30450 0 : if (resultobj && wrapper4 && view4.buf)
30451 : {
30452 : int dirty;
30453 0 : char *new_data = NULL;
30454 : size_t new_size;
30455 :
30456 :
30457 0 : new_data = wrapper4->data.mem.buffer;
30458 0 : new_size = wrapper4->data.mem.length;
30459 0 : dirty = new_data != NULL;
30460 :
30461 :
30462 :
30463 :
30464 :
30465 :
30466 :
30467 0 : if (dirty)
30468 : {
30469 : /* The buffer is dirty. */
30470 0 : if (view4.readonly)
30471 : {
30472 0 : Py_XDECREF(resultobj);
30473 0 : resultobj = NULL;
30474 0 : PyErr_SetString(PyExc_ValueError,
30475 : "cannot update read-only buffer");
30476 : }
30477 :
30478 : /* See if we need to truncate the buffer. */
30479 0 : if (resultobj && view4.len != new_size)
30480 : {
30481 0 : if (bytesio4 == NULL)
30482 : {
30483 0 : Py_XDECREF(resultobj);
30484 0 : resultobj = NULL;
30485 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
30486 : }
30487 : else
30488 : {
30489 : PyObject *retval;
30490 0 : PyBuffer_Release(&view4);
30491 : assert(view4.obj == NULL);
30492 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
30493 : "l", (long) new_size);
30494 0 : if (retval == NULL)
30495 : {
30496 0 : Py_XDECREF(resultobj);
30497 : resultobj = NULL;
30498 : }
30499 : else
30500 : {
30501 0 : Py_DECREF(retval);
30502 :
30503 0 : retval = PyObject_CallMethod(bytesio4,
30504 : "getbuffer", NULL);
30505 0 : if (retval == NULL
30506 0 : || PyObject_GetBuffer(retval, &view4,
30507 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
30508 : {
30509 0 : Py_XDECREF(resultobj);
30510 : resultobj = NULL;
30511 : }
30512 :
30513 0 : Py_XDECREF(retval);
30514 :
30515 0 : if (resultobj && view4.len
30516 : != new_size)
30517 : {
30518 0 : Py_XDECREF(resultobj);
30519 0 : resultobj = NULL;
30520 0 : PyErr_Format(PyExc_ValueError,
30521 : "Expected buffer of length %zu, got %zi",
30522 : new_size,
30523 : view4.len);
30524 : }
30525 : }
30526 : }
30527 : }
30528 0 : if (resultobj)
30529 0 : memcpy(view4.buf, new_data, new_size);
30530 : }
30531 :
30532 :
30533 :
30534 : }
30535 :
30536 : /* Free the temporary wrapper, if any. */
30537 0 : if (wrapper4)
30538 0 : gpgme_data_release(wrapper4);
30539 0 : Py_XDECREF (bytesio4);
30540 0 : if (have_view4 && view4.buf)
30541 0 : PyBuffer_Release(&view4);
30542 : }
30543 : return resultobj;
30544 : fail:
30545 : {
30546 0 : Py_XDECREF(encodedInput2);
30547 : }
30548 : {
30549 : /* See whether we need to update the Python buffer. */
30550 : if (resultobj && wrapper4 && view4.buf)
30551 : {
30552 : int dirty;
30553 : char *new_data = NULL;
30554 : size_t new_size;
30555 :
30556 :
30557 : new_data = wrapper4->data.mem.buffer;
30558 : new_size = wrapper4->data.mem.length;
30559 : dirty = new_data != NULL;
30560 :
30561 :
30562 :
30563 :
30564 :
30565 :
30566 :
30567 : if (dirty)
30568 : {
30569 : /* The buffer is dirty. */
30570 : if (view4.readonly)
30571 : {
30572 : Py_XDECREF(resultobj);
30573 : resultobj = NULL;
30574 : PyErr_SetString(PyExc_ValueError,
30575 : "cannot update read-only buffer");
30576 : }
30577 :
30578 : /* See if we need to truncate the buffer. */
30579 : if (resultobj && view4.len != new_size)
30580 : {
30581 : if (bytesio4 == NULL)
30582 : {
30583 : Py_XDECREF(resultobj);
30584 : resultobj = NULL;
30585 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
30586 : }
30587 : else
30588 : {
30589 : PyObject *retval;
30590 : PyBuffer_Release(&view4);
30591 : assert(view4.obj == NULL);
30592 : retval = PyObject_CallMethod(bytesio4, "truncate",
30593 : "l", (long) new_size);
30594 : if (retval == NULL)
30595 : {
30596 : Py_XDECREF(resultobj);
30597 : resultobj = NULL;
30598 : }
30599 : else
30600 : {
30601 : Py_DECREF(retval);
30602 :
30603 : retval = PyObject_CallMethod(bytesio4,
30604 : "getbuffer", NULL);
30605 : if (retval == NULL
30606 : || PyObject_GetBuffer(retval, &view4,
30607 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
30608 : {
30609 : Py_XDECREF(resultobj);
30610 : resultobj = NULL;
30611 : }
30612 :
30613 : Py_XDECREF(retval);
30614 :
30615 : if (resultobj && view4.len
30616 : != new_size)
30617 : {
30618 : Py_XDECREF(resultobj);
30619 : resultobj = NULL;
30620 : PyErr_Format(PyExc_ValueError,
30621 : "Expected buffer of length %zu, got %zi",
30622 : new_size,
30623 : view4.len);
30624 : }
30625 : }
30626 : }
30627 : }
30628 : if (resultobj)
30629 : memcpy(view4.buf, new_data, new_size);
30630 : }
30631 :
30632 :
30633 :
30634 : }
30635 :
30636 : /* Free the temporary wrapper, if any. */
30637 0 : if (wrapper4)
30638 0 : gpgme_data_release(wrapper4);
30639 0 : Py_XDECREF (bytesio4);
30640 : if (have_view4 && view4.buf)
30641 : PyBuffer_Release(&view4);
30642 : }
30643 : return NULL;
30644 : }
30645 :
30646 :
30647 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_ext_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30648 0 : PyObject *resultobj = 0;
30649 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30650 : char **arg2 ;
30651 : gpgme_export_mode_t arg3 ;
30652 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
30653 0 : void *argp1 = 0 ;
30654 0 : int res1 = 0 ;
30655 0 : void *vector2 = NULL ;
30656 : size_t size2 ;
30657 0 : PyObject **pyVector2 = NULL ;
30658 : unsigned int val3 ;
30659 0 : int ecode3 = 0 ;
30660 0 : gpgme_data_t wrapper4 = NULL ;
30661 0 : PyObject *bytesio4 = NULL ;
30662 : Py_buffer view4 ;
30663 0 : int have_view4 = 0 ;
30664 0 : PyObject * obj0 = 0 ;
30665 0 : PyObject * obj1 = 0 ;
30666 0 : PyObject * obj2 = 0 ;
30667 0 : PyObject * obj3 = 0 ;
30668 : gpgme_error_t result;
30669 :
30670 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_ext_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30671 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30672 0 : if (!SWIG_IsOK(res1)) {
30673 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30674 : }
30675 0 : arg1 = (gpgme_ctx_t)(argp1);
30676 : {
30677 : /* Check if is a list */
30678 0 : if (PyList_Check(obj1)) {
30679 : size_t i, j;
30680 0 : size2 = PyList_Size(obj1);
30681 0 : arg2 = (char **) (vector2 = malloc((size2+1) * sizeof(char *)));
30682 0 : pyVector2 = calloc(sizeof *pyVector2, size2);
30683 :
30684 0 : for (i = 0; i < size2; i++) {
30685 0 : PyObject *o = PyList_GetItem(obj1,i);
30686 0 : if (PyUnicode_Check(o))
30687 : {
30688 0 : pyVector2[i] = PyUnicode_AsUTF8String(o);
30689 0 : if (pyVector2[i] == NULL)
30690 : {
30691 0 : free(vector2);
30692 0 : for (j = 0; j < i; j++)
30693 0 : Py_XDECREF(pyVector2[j]);
30694 : return NULL;
30695 : }
30696 0 : arg2[i] = PyBytes_AsString(pyVector2[i]);
30697 : }
30698 0 : else if (PyString_Check(o))
30699 0 : arg2[i] = PyString_AsString(o);
30700 : else {
30701 0 : PyErr_Format(PyExc_TypeError,
30702 : "arg %d: list must contain only str or bytes, got %s "
30703 : "at position %d",
30704 : 2, o->ob_type->tp_name, i);
30705 0 : free(arg2);
30706 0 : return NULL;
30707 : }
30708 : }
30709 0 : arg2[i] = NULL;
30710 : } else {
30711 0 : PyErr_Format(PyExc_TypeError,
30712 : "arg %d: expected a list of str or bytes, got %s",
30713 : 2, obj1->ob_type->tp_name);
30714 0 : return NULL;
30715 : }
30716 : }
30717 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
30718 0 : if (!SWIG_IsOK(ecode3)) {
30719 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_ext_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
30720 : }
30721 0 : arg3 = (gpgme_export_mode_t)(val3);
30722 : {
30723 : /* If we create a temporary wrapper4 object, we will store it in
30724 : wrapperN, where N is 4. Here in this fragment, SWIG will
30725 : automatically append 4. */
30726 0 : memset(&view4, 0, sizeof view4);
30727 0 : if (obj3 == Py_None)
30728 0 : arg4 = NULL;
30729 : else {
30730 : PyObject *pypointer;
30731 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
30732 : &bytesio4, &view4);
30733 0 : if (pypointer == NULL)
30734 : return NULL;
30735 0 : have_view4 = !! view4.obj;
30736 :
30737 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
30738 :
30739 : /* Following code is from swig's python.swg. */
30740 :
30741 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
30742 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
30743 0 : Py_DECREF(pypointer);
30744 : return NULL;
30745 : }
30746 0 : Py_DECREF(pypointer);
30747 : }
30748 : }
30749 : {
30750 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30751 0 : result = gpgme_op_export_ext_start(arg1,(char const *(*))arg2,arg3,arg4);
30752 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30753 : }
30754 : {
30755 0 : resultobj = PyLong_FromLong(result);
30756 : }
30757 : {
30758 : size_t i;
30759 0 : free(vector2);
30760 0 : for (i = 0; i < size2; i++)
30761 0 : Py_XDECREF(pyVector2[i]);
30762 : }
30763 : {
30764 : /* See whether we need to update the Python buffer. */
30765 0 : if (resultobj && wrapper4 && view4.buf)
30766 : {
30767 : int dirty;
30768 0 : char *new_data = NULL;
30769 : size_t new_size;
30770 :
30771 :
30772 0 : new_data = wrapper4->data.mem.buffer;
30773 0 : new_size = wrapper4->data.mem.length;
30774 0 : dirty = new_data != NULL;
30775 :
30776 :
30777 :
30778 :
30779 :
30780 :
30781 :
30782 0 : if (dirty)
30783 : {
30784 : /* The buffer is dirty. */
30785 0 : if (view4.readonly)
30786 : {
30787 0 : Py_XDECREF(resultobj);
30788 0 : resultobj = NULL;
30789 0 : PyErr_SetString(PyExc_ValueError,
30790 : "cannot update read-only buffer");
30791 : }
30792 :
30793 : /* See if we need to truncate the buffer. */
30794 0 : if (resultobj && view4.len != new_size)
30795 : {
30796 0 : if (bytesio4 == NULL)
30797 : {
30798 0 : Py_XDECREF(resultobj);
30799 0 : resultobj = NULL;
30800 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
30801 : }
30802 : else
30803 : {
30804 : PyObject *retval;
30805 0 : PyBuffer_Release(&view4);
30806 : assert(view4.obj == NULL);
30807 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
30808 : "l", (long) new_size);
30809 0 : if (retval == NULL)
30810 : {
30811 0 : Py_XDECREF(resultobj);
30812 : resultobj = NULL;
30813 : }
30814 : else
30815 : {
30816 0 : Py_DECREF(retval);
30817 :
30818 0 : retval = PyObject_CallMethod(bytesio4,
30819 : "getbuffer", NULL);
30820 0 : if (retval == NULL
30821 0 : || PyObject_GetBuffer(retval, &view4,
30822 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
30823 : {
30824 0 : Py_XDECREF(resultobj);
30825 : resultobj = NULL;
30826 : }
30827 :
30828 0 : Py_XDECREF(retval);
30829 :
30830 0 : if (resultobj && view4.len
30831 : != new_size)
30832 : {
30833 0 : Py_XDECREF(resultobj);
30834 0 : resultobj = NULL;
30835 0 : PyErr_Format(PyExc_ValueError,
30836 : "Expected buffer of length %zu, got %zi",
30837 : new_size,
30838 : view4.len);
30839 : }
30840 : }
30841 : }
30842 : }
30843 0 : if (resultobj)
30844 0 : memcpy(view4.buf, new_data, new_size);
30845 : }
30846 :
30847 :
30848 :
30849 : }
30850 :
30851 : /* Free the temporary wrapper, if any. */
30852 0 : if (wrapper4)
30853 0 : gpgme_data_release(wrapper4);
30854 0 : Py_XDECREF (bytesio4);
30855 0 : if (have_view4 && view4.buf)
30856 0 : PyBuffer_Release(&view4);
30857 : }
30858 : return resultobj;
30859 : fail:
30860 : {
30861 : size_t i;
30862 0 : free(vector2);
30863 0 : for (i = 0; i < size2; i++)
30864 0 : Py_XDECREF(pyVector2[i]);
30865 : }
30866 : {
30867 : /* See whether we need to update the Python buffer. */
30868 : if (resultobj && wrapper4 && view4.buf)
30869 : {
30870 : int dirty;
30871 : char *new_data = NULL;
30872 : size_t new_size;
30873 :
30874 :
30875 : new_data = wrapper4->data.mem.buffer;
30876 : new_size = wrapper4->data.mem.length;
30877 : dirty = new_data != NULL;
30878 :
30879 :
30880 :
30881 :
30882 :
30883 :
30884 :
30885 : if (dirty)
30886 : {
30887 : /* The buffer is dirty. */
30888 : if (view4.readonly)
30889 : {
30890 : Py_XDECREF(resultobj);
30891 : resultobj = NULL;
30892 : PyErr_SetString(PyExc_ValueError,
30893 : "cannot update read-only buffer");
30894 : }
30895 :
30896 : /* See if we need to truncate the buffer. */
30897 : if (resultobj && view4.len != new_size)
30898 : {
30899 : if (bytesio4 == NULL)
30900 : {
30901 : Py_XDECREF(resultobj);
30902 : resultobj = NULL;
30903 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
30904 : }
30905 : else
30906 : {
30907 : PyObject *retval;
30908 : PyBuffer_Release(&view4);
30909 : assert(view4.obj == NULL);
30910 : retval = PyObject_CallMethod(bytesio4, "truncate",
30911 : "l", (long) new_size);
30912 : if (retval == NULL)
30913 : {
30914 : Py_XDECREF(resultobj);
30915 : resultobj = NULL;
30916 : }
30917 : else
30918 : {
30919 : Py_DECREF(retval);
30920 :
30921 : retval = PyObject_CallMethod(bytesio4,
30922 : "getbuffer", NULL);
30923 : if (retval == NULL
30924 : || PyObject_GetBuffer(retval, &view4,
30925 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
30926 : {
30927 : Py_XDECREF(resultobj);
30928 : resultobj = NULL;
30929 : }
30930 :
30931 : Py_XDECREF(retval);
30932 :
30933 : if (resultobj && view4.len
30934 : != new_size)
30935 : {
30936 : Py_XDECREF(resultobj);
30937 : resultobj = NULL;
30938 : PyErr_Format(PyExc_ValueError,
30939 : "Expected buffer of length %zu, got %zi",
30940 : new_size,
30941 : view4.len);
30942 : }
30943 : }
30944 : }
30945 : }
30946 : if (resultobj)
30947 : memcpy(view4.buf, new_data, new_size);
30948 : }
30949 :
30950 :
30951 :
30952 : }
30953 :
30954 : /* Free the temporary wrapper, if any. */
30955 0 : if (wrapper4)
30956 0 : gpgme_data_release(wrapper4);
30957 0 : Py_XDECREF (bytesio4);
30958 : if (have_view4 && view4.buf)
30959 : PyBuffer_Release(&view4);
30960 : }
30961 : return NULL;
30962 : }
30963 :
30964 :
30965 1 : SWIGINTERN PyObject *_wrap_gpgme_op_export_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30966 1 : PyObject *resultobj = 0;
30967 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30968 : char **arg2 ;
30969 : gpgme_export_mode_t arg3 ;
30970 1 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
30971 1 : void *argp1 = 0 ;
30972 1 : int res1 = 0 ;
30973 1 : void *vector2 = NULL ;
30974 : size_t size2 ;
30975 1 : PyObject **pyVector2 = NULL ;
30976 : unsigned int val3 ;
30977 1 : int ecode3 = 0 ;
30978 1 : gpgme_data_t wrapper4 = NULL ;
30979 1 : PyObject *bytesio4 = NULL ;
30980 : Py_buffer view4 ;
30981 1 : int have_view4 = 0 ;
30982 1 : PyObject * obj0 = 0 ;
30983 1 : PyObject * obj1 = 0 ;
30984 1 : PyObject * obj2 = 0 ;
30985 1 : PyObject * obj3 = 0 ;
30986 : gpgme_error_t result;
30987 :
30988 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_ext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30989 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30990 1 : if (!SWIG_IsOK(res1)) {
30991 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30992 : }
30993 1 : arg1 = (gpgme_ctx_t)(argp1);
30994 : {
30995 : /* Check if is a list */
30996 1 : if (PyList_Check(obj1)) {
30997 : size_t i, j;
30998 1 : size2 = PyList_Size(obj1);
30999 1 : arg2 = (char **) (vector2 = malloc((size2+1) * sizeof(char *)));
31000 1 : pyVector2 = calloc(sizeof *pyVector2, size2);
31001 :
31002 3 : for (i = 0; i < size2; i++) {
31003 2 : PyObject *o = PyList_GetItem(obj1,i);
31004 2 : if (PyUnicode_Check(o))
31005 : {
31006 2 : pyVector2[i] = PyUnicode_AsUTF8String(o);
31007 2 : if (pyVector2[i] == NULL)
31008 : {
31009 0 : free(vector2);
31010 0 : for (j = 0; j < i; j++)
31011 0 : Py_XDECREF(pyVector2[j]);
31012 : return NULL;
31013 : }
31014 2 : arg2[i] = PyBytes_AsString(pyVector2[i]);
31015 : }
31016 0 : else if (PyString_Check(o))
31017 0 : arg2[i] = PyString_AsString(o);
31018 : else {
31019 0 : PyErr_Format(PyExc_TypeError,
31020 : "arg %d: list must contain only str or bytes, got %s "
31021 : "at position %d",
31022 : 2, o->ob_type->tp_name, i);
31023 0 : free(arg2);
31024 0 : return NULL;
31025 : }
31026 : }
31027 1 : arg2[i] = NULL;
31028 : } else {
31029 0 : PyErr_Format(PyExc_TypeError,
31030 : "arg %d: expected a list of str or bytes, got %s",
31031 : 2, obj1->ob_type->tp_name);
31032 0 : return NULL;
31033 : }
31034 : }
31035 2 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
31036 1 : if (!SWIG_IsOK(ecode3)) {
31037 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_ext" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
31038 : }
31039 1 : arg3 = (gpgme_export_mode_t)(val3);
31040 : {
31041 : /* If we create a temporary wrapper4 object, we will store it in
31042 : wrapperN, where N is 4. Here in this fragment, SWIG will
31043 : automatically append 4. */
31044 1 : memset(&view4, 0, sizeof view4);
31045 1 : if (obj3 == Py_None)
31046 0 : arg4 = NULL;
31047 : else {
31048 : PyObject *pypointer;
31049 1 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
31050 : &bytesio4, &view4);
31051 1 : if (pypointer == NULL)
31052 : return NULL;
31053 1 : have_view4 = !! view4.obj;
31054 :
31055 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
31056 :
31057 : /* Following code is from swig's python.swg. */
31058 :
31059 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
31060 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
31061 0 : Py_DECREF(pypointer);
31062 : return NULL;
31063 : }
31064 1 : Py_DECREF(pypointer);
31065 : }
31066 : }
31067 : {
31068 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31069 1 : result = gpgme_op_export_ext(arg1,(char const *(*))arg2,arg3,arg4);
31070 1 : SWIG_PYTHON_THREAD_END_ALLOW;
31071 : }
31072 : {
31073 1 : resultobj = PyLong_FromLong(result);
31074 : }
31075 : {
31076 : size_t i;
31077 1 : free(vector2);
31078 3 : for (i = 0; i < size2; i++)
31079 2 : Py_XDECREF(pyVector2[i]);
31080 : }
31081 : {
31082 : /* See whether we need to update the Python buffer. */
31083 1 : if (resultobj && wrapper4 && view4.buf)
31084 : {
31085 : int dirty;
31086 0 : char *new_data = NULL;
31087 : size_t new_size;
31088 :
31089 :
31090 0 : new_data = wrapper4->data.mem.buffer;
31091 0 : new_size = wrapper4->data.mem.length;
31092 0 : dirty = new_data != NULL;
31093 :
31094 :
31095 :
31096 :
31097 :
31098 :
31099 :
31100 0 : if (dirty)
31101 : {
31102 : /* The buffer is dirty. */
31103 0 : if (view4.readonly)
31104 : {
31105 0 : Py_XDECREF(resultobj);
31106 0 : resultobj = NULL;
31107 0 : PyErr_SetString(PyExc_ValueError,
31108 : "cannot update read-only buffer");
31109 : }
31110 :
31111 : /* See if we need to truncate the buffer. */
31112 0 : if (resultobj && view4.len != new_size)
31113 : {
31114 0 : if (bytesio4 == NULL)
31115 : {
31116 0 : Py_XDECREF(resultobj);
31117 0 : resultobj = NULL;
31118 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
31119 : }
31120 : else
31121 : {
31122 : PyObject *retval;
31123 0 : PyBuffer_Release(&view4);
31124 : assert(view4.obj == NULL);
31125 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
31126 : "l", (long) new_size);
31127 0 : if (retval == NULL)
31128 : {
31129 0 : Py_XDECREF(resultobj);
31130 : resultobj = NULL;
31131 : }
31132 : else
31133 : {
31134 0 : Py_DECREF(retval);
31135 :
31136 0 : retval = PyObject_CallMethod(bytesio4,
31137 : "getbuffer", NULL);
31138 0 : if (retval == NULL
31139 0 : || PyObject_GetBuffer(retval, &view4,
31140 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
31141 : {
31142 0 : Py_XDECREF(resultobj);
31143 : resultobj = NULL;
31144 : }
31145 :
31146 0 : Py_XDECREF(retval);
31147 :
31148 0 : if (resultobj && view4.len
31149 : != new_size)
31150 : {
31151 0 : Py_XDECREF(resultobj);
31152 0 : resultobj = NULL;
31153 0 : PyErr_Format(PyExc_ValueError,
31154 : "Expected buffer of length %zu, got %zi",
31155 : new_size,
31156 : view4.len);
31157 : }
31158 : }
31159 : }
31160 : }
31161 0 : if (resultobj)
31162 0 : memcpy(view4.buf, new_data, new_size);
31163 : }
31164 :
31165 :
31166 :
31167 : }
31168 :
31169 : /* Free the temporary wrapper, if any. */
31170 1 : if (wrapper4)
31171 0 : gpgme_data_release(wrapper4);
31172 1 : Py_XDECREF (bytesio4);
31173 1 : if (have_view4 && view4.buf)
31174 0 : PyBuffer_Release(&view4);
31175 : }
31176 : return resultobj;
31177 : fail:
31178 : {
31179 : size_t i;
31180 0 : free(vector2);
31181 0 : for (i = 0; i < size2; i++)
31182 0 : Py_XDECREF(pyVector2[i]);
31183 : }
31184 : {
31185 : /* See whether we need to update the Python buffer. */
31186 : if (resultobj && wrapper4 && view4.buf)
31187 : {
31188 : int dirty;
31189 : char *new_data = NULL;
31190 : size_t new_size;
31191 :
31192 :
31193 : new_data = wrapper4->data.mem.buffer;
31194 : new_size = wrapper4->data.mem.length;
31195 : dirty = new_data != NULL;
31196 :
31197 :
31198 :
31199 :
31200 :
31201 :
31202 :
31203 : if (dirty)
31204 : {
31205 : /* The buffer is dirty. */
31206 : if (view4.readonly)
31207 : {
31208 : Py_XDECREF(resultobj);
31209 : resultobj = NULL;
31210 : PyErr_SetString(PyExc_ValueError,
31211 : "cannot update read-only buffer");
31212 : }
31213 :
31214 : /* See if we need to truncate the buffer. */
31215 : if (resultobj && view4.len != new_size)
31216 : {
31217 : if (bytesio4 == NULL)
31218 : {
31219 : Py_XDECREF(resultobj);
31220 : resultobj = NULL;
31221 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
31222 : }
31223 : else
31224 : {
31225 : PyObject *retval;
31226 : PyBuffer_Release(&view4);
31227 : assert(view4.obj == NULL);
31228 : retval = PyObject_CallMethod(bytesio4, "truncate",
31229 : "l", (long) new_size);
31230 : if (retval == NULL)
31231 : {
31232 : Py_XDECREF(resultobj);
31233 : resultobj = NULL;
31234 : }
31235 : else
31236 : {
31237 : Py_DECREF(retval);
31238 :
31239 : retval = PyObject_CallMethod(bytesio4,
31240 : "getbuffer", NULL);
31241 : if (retval == NULL
31242 : || PyObject_GetBuffer(retval, &view4,
31243 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
31244 : {
31245 : Py_XDECREF(resultobj);
31246 : resultobj = NULL;
31247 : }
31248 :
31249 : Py_XDECREF(retval);
31250 :
31251 : if (resultobj && view4.len
31252 : != new_size)
31253 : {
31254 : Py_XDECREF(resultobj);
31255 : resultobj = NULL;
31256 : PyErr_Format(PyExc_ValueError,
31257 : "Expected buffer of length %zu, got %zi",
31258 : new_size,
31259 : view4.len);
31260 : }
31261 : }
31262 : }
31263 : }
31264 : if (resultobj)
31265 : memcpy(view4.buf, new_data, new_size);
31266 : }
31267 :
31268 :
31269 :
31270 : }
31271 :
31272 : /* Free the temporary wrapper, if any. */
31273 0 : if (wrapper4)
31274 0 : gpgme_data_release(wrapper4);
31275 0 : Py_XDECREF (bytesio4);
31276 : if (have_view4 && view4.buf)
31277 : PyBuffer_Release(&view4);
31278 : }
31279 : return NULL;
31280 : }
31281 :
31282 :
31283 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_keys_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31284 0 : PyObject *resultobj = 0;
31285 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31286 : gpgme_key_t *arg2 ;
31287 : gpgme_export_mode_t arg3 ;
31288 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
31289 0 : void *argp1 = 0 ;
31290 0 : int res1 = 0 ;
31291 : unsigned int val3 ;
31292 0 : int ecode3 = 0 ;
31293 0 : gpgme_data_t wrapper4 = NULL ;
31294 0 : PyObject *bytesio4 = NULL ;
31295 : Py_buffer view4 ;
31296 0 : int have_view4 = 0 ;
31297 0 : PyObject * obj0 = 0 ;
31298 0 : PyObject * obj1 = 0 ;
31299 0 : PyObject * obj2 = 0 ;
31300 0 : PyObject * obj3 = 0 ;
31301 : gpgme_error_t result;
31302 :
31303 : {
31304 0 : arg2 = NULL;
31305 : }
31306 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_keys_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31307 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31308 0 : if (!SWIG_IsOK(res1)) {
31309 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_keys_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31310 : }
31311 0 : arg1 = (gpgme_ctx_t)(argp1);
31312 : {
31313 0 : int i, numb = 0;
31314 0 : if (!PySequence_Check(obj1)) {
31315 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
31316 : 2);
31317 0 : return NULL;
31318 : }
31319 0 : if((numb = PySequence_Length(obj1)) != 0) {
31320 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
31321 0 : for(i=0; i<numb; i++) {
31322 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
31323 :
31324 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
31325 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
31326 :
31327 : /* Following code is from swig's python.swg. */
31328 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
31329 0 : Py_DECREF(pypointer);
31330 0 : PyErr_Format(PyExc_TypeError,
31331 : "arg %d: list must contain only gpgme_key_ts, got %s "
31332 : "at position %d",
31333 0 : 2, pypointer->ob_type->tp_name, i);
31334 0 : free(arg2);
31335 0 : return NULL;
31336 : }
31337 0 : Py_DECREF(pypointer);
31338 : }
31339 0 : arg2[numb] = NULL;
31340 : }
31341 : }
31342 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
31343 0 : if (!SWIG_IsOK(ecode3)) {
31344 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_keys_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
31345 : }
31346 0 : arg3 = (gpgme_export_mode_t)(val3);
31347 : {
31348 : /* If we create a temporary wrapper4 object, we will store it in
31349 : wrapperN, where N is 4. Here in this fragment, SWIG will
31350 : automatically append 4. */
31351 0 : memset(&view4, 0, sizeof view4);
31352 0 : if (obj3 == Py_None)
31353 0 : arg4 = NULL;
31354 : else {
31355 : PyObject *pypointer;
31356 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
31357 : &bytesio4, &view4);
31358 0 : if (pypointer == NULL)
31359 : return NULL;
31360 0 : have_view4 = !! view4.obj;
31361 :
31362 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
31363 :
31364 : /* Following code is from swig's python.swg. */
31365 :
31366 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
31367 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
31368 0 : Py_DECREF(pypointer);
31369 : return NULL;
31370 : }
31371 0 : Py_DECREF(pypointer);
31372 : }
31373 : }
31374 : {
31375 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31376 0 : result = gpgme_op_export_keys_start(arg1,arg2,arg3,arg4);
31377 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31378 : }
31379 : {
31380 0 : resultobj = PyLong_FromLong(result);
31381 : }
31382 : {
31383 0 : if (arg2) free(arg2);
31384 : }
31385 : {
31386 : /* See whether we need to update the Python buffer. */
31387 0 : if (resultobj && wrapper4 && view4.buf)
31388 : {
31389 : int dirty;
31390 0 : char *new_data = NULL;
31391 : size_t new_size;
31392 :
31393 :
31394 0 : new_data = wrapper4->data.mem.buffer;
31395 0 : new_size = wrapper4->data.mem.length;
31396 0 : dirty = new_data != NULL;
31397 :
31398 :
31399 :
31400 :
31401 :
31402 :
31403 :
31404 0 : if (dirty)
31405 : {
31406 : /* The buffer is dirty. */
31407 0 : if (view4.readonly)
31408 : {
31409 0 : Py_XDECREF(resultobj);
31410 0 : resultobj = NULL;
31411 0 : PyErr_SetString(PyExc_ValueError,
31412 : "cannot update read-only buffer");
31413 : }
31414 :
31415 : /* See if we need to truncate the buffer. */
31416 0 : if (resultobj && view4.len != new_size)
31417 : {
31418 0 : if (bytesio4 == NULL)
31419 : {
31420 0 : Py_XDECREF(resultobj);
31421 0 : resultobj = NULL;
31422 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
31423 : }
31424 : else
31425 : {
31426 : PyObject *retval;
31427 0 : PyBuffer_Release(&view4);
31428 : assert(view4.obj == NULL);
31429 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
31430 : "l", (long) new_size);
31431 0 : if (retval == NULL)
31432 : {
31433 0 : Py_XDECREF(resultobj);
31434 : resultobj = NULL;
31435 : }
31436 : else
31437 : {
31438 0 : Py_DECREF(retval);
31439 :
31440 0 : retval = PyObject_CallMethod(bytesio4,
31441 : "getbuffer", NULL);
31442 0 : if (retval == NULL
31443 0 : || PyObject_GetBuffer(retval, &view4,
31444 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
31445 : {
31446 0 : Py_XDECREF(resultobj);
31447 : resultobj = NULL;
31448 : }
31449 :
31450 0 : Py_XDECREF(retval);
31451 :
31452 0 : if (resultobj && view4.len
31453 : != new_size)
31454 : {
31455 0 : Py_XDECREF(resultobj);
31456 0 : resultobj = NULL;
31457 0 : PyErr_Format(PyExc_ValueError,
31458 : "Expected buffer of length %zu, got %zi",
31459 : new_size,
31460 : view4.len);
31461 : }
31462 : }
31463 : }
31464 : }
31465 0 : if (resultobj)
31466 0 : memcpy(view4.buf, new_data, new_size);
31467 : }
31468 :
31469 :
31470 :
31471 : }
31472 :
31473 : /* Free the temporary wrapper, if any. */
31474 0 : if (wrapper4)
31475 0 : gpgme_data_release(wrapper4);
31476 0 : Py_XDECREF (bytesio4);
31477 0 : if (have_view4 && view4.buf)
31478 0 : PyBuffer_Release(&view4);
31479 : }
31480 : return resultobj;
31481 : fail:
31482 : {
31483 0 : if (arg2) free(arg2);
31484 : }
31485 : {
31486 : /* See whether we need to update the Python buffer. */
31487 : if (resultobj && wrapper4 && view4.buf)
31488 : {
31489 : int dirty;
31490 : char *new_data = NULL;
31491 : size_t new_size;
31492 :
31493 :
31494 : new_data = wrapper4->data.mem.buffer;
31495 : new_size = wrapper4->data.mem.length;
31496 : dirty = new_data != NULL;
31497 :
31498 :
31499 :
31500 :
31501 :
31502 :
31503 :
31504 : if (dirty)
31505 : {
31506 : /* The buffer is dirty. */
31507 : if (view4.readonly)
31508 : {
31509 : Py_XDECREF(resultobj);
31510 : resultobj = NULL;
31511 : PyErr_SetString(PyExc_ValueError,
31512 : "cannot update read-only buffer");
31513 : }
31514 :
31515 : /* See if we need to truncate the buffer. */
31516 : if (resultobj && view4.len != new_size)
31517 : {
31518 : if (bytesio4 == NULL)
31519 : {
31520 : Py_XDECREF(resultobj);
31521 : resultobj = NULL;
31522 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
31523 : }
31524 : else
31525 : {
31526 : PyObject *retval;
31527 : PyBuffer_Release(&view4);
31528 : assert(view4.obj == NULL);
31529 : retval = PyObject_CallMethod(bytesio4, "truncate",
31530 : "l", (long) new_size);
31531 : if (retval == NULL)
31532 : {
31533 : Py_XDECREF(resultobj);
31534 : resultobj = NULL;
31535 : }
31536 : else
31537 : {
31538 : Py_DECREF(retval);
31539 :
31540 : retval = PyObject_CallMethod(bytesio4,
31541 : "getbuffer", NULL);
31542 : if (retval == NULL
31543 : || PyObject_GetBuffer(retval, &view4,
31544 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
31545 : {
31546 : Py_XDECREF(resultobj);
31547 : resultobj = NULL;
31548 : }
31549 :
31550 : Py_XDECREF(retval);
31551 :
31552 : if (resultobj && view4.len
31553 : != new_size)
31554 : {
31555 : Py_XDECREF(resultobj);
31556 : resultobj = NULL;
31557 : PyErr_Format(PyExc_ValueError,
31558 : "Expected buffer of length %zu, got %zi",
31559 : new_size,
31560 : view4.len);
31561 : }
31562 : }
31563 : }
31564 : }
31565 : if (resultobj)
31566 : memcpy(view4.buf, new_data, new_size);
31567 : }
31568 :
31569 :
31570 :
31571 : }
31572 :
31573 : /* Free the temporary wrapper, if any. */
31574 0 : if (wrapper4)
31575 0 : gpgme_data_release(wrapper4);
31576 0 : Py_XDECREF (bytesio4);
31577 : if (have_view4 && view4.buf)
31578 : PyBuffer_Release(&view4);
31579 : }
31580 : return NULL;
31581 : }
31582 :
31583 :
31584 2 : SWIGINTERN PyObject *_wrap_gpgme_op_export_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31585 2 : PyObject *resultobj = 0;
31586 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31587 : gpgme_key_t *arg2 ;
31588 : gpgme_export_mode_t arg3 ;
31589 2 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
31590 2 : void *argp1 = 0 ;
31591 2 : int res1 = 0 ;
31592 : unsigned int val3 ;
31593 2 : int ecode3 = 0 ;
31594 2 : gpgme_data_t wrapper4 = NULL ;
31595 2 : PyObject *bytesio4 = NULL ;
31596 : Py_buffer view4 ;
31597 2 : int have_view4 = 0 ;
31598 2 : PyObject * obj0 = 0 ;
31599 2 : PyObject * obj1 = 0 ;
31600 2 : PyObject * obj2 = 0 ;
31601 2 : PyObject * obj3 = 0 ;
31602 : gpgme_error_t result;
31603 :
31604 : {
31605 2 : arg2 = NULL;
31606 : }
31607 2 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_keys",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31608 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31609 2 : if (!SWIG_IsOK(res1)) {
31610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_keys" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31611 : }
31612 2 : arg1 = (gpgme_ctx_t)(argp1);
31613 : {
31614 2 : int i, numb = 0;
31615 2 : if (!PySequence_Check(obj1)) {
31616 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
31617 : 2);
31618 0 : return NULL;
31619 : }
31620 2 : if((numb = PySequence_Length(obj1)) != 0) {
31621 2 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
31622 30 : for(i=0; i<numb; i++) {
31623 28 : PyObject *pypointer = PySequence_GetItem(obj1, i);
31624 :
31625 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
31626 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
31627 :
31628 : /* Following code is from swig's python.swg. */
31629 28 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
31630 0 : Py_DECREF(pypointer);
31631 0 : PyErr_Format(PyExc_TypeError,
31632 : "arg %d: list must contain only gpgme_key_ts, got %s "
31633 : "at position %d",
31634 0 : 2, pypointer->ob_type->tp_name, i);
31635 0 : free(arg2);
31636 0 : return NULL;
31637 : }
31638 28 : Py_DECREF(pypointer);
31639 : }
31640 2 : arg2[numb] = NULL;
31641 : }
31642 : }
31643 4 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
31644 2 : if (!SWIG_IsOK(ecode3)) {
31645 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_keys" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
31646 : }
31647 2 : arg3 = (gpgme_export_mode_t)(val3);
31648 : {
31649 : /* If we create a temporary wrapper4 object, we will store it in
31650 : wrapperN, where N is 4. Here in this fragment, SWIG will
31651 : automatically append 4. */
31652 2 : memset(&view4, 0, sizeof view4);
31653 2 : if (obj3 == Py_None)
31654 0 : arg4 = NULL;
31655 : else {
31656 : PyObject *pypointer;
31657 2 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
31658 : &bytesio4, &view4);
31659 2 : if (pypointer == NULL)
31660 : return NULL;
31661 2 : have_view4 = !! view4.obj;
31662 :
31663 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
31664 :
31665 : /* Following code is from swig's python.swg. */
31666 :
31667 2 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
31668 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
31669 0 : Py_DECREF(pypointer);
31670 : return NULL;
31671 : }
31672 2 : Py_DECREF(pypointer);
31673 : }
31674 : }
31675 : {
31676 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31677 2 : result = gpgme_op_export_keys(arg1,arg2,arg3,arg4);
31678 2 : SWIG_PYTHON_THREAD_END_ALLOW;
31679 : }
31680 : {
31681 2 : resultobj = PyLong_FromLong(result);
31682 : }
31683 : {
31684 2 : if (arg2) free(arg2);
31685 : }
31686 : {
31687 : /* See whether we need to update the Python buffer. */
31688 2 : if (resultobj && wrapper4 && view4.buf)
31689 : {
31690 : int dirty;
31691 0 : char *new_data = NULL;
31692 : size_t new_size;
31693 :
31694 :
31695 0 : new_data = wrapper4->data.mem.buffer;
31696 0 : new_size = wrapper4->data.mem.length;
31697 0 : dirty = new_data != NULL;
31698 :
31699 :
31700 :
31701 :
31702 :
31703 :
31704 :
31705 0 : if (dirty)
31706 : {
31707 : /* The buffer is dirty. */
31708 0 : if (view4.readonly)
31709 : {
31710 0 : Py_XDECREF(resultobj);
31711 0 : resultobj = NULL;
31712 0 : PyErr_SetString(PyExc_ValueError,
31713 : "cannot update read-only buffer");
31714 : }
31715 :
31716 : /* See if we need to truncate the buffer. */
31717 0 : if (resultobj && view4.len != new_size)
31718 : {
31719 0 : if (bytesio4 == NULL)
31720 : {
31721 0 : Py_XDECREF(resultobj);
31722 0 : resultobj = NULL;
31723 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
31724 : }
31725 : else
31726 : {
31727 : PyObject *retval;
31728 0 : PyBuffer_Release(&view4);
31729 : assert(view4.obj == NULL);
31730 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
31731 : "l", (long) new_size);
31732 0 : if (retval == NULL)
31733 : {
31734 0 : Py_XDECREF(resultobj);
31735 : resultobj = NULL;
31736 : }
31737 : else
31738 : {
31739 0 : Py_DECREF(retval);
31740 :
31741 0 : retval = PyObject_CallMethod(bytesio4,
31742 : "getbuffer", NULL);
31743 0 : if (retval == NULL
31744 0 : || PyObject_GetBuffer(retval, &view4,
31745 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
31746 : {
31747 0 : Py_XDECREF(resultobj);
31748 : resultobj = NULL;
31749 : }
31750 :
31751 0 : Py_XDECREF(retval);
31752 :
31753 0 : if (resultobj && view4.len
31754 : != new_size)
31755 : {
31756 0 : Py_XDECREF(resultobj);
31757 0 : resultobj = NULL;
31758 0 : PyErr_Format(PyExc_ValueError,
31759 : "Expected buffer of length %zu, got %zi",
31760 : new_size,
31761 : view4.len);
31762 : }
31763 : }
31764 : }
31765 : }
31766 0 : if (resultobj)
31767 0 : memcpy(view4.buf, new_data, new_size);
31768 : }
31769 :
31770 :
31771 :
31772 : }
31773 :
31774 : /* Free the temporary wrapper, if any. */
31775 2 : if (wrapper4)
31776 0 : gpgme_data_release(wrapper4);
31777 2 : Py_XDECREF (bytesio4);
31778 2 : if (have_view4 && view4.buf)
31779 0 : PyBuffer_Release(&view4);
31780 : }
31781 : return resultobj;
31782 : fail:
31783 : {
31784 0 : if (arg2) free(arg2);
31785 : }
31786 : {
31787 : /* See whether we need to update the Python buffer. */
31788 : if (resultobj && wrapper4 && view4.buf)
31789 : {
31790 : int dirty;
31791 : char *new_data = NULL;
31792 : size_t new_size;
31793 :
31794 :
31795 : new_data = wrapper4->data.mem.buffer;
31796 : new_size = wrapper4->data.mem.length;
31797 : dirty = new_data != NULL;
31798 :
31799 :
31800 :
31801 :
31802 :
31803 :
31804 :
31805 : if (dirty)
31806 : {
31807 : /* The buffer is dirty. */
31808 : if (view4.readonly)
31809 : {
31810 : Py_XDECREF(resultobj);
31811 : resultobj = NULL;
31812 : PyErr_SetString(PyExc_ValueError,
31813 : "cannot update read-only buffer");
31814 : }
31815 :
31816 : /* See if we need to truncate the buffer. */
31817 : if (resultobj && view4.len != new_size)
31818 : {
31819 : if (bytesio4 == NULL)
31820 : {
31821 : Py_XDECREF(resultobj);
31822 : resultobj = NULL;
31823 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
31824 : }
31825 : else
31826 : {
31827 : PyObject *retval;
31828 : PyBuffer_Release(&view4);
31829 : assert(view4.obj == NULL);
31830 : retval = PyObject_CallMethod(bytesio4, "truncate",
31831 : "l", (long) new_size);
31832 : if (retval == NULL)
31833 : {
31834 : Py_XDECREF(resultobj);
31835 : resultobj = NULL;
31836 : }
31837 : else
31838 : {
31839 : Py_DECREF(retval);
31840 :
31841 : retval = PyObject_CallMethod(bytesio4,
31842 : "getbuffer", NULL);
31843 : if (retval == NULL
31844 : || PyObject_GetBuffer(retval, &view4,
31845 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
31846 : {
31847 : Py_XDECREF(resultobj);
31848 : resultobj = NULL;
31849 : }
31850 :
31851 : Py_XDECREF(retval);
31852 :
31853 : if (resultobj && view4.len
31854 : != new_size)
31855 : {
31856 : Py_XDECREF(resultobj);
31857 : resultobj = NULL;
31858 : PyErr_Format(PyExc_ValueError,
31859 : "Expected buffer of length %zu, got %zi",
31860 : new_size,
31861 : view4.len);
31862 : }
31863 : }
31864 : }
31865 : }
31866 : if (resultobj)
31867 : memcpy(view4.buf, new_data, new_size);
31868 : }
31869 :
31870 :
31871 :
31872 : }
31873 :
31874 : /* Free the temporary wrapper, if any. */
31875 0 : if (wrapper4)
31876 0 : gpgme_data_release(wrapper4);
31877 0 : Py_XDECREF (bytesio4);
31878 : if (have_view4 && view4.buf)
31879 : PyBuffer_Release(&view4);
31880 : }
31881 : return NULL;
31882 : }
31883 :
31884 :
31885 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_primary_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31886 0 : PyObject *resultobj = 0;
31887 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
31888 : unsigned int arg2 ;
31889 0 : void *argp1 = 0 ;
31890 0 : int res1 = 0 ;
31891 : unsigned int val2 ;
31892 0 : int ecode2 = 0 ;
31893 0 : PyObject * obj0 = 0 ;
31894 0 : PyObject * obj1 = 0 ;
31895 :
31896 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_primary_set",&obj0,&obj1)) SWIG_fail;
31897 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
31898 0 : if (!SWIG_IsOK(res1)) {
31899 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_primary_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
31900 : }
31901 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
31902 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
31903 0 : if (!SWIG_IsOK(ecode2)) {
31904 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result_primary_set" "', argument " "2"" of type '" "unsigned int""'");
31905 : }
31906 0 : arg2 = (unsigned int)(val2);
31907 : {
31908 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31909 0 : if (arg1) (arg1)->primary = arg2;
31910 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31911 : }
31912 0 : resultobj = SWIG_Py_Void();
31913 0 : return resultobj;
31914 : fail:
31915 : return NULL;
31916 : }
31917 :
31918 :
31919 72 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_primary_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31920 72 : PyObject *resultobj = 0;
31921 72 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
31922 72 : void *argp1 = 0 ;
31923 72 : int res1 = 0 ;
31924 72 : PyObject * obj0 = 0 ;
31925 : unsigned int result;
31926 :
31927 72 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_primary_get",&obj0)) SWIG_fail;
31928 72 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
31929 72 : if (!SWIG_IsOK(res1)) {
31930 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_primary_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
31931 : }
31932 72 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
31933 : {
31934 72 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31935 72 : result = (unsigned int) ((arg1)->primary);
31936 72 : SWIG_PYTHON_THREAD_END_ALLOW;
31937 : }
31938 72 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
31939 72 : return resultobj;
31940 : fail:
31941 : return NULL;
31942 : }
31943 :
31944 :
31945 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_sub_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31946 0 : PyObject *resultobj = 0;
31947 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
31948 : unsigned int arg2 ;
31949 0 : void *argp1 = 0 ;
31950 0 : int res1 = 0 ;
31951 : unsigned int val2 ;
31952 0 : int ecode2 = 0 ;
31953 0 : PyObject * obj0 = 0 ;
31954 0 : PyObject * obj1 = 0 ;
31955 :
31956 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_sub_set",&obj0,&obj1)) SWIG_fail;
31957 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
31958 0 : if (!SWIG_IsOK(res1)) {
31959 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_sub_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
31960 : }
31961 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
31962 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
31963 0 : if (!SWIG_IsOK(ecode2)) {
31964 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result_sub_set" "', argument " "2"" of type '" "unsigned int""'");
31965 : }
31966 0 : arg2 = (unsigned int)(val2);
31967 : {
31968 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31969 0 : if (arg1) (arg1)->sub = arg2;
31970 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31971 : }
31972 0 : resultobj = SWIG_Py_Void();
31973 0 : return resultobj;
31974 : fail:
31975 : return NULL;
31976 : }
31977 :
31978 :
31979 72 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_sub_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31980 72 : PyObject *resultobj = 0;
31981 72 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
31982 72 : void *argp1 = 0 ;
31983 72 : int res1 = 0 ;
31984 72 : PyObject * obj0 = 0 ;
31985 : unsigned int result;
31986 :
31987 72 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_sub_get",&obj0)) SWIG_fail;
31988 72 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
31989 72 : if (!SWIG_IsOK(res1)) {
31990 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_sub_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
31991 : }
31992 72 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
31993 : {
31994 72 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31995 72 : result = (unsigned int) ((arg1)->sub);
31996 72 : SWIG_PYTHON_THREAD_END_ALLOW;
31997 : }
31998 72 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
31999 72 : return resultobj;
32000 : fail:
32001 : return NULL;
32002 : }
32003 :
32004 :
32005 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_uid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32006 0 : PyObject *resultobj = 0;
32007 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32008 : unsigned int arg2 ;
32009 0 : void *argp1 = 0 ;
32010 0 : int res1 = 0 ;
32011 : unsigned int val2 ;
32012 0 : int ecode2 = 0 ;
32013 0 : PyObject * obj0 = 0 ;
32014 0 : PyObject * obj1 = 0 ;
32015 :
32016 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_uid_set",&obj0,&obj1)) SWIG_fail;
32017 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32018 0 : if (!SWIG_IsOK(res1)) {
32019 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_uid_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32020 : }
32021 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32022 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
32023 0 : if (!SWIG_IsOK(ecode2)) {
32024 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result_uid_set" "', argument " "2"" of type '" "unsigned int""'");
32025 : }
32026 0 : arg2 = (unsigned int)(val2);
32027 : {
32028 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32029 0 : if (arg1) (arg1)->uid = arg2;
32030 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32031 : }
32032 0 : resultobj = SWIG_Py_Void();
32033 0 : return resultobj;
32034 : fail:
32035 : return NULL;
32036 : }
32037 :
32038 :
32039 36 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_uid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32040 36 : PyObject *resultobj = 0;
32041 36 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32042 36 : void *argp1 = 0 ;
32043 36 : int res1 = 0 ;
32044 36 : PyObject * obj0 = 0 ;
32045 : unsigned int result;
32046 :
32047 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_uid_get",&obj0)) SWIG_fail;
32048 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32049 36 : if (!SWIG_IsOK(res1)) {
32050 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_uid_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32051 : }
32052 36 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32053 : {
32054 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32055 36 : result = (unsigned int) ((arg1)->uid);
32056 36 : SWIG_PYTHON_THREAD_END_ALLOW;
32057 : }
32058 36 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
32059 36 : return resultobj;
32060 : fail:
32061 : return NULL;
32062 : }
32063 :
32064 :
32065 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32066 0 : PyObject *resultobj = 0;
32067 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32068 : unsigned int arg2 ;
32069 0 : void *argp1 = 0 ;
32070 0 : int res1 = 0 ;
32071 : unsigned int val2 ;
32072 0 : int ecode2 = 0 ;
32073 0 : PyObject * obj0 = 0 ;
32074 0 : PyObject * obj1 = 0 ;
32075 :
32076 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result__unused_set",&obj0,&obj1)) SWIG_fail;
32077 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32078 0 : if (!SWIG_IsOK(res1)) {
32079 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32080 : }
32081 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32082 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
32083 0 : if (!SWIG_IsOK(ecode2)) {
32084 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result__unused_set" "', argument " "2"" of type '" "unsigned int""'");
32085 : }
32086 0 : arg2 = (unsigned int)(val2);
32087 : {
32088 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32089 0 : if (arg1) (arg1)->_unused = arg2;
32090 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32091 : }
32092 0 : resultobj = SWIG_Py_Void();
32093 0 : return resultobj;
32094 : fail:
32095 : return NULL;
32096 : }
32097 :
32098 :
32099 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32100 0 : PyObject *resultobj = 0;
32101 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32102 0 : void *argp1 = 0 ;
32103 0 : int res1 = 0 ;
32104 0 : PyObject * obj0 = 0 ;
32105 : unsigned int result;
32106 :
32107 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result__unused_get",&obj0)) SWIG_fail;
32108 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32109 0 : if (!SWIG_IsOK(res1)) {
32110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32111 : }
32112 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32113 : {
32114 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32115 0 : result = (unsigned int) ((arg1)->_unused);
32116 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32117 : }
32118 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
32119 0 : return resultobj;
32120 : fail:
32121 : return NULL;
32122 : }
32123 :
32124 :
32125 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32126 0 : PyObject *resultobj = 0;
32127 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32128 0 : char *arg2 = (char *) 0 ;
32129 0 : void *argp1 = 0 ;
32130 0 : int res1 = 0 ;
32131 : int res2 ;
32132 0 : char *buf2 = 0 ;
32133 0 : int alloc2 = 0 ;
32134 0 : PyObject * obj0 = 0 ;
32135 0 : PyObject * obj1 = 0 ;
32136 :
32137 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_fpr_set",&obj0,&obj1)) SWIG_fail;
32138 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32139 0 : if (!SWIG_IsOK(res1)) {
32140 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_fpr_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32141 : }
32142 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32143 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32144 0 : if (!SWIG_IsOK(res2)) {
32145 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_genkey_result_fpr_set" "', argument " "2"" of type '" "char *""'");
32146 : }
32147 0 : arg2 = (char *)(buf2);
32148 : {
32149 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32150 0 : if (arg1->fpr) free((char*)arg1->fpr);
32151 0 : if (arg2) {
32152 0 : size_t size = strlen((const char *)(arg2)) + 1;
32153 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
32154 : } else {
32155 0 : arg1->fpr = 0;
32156 : }
32157 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32158 : }
32159 0 : resultobj = SWIG_Py_Void();
32160 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32161 : return resultobj;
32162 : fail:
32163 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32164 : return NULL;
32165 : }
32166 :
32167 :
32168 36 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32169 36 : PyObject *resultobj = 0;
32170 36 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32171 36 : void *argp1 = 0 ;
32172 36 : int res1 = 0 ;
32173 36 : PyObject * obj0 = 0 ;
32174 36 : char *result = 0 ;
32175 :
32176 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_fpr_get",&obj0)) SWIG_fail;
32177 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32178 36 : if (!SWIG_IsOK(res1)) {
32179 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_fpr_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32180 : }
32181 36 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32182 : {
32183 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32184 36 : result = (char *) ((arg1)->fpr);
32185 36 : SWIG_PYTHON_THREAD_END_ALLOW;
32186 : }
32187 36 : resultobj = SWIG_FromCharPtr((const char *)result);
32188 36 : return resultobj;
32189 : fail:
32190 : return NULL;
32191 : }
32192 :
32193 :
32194 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_pubkey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32195 0 : PyObject *resultobj = 0;
32196 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32197 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
32198 0 : void *argp1 = 0 ;
32199 0 : int res1 = 0 ;
32200 0 : gpgme_data_t wrapper2 = NULL ;
32201 0 : PyObject *bytesio2 = NULL ;
32202 : Py_buffer view2 ;
32203 0 : int have_view2 = 0 ;
32204 0 : PyObject * obj0 = 0 ;
32205 0 : PyObject * obj1 = 0 ;
32206 :
32207 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_pubkey_set",&obj0,&obj1)) SWIG_fail;
32208 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32209 0 : if (!SWIG_IsOK(res1)) {
32210 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_pubkey_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32211 : }
32212 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32213 : {
32214 : /* If we create a temporary wrapper2 object, we will store it in
32215 : wrapperN, where N is 2. Here in this fragment, SWIG will
32216 : automatically append 2. */
32217 0 : memset(&view2, 0, sizeof view2);
32218 0 : if (obj1 == Py_None)
32219 0 : arg2 = NULL;
32220 : else {
32221 : PyObject *pypointer;
32222 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
32223 : &bytesio2, &view2);
32224 0 : if (pypointer == NULL)
32225 : return NULL;
32226 0 : have_view2 = !! view2.obj;
32227 :
32228 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
32229 :
32230 : /* Following code is from swig's python.swg. */
32231 :
32232 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
32233 : SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN )) == -1) {
32234 0 : Py_DECREF(pypointer);
32235 : return NULL;
32236 : }
32237 0 : Py_DECREF(pypointer);
32238 : }
32239 : }
32240 : {
32241 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32242 0 : if (arg1) (arg1)->pubkey = arg2;
32243 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32244 : }
32245 0 : resultobj = SWIG_Py_Void();
32246 : {
32247 : /* See whether we need to update the Python buffer. */
32248 0 : if (resultobj && wrapper2 && view2.buf)
32249 : {
32250 : int dirty;
32251 0 : char *new_data = NULL;
32252 : size_t new_size;
32253 :
32254 :
32255 0 : new_data = wrapper2->data.mem.buffer;
32256 0 : new_size = wrapper2->data.mem.length;
32257 0 : dirty = new_data != NULL;
32258 :
32259 :
32260 :
32261 :
32262 :
32263 :
32264 :
32265 0 : if (dirty)
32266 : {
32267 : /* The buffer is dirty. */
32268 0 : if (view2.readonly)
32269 : {
32270 0 : Py_XDECREF(resultobj);
32271 0 : resultobj = NULL;
32272 0 : PyErr_SetString(PyExc_ValueError,
32273 : "cannot update read-only buffer");
32274 : }
32275 :
32276 : /* See if we need to truncate the buffer. */
32277 0 : if (resultobj && view2.len != new_size)
32278 : {
32279 0 : if (bytesio2 == NULL)
32280 : {
32281 0 : Py_XDECREF(resultobj);
32282 0 : resultobj = NULL;
32283 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
32284 : }
32285 : else
32286 : {
32287 : PyObject *retval;
32288 0 : PyBuffer_Release(&view2);
32289 : assert(view2.obj == NULL);
32290 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
32291 : "l", (long) new_size);
32292 0 : if (retval == NULL)
32293 : {
32294 0 : Py_XDECREF(resultobj);
32295 : resultobj = NULL;
32296 : }
32297 : else
32298 : {
32299 0 : Py_DECREF(retval);
32300 :
32301 0 : retval = PyObject_CallMethod(bytesio2,
32302 : "getbuffer", NULL);
32303 0 : if (retval == NULL
32304 0 : || PyObject_GetBuffer(retval, &view2,
32305 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
32306 : {
32307 0 : Py_XDECREF(resultobj);
32308 : resultobj = NULL;
32309 : }
32310 :
32311 0 : Py_XDECREF(retval);
32312 :
32313 0 : if (resultobj && view2.len
32314 : != new_size)
32315 : {
32316 0 : Py_XDECREF(resultobj);
32317 0 : resultobj = NULL;
32318 0 : PyErr_Format(PyExc_ValueError,
32319 : "Expected buffer of length %zu, got %zi",
32320 : new_size,
32321 : view2.len);
32322 : }
32323 : }
32324 : }
32325 : }
32326 0 : if (resultobj)
32327 0 : memcpy(view2.buf, new_data, new_size);
32328 : }
32329 :
32330 :
32331 :
32332 : }
32333 :
32334 : /* Free the temporary wrapper, if any. */
32335 0 : if (wrapper2)
32336 0 : gpgme_data_release(wrapper2);
32337 0 : Py_XDECREF (bytesio2);
32338 0 : if (have_view2 && view2.buf)
32339 0 : PyBuffer_Release(&view2);
32340 : }
32341 : return resultobj;
32342 : fail:
32343 : {
32344 : /* See whether we need to update the Python buffer. */
32345 : if (resultobj && wrapper2 && view2.buf)
32346 : {
32347 : int dirty;
32348 : char *new_data = NULL;
32349 : size_t new_size;
32350 :
32351 :
32352 : new_data = wrapper2->data.mem.buffer;
32353 : new_size = wrapper2->data.mem.length;
32354 : dirty = new_data != NULL;
32355 :
32356 :
32357 :
32358 :
32359 :
32360 :
32361 :
32362 : if (dirty)
32363 : {
32364 : /* The buffer is dirty. */
32365 : if (view2.readonly)
32366 : {
32367 : Py_XDECREF(resultobj);
32368 : resultobj = NULL;
32369 : PyErr_SetString(PyExc_ValueError,
32370 : "cannot update read-only buffer");
32371 : }
32372 :
32373 : /* See if we need to truncate the buffer. */
32374 : if (resultobj && view2.len != new_size)
32375 : {
32376 : if (bytesio2 == NULL)
32377 : {
32378 : Py_XDECREF(resultobj);
32379 : resultobj = NULL;
32380 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
32381 : }
32382 : else
32383 : {
32384 : PyObject *retval;
32385 : PyBuffer_Release(&view2);
32386 : assert(view2.obj == NULL);
32387 : retval = PyObject_CallMethod(bytesio2, "truncate",
32388 : "l", (long) new_size);
32389 : if (retval == NULL)
32390 : {
32391 : Py_XDECREF(resultobj);
32392 : resultobj = NULL;
32393 : }
32394 : else
32395 : {
32396 : Py_DECREF(retval);
32397 :
32398 : retval = PyObject_CallMethod(bytesio2,
32399 : "getbuffer", NULL);
32400 : if (retval == NULL
32401 : || PyObject_GetBuffer(retval, &view2,
32402 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
32403 : {
32404 : Py_XDECREF(resultobj);
32405 : resultobj = NULL;
32406 : }
32407 :
32408 : Py_XDECREF(retval);
32409 :
32410 : if (resultobj && view2.len
32411 : != new_size)
32412 : {
32413 : Py_XDECREF(resultobj);
32414 : resultobj = NULL;
32415 : PyErr_Format(PyExc_ValueError,
32416 : "Expected buffer of length %zu, got %zi",
32417 : new_size,
32418 : view2.len);
32419 : }
32420 : }
32421 : }
32422 : }
32423 : if (resultobj)
32424 : memcpy(view2.buf, new_data, new_size);
32425 : }
32426 :
32427 :
32428 :
32429 : }
32430 :
32431 : /* Free the temporary wrapper, if any. */
32432 0 : if (wrapper2)
32433 0 : gpgme_data_release(wrapper2);
32434 0 : Py_XDECREF (bytesio2);
32435 : if (have_view2 && view2.buf)
32436 : PyBuffer_Release(&view2);
32437 : }
32438 : return NULL;
32439 : }
32440 :
32441 :
32442 36 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_pubkey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32443 36 : PyObject *resultobj = 0;
32444 36 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32445 36 : void *argp1 = 0 ;
32446 36 : int res1 = 0 ;
32447 36 : PyObject * obj0 = 0 ;
32448 : gpgme_data_t result;
32449 :
32450 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_pubkey_get",&obj0)) SWIG_fail;
32451 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32452 36 : if (!SWIG_IsOK(res1)) {
32453 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_pubkey_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32454 : }
32455 36 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32456 : {
32457 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32458 36 : result = (gpgme_data_t) ((arg1)->pubkey);
32459 36 : SWIG_PYTHON_THREAD_END_ALLOW;
32460 : }
32461 36 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data, 0 | 0 );
32462 36 : return resultobj;
32463 : fail:
32464 : return NULL;
32465 : }
32466 :
32467 :
32468 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_seckey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32469 0 : PyObject *resultobj = 0;
32470 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32471 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
32472 0 : void *argp1 = 0 ;
32473 0 : int res1 = 0 ;
32474 0 : gpgme_data_t wrapper2 = NULL ;
32475 0 : PyObject *bytesio2 = NULL ;
32476 : Py_buffer view2 ;
32477 0 : int have_view2 = 0 ;
32478 0 : PyObject * obj0 = 0 ;
32479 0 : PyObject * obj1 = 0 ;
32480 :
32481 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_seckey_set",&obj0,&obj1)) SWIG_fail;
32482 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32483 0 : if (!SWIG_IsOK(res1)) {
32484 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_seckey_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32485 : }
32486 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32487 : {
32488 : /* If we create a temporary wrapper2 object, we will store it in
32489 : wrapperN, where N is 2. Here in this fragment, SWIG will
32490 : automatically append 2. */
32491 0 : memset(&view2, 0, sizeof view2);
32492 0 : if (obj1 == Py_None)
32493 0 : arg2 = NULL;
32494 : else {
32495 : PyObject *pypointer;
32496 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
32497 : &bytesio2, &view2);
32498 0 : if (pypointer == NULL)
32499 : return NULL;
32500 0 : have_view2 = !! view2.obj;
32501 :
32502 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
32503 :
32504 : /* Following code is from swig's python.swg. */
32505 :
32506 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
32507 : SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN )) == -1) {
32508 0 : Py_DECREF(pypointer);
32509 : return NULL;
32510 : }
32511 0 : Py_DECREF(pypointer);
32512 : }
32513 : }
32514 : {
32515 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32516 0 : if (arg1) (arg1)->seckey = arg2;
32517 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32518 : }
32519 0 : resultobj = SWIG_Py_Void();
32520 : {
32521 : /* See whether we need to update the Python buffer. */
32522 0 : if (resultobj && wrapper2 && view2.buf)
32523 : {
32524 : int dirty;
32525 0 : char *new_data = NULL;
32526 : size_t new_size;
32527 :
32528 :
32529 0 : new_data = wrapper2->data.mem.buffer;
32530 0 : new_size = wrapper2->data.mem.length;
32531 0 : dirty = new_data != NULL;
32532 :
32533 :
32534 :
32535 :
32536 :
32537 :
32538 :
32539 0 : if (dirty)
32540 : {
32541 : /* The buffer is dirty. */
32542 0 : if (view2.readonly)
32543 : {
32544 0 : Py_XDECREF(resultobj);
32545 0 : resultobj = NULL;
32546 0 : PyErr_SetString(PyExc_ValueError,
32547 : "cannot update read-only buffer");
32548 : }
32549 :
32550 : /* See if we need to truncate the buffer. */
32551 0 : if (resultobj && view2.len != new_size)
32552 : {
32553 0 : if (bytesio2 == NULL)
32554 : {
32555 0 : Py_XDECREF(resultobj);
32556 0 : resultobj = NULL;
32557 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
32558 : }
32559 : else
32560 : {
32561 : PyObject *retval;
32562 0 : PyBuffer_Release(&view2);
32563 : assert(view2.obj == NULL);
32564 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
32565 : "l", (long) new_size);
32566 0 : if (retval == NULL)
32567 : {
32568 0 : Py_XDECREF(resultobj);
32569 : resultobj = NULL;
32570 : }
32571 : else
32572 : {
32573 0 : Py_DECREF(retval);
32574 :
32575 0 : retval = PyObject_CallMethod(bytesio2,
32576 : "getbuffer", NULL);
32577 0 : if (retval == NULL
32578 0 : || PyObject_GetBuffer(retval, &view2,
32579 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
32580 : {
32581 0 : Py_XDECREF(resultobj);
32582 : resultobj = NULL;
32583 : }
32584 :
32585 0 : Py_XDECREF(retval);
32586 :
32587 0 : if (resultobj && view2.len
32588 : != new_size)
32589 : {
32590 0 : Py_XDECREF(resultobj);
32591 0 : resultobj = NULL;
32592 0 : PyErr_Format(PyExc_ValueError,
32593 : "Expected buffer of length %zu, got %zi",
32594 : new_size,
32595 : view2.len);
32596 : }
32597 : }
32598 : }
32599 : }
32600 0 : if (resultobj)
32601 0 : memcpy(view2.buf, new_data, new_size);
32602 : }
32603 :
32604 :
32605 :
32606 : }
32607 :
32608 : /* Free the temporary wrapper, if any. */
32609 0 : if (wrapper2)
32610 0 : gpgme_data_release(wrapper2);
32611 0 : Py_XDECREF (bytesio2);
32612 0 : if (have_view2 && view2.buf)
32613 0 : PyBuffer_Release(&view2);
32614 : }
32615 : return resultobj;
32616 : fail:
32617 : {
32618 : /* See whether we need to update the Python buffer. */
32619 : if (resultobj && wrapper2 && view2.buf)
32620 : {
32621 : int dirty;
32622 : char *new_data = NULL;
32623 : size_t new_size;
32624 :
32625 :
32626 : new_data = wrapper2->data.mem.buffer;
32627 : new_size = wrapper2->data.mem.length;
32628 : dirty = new_data != NULL;
32629 :
32630 :
32631 :
32632 :
32633 :
32634 :
32635 :
32636 : if (dirty)
32637 : {
32638 : /* The buffer is dirty. */
32639 : if (view2.readonly)
32640 : {
32641 : Py_XDECREF(resultobj);
32642 : resultobj = NULL;
32643 : PyErr_SetString(PyExc_ValueError,
32644 : "cannot update read-only buffer");
32645 : }
32646 :
32647 : /* See if we need to truncate the buffer. */
32648 : if (resultobj && view2.len != new_size)
32649 : {
32650 : if (bytesio2 == NULL)
32651 : {
32652 : Py_XDECREF(resultobj);
32653 : resultobj = NULL;
32654 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
32655 : }
32656 : else
32657 : {
32658 : PyObject *retval;
32659 : PyBuffer_Release(&view2);
32660 : assert(view2.obj == NULL);
32661 : retval = PyObject_CallMethod(bytesio2, "truncate",
32662 : "l", (long) new_size);
32663 : if (retval == NULL)
32664 : {
32665 : Py_XDECREF(resultobj);
32666 : resultobj = NULL;
32667 : }
32668 : else
32669 : {
32670 : Py_DECREF(retval);
32671 :
32672 : retval = PyObject_CallMethod(bytesio2,
32673 : "getbuffer", NULL);
32674 : if (retval == NULL
32675 : || PyObject_GetBuffer(retval, &view2,
32676 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
32677 : {
32678 : Py_XDECREF(resultobj);
32679 : resultobj = NULL;
32680 : }
32681 :
32682 : Py_XDECREF(retval);
32683 :
32684 : if (resultobj && view2.len
32685 : != new_size)
32686 : {
32687 : Py_XDECREF(resultobj);
32688 : resultobj = NULL;
32689 : PyErr_Format(PyExc_ValueError,
32690 : "Expected buffer of length %zu, got %zi",
32691 : new_size,
32692 : view2.len);
32693 : }
32694 : }
32695 : }
32696 : }
32697 : if (resultobj)
32698 : memcpy(view2.buf, new_data, new_size);
32699 : }
32700 :
32701 :
32702 :
32703 : }
32704 :
32705 : /* Free the temporary wrapper, if any. */
32706 0 : if (wrapper2)
32707 0 : gpgme_data_release(wrapper2);
32708 0 : Py_XDECREF (bytesio2);
32709 : if (have_view2 && view2.buf)
32710 : PyBuffer_Release(&view2);
32711 : }
32712 : return NULL;
32713 : }
32714 :
32715 :
32716 36 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_seckey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32717 36 : PyObject *resultobj = 0;
32718 36 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32719 36 : void *argp1 = 0 ;
32720 36 : int res1 = 0 ;
32721 36 : PyObject * obj0 = 0 ;
32722 : gpgme_data_t result;
32723 :
32724 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_seckey_get",&obj0)) SWIG_fail;
32725 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
32726 36 : if (!SWIG_IsOK(res1)) {
32727 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_seckey_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32728 : }
32729 36 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32730 : {
32731 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32732 36 : result = (gpgme_data_t) ((arg1)->seckey);
32733 36 : SWIG_PYTHON_THREAD_END_ALLOW;
32734 : }
32735 36 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data, 0 | 0 );
32736 36 : return resultobj;
32737 : fail:
32738 : return NULL;
32739 : }
32740 :
32741 :
32742 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_genkey_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32743 0 : PyObject *resultobj = 0;
32744 0 : struct _gpgme_op_genkey_result *result = 0 ;
32745 :
32746 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_genkey_result")) SWIG_fail;
32747 : {
32748 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32749 0 : result = (struct _gpgme_op_genkey_result *)calloc(1, sizeof(struct _gpgme_op_genkey_result));
32750 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32751 : }
32752 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_genkey_result, SWIG_POINTER_NEW | 0 );
32753 0 : return resultobj;
32754 : fail:
32755 : return NULL;
32756 : }
32757 :
32758 :
32759 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_genkey_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32760 0 : PyObject *resultobj = 0;
32761 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
32762 0 : void *argp1 = 0 ;
32763 0 : int res1 = 0 ;
32764 0 : PyObject * obj0 = 0 ;
32765 :
32766 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_genkey_result",&obj0)) SWIG_fail;
32767 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, SWIG_POINTER_DISOWN | 0 );
32768 0 : if (!SWIG_IsOK(res1)) {
32769 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_genkey_result" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
32770 : }
32771 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
32772 : {
32773 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32774 0 : free((char *) arg1);
32775 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32776 : }
32777 0 : resultobj = SWIG_Py_Void();
32778 0 : return resultobj;
32779 : fail:
32780 : return NULL;
32781 : }
32782 :
32783 :
32784 29 : SWIGINTERN PyObject *_gpgme_op_genkey_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32785 : PyObject *obj;
32786 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
32787 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_genkey_result, SWIG_NewClientData(obj));
32788 29 : return SWIG_Py_Void();
32789 : }
32790 :
32791 0 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32792 0 : PyObject *resultobj = 0;
32793 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
32794 0 : char *arg2 = (char *) 0 ;
32795 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
32796 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
32797 0 : void *argp1 = 0 ;
32798 0 : int res1 = 0 ;
32799 0 : PyObject *encodedInput2 = NULL ;
32800 0 : gpgme_data_t wrapper3 = NULL ;
32801 0 : PyObject *bytesio3 = NULL ;
32802 : Py_buffer view3 ;
32803 0 : int have_view3 = 0 ;
32804 0 : gpgme_data_t wrapper4 = NULL ;
32805 0 : PyObject *bytesio4 = NULL ;
32806 : Py_buffer view4 ;
32807 0 : int have_view4 = 0 ;
32808 0 : PyObject * obj0 = 0 ;
32809 0 : PyObject * obj1 = 0 ;
32810 0 : PyObject * obj2 = 0 ;
32811 0 : PyObject * obj3 = 0 ;
32812 : gpgme_error_t result;
32813 :
32814 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_genkey_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32815 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
32816 0 : if (!SWIG_IsOK(res1)) {
32817 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
32818 : }
32819 0 : arg1 = (gpgme_ctx_t)(argp1);
32820 : {
32821 0 : if (obj1 == Py_None)
32822 : arg2 = NULL;
32823 0 : else if (PyUnicode_Check(obj1))
32824 : {
32825 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
32826 0 : if (encodedInput2 == NULL)
32827 : return NULL;
32828 0 : arg2 = PyBytes_AsString(encodedInput2);
32829 : }
32830 0 : else if (PyBytes_Check(obj1))
32831 0 : arg2 = PyBytes_AsString(obj1);
32832 : else {
32833 0 : PyErr_Format(PyExc_TypeError,
32834 : "arg %d: expected str, bytes, or None, got %s",
32835 : 2, obj1->ob_type->tp_name);
32836 0 : return NULL;
32837 : }
32838 : }
32839 : {
32840 : /* If we create a temporary wrapper3 object, we will store it in
32841 : wrapperN, where N is 3. Here in this fragment, SWIG will
32842 : automatically append 3. */
32843 0 : memset(&view3, 0, sizeof view3);
32844 0 : if (obj2 == Py_None)
32845 0 : arg3 = NULL;
32846 : else {
32847 : PyObject *pypointer;
32848 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
32849 : &bytesio3, &view3);
32850 0 : if (pypointer == NULL)
32851 : return NULL;
32852 0 : have_view3 = !! view3.obj;
32853 :
32854 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
32855 :
32856 : /* Following code is from swig's python.swg. */
32857 :
32858 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
32859 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
32860 0 : Py_DECREF(pypointer);
32861 : return NULL;
32862 : }
32863 0 : Py_DECREF(pypointer);
32864 : }
32865 : }
32866 : {
32867 : /* If we create a temporary wrapper4 object, we will store it in
32868 : wrapperN, where N is 4. Here in this fragment, SWIG will
32869 : automatically append 4. */
32870 0 : memset(&view4, 0, sizeof view4);
32871 0 : if (obj3 == Py_None)
32872 0 : arg4 = NULL;
32873 : else {
32874 : PyObject *pypointer;
32875 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
32876 : &bytesio4, &view4);
32877 0 : if (pypointer == NULL)
32878 : return NULL;
32879 0 : have_view4 = !! view4.obj;
32880 :
32881 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
32882 :
32883 : /* Following code is from swig's python.swg. */
32884 :
32885 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
32886 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
32887 0 : Py_DECREF(pypointer);
32888 : return NULL;
32889 : }
32890 0 : Py_DECREF(pypointer);
32891 : }
32892 : }
32893 : {
32894 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32895 0 : result = gpgme_op_genkey_start(arg1,(char const *)arg2,arg3,arg4);
32896 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32897 : }
32898 : {
32899 0 : resultobj = PyLong_FromLong(result);
32900 : }
32901 : {
32902 0 : Py_XDECREF(encodedInput2);
32903 : }
32904 : {
32905 : /* See whether we need to update the Python buffer. */
32906 0 : if (resultobj && wrapper3 && view3.buf)
32907 : {
32908 : int dirty;
32909 0 : char *new_data = NULL;
32910 : size_t new_size;
32911 :
32912 :
32913 0 : new_data = wrapper3->data.mem.buffer;
32914 0 : new_size = wrapper3->data.mem.length;
32915 0 : dirty = new_data != NULL;
32916 :
32917 :
32918 :
32919 :
32920 :
32921 :
32922 :
32923 0 : if (dirty)
32924 : {
32925 : /* The buffer is dirty. */
32926 0 : if (view3.readonly)
32927 : {
32928 0 : Py_XDECREF(resultobj);
32929 0 : resultobj = NULL;
32930 0 : PyErr_SetString(PyExc_ValueError,
32931 : "cannot update read-only buffer");
32932 : }
32933 :
32934 : /* See if we need to truncate the buffer. */
32935 0 : if (resultobj && view3.len != new_size)
32936 : {
32937 0 : if (bytesio3 == NULL)
32938 : {
32939 0 : Py_XDECREF(resultobj);
32940 0 : resultobj = NULL;
32941 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
32942 : }
32943 : else
32944 : {
32945 : PyObject *retval;
32946 0 : PyBuffer_Release(&view3);
32947 : assert(view3.obj == NULL);
32948 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
32949 : "l", (long) new_size);
32950 0 : if (retval == NULL)
32951 : {
32952 0 : Py_XDECREF(resultobj);
32953 : resultobj = NULL;
32954 : }
32955 : else
32956 : {
32957 0 : Py_DECREF(retval);
32958 :
32959 0 : retval = PyObject_CallMethod(bytesio3,
32960 : "getbuffer", NULL);
32961 0 : if (retval == NULL
32962 0 : || PyObject_GetBuffer(retval, &view3,
32963 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
32964 : {
32965 0 : Py_XDECREF(resultobj);
32966 : resultobj = NULL;
32967 : }
32968 :
32969 0 : Py_XDECREF(retval);
32970 :
32971 0 : if (resultobj && view3.len
32972 : != new_size)
32973 : {
32974 0 : Py_XDECREF(resultobj);
32975 0 : resultobj = NULL;
32976 0 : PyErr_Format(PyExc_ValueError,
32977 : "Expected buffer of length %zu, got %zi",
32978 : new_size,
32979 : view3.len);
32980 : }
32981 : }
32982 : }
32983 : }
32984 0 : if (resultobj)
32985 0 : memcpy(view3.buf, new_data, new_size);
32986 : }
32987 :
32988 :
32989 :
32990 : }
32991 :
32992 : /* Free the temporary wrapper, if any. */
32993 0 : if (wrapper3)
32994 0 : gpgme_data_release(wrapper3);
32995 0 : Py_XDECREF (bytesio3);
32996 0 : if (have_view3 && view3.buf)
32997 0 : PyBuffer_Release(&view3);
32998 : }
32999 : {
33000 : /* See whether we need to update the Python buffer. */
33001 0 : if (resultobj && wrapper4 && view4.buf)
33002 : {
33003 : int dirty;
33004 0 : char *new_data = NULL;
33005 : size_t new_size;
33006 :
33007 :
33008 0 : new_data = wrapper4->data.mem.buffer;
33009 0 : new_size = wrapper4->data.mem.length;
33010 0 : dirty = new_data != NULL;
33011 :
33012 :
33013 :
33014 :
33015 :
33016 :
33017 :
33018 0 : if (dirty)
33019 : {
33020 : /* The buffer is dirty. */
33021 0 : if (view4.readonly)
33022 : {
33023 0 : Py_XDECREF(resultobj);
33024 0 : resultobj = NULL;
33025 0 : PyErr_SetString(PyExc_ValueError,
33026 : "cannot update read-only buffer");
33027 : }
33028 :
33029 : /* See if we need to truncate the buffer. */
33030 0 : if (resultobj && view4.len != new_size)
33031 : {
33032 0 : if (bytesio4 == NULL)
33033 : {
33034 0 : Py_XDECREF(resultobj);
33035 0 : resultobj = NULL;
33036 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
33037 : }
33038 : else
33039 : {
33040 : PyObject *retval;
33041 0 : PyBuffer_Release(&view4);
33042 : assert(view4.obj == NULL);
33043 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
33044 : "l", (long) new_size);
33045 0 : if (retval == NULL)
33046 : {
33047 0 : Py_XDECREF(resultobj);
33048 : resultobj = NULL;
33049 : }
33050 : else
33051 : {
33052 0 : Py_DECREF(retval);
33053 :
33054 0 : retval = PyObject_CallMethod(bytesio4,
33055 : "getbuffer", NULL);
33056 0 : if (retval == NULL
33057 0 : || PyObject_GetBuffer(retval, &view4,
33058 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
33059 : {
33060 0 : Py_XDECREF(resultobj);
33061 : resultobj = NULL;
33062 : }
33063 :
33064 0 : Py_XDECREF(retval);
33065 :
33066 0 : if (resultobj && view4.len
33067 : != new_size)
33068 : {
33069 0 : Py_XDECREF(resultobj);
33070 0 : resultobj = NULL;
33071 0 : PyErr_Format(PyExc_ValueError,
33072 : "Expected buffer of length %zu, got %zi",
33073 : new_size,
33074 : view4.len);
33075 : }
33076 : }
33077 : }
33078 : }
33079 0 : if (resultobj)
33080 0 : memcpy(view4.buf, new_data, new_size);
33081 : }
33082 :
33083 :
33084 :
33085 : }
33086 :
33087 : /* Free the temporary wrapper, if any. */
33088 0 : if (wrapper4)
33089 0 : gpgme_data_release(wrapper4);
33090 0 : Py_XDECREF (bytesio4);
33091 0 : if (have_view4 && view4.buf)
33092 0 : PyBuffer_Release(&view4);
33093 : }
33094 : return resultobj;
33095 : fail:
33096 : {
33097 0 : Py_XDECREF(encodedInput2);
33098 : }
33099 : {
33100 : /* See whether we need to update the Python buffer. */
33101 : if (resultobj && wrapper3 && view3.buf)
33102 : {
33103 : int dirty;
33104 : char *new_data = NULL;
33105 : size_t new_size;
33106 :
33107 :
33108 : new_data = wrapper3->data.mem.buffer;
33109 : new_size = wrapper3->data.mem.length;
33110 : dirty = new_data != NULL;
33111 :
33112 :
33113 :
33114 :
33115 :
33116 :
33117 :
33118 : if (dirty)
33119 : {
33120 : /* The buffer is dirty. */
33121 : if (view3.readonly)
33122 : {
33123 : Py_XDECREF(resultobj);
33124 : resultobj = NULL;
33125 : PyErr_SetString(PyExc_ValueError,
33126 : "cannot update read-only buffer");
33127 : }
33128 :
33129 : /* See if we need to truncate the buffer. */
33130 : if (resultobj && view3.len != new_size)
33131 : {
33132 : if (bytesio3 == NULL)
33133 : {
33134 : Py_XDECREF(resultobj);
33135 : resultobj = NULL;
33136 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
33137 : }
33138 : else
33139 : {
33140 : PyObject *retval;
33141 : PyBuffer_Release(&view3);
33142 : assert(view3.obj == NULL);
33143 : retval = PyObject_CallMethod(bytesio3, "truncate",
33144 : "l", (long) new_size);
33145 : if (retval == NULL)
33146 : {
33147 : Py_XDECREF(resultobj);
33148 : resultobj = NULL;
33149 : }
33150 : else
33151 : {
33152 : Py_DECREF(retval);
33153 :
33154 : retval = PyObject_CallMethod(bytesio3,
33155 : "getbuffer", NULL);
33156 : if (retval == NULL
33157 : || PyObject_GetBuffer(retval, &view3,
33158 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
33159 : {
33160 : Py_XDECREF(resultobj);
33161 : resultobj = NULL;
33162 : }
33163 :
33164 : Py_XDECREF(retval);
33165 :
33166 : if (resultobj && view3.len
33167 : != new_size)
33168 : {
33169 : Py_XDECREF(resultobj);
33170 : resultobj = NULL;
33171 : PyErr_Format(PyExc_ValueError,
33172 : "Expected buffer of length %zu, got %zi",
33173 : new_size,
33174 : view3.len);
33175 : }
33176 : }
33177 : }
33178 : }
33179 : if (resultobj)
33180 : memcpy(view3.buf, new_data, new_size);
33181 : }
33182 :
33183 :
33184 :
33185 : }
33186 :
33187 : /* Free the temporary wrapper, if any. */
33188 0 : if (wrapper3)
33189 0 : gpgme_data_release(wrapper3);
33190 0 : Py_XDECREF (bytesio3);
33191 : if (have_view3 && view3.buf)
33192 : PyBuffer_Release(&view3);
33193 : }
33194 : {
33195 : /* See whether we need to update the Python buffer. */
33196 : if (resultobj && wrapper4 && view4.buf)
33197 : {
33198 : int dirty;
33199 : char *new_data = NULL;
33200 : size_t new_size;
33201 :
33202 :
33203 : new_data = wrapper4->data.mem.buffer;
33204 : new_size = wrapper4->data.mem.length;
33205 : dirty = new_data != NULL;
33206 :
33207 :
33208 :
33209 :
33210 :
33211 :
33212 :
33213 : if (dirty)
33214 : {
33215 : /* The buffer is dirty. */
33216 : if (view4.readonly)
33217 : {
33218 : Py_XDECREF(resultobj);
33219 : resultobj = NULL;
33220 : PyErr_SetString(PyExc_ValueError,
33221 : "cannot update read-only buffer");
33222 : }
33223 :
33224 : /* See if we need to truncate the buffer. */
33225 : if (resultobj && view4.len != new_size)
33226 : {
33227 : if (bytesio4 == NULL)
33228 : {
33229 : Py_XDECREF(resultobj);
33230 : resultobj = NULL;
33231 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
33232 : }
33233 : else
33234 : {
33235 : PyObject *retval;
33236 : PyBuffer_Release(&view4);
33237 : assert(view4.obj == NULL);
33238 : retval = PyObject_CallMethod(bytesio4, "truncate",
33239 : "l", (long) new_size);
33240 : if (retval == NULL)
33241 : {
33242 : Py_XDECREF(resultobj);
33243 : resultobj = NULL;
33244 : }
33245 : else
33246 : {
33247 : Py_DECREF(retval);
33248 :
33249 : retval = PyObject_CallMethod(bytesio4,
33250 : "getbuffer", NULL);
33251 : if (retval == NULL
33252 : || PyObject_GetBuffer(retval, &view4,
33253 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
33254 : {
33255 : Py_XDECREF(resultobj);
33256 : resultobj = NULL;
33257 : }
33258 :
33259 : Py_XDECREF(retval);
33260 :
33261 : if (resultobj && view4.len
33262 : != new_size)
33263 : {
33264 : Py_XDECREF(resultobj);
33265 : resultobj = NULL;
33266 : PyErr_Format(PyExc_ValueError,
33267 : "Expected buffer of length %zu, got %zi",
33268 : new_size,
33269 : view4.len);
33270 : }
33271 : }
33272 : }
33273 : }
33274 : if (resultobj)
33275 : memcpy(view4.buf, new_data, new_size);
33276 : }
33277 :
33278 :
33279 :
33280 : }
33281 :
33282 : /* Free the temporary wrapper, if any. */
33283 0 : if (wrapper4)
33284 0 : gpgme_data_release(wrapper4);
33285 0 : Py_XDECREF (bytesio4);
33286 : if (have_view4 && view4.buf)
33287 : PyBuffer_Release(&view4);
33288 : }
33289 : return NULL;
33290 : }
33291 :
33292 :
33293 3 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33294 3 : PyObject *resultobj = 0;
33295 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
33296 3 : char *arg2 = (char *) 0 ;
33297 3 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
33298 3 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
33299 3 : void *argp1 = 0 ;
33300 3 : int res1 = 0 ;
33301 3 : PyObject *encodedInput2 = NULL ;
33302 3 : gpgme_data_t wrapper3 = NULL ;
33303 3 : PyObject *bytesio3 = NULL ;
33304 : Py_buffer view3 ;
33305 3 : int have_view3 = 0 ;
33306 3 : gpgme_data_t wrapper4 = NULL ;
33307 3 : PyObject *bytesio4 = NULL ;
33308 : Py_buffer view4 ;
33309 3 : int have_view4 = 0 ;
33310 3 : PyObject * obj0 = 0 ;
33311 3 : PyObject * obj1 = 0 ;
33312 3 : PyObject * obj2 = 0 ;
33313 3 : PyObject * obj3 = 0 ;
33314 : gpgme_error_t result;
33315 :
33316 3 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_genkey",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33317 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
33318 3 : if (!SWIG_IsOK(res1)) {
33319 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey" "', argument " "1"" of type '" "gpgme_ctx_t""'");
33320 : }
33321 3 : arg1 = (gpgme_ctx_t)(argp1);
33322 : {
33323 3 : if (obj1 == Py_None)
33324 : arg2 = NULL;
33325 3 : else if (PyUnicode_Check(obj1))
33326 : {
33327 3 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
33328 3 : if (encodedInput2 == NULL)
33329 : return NULL;
33330 3 : arg2 = PyBytes_AsString(encodedInput2);
33331 : }
33332 0 : else if (PyBytes_Check(obj1))
33333 0 : arg2 = PyBytes_AsString(obj1);
33334 : else {
33335 0 : PyErr_Format(PyExc_TypeError,
33336 : "arg %d: expected str, bytes, or None, got %s",
33337 : 2, obj1->ob_type->tp_name);
33338 0 : return NULL;
33339 : }
33340 : }
33341 : {
33342 : /* If we create a temporary wrapper3 object, we will store it in
33343 : wrapperN, where N is 3. Here in this fragment, SWIG will
33344 : automatically append 3. */
33345 3 : memset(&view3, 0, sizeof view3);
33346 3 : if (obj2 == Py_None)
33347 3 : arg3 = NULL;
33348 : else {
33349 : PyObject *pypointer;
33350 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
33351 : &bytesio3, &view3);
33352 0 : if (pypointer == NULL)
33353 : return NULL;
33354 0 : have_view3 = !! view3.obj;
33355 :
33356 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
33357 :
33358 : /* Following code is from swig's python.swg. */
33359 :
33360 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
33361 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
33362 0 : Py_DECREF(pypointer);
33363 : return NULL;
33364 : }
33365 0 : Py_DECREF(pypointer);
33366 : }
33367 : }
33368 : {
33369 : /* If we create a temporary wrapper4 object, we will store it in
33370 : wrapperN, where N is 4. Here in this fragment, SWIG will
33371 : automatically append 4. */
33372 3 : memset(&view4, 0, sizeof view4);
33373 3 : if (obj3 == Py_None)
33374 3 : arg4 = NULL;
33375 : else {
33376 : PyObject *pypointer;
33377 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
33378 : &bytesio4, &view4);
33379 0 : if (pypointer == NULL)
33380 : return NULL;
33381 0 : have_view4 = !! view4.obj;
33382 :
33383 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
33384 :
33385 : /* Following code is from swig's python.swg. */
33386 :
33387 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
33388 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
33389 0 : Py_DECREF(pypointer);
33390 : return NULL;
33391 : }
33392 0 : Py_DECREF(pypointer);
33393 : }
33394 : }
33395 : {
33396 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33397 3 : result = gpgme_op_genkey(arg1,(char const *)arg2,arg3,arg4);
33398 3 : SWIG_PYTHON_THREAD_END_ALLOW;
33399 : }
33400 : {
33401 3 : resultobj = PyLong_FromLong(result);
33402 : }
33403 : {
33404 3 : Py_XDECREF(encodedInput2);
33405 : }
33406 : {
33407 : /* See whether we need to update the Python buffer. */
33408 3 : if (resultobj && wrapper3 && view3.buf)
33409 : {
33410 : int dirty;
33411 0 : char *new_data = NULL;
33412 : size_t new_size;
33413 :
33414 :
33415 0 : new_data = wrapper3->data.mem.buffer;
33416 0 : new_size = wrapper3->data.mem.length;
33417 0 : dirty = new_data != NULL;
33418 :
33419 :
33420 :
33421 :
33422 :
33423 :
33424 :
33425 0 : if (dirty)
33426 : {
33427 : /* The buffer is dirty. */
33428 0 : if (view3.readonly)
33429 : {
33430 0 : Py_XDECREF(resultobj);
33431 0 : resultobj = NULL;
33432 0 : PyErr_SetString(PyExc_ValueError,
33433 : "cannot update read-only buffer");
33434 : }
33435 :
33436 : /* See if we need to truncate the buffer. */
33437 0 : if (resultobj && view3.len != new_size)
33438 : {
33439 0 : if (bytesio3 == NULL)
33440 : {
33441 0 : Py_XDECREF(resultobj);
33442 0 : resultobj = NULL;
33443 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
33444 : }
33445 : else
33446 : {
33447 : PyObject *retval;
33448 0 : PyBuffer_Release(&view3);
33449 : assert(view3.obj == NULL);
33450 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
33451 : "l", (long) new_size);
33452 0 : if (retval == NULL)
33453 : {
33454 0 : Py_XDECREF(resultobj);
33455 : resultobj = NULL;
33456 : }
33457 : else
33458 : {
33459 0 : Py_DECREF(retval);
33460 :
33461 0 : retval = PyObject_CallMethod(bytesio3,
33462 : "getbuffer", NULL);
33463 0 : if (retval == NULL
33464 0 : || PyObject_GetBuffer(retval, &view3,
33465 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
33466 : {
33467 0 : Py_XDECREF(resultobj);
33468 : resultobj = NULL;
33469 : }
33470 :
33471 0 : Py_XDECREF(retval);
33472 :
33473 0 : if (resultobj && view3.len
33474 : != new_size)
33475 : {
33476 0 : Py_XDECREF(resultobj);
33477 0 : resultobj = NULL;
33478 0 : PyErr_Format(PyExc_ValueError,
33479 : "Expected buffer of length %zu, got %zi",
33480 : new_size,
33481 : view3.len);
33482 : }
33483 : }
33484 : }
33485 : }
33486 0 : if (resultobj)
33487 0 : memcpy(view3.buf, new_data, new_size);
33488 : }
33489 :
33490 :
33491 :
33492 : }
33493 :
33494 : /* Free the temporary wrapper, if any. */
33495 3 : if (wrapper3)
33496 0 : gpgme_data_release(wrapper3);
33497 3 : Py_XDECREF (bytesio3);
33498 3 : if (have_view3 && view3.buf)
33499 0 : PyBuffer_Release(&view3);
33500 : }
33501 : {
33502 : /* See whether we need to update the Python buffer. */
33503 3 : if (resultobj && wrapper4 && view4.buf)
33504 : {
33505 : int dirty;
33506 0 : char *new_data = NULL;
33507 : size_t new_size;
33508 :
33509 :
33510 0 : new_data = wrapper4->data.mem.buffer;
33511 0 : new_size = wrapper4->data.mem.length;
33512 0 : dirty = new_data != NULL;
33513 :
33514 :
33515 :
33516 :
33517 :
33518 :
33519 :
33520 0 : if (dirty)
33521 : {
33522 : /* The buffer is dirty. */
33523 0 : if (view4.readonly)
33524 : {
33525 0 : Py_XDECREF(resultobj);
33526 0 : resultobj = NULL;
33527 0 : PyErr_SetString(PyExc_ValueError,
33528 : "cannot update read-only buffer");
33529 : }
33530 :
33531 : /* See if we need to truncate the buffer. */
33532 0 : if (resultobj && view4.len != new_size)
33533 : {
33534 0 : if (bytesio4 == NULL)
33535 : {
33536 0 : Py_XDECREF(resultobj);
33537 0 : resultobj = NULL;
33538 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
33539 : }
33540 : else
33541 : {
33542 : PyObject *retval;
33543 0 : PyBuffer_Release(&view4);
33544 : assert(view4.obj == NULL);
33545 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
33546 : "l", (long) new_size);
33547 0 : if (retval == NULL)
33548 : {
33549 0 : Py_XDECREF(resultobj);
33550 : resultobj = NULL;
33551 : }
33552 : else
33553 : {
33554 0 : Py_DECREF(retval);
33555 :
33556 0 : retval = PyObject_CallMethod(bytesio4,
33557 : "getbuffer", NULL);
33558 0 : if (retval == NULL
33559 0 : || PyObject_GetBuffer(retval, &view4,
33560 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
33561 : {
33562 0 : Py_XDECREF(resultobj);
33563 : resultobj = NULL;
33564 : }
33565 :
33566 0 : Py_XDECREF(retval);
33567 :
33568 0 : if (resultobj && view4.len
33569 : != new_size)
33570 : {
33571 0 : Py_XDECREF(resultobj);
33572 0 : resultobj = NULL;
33573 0 : PyErr_Format(PyExc_ValueError,
33574 : "Expected buffer of length %zu, got %zi",
33575 : new_size,
33576 : view4.len);
33577 : }
33578 : }
33579 : }
33580 : }
33581 0 : if (resultobj)
33582 0 : memcpy(view4.buf, new_data, new_size);
33583 : }
33584 :
33585 :
33586 :
33587 : }
33588 :
33589 : /* Free the temporary wrapper, if any. */
33590 3 : if (wrapper4)
33591 0 : gpgme_data_release(wrapper4);
33592 3 : Py_XDECREF (bytesio4);
33593 3 : if (have_view4 && view4.buf)
33594 0 : PyBuffer_Release(&view4);
33595 : }
33596 : return resultobj;
33597 : fail:
33598 : {
33599 0 : Py_XDECREF(encodedInput2);
33600 : }
33601 : {
33602 : /* See whether we need to update the Python buffer. */
33603 : if (resultobj && wrapper3 && view3.buf)
33604 : {
33605 : int dirty;
33606 : char *new_data = NULL;
33607 : size_t new_size;
33608 :
33609 :
33610 : new_data = wrapper3->data.mem.buffer;
33611 : new_size = wrapper3->data.mem.length;
33612 : dirty = new_data != NULL;
33613 :
33614 :
33615 :
33616 :
33617 :
33618 :
33619 :
33620 : if (dirty)
33621 : {
33622 : /* The buffer is dirty. */
33623 : if (view3.readonly)
33624 : {
33625 : Py_XDECREF(resultobj);
33626 : resultobj = NULL;
33627 : PyErr_SetString(PyExc_ValueError,
33628 : "cannot update read-only buffer");
33629 : }
33630 :
33631 : /* See if we need to truncate the buffer. */
33632 : if (resultobj && view3.len != new_size)
33633 : {
33634 : if (bytesio3 == NULL)
33635 : {
33636 : Py_XDECREF(resultobj);
33637 : resultobj = NULL;
33638 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
33639 : }
33640 : else
33641 : {
33642 : PyObject *retval;
33643 : PyBuffer_Release(&view3);
33644 : assert(view3.obj == NULL);
33645 : retval = PyObject_CallMethod(bytesio3, "truncate",
33646 : "l", (long) new_size);
33647 : if (retval == NULL)
33648 : {
33649 : Py_XDECREF(resultobj);
33650 : resultobj = NULL;
33651 : }
33652 : else
33653 : {
33654 : Py_DECREF(retval);
33655 :
33656 : retval = PyObject_CallMethod(bytesio3,
33657 : "getbuffer", NULL);
33658 : if (retval == NULL
33659 : || PyObject_GetBuffer(retval, &view3,
33660 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
33661 : {
33662 : Py_XDECREF(resultobj);
33663 : resultobj = NULL;
33664 : }
33665 :
33666 : Py_XDECREF(retval);
33667 :
33668 : if (resultobj && view3.len
33669 : != new_size)
33670 : {
33671 : Py_XDECREF(resultobj);
33672 : resultobj = NULL;
33673 : PyErr_Format(PyExc_ValueError,
33674 : "Expected buffer of length %zu, got %zi",
33675 : new_size,
33676 : view3.len);
33677 : }
33678 : }
33679 : }
33680 : }
33681 : if (resultobj)
33682 : memcpy(view3.buf, new_data, new_size);
33683 : }
33684 :
33685 :
33686 :
33687 : }
33688 :
33689 : /* Free the temporary wrapper, if any. */
33690 0 : if (wrapper3)
33691 0 : gpgme_data_release(wrapper3);
33692 0 : Py_XDECREF (bytesio3);
33693 : if (have_view3 && view3.buf)
33694 : PyBuffer_Release(&view3);
33695 : }
33696 : {
33697 : /* See whether we need to update the Python buffer. */
33698 : if (resultobj && wrapper4 && view4.buf)
33699 : {
33700 : int dirty;
33701 : char *new_data = NULL;
33702 : size_t new_size;
33703 :
33704 :
33705 : new_data = wrapper4->data.mem.buffer;
33706 : new_size = wrapper4->data.mem.length;
33707 : dirty = new_data != NULL;
33708 :
33709 :
33710 :
33711 :
33712 :
33713 :
33714 :
33715 : if (dirty)
33716 : {
33717 : /* The buffer is dirty. */
33718 : if (view4.readonly)
33719 : {
33720 : Py_XDECREF(resultobj);
33721 : resultobj = NULL;
33722 : PyErr_SetString(PyExc_ValueError,
33723 : "cannot update read-only buffer");
33724 : }
33725 :
33726 : /* See if we need to truncate the buffer. */
33727 : if (resultobj && view4.len != new_size)
33728 : {
33729 : if (bytesio4 == NULL)
33730 : {
33731 : Py_XDECREF(resultobj);
33732 : resultobj = NULL;
33733 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
33734 : }
33735 : else
33736 : {
33737 : PyObject *retval;
33738 : PyBuffer_Release(&view4);
33739 : assert(view4.obj == NULL);
33740 : retval = PyObject_CallMethod(bytesio4, "truncate",
33741 : "l", (long) new_size);
33742 : if (retval == NULL)
33743 : {
33744 : Py_XDECREF(resultobj);
33745 : resultobj = NULL;
33746 : }
33747 : else
33748 : {
33749 : Py_DECREF(retval);
33750 :
33751 : retval = PyObject_CallMethod(bytesio4,
33752 : "getbuffer", NULL);
33753 : if (retval == NULL
33754 : || PyObject_GetBuffer(retval, &view4,
33755 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
33756 : {
33757 : Py_XDECREF(resultobj);
33758 : resultobj = NULL;
33759 : }
33760 :
33761 : Py_XDECREF(retval);
33762 :
33763 : if (resultobj && view4.len
33764 : != new_size)
33765 : {
33766 : Py_XDECREF(resultobj);
33767 : resultobj = NULL;
33768 : PyErr_Format(PyExc_ValueError,
33769 : "Expected buffer of length %zu, got %zi",
33770 : new_size,
33771 : view4.len);
33772 : }
33773 : }
33774 : }
33775 : }
33776 : if (resultobj)
33777 : memcpy(view4.buf, new_data, new_size);
33778 : }
33779 :
33780 :
33781 :
33782 : }
33783 :
33784 : /* Free the temporary wrapper, if any. */
33785 0 : if (wrapper4)
33786 0 : gpgme_data_release(wrapper4);
33787 0 : Py_XDECREF (bytesio4);
33788 : if (have_view4 && view4.buf)
33789 : PyBuffer_Release(&view4);
33790 : }
33791 : return NULL;
33792 : }
33793 :
33794 :
33795 0 : SWIGINTERN PyObject *_wrap_gpgme_op_createkey_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33796 0 : PyObject *resultobj = 0;
33797 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
33798 0 : char *arg2 = (char *) 0 ;
33799 0 : char *arg3 = (char *) 0 ;
33800 : unsigned long arg4 ;
33801 : unsigned long arg5 ;
33802 0 : gpgme_key_t arg6 = (gpgme_key_t) 0 ;
33803 : unsigned int arg7 ;
33804 0 : void *argp1 = 0 ;
33805 0 : int res1 = 0 ;
33806 0 : PyObject *encodedInput2 = NULL ;
33807 0 : PyObject *encodedInput3 = NULL ;
33808 : unsigned long val4 ;
33809 0 : int ecode4 = 0 ;
33810 : unsigned long val5 ;
33811 0 : int ecode5 = 0 ;
33812 0 : void *argp6 = 0 ;
33813 0 : int res6 = 0 ;
33814 : unsigned int val7 ;
33815 0 : int ecode7 = 0 ;
33816 0 : PyObject * obj0 = 0 ;
33817 0 : PyObject * obj1 = 0 ;
33818 0 : PyObject * obj2 = 0 ;
33819 0 : PyObject * obj3 = 0 ;
33820 0 : PyObject * obj4 = 0 ;
33821 0 : PyObject * obj5 = 0 ;
33822 0 : PyObject * obj6 = 0 ;
33823 : gpgme_error_t result;
33824 :
33825 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_createkey_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33826 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
33827 0 : if (!SWIG_IsOK(res1)) {
33828 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_createkey_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
33829 : }
33830 0 : arg1 = (gpgme_ctx_t)(argp1);
33831 : {
33832 0 : if (obj1 == Py_None)
33833 : arg2 = NULL;
33834 0 : else if (PyUnicode_Check(obj1))
33835 : {
33836 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
33837 0 : if (encodedInput2 == NULL)
33838 : return NULL;
33839 0 : arg2 = PyBytes_AsString(encodedInput2);
33840 : }
33841 0 : else if (PyBytes_Check(obj1))
33842 0 : arg2 = PyBytes_AsString(obj1);
33843 : else {
33844 0 : PyErr_Format(PyExc_TypeError,
33845 : "arg %d: expected str, bytes, or None, got %s",
33846 : 2, obj1->ob_type->tp_name);
33847 0 : return NULL;
33848 : }
33849 : }
33850 : {
33851 0 : if (obj2 == Py_None)
33852 : arg3 = NULL;
33853 0 : else if (PyUnicode_Check(obj2))
33854 : {
33855 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
33856 0 : if (encodedInput3 == NULL)
33857 : return NULL;
33858 0 : arg3 = PyBytes_AsString(encodedInput3);
33859 : }
33860 0 : else if (PyBytes_Check(obj2))
33861 0 : arg3 = PyBytes_AsString(obj2);
33862 : else {
33863 0 : PyErr_Format(PyExc_TypeError,
33864 : "arg %d: expected str, bytes, or None, got %s",
33865 : 3, obj2->ob_type->tp_name);
33866 0 : return NULL;
33867 : }
33868 : }
33869 0 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
33870 0 : if (!SWIG_IsOK(ecode4)) {
33871 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_createkey_start" "', argument " "4"" of type '" "unsigned long""'");
33872 : }
33873 0 : arg4 = (unsigned long)(val4);
33874 0 : ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
33875 0 : if (!SWIG_IsOK(ecode5)) {
33876 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_createkey_start" "', argument " "5"" of type '" "unsigned long""'");
33877 : }
33878 0 : arg5 = (unsigned long)(val5);
33879 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p__gpgme_key, 0 | 0 );
33880 0 : if (!SWIG_IsOK(res6)) {
33881 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_createkey_start" "', argument " "6"" of type '" "gpgme_key_t""'");
33882 : }
33883 0 : arg6 = (gpgme_key_t)(argp6);
33884 0 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
33885 0 : if (!SWIG_IsOK(ecode7)) {
33886 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_createkey_start" "', argument " "7"" of type '" "unsigned int""'");
33887 : }
33888 0 : arg7 = (unsigned int)(val7);
33889 : {
33890 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33891 0 : result = gpgme_op_createkey_start(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
33892 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33893 : }
33894 : {
33895 0 : resultobj = PyLong_FromLong(result);
33896 : }
33897 : {
33898 0 : Py_XDECREF(encodedInput2);
33899 : }
33900 : {
33901 0 : Py_XDECREF(encodedInput3);
33902 : }
33903 : return resultobj;
33904 : fail:
33905 : {
33906 0 : Py_XDECREF(encodedInput2);
33907 : }
33908 : {
33909 0 : Py_XDECREF(encodedInput3);
33910 : }
33911 : return NULL;
33912 : }
33913 :
33914 :
33915 24 : SWIGINTERN PyObject *_wrap_gpgme_op_createkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33916 24 : PyObject *resultobj = 0;
33917 24 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
33918 24 : char *arg2 = (char *) 0 ;
33919 24 : char *arg3 = (char *) 0 ;
33920 : unsigned long arg4 ;
33921 : unsigned long arg5 ;
33922 24 : gpgme_key_t arg6 = (gpgme_key_t) 0 ;
33923 : unsigned int arg7 ;
33924 24 : void *argp1 = 0 ;
33925 24 : int res1 = 0 ;
33926 24 : PyObject *encodedInput2 = NULL ;
33927 24 : PyObject *encodedInput3 = NULL ;
33928 : unsigned long val4 ;
33929 24 : int ecode4 = 0 ;
33930 : unsigned long val5 ;
33931 24 : int ecode5 = 0 ;
33932 24 : void *argp6 = 0 ;
33933 24 : int res6 = 0 ;
33934 : unsigned int val7 ;
33935 24 : int ecode7 = 0 ;
33936 24 : PyObject * obj0 = 0 ;
33937 24 : PyObject * obj1 = 0 ;
33938 24 : PyObject * obj2 = 0 ;
33939 24 : PyObject * obj3 = 0 ;
33940 24 : PyObject * obj4 = 0 ;
33941 24 : PyObject * obj5 = 0 ;
33942 24 : PyObject * obj6 = 0 ;
33943 : gpgme_error_t result;
33944 :
33945 24 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_createkey",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33946 24 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
33947 24 : if (!SWIG_IsOK(res1)) {
33948 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_createkey" "', argument " "1"" of type '" "gpgme_ctx_t""'");
33949 : }
33950 24 : arg1 = (gpgme_ctx_t)(argp1);
33951 : {
33952 24 : if (obj1 == Py_None)
33953 : arg2 = NULL;
33954 24 : else if (PyUnicode_Check(obj1))
33955 : {
33956 24 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
33957 24 : if (encodedInput2 == NULL)
33958 : return NULL;
33959 24 : arg2 = PyBytes_AsString(encodedInput2);
33960 : }
33961 0 : else if (PyBytes_Check(obj1))
33962 0 : arg2 = PyBytes_AsString(obj1);
33963 : else {
33964 0 : PyErr_Format(PyExc_TypeError,
33965 : "arg %d: expected str, bytes, or None, got %s",
33966 : 2, obj1->ob_type->tp_name);
33967 0 : return NULL;
33968 : }
33969 : }
33970 : {
33971 24 : if (obj2 == Py_None)
33972 : arg3 = NULL;
33973 11 : else if (PyUnicode_Check(obj2))
33974 : {
33975 11 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
33976 11 : if (encodedInput3 == NULL)
33977 : return NULL;
33978 11 : arg3 = PyBytes_AsString(encodedInput3);
33979 : }
33980 0 : else if (PyBytes_Check(obj2))
33981 0 : arg3 = PyBytes_AsString(obj2);
33982 : else {
33983 0 : PyErr_Format(PyExc_TypeError,
33984 : "arg %d: expected str, bytes, or None, got %s",
33985 : 3, obj2->ob_type->tp_name);
33986 0 : return NULL;
33987 : }
33988 : }
33989 24 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
33990 24 : if (!SWIG_IsOK(ecode4)) {
33991 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_createkey" "', argument " "4"" of type '" "unsigned long""'");
33992 : }
33993 24 : arg4 = (unsigned long)(val4);
33994 24 : ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
33995 24 : if (!SWIG_IsOK(ecode5)) {
33996 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_createkey" "', argument " "5"" of type '" "unsigned long""'");
33997 : }
33998 24 : arg5 = (unsigned long)(val5);
33999 24 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p__gpgme_key, 0 | 0 );
34000 24 : if (!SWIG_IsOK(res6)) {
34001 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_createkey" "', argument " "6"" of type '" "gpgme_key_t""'");
34002 : }
34003 24 : arg6 = (gpgme_key_t)(argp6);
34004 48 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
34005 24 : if (!SWIG_IsOK(ecode7)) {
34006 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_createkey" "', argument " "7"" of type '" "unsigned int""'");
34007 : }
34008 24 : arg7 = (unsigned int)(val7);
34009 : {
34010 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34011 24 : result = gpgme_op_createkey(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
34012 24 : SWIG_PYTHON_THREAD_END_ALLOW;
34013 : }
34014 : {
34015 24 : resultobj = PyLong_FromLong(result);
34016 : }
34017 : {
34018 24 : Py_XDECREF(encodedInput2);
34019 : }
34020 : {
34021 24 : Py_XDECREF(encodedInput3);
34022 : }
34023 : return resultobj;
34024 : fail:
34025 : {
34026 0 : Py_XDECREF(encodedInput2);
34027 : }
34028 : {
34029 0 : Py_XDECREF(encodedInput3);
34030 : }
34031 : return NULL;
34032 : }
34033 :
34034 :
34035 0 : SWIGINTERN PyObject *_wrap_gpgme_op_createsubkey_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34036 0 : PyObject *resultobj = 0;
34037 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34038 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34039 0 : char *arg3 = (char *) 0 ;
34040 : unsigned long arg4 ;
34041 : unsigned long arg5 ;
34042 : unsigned int arg6 ;
34043 0 : void *argp1 = 0 ;
34044 0 : int res1 = 0 ;
34045 0 : void *argp2 = 0 ;
34046 0 : int res2 = 0 ;
34047 0 : PyObject *encodedInput3 = NULL ;
34048 : unsigned long val4 ;
34049 0 : int ecode4 = 0 ;
34050 : unsigned long val5 ;
34051 0 : int ecode5 = 0 ;
34052 : unsigned int val6 ;
34053 0 : int ecode6 = 0 ;
34054 0 : PyObject * obj0 = 0 ;
34055 0 : PyObject * obj1 = 0 ;
34056 0 : PyObject * obj2 = 0 ;
34057 0 : PyObject * obj3 = 0 ;
34058 0 : PyObject * obj4 = 0 ;
34059 0 : PyObject * obj5 = 0 ;
34060 : gpgme_error_t result;
34061 :
34062 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_createsubkey_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
34063 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34064 0 : if (!SWIG_IsOK(res1)) {
34065 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_createsubkey_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34066 : }
34067 0 : arg1 = (gpgme_ctx_t)(argp1);
34068 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34069 0 : if (!SWIG_IsOK(res2)) {
34070 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_createsubkey_start" "', argument " "2"" of type '" "gpgme_key_t""'");
34071 : }
34072 0 : arg2 = (gpgme_key_t)(argp2);
34073 : {
34074 0 : if (obj2 == Py_None)
34075 : arg3 = NULL;
34076 0 : else if (PyUnicode_Check(obj2))
34077 : {
34078 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
34079 0 : if (encodedInput3 == NULL)
34080 : return NULL;
34081 0 : arg3 = PyBytes_AsString(encodedInput3);
34082 : }
34083 0 : else if (PyBytes_Check(obj2))
34084 0 : arg3 = PyBytes_AsString(obj2);
34085 : else {
34086 0 : PyErr_Format(PyExc_TypeError,
34087 : "arg %d: expected str, bytes, or None, got %s",
34088 : 3, obj2->ob_type->tp_name);
34089 0 : return NULL;
34090 : }
34091 : }
34092 0 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
34093 0 : if (!SWIG_IsOK(ecode4)) {
34094 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_createsubkey_start" "', argument " "4"" of type '" "unsigned long""'");
34095 : }
34096 0 : arg4 = (unsigned long)(val4);
34097 0 : ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
34098 0 : if (!SWIG_IsOK(ecode5)) {
34099 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_createsubkey_start" "', argument " "5"" of type '" "unsigned long""'");
34100 : }
34101 0 : arg5 = (unsigned long)(val5);
34102 0 : ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
34103 0 : if (!SWIG_IsOK(ecode6)) {
34104 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gpgme_op_createsubkey_start" "', argument " "6"" of type '" "unsigned int""'");
34105 : }
34106 0 : arg6 = (unsigned int)(val6);
34107 : {
34108 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34109 0 : result = gpgme_op_createsubkey_start(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
34110 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34111 : }
34112 : {
34113 0 : resultobj = PyLong_FromLong(result);
34114 : }
34115 : {
34116 0 : Py_XDECREF(encodedInput3);
34117 : }
34118 : return resultobj;
34119 : fail:
34120 : {
34121 0 : Py_XDECREF(encodedInput3);
34122 : }
34123 : return NULL;
34124 : }
34125 :
34126 :
34127 13 : SWIGINTERN PyObject *_wrap_gpgme_op_createsubkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34128 13 : PyObject *resultobj = 0;
34129 13 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34130 13 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34131 13 : char *arg3 = (char *) 0 ;
34132 : unsigned long arg4 ;
34133 : unsigned long arg5 ;
34134 : unsigned int arg6 ;
34135 13 : void *argp1 = 0 ;
34136 13 : int res1 = 0 ;
34137 13 : void *argp2 = 0 ;
34138 13 : int res2 = 0 ;
34139 13 : PyObject *encodedInput3 = NULL ;
34140 : unsigned long val4 ;
34141 13 : int ecode4 = 0 ;
34142 : unsigned long val5 ;
34143 13 : int ecode5 = 0 ;
34144 : unsigned int val6 ;
34145 13 : int ecode6 = 0 ;
34146 13 : PyObject * obj0 = 0 ;
34147 13 : PyObject * obj1 = 0 ;
34148 13 : PyObject * obj2 = 0 ;
34149 13 : PyObject * obj3 = 0 ;
34150 13 : PyObject * obj4 = 0 ;
34151 13 : PyObject * obj5 = 0 ;
34152 : gpgme_error_t result;
34153 :
34154 13 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_createsubkey",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
34155 13 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34156 13 : if (!SWIG_IsOK(res1)) {
34157 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_createsubkey" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34158 : }
34159 13 : arg1 = (gpgme_ctx_t)(argp1);
34160 13 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34161 13 : if (!SWIG_IsOK(res2)) {
34162 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_createsubkey" "', argument " "2"" of type '" "gpgme_key_t""'");
34163 : }
34164 13 : arg2 = (gpgme_key_t)(argp2);
34165 : {
34166 13 : if (obj2 == Py_None)
34167 : arg3 = NULL;
34168 3 : else if (PyUnicode_Check(obj2))
34169 : {
34170 3 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
34171 3 : if (encodedInput3 == NULL)
34172 : return NULL;
34173 3 : arg3 = PyBytes_AsString(encodedInput3);
34174 : }
34175 0 : else if (PyBytes_Check(obj2))
34176 0 : arg3 = PyBytes_AsString(obj2);
34177 : else {
34178 0 : PyErr_Format(PyExc_TypeError,
34179 : "arg %d: expected str, bytes, or None, got %s",
34180 : 3, obj2->ob_type->tp_name);
34181 0 : return NULL;
34182 : }
34183 : }
34184 13 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
34185 13 : if (!SWIG_IsOK(ecode4)) {
34186 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_createsubkey" "', argument " "4"" of type '" "unsigned long""'");
34187 : }
34188 13 : arg4 = (unsigned long)(val4);
34189 13 : ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
34190 13 : if (!SWIG_IsOK(ecode5)) {
34191 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_createsubkey" "', argument " "5"" of type '" "unsigned long""'");
34192 : }
34193 13 : arg5 = (unsigned long)(val5);
34194 26 : ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
34195 13 : if (!SWIG_IsOK(ecode6)) {
34196 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gpgme_op_createsubkey" "', argument " "6"" of type '" "unsigned int""'");
34197 : }
34198 13 : arg6 = (unsigned int)(val6);
34199 : {
34200 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34201 13 : result = gpgme_op_createsubkey(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
34202 13 : SWIG_PYTHON_THREAD_END_ALLOW;
34203 : }
34204 : {
34205 13 : resultobj = PyLong_FromLong(result);
34206 : }
34207 : {
34208 13 : Py_XDECREF(encodedInput3);
34209 : }
34210 : return resultobj;
34211 : fail:
34212 : {
34213 0 : Py_XDECREF(encodedInput3);
34214 : }
34215 : return NULL;
34216 : }
34217 :
34218 :
34219 0 : SWIGINTERN PyObject *_wrap_gpgme_op_adduid_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34220 0 : PyObject *resultobj = 0;
34221 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34222 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34223 0 : char *arg3 = (char *) 0 ;
34224 : unsigned int arg4 ;
34225 0 : void *argp1 = 0 ;
34226 0 : int res1 = 0 ;
34227 0 : void *argp2 = 0 ;
34228 0 : int res2 = 0 ;
34229 0 : PyObject *encodedInput3 = NULL ;
34230 : unsigned int val4 ;
34231 0 : int ecode4 = 0 ;
34232 0 : PyObject * obj0 = 0 ;
34233 0 : PyObject * obj1 = 0 ;
34234 0 : PyObject * obj2 = 0 ;
34235 0 : PyObject * obj3 = 0 ;
34236 : gpgme_error_t result;
34237 :
34238 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_adduid_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34239 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34240 0 : if (!SWIG_IsOK(res1)) {
34241 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_adduid_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34242 : }
34243 0 : arg1 = (gpgme_ctx_t)(argp1);
34244 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34245 0 : if (!SWIG_IsOK(res2)) {
34246 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_adduid_start" "', argument " "2"" of type '" "gpgme_key_t""'");
34247 : }
34248 0 : arg2 = (gpgme_key_t)(argp2);
34249 : {
34250 0 : if (obj2 == Py_None)
34251 : arg3 = NULL;
34252 0 : else if (PyUnicode_Check(obj2))
34253 : {
34254 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
34255 0 : if (encodedInput3 == NULL)
34256 : return NULL;
34257 0 : arg3 = PyBytes_AsString(encodedInput3);
34258 : }
34259 0 : else if (PyBytes_Check(obj2))
34260 0 : arg3 = PyBytes_AsString(obj2);
34261 : else {
34262 0 : PyErr_Format(PyExc_TypeError,
34263 : "arg %d: expected str, bytes, or None, got %s",
34264 : 3, obj2->ob_type->tp_name);
34265 0 : return NULL;
34266 : }
34267 : }
34268 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
34269 0 : if (!SWIG_IsOK(ecode4)) {
34270 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_adduid_start" "', argument " "4"" of type '" "unsigned int""'");
34271 : }
34272 0 : arg4 = (unsigned int)(val4);
34273 : {
34274 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34275 0 : result = gpgme_op_adduid_start(arg1,arg2,(char const *)arg3,arg4);
34276 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34277 : }
34278 : {
34279 0 : resultobj = PyLong_FromLong(result);
34280 : }
34281 : {
34282 0 : Py_XDECREF(encodedInput3);
34283 : }
34284 : return resultobj;
34285 : fail:
34286 : {
34287 0 : Py_XDECREF(encodedInput3);
34288 : }
34289 : return NULL;
34290 : }
34291 :
34292 :
34293 10 : SWIGINTERN PyObject *_wrap_gpgme_op_adduid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34294 10 : PyObject *resultobj = 0;
34295 10 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34296 10 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34297 10 : char *arg3 = (char *) 0 ;
34298 : unsigned int arg4 ;
34299 10 : void *argp1 = 0 ;
34300 10 : int res1 = 0 ;
34301 10 : void *argp2 = 0 ;
34302 10 : int res2 = 0 ;
34303 10 : PyObject *encodedInput3 = NULL ;
34304 : unsigned int val4 ;
34305 10 : int ecode4 = 0 ;
34306 10 : PyObject * obj0 = 0 ;
34307 10 : PyObject * obj1 = 0 ;
34308 10 : PyObject * obj2 = 0 ;
34309 10 : PyObject * obj3 = 0 ;
34310 : gpgme_error_t result;
34311 :
34312 10 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_adduid",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34313 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34314 10 : if (!SWIG_IsOK(res1)) {
34315 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_adduid" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34316 : }
34317 10 : arg1 = (gpgme_ctx_t)(argp1);
34318 10 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34319 10 : if (!SWIG_IsOK(res2)) {
34320 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_adduid" "', argument " "2"" of type '" "gpgme_key_t""'");
34321 : }
34322 10 : arg2 = (gpgme_key_t)(argp2);
34323 : {
34324 10 : if (obj2 == Py_None)
34325 : arg3 = NULL;
34326 10 : else if (PyUnicode_Check(obj2))
34327 : {
34328 10 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
34329 10 : if (encodedInput3 == NULL)
34330 : return NULL;
34331 10 : arg3 = PyBytes_AsString(encodedInput3);
34332 : }
34333 0 : else if (PyBytes_Check(obj2))
34334 0 : arg3 = PyBytes_AsString(obj2);
34335 : else {
34336 0 : PyErr_Format(PyExc_TypeError,
34337 : "arg %d: expected str, bytes, or None, got %s",
34338 : 3, obj2->ob_type->tp_name);
34339 0 : return NULL;
34340 : }
34341 : }
34342 20 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
34343 10 : if (!SWIG_IsOK(ecode4)) {
34344 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_adduid" "', argument " "4"" of type '" "unsigned int""'");
34345 : }
34346 10 : arg4 = (unsigned int)(val4);
34347 : {
34348 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34349 10 : result = gpgme_op_adduid(arg1,arg2,(char const *)arg3,arg4);
34350 10 : SWIG_PYTHON_THREAD_END_ALLOW;
34351 : }
34352 : {
34353 10 : resultobj = PyLong_FromLong(result);
34354 : }
34355 : {
34356 10 : Py_XDECREF(encodedInput3);
34357 : }
34358 : return resultobj;
34359 : fail:
34360 : {
34361 0 : Py_XDECREF(encodedInput3);
34362 : }
34363 : return NULL;
34364 : }
34365 :
34366 :
34367 0 : SWIGINTERN PyObject *_wrap_gpgme_op_revuid_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34368 0 : PyObject *resultobj = 0;
34369 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34370 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34371 0 : char *arg3 = (char *) 0 ;
34372 : unsigned int arg4 ;
34373 0 : void *argp1 = 0 ;
34374 0 : int res1 = 0 ;
34375 0 : void *argp2 = 0 ;
34376 0 : int res2 = 0 ;
34377 0 : PyObject *encodedInput3 = NULL ;
34378 : unsigned int val4 ;
34379 0 : int ecode4 = 0 ;
34380 0 : PyObject * obj0 = 0 ;
34381 0 : PyObject * obj1 = 0 ;
34382 0 : PyObject * obj2 = 0 ;
34383 0 : PyObject * obj3 = 0 ;
34384 : gpgme_error_t result;
34385 :
34386 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_revuid_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34387 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34388 0 : if (!SWIG_IsOK(res1)) {
34389 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_revuid_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34390 : }
34391 0 : arg1 = (gpgme_ctx_t)(argp1);
34392 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34393 0 : if (!SWIG_IsOK(res2)) {
34394 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_revuid_start" "', argument " "2"" of type '" "gpgme_key_t""'");
34395 : }
34396 0 : arg2 = (gpgme_key_t)(argp2);
34397 : {
34398 0 : if (obj2 == Py_None)
34399 : arg3 = NULL;
34400 0 : else if (PyUnicode_Check(obj2))
34401 : {
34402 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
34403 0 : if (encodedInput3 == NULL)
34404 : return NULL;
34405 0 : arg3 = PyBytes_AsString(encodedInput3);
34406 : }
34407 0 : else if (PyBytes_Check(obj2))
34408 0 : arg3 = PyBytes_AsString(obj2);
34409 : else {
34410 0 : PyErr_Format(PyExc_TypeError,
34411 : "arg %d: expected str, bytes, or None, got %s",
34412 : 3, obj2->ob_type->tp_name);
34413 0 : return NULL;
34414 : }
34415 : }
34416 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
34417 0 : if (!SWIG_IsOK(ecode4)) {
34418 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_revuid_start" "', argument " "4"" of type '" "unsigned int""'");
34419 : }
34420 0 : arg4 = (unsigned int)(val4);
34421 : {
34422 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34423 0 : result = gpgme_op_revuid_start(arg1,arg2,(char const *)arg3,arg4);
34424 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34425 : }
34426 : {
34427 0 : resultobj = PyLong_FromLong(result);
34428 : }
34429 : {
34430 0 : Py_XDECREF(encodedInput3);
34431 : }
34432 : return resultobj;
34433 : fail:
34434 : {
34435 0 : Py_XDECREF(encodedInput3);
34436 : }
34437 : return NULL;
34438 : }
34439 :
34440 :
34441 3 : SWIGINTERN PyObject *_wrap_gpgme_op_revuid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34442 3 : PyObject *resultobj = 0;
34443 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34444 3 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34445 3 : char *arg3 = (char *) 0 ;
34446 : unsigned int arg4 ;
34447 3 : void *argp1 = 0 ;
34448 3 : int res1 = 0 ;
34449 3 : void *argp2 = 0 ;
34450 3 : int res2 = 0 ;
34451 3 : PyObject *encodedInput3 = NULL ;
34452 : unsigned int val4 ;
34453 3 : int ecode4 = 0 ;
34454 3 : PyObject * obj0 = 0 ;
34455 3 : PyObject * obj1 = 0 ;
34456 3 : PyObject * obj2 = 0 ;
34457 3 : PyObject * obj3 = 0 ;
34458 : gpgme_error_t result;
34459 :
34460 3 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_revuid",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34461 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34462 3 : if (!SWIG_IsOK(res1)) {
34463 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_revuid" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34464 : }
34465 3 : arg1 = (gpgme_ctx_t)(argp1);
34466 3 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34467 3 : if (!SWIG_IsOK(res2)) {
34468 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_revuid" "', argument " "2"" of type '" "gpgme_key_t""'");
34469 : }
34470 3 : arg2 = (gpgme_key_t)(argp2);
34471 : {
34472 3 : if (obj2 == Py_None)
34473 : arg3 = NULL;
34474 3 : else if (PyUnicode_Check(obj2))
34475 : {
34476 3 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
34477 3 : if (encodedInput3 == NULL)
34478 : return NULL;
34479 3 : arg3 = PyBytes_AsString(encodedInput3);
34480 : }
34481 0 : else if (PyBytes_Check(obj2))
34482 0 : arg3 = PyBytes_AsString(obj2);
34483 : else {
34484 0 : PyErr_Format(PyExc_TypeError,
34485 : "arg %d: expected str, bytes, or None, got %s",
34486 : 3, obj2->ob_type->tp_name);
34487 0 : return NULL;
34488 : }
34489 : }
34490 6 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
34491 3 : if (!SWIG_IsOK(ecode4)) {
34492 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_revuid" "', argument " "4"" of type '" "unsigned int""'");
34493 : }
34494 3 : arg4 = (unsigned int)(val4);
34495 : {
34496 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34497 3 : result = gpgme_op_revuid(arg1,arg2,(char const *)arg3,arg4);
34498 3 : SWIG_PYTHON_THREAD_END_ALLOW;
34499 : }
34500 : {
34501 3 : resultobj = PyLong_FromLong(result);
34502 : }
34503 : {
34504 3 : Py_XDECREF(encodedInput3);
34505 : }
34506 : return resultobj;
34507 : fail:
34508 : {
34509 0 : Py_XDECREF(encodedInput3);
34510 : }
34511 : return NULL;
34512 : }
34513 :
34514 :
34515 0 : SWIGINTERN PyObject *_wrap_gpgme_op_set_uid_flag_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34516 0 : PyObject *resultobj = 0;
34517 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34518 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34519 0 : char *arg3 = (char *) 0 ;
34520 0 : char *arg4 = (char *) 0 ;
34521 0 : char *arg5 = (char *) 0 ;
34522 0 : void *argp1 = 0 ;
34523 0 : int res1 = 0 ;
34524 0 : void *argp2 = 0 ;
34525 0 : int res2 = 0 ;
34526 0 : PyObject *encodedInput3 = NULL ;
34527 0 : PyObject *encodedInput4 = NULL ;
34528 0 : PyObject *encodedInput5 = NULL ;
34529 0 : PyObject * obj0 = 0 ;
34530 0 : PyObject * obj1 = 0 ;
34531 0 : PyObject * obj2 = 0 ;
34532 0 : PyObject * obj3 = 0 ;
34533 0 : PyObject * obj4 = 0 ;
34534 : gpgme_error_t result;
34535 :
34536 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_set_uid_flag_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34537 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34538 0 : if (!SWIG_IsOK(res1)) {
34539 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_set_uid_flag_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34540 : }
34541 0 : arg1 = (gpgme_ctx_t)(argp1);
34542 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34543 0 : if (!SWIG_IsOK(res2)) {
34544 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_set_uid_flag_start" "', argument " "2"" of type '" "gpgme_key_t""'");
34545 : }
34546 0 : arg2 = (gpgme_key_t)(argp2);
34547 : {
34548 0 : if (obj2 == Py_None)
34549 : arg3 = NULL;
34550 0 : else if (PyUnicode_Check(obj2))
34551 : {
34552 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
34553 0 : if (encodedInput3 == NULL)
34554 : return NULL;
34555 0 : arg3 = PyBytes_AsString(encodedInput3);
34556 : }
34557 0 : else if (PyBytes_Check(obj2))
34558 0 : arg3 = PyBytes_AsString(obj2);
34559 : else {
34560 0 : PyErr_Format(PyExc_TypeError,
34561 : "arg %d: expected str, bytes, or None, got %s",
34562 : 3, obj2->ob_type->tp_name);
34563 0 : return NULL;
34564 : }
34565 : }
34566 : {
34567 0 : if (obj3 == Py_None)
34568 : arg4 = NULL;
34569 0 : else if (PyUnicode_Check(obj3))
34570 : {
34571 0 : encodedInput4 = PyUnicode_AsUTF8String(obj3);
34572 0 : if (encodedInput4 == NULL)
34573 : return NULL;
34574 0 : arg4 = PyBytes_AsString(encodedInput4);
34575 : }
34576 0 : else if (PyBytes_Check(obj3))
34577 0 : arg4 = PyBytes_AsString(obj3);
34578 : else {
34579 0 : PyErr_Format(PyExc_TypeError,
34580 : "arg %d: expected str, bytes, or None, got %s",
34581 : 4, obj3->ob_type->tp_name);
34582 0 : return NULL;
34583 : }
34584 : }
34585 : {
34586 0 : if (obj4 == Py_None)
34587 : arg5 = NULL;
34588 0 : else if (PyUnicode_Check(obj4))
34589 : {
34590 0 : encodedInput5 = PyUnicode_AsUTF8String(obj4);
34591 0 : if (encodedInput5 == NULL)
34592 : return NULL;
34593 0 : arg5 = PyBytes_AsString(encodedInput5);
34594 : }
34595 0 : else if (PyBytes_Check(obj4))
34596 0 : arg5 = PyBytes_AsString(obj4);
34597 : else {
34598 0 : PyErr_Format(PyExc_TypeError,
34599 : "arg %d: expected str, bytes, or None, got %s",
34600 : 5, obj4->ob_type->tp_name);
34601 0 : return NULL;
34602 : }
34603 : }
34604 : {
34605 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34606 0 : result = gpgme_op_set_uid_flag_start(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
34607 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34608 : }
34609 : {
34610 0 : resultobj = PyLong_FromLong(result);
34611 : }
34612 : {
34613 0 : Py_XDECREF(encodedInput3);
34614 : }
34615 : {
34616 0 : Py_XDECREF(encodedInput4);
34617 : }
34618 : {
34619 0 : Py_XDECREF(encodedInput5);
34620 : }
34621 : return resultobj;
34622 : fail:
34623 : {
34624 : Py_XDECREF(encodedInput3);
34625 : }
34626 : {
34627 : Py_XDECREF(encodedInput4);
34628 : }
34629 : {
34630 : Py_XDECREF(encodedInput5);
34631 : }
34632 : return NULL;
34633 : }
34634 :
34635 :
34636 0 : SWIGINTERN PyObject *_wrap_gpgme_op_set_uid_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34637 0 : PyObject *resultobj = 0;
34638 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34639 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34640 0 : char *arg3 = (char *) 0 ;
34641 0 : char *arg4 = (char *) 0 ;
34642 0 : char *arg5 = (char *) 0 ;
34643 0 : void *argp1 = 0 ;
34644 0 : int res1 = 0 ;
34645 0 : void *argp2 = 0 ;
34646 0 : int res2 = 0 ;
34647 0 : PyObject *encodedInput3 = NULL ;
34648 0 : PyObject *encodedInput4 = NULL ;
34649 0 : PyObject *encodedInput5 = NULL ;
34650 0 : PyObject * obj0 = 0 ;
34651 0 : PyObject * obj1 = 0 ;
34652 0 : PyObject * obj2 = 0 ;
34653 0 : PyObject * obj3 = 0 ;
34654 0 : PyObject * obj4 = 0 ;
34655 : gpgme_error_t result;
34656 :
34657 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_set_uid_flag",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34658 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34659 0 : if (!SWIG_IsOK(res1)) {
34660 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_set_uid_flag" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34661 : }
34662 0 : arg1 = (gpgme_ctx_t)(argp1);
34663 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34664 0 : if (!SWIG_IsOK(res2)) {
34665 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_set_uid_flag" "', argument " "2"" of type '" "gpgme_key_t""'");
34666 : }
34667 0 : arg2 = (gpgme_key_t)(argp2);
34668 : {
34669 0 : if (obj2 == Py_None)
34670 : arg3 = NULL;
34671 0 : else if (PyUnicode_Check(obj2))
34672 : {
34673 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
34674 0 : if (encodedInput3 == NULL)
34675 : return NULL;
34676 0 : arg3 = PyBytes_AsString(encodedInput3);
34677 : }
34678 0 : else if (PyBytes_Check(obj2))
34679 0 : arg3 = PyBytes_AsString(obj2);
34680 : else {
34681 0 : PyErr_Format(PyExc_TypeError,
34682 : "arg %d: expected str, bytes, or None, got %s",
34683 : 3, obj2->ob_type->tp_name);
34684 0 : return NULL;
34685 : }
34686 : }
34687 : {
34688 0 : if (obj3 == Py_None)
34689 : arg4 = NULL;
34690 0 : else if (PyUnicode_Check(obj3))
34691 : {
34692 0 : encodedInput4 = PyUnicode_AsUTF8String(obj3);
34693 0 : if (encodedInput4 == NULL)
34694 : return NULL;
34695 0 : arg4 = PyBytes_AsString(encodedInput4);
34696 : }
34697 0 : else if (PyBytes_Check(obj3))
34698 0 : arg4 = PyBytes_AsString(obj3);
34699 : else {
34700 0 : PyErr_Format(PyExc_TypeError,
34701 : "arg %d: expected str, bytes, or None, got %s",
34702 : 4, obj3->ob_type->tp_name);
34703 0 : return NULL;
34704 : }
34705 : }
34706 : {
34707 0 : if (obj4 == Py_None)
34708 : arg5 = NULL;
34709 0 : else if (PyUnicode_Check(obj4))
34710 : {
34711 0 : encodedInput5 = PyUnicode_AsUTF8String(obj4);
34712 0 : if (encodedInput5 == NULL)
34713 : return NULL;
34714 0 : arg5 = PyBytes_AsString(encodedInput5);
34715 : }
34716 0 : else if (PyBytes_Check(obj4))
34717 0 : arg5 = PyBytes_AsString(obj4);
34718 : else {
34719 0 : PyErr_Format(PyExc_TypeError,
34720 : "arg %d: expected str, bytes, or None, got %s",
34721 : 5, obj4->ob_type->tp_name);
34722 0 : return NULL;
34723 : }
34724 : }
34725 : {
34726 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34727 0 : result = gpgme_op_set_uid_flag(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
34728 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34729 : }
34730 : {
34731 0 : resultobj = PyLong_FromLong(result);
34732 : }
34733 : {
34734 0 : Py_XDECREF(encodedInput3);
34735 : }
34736 : {
34737 0 : Py_XDECREF(encodedInput4);
34738 : }
34739 : {
34740 0 : Py_XDECREF(encodedInput5);
34741 : }
34742 : return resultobj;
34743 : fail:
34744 : {
34745 : Py_XDECREF(encodedInput3);
34746 : }
34747 : {
34748 : Py_XDECREF(encodedInput4);
34749 : }
34750 : {
34751 : Py_XDECREF(encodedInput5);
34752 : }
34753 : return NULL;
34754 : }
34755 :
34756 :
34757 36 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34758 36 : PyObject *resultobj = 0;
34759 36 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34760 36 : void *argp1 = 0 ;
34761 36 : int res1 = 0 ;
34762 36 : PyObject * obj0 = 0 ;
34763 : gpgme_genkey_result_t result;
34764 :
34765 36 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_genkey_result",&obj0)) SWIG_fail;
34766 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34767 36 : if (!SWIG_IsOK(res1)) {
34768 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34769 : }
34770 36 : arg1 = (gpgme_ctx_t)(argp1);
34771 : {
34772 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34773 36 : result = (gpgme_genkey_result_t)gpgme_op_genkey_result(arg1);
34774 36 : SWIG_PYTHON_THREAD_END_ALLOW;
34775 : }
34776 : {
34777 : PyObject *fragile;
34778 36 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_genkey_result,
34779 : 0 );
34780 36 : resultobj = _gpg_wrap_result(fragile, "GenkeyResult");
34781 36 : Py_DECREF(fragile);
34782 : }
34783 : return resultobj;
34784 : fail:
34785 : return NULL;
34786 : }
34787 :
34788 :
34789 0 : SWIGINTERN PyObject *_wrap_gpgme_op_delete_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34790 0 : PyObject *resultobj = 0;
34791 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34792 0 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
34793 : int arg3 ;
34794 0 : void *argp1 = 0 ;
34795 0 : int res1 = 0 ;
34796 0 : void *argp2 = 0 ;
34797 0 : int res2 = 0 ;
34798 : int val3 ;
34799 0 : int ecode3 = 0 ;
34800 0 : PyObject * obj0 = 0 ;
34801 0 : PyObject * obj1 = 0 ;
34802 0 : PyObject * obj2 = 0 ;
34803 : gpgme_error_t result;
34804 :
34805 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_delete_start",&obj0,&obj1,&obj2)) SWIG_fail;
34806 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34807 0 : if (!SWIG_IsOK(res1)) {
34808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_delete_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34809 : }
34810 0 : arg1 = (gpgme_ctx_t)(argp1);
34811 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34812 0 : if (!SWIG_IsOK(res2)) {
34813 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_delete_start" "', argument " "2"" of type '" "gpgme_key_t const""'");
34814 : }
34815 0 : arg2 = (gpgme_key_t)(argp2);
34816 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
34817 0 : if (!SWIG_IsOK(ecode3)) {
34818 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_delete_start" "', argument " "3"" of type '" "int""'");
34819 : }
34820 0 : arg3 = (int)(val3);
34821 : {
34822 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34823 0 : result = gpgme_op_delete_start(arg1,arg2,arg3);
34824 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34825 : }
34826 : {
34827 0 : resultobj = PyLong_FromLong(result);
34828 : }
34829 0 : return resultobj;
34830 : fail:
34831 : return NULL;
34832 : }
34833 :
34834 :
34835 0 : SWIGINTERN PyObject *_wrap_gpgme_op_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34836 0 : PyObject *resultobj = 0;
34837 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34838 0 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
34839 : int arg3 ;
34840 0 : void *argp1 = 0 ;
34841 0 : int res1 = 0 ;
34842 0 : void *argp2 = 0 ;
34843 0 : int res2 = 0 ;
34844 : int val3 ;
34845 0 : int ecode3 = 0 ;
34846 0 : PyObject * obj0 = 0 ;
34847 0 : PyObject * obj1 = 0 ;
34848 0 : PyObject * obj2 = 0 ;
34849 : gpgme_error_t result;
34850 :
34851 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_delete",&obj0,&obj1,&obj2)) SWIG_fail;
34852 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34853 0 : if (!SWIG_IsOK(res1)) {
34854 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_delete" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34855 : }
34856 0 : arg1 = (gpgme_ctx_t)(argp1);
34857 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34858 0 : if (!SWIG_IsOK(res2)) {
34859 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_delete" "', argument " "2"" of type '" "gpgme_key_t const""'");
34860 : }
34861 0 : arg2 = (gpgme_key_t)(argp2);
34862 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
34863 0 : if (!SWIG_IsOK(ecode3)) {
34864 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_delete" "', argument " "3"" of type '" "int""'");
34865 : }
34866 0 : arg3 = (int)(val3);
34867 : {
34868 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34869 0 : result = gpgme_op_delete(arg1,arg2,arg3);
34870 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34871 : }
34872 : {
34873 0 : resultobj = PyLong_FromLong(result);
34874 : }
34875 0 : return resultobj;
34876 : fail:
34877 : return NULL;
34878 : }
34879 :
34880 :
34881 0 : SWIGINTERN PyObject *_wrap_gpgme_op_delete_ext_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34882 0 : PyObject *resultobj = 0;
34883 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34884 0 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
34885 : unsigned int arg3 ;
34886 0 : void *argp1 = 0 ;
34887 0 : int res1 = 0 ;
34888 0 : void *argp2 = 0 ;
34889 0 : int res2 = 0 ;
34890 : unsigned int val3 ;
34891 0 : int ecode3 = 0 ;
34892 0 : PyObject * obj0 = 0 ;
34893 0 : PyObject * obj1 = 0 ;
34894 0 : PyObject * obj2 = 0 ;
34895 : gpgme_error_t result;
34896 :
34897 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_delete_ext_start",&obj0,&obj1,&obj2)) SWIG_fail;
34898 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34899 0 : if (!SWIG_IsOK(res1)) {
34900 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_delete_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34901 : }
34902 0 : arg1 = (gpgme_ctx_t)(argp1);
34903 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34904 0 : if (!SWIG_IsOK(res2)) {
34905 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_delete_ext_start" "', argument " "2"" of type '" "gpgme_key_t const""'");
34906 : }
34907 0 : arg2 = (gpgme_key_t)(argp2);
34908 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
34909 0 : if (!SWIG_IsOK(ecode3)) {
34910 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_delete_ext_start" "', argument " "3"" of type '" "unsigned int""'");
34911 : }
34912 0 : arg3 = (unsigned int)(val3);
34913 : {
34914 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34915 0 : result = gpgme_op_delete_ext_start(arg1,arg2,arg3);
34916 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34917 : }
34918 : {
34919 0 : resultobj = PyLong_FromLong(result);
34920 : }
34921 0 : return resultobj;
34922 : fail:
34923 : return NULL;
34924 : }
34925 :
34926 :
34927 0 : SWIGINTERN PyObject *_wrap_gpgme_op_delete_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34928 0 : PyObject *resultobj = 0;
34929 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34930 0 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
34931 : unsigned int arg3 ;
34932 0 : void *argp1 = 0 ;
34933 0 : int res1 = 0 ;
34934 0 : void *argp2 = 0 ;
34935 0 : int res2 = 0 ;
34936 : unsigned int val3 ;
34937 0 : int ecode3 = 0 ;
34938 0 : PyObject * obj0 = 0 ;
34939 0 : PyObject * obj1 = 0 ;
34940 0 : PyObject * obj2 = 0 ;
34941 : gpgme_error_t result;
34942 :
34943 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_delete_ext",&obj0,&obj1,&obj2)) SWIG_fail;
34944 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34945 0 : if (!SWIG_IsOK(res1)) {
34946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_delete_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
34947 : }
34948 0 : arg1 = (gpgme_ctx_t)(argp1);
34949 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
34950 0 : if (!SWIG_IsOK(res2)) {
34951 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_delete_ext" "', argument " "2"" of type '" "gpgme_key_t const""'");
34952 : }
34953 0 : arg2 = (gpgme_key_t)(argp2);
34954 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
34955 0 : if (!SWIG_IsOK(ecode3)) {
34956 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_delete_ext" "', argument " "3"" of type '" "unsigned int""'");
34957 : }
34958 0 : arg3 = (unsigned int)(val3);
34959 : {
34960 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34961 0 : result = gpgme_op_delete_ext(arg1,arg2,arg3);
34962 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34963 : }
34964 : {
34965 0 : resultobj = PyLong_FromLong(result);
34966 : }
34967 0 : return resultobj;
34968 : fail:
34969 : return NULL;
34970 : }
34971 :
34972 :
34973 0 : SWIGINTERN PyObject *_wrap_gpgme_op_keysign_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34974 0 : PyObject *resultobj = 0;
34975 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
34976 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
34977 0 : char *arg3 = (char *) 0 ;
34978 : unsigned long arg4 ;
34979 : unsigned int arg5 ;
34980 0 : void *argp1 = 0 ;
34981 0 : int res1 = 0 ;
34982 0 : void *argp2 = 0 ;
34983 0 : int res2 = 0 ;
34984 0 : PyObject *encodedInput3 = NULL ;
34985 : unsigned long val4 ;
34986 0 : int ecode4 = 0 ;
34987 : unsigned int val5 ;
34988 0 : int ecode5 = 0 ;
34989 0 : PyObject * obj0 = 0 ;
34990 0 : PyObject * obj1 = 0 ;
34991 0 : PyObject * obj2 = 0 ;
34992 0 : PyObject * obj3 = 0 ;
34993 0 : PyObject * obj4 = 0 ;
34994 : gpgme_error_t result;
34995 :
34996 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_keysign_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34997 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
34998 0 : if (!SWIG_IsOK(res1)) {
34999 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keysign_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35000 : }
35001 0 : arg1 = (gpgme_ctx_t)(argp1);
35002 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
35003 0 : if (!SWIG_IsOK(res2)) {
35004 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_keysign_start" "', argument " "2"" of type '" "gpgme_key_t""'");
35005 : }
35006 0 : arg2 = (gpgme_key_t)(argp2);
35007 : {
35008 0 : if (obj2 == Py_None)
35009 : arg3 = NULL;
35010 0 : else if (PyUnicode_Check(obj2))
35011 : {
35012 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
35013 0 : if (encodedInput3 == NULL)
35014 : return NULL;
35015 0 : arg3 = PyBytes_AsString(encodedInput3);
35016 : }
35017 0 : else if (PyBytes_Check(obj2))
35018 0 : arg3 = PyBytes_AsString(obj2);
35019 : else {
35020 0 : PyErr_Format(PyExc_TypeError,
35021 : "arg %d: expected str, bytes, or None, got %s",
35022 : 3, obj2->ob_type->tp_name);
35023 0 : return NULL;
35024 : }
35025 : }
35026 0 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
35027 0 : if (!SWIG_IsOK(ecode4)) {
35028 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_keysign_start" "', argument " "4"" of type '" "unsigned long""'");
35029 : }
35030 0 : arg4 = (unsigned long)(val4);
35031 0 : ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
35032 0 : if (!SWIG_IsOK(ecode5)) {
35033 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_keysign_start" "', argument " "5"" of type '" "unsigned int""'");
35034 : }
35035 0 : arg5 = (unsigned int)(val5);
35036 : {
35037 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35038 0 : result = gpgme_op_keysign_start(arg1,arg2,(char const *)arg3,arg4,arg5);
35039 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35040 : }
35041 : {
35042 0 : resultobj = PyLong_FromLong(result);
35043 : }
35044 : {
35045 0 : Py_XDECREF(encodedInput3);
35046 : }
35047 : return resultobj;
35048 : fail:
35049 : {
35050 0 : Py_XDECREF(encodedInput3);
35051 : }
35052 : return NULL;
35053 : }
35054 :
35055 :
35056 4 : SWIGINTERN PyObject *_wrap_gpgme_op_keysign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35057 4 : PyObject *resultobj = 0;
35058 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35059 4 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
35060 4 : char *arg3 = (char *) 0 ;
35061 : unsigned long arg4 ;
35062 : unsigned int arg5 ;
35063 4 : void *argp1 = 0 ;
35064 4 : int res1 = 0 ;
35065 4 : void *argp2 = 0 ;
35066 4 : int res2 = 0 ;
35067 4 : PyObject *encodedInput3 = NULL ;
35068 : unsigned long val4 ;
35069 4 : int ecode4 = 0 ;
35070 : unsigned int val5 ;
35071 4 : int ecode5 = 0 ;
35072 4 : PyObject * obj0 = 0 ;
35073 4 : PyObject * obj1 = 0 ;
35074 4 : PyObject * obj2 = 0 ;
35075 4 : PyObject * obj3 = 0 ;
35076 4 : PyObject * obj4 = 0 ;
35077 : gpgme_error_t result;
35078 :
35079 4 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_keysign",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35080 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
35081 4 : if (!SWIG_IsOK(res1)) {
35082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keysign" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35083 : }
35084 4 : arg1 = (gpgme_ctx_t)(argp1);
35085 4 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
35086 4 : if (!SWIG_IsOK(res2)) {
35087 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_keysign" "', argument " "2"" of type '" "gpgme_key_t""'");
35088 : }
35089 4 : arg2 = (gpgme_key_t)(argp2);
35090 : {
35091 4 : if (obj2 == Py_None)
35092 : arg3 = NULL;
35093 3 : else if (PyUnicode_Check(obj2))
35094 : {
35095 3 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
35096 3 : if (encodedInput3 == NULL)
35097 : return NULL;
35098 3 : arg3 = PyBytes_AsString(encodedInput3);
35099 : }
35100 0 : else if (PyBytes_Check(obj2))
35101 0 : arg3 = PyBytes_AsString(obj2);
35102 : else {
35103 0 : PyErr_Format(PyExc_TypeError,
35104 : "arg %d: expected str, bytes, or None, got %s",
35105 : 3, obj2->ob_type->tp_name);
35106 0 : return NULL;
35107 : }
35108 : }
35109 4 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
35110 4 : if (!SWIG_IsOK(ecode4)) {
35111 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_keysign" "', argument " "4"" of type '" "unsigned long""'");
35112 : }
35113 4 : arg4 = (unsigned long)(val4);
35114 8 : ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
35115 4 : if (!SWIG_IsOK(ecode5)) {
35116 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_keysign" "', argument " "5"" of type '" "unsigned int""'");
35117 : }
35118 4 : arg5 = (unsigned int)(val5);
35119 : {
35120 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35121 4 : result = gpgme_op_keysign(arg1,arg2,(char const *)arg3,arg4,arg5);
35122 4 : SWIG_PYTHON_THREAD_END_ALLOW;
35123 : }
35124 : {
35125 4 : resultobj = PyLong_FromLong(result);
35126 : }
35127 : {
35128 4 : Py_XDECREF(encodedInput3);
35129 : }
35130 : return resultobj;
35131 : fail:
35132 : {
35133 0 : Py_XDECREF(encodedInput3);
35134 : }
35135 : return NULL;
35136 : }
35137 :
35138 :
35139 0 : SWIGINTERN PyObject *_wrap_gpgme_op_interact_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35140 0 : PyObject *resultobj = 0;
35141 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35142 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
35143 : unsigned int arg3 ;
35144 0 : gpgme_interact_cb_t arg4 = (gpgme_interact_cb_t) 0 ;
35145 0 : void *arg5 = (void *) 0 ;
35146 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
35147 0 : void *argp1 = 0 ;
35148 0 : int res1 = 0 ;
35149 0 : void *argp2 = 0 ;
35150 0 : int res2 = 0 ;
35151 : unsigned int val3 ;
35152 0 : int ecode3 = 0 ;
35153 0 : gpgme_data_t wrapper6 = NULL ;
35154 0 : PyObject *bytesio6 = NULL ;
35155 : Py_buffer view6 ;
35156 0 : int have_view6 = 0 ;
35157 0 : PyObject * obj0 = 0 ;
35158 0 : PyObject * obj1 = 0 ;
35159 0 : PyObject * obj2 = 0 ;
35160 0 : PyObject * obj3 = 0 ;
35161 0 : PyObject * obj4 = 0 ;
35162 : gpgme_error_t result;
35163 :
35164 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_interact_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35165 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
35166 0 : if (!SWIG_IsOK(res1)) {
35167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_interact_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35168 : }
35169 0 : arg1 = (gpgme_ctx_t)(argp1);
35170 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
35171 0 : if (!SWIG_IsOK(res2)) {
35172 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_interact_start" "', argument " "2"" of type '" "gpgme_key_t""'");
35173 : }
35174 0 : arg2 = (gpgme_key_t)(argp2);
35175 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
35176 0 : if (!SWIG_IsOK(ecode3)) {
35177 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_interact_start" "', argument " "3"" of type '" "unsigned int""'");
35178 : }
35179 0 : arg3 = (unsigned int)(val3);
35180 : {
35181 0 : if (! PyTuple_Check(obj3))
35182 0 : return PyErr_Format(PyExc_TypeError, "interact callback must be a tuple");
35183 0 : if (PyTuple_Size(obj3) != 2 && PyTuple_Size(obj3) != 3)
35184 0 : return PyErr_Format(PyExc_TypeError,
35185 : "interact callback must be a tuple of size 2 or 3");
35186 :
35187 0 : arg4 = (gpgme_interact_cb_t) _gpg_interact_cb;
35188 0 : arg5 = obj3;
35189 : }
35190 : {
35191 : /* If we create a temporary wrapper6 object, we will store it in
35192 : wrapperN, where N is 6. Here in this fragment, SWIG will
35193 : automatically append 6. */
35194 0 : memset(&view6, 0, sizeof view6);
35195 0 : if (obj4 == Py_None)
35196 0 : arg6 = NULL;
35197 : else {
35198 : PyObject *pypointer;
35199 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 6, &wrapper6,
35200 : &bytesio6, &view6);
35201 0 : if (pypointer == NULL)
35202 : return NULL;
35203 0 : have_view6 = !! view6.obj;
35204 :
35205 : /* input = obj4, 1 = arg6, 1_descriptor = SWIGTYPE_p_gpgme_data */
35206 :
35207 : /* Following code is from swig's python.swg. */
35208 :
35209 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg6, SWIGTYPE_p_gpgme_data,
35210 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
35211 0 : Py_DECREF(pypointer);
35212 : return NULL;
35213 : }
35214 0 : Py_DECREF(pypointer);
35215 : }
35216 : }
35217 : {
35218 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35219 0 : result = gpgme_op_interact_start(arg1,arg2,arg3,arg4,arg5,arg6);
35220 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35221 : }
35222 : {
35223 0 : resultobj = PyLong_FromLong(result);
35224 : }
35225 : {
35226 : /* See whether we need to update the Python buffer. */
35227 0 : if (resultobj && wrapper6 && view6.buf)
35228 : {
35229 : int dirty;
35230 0 : char *new_data = NULL;
35231 : size_t new_size;
35232 :
35233 :
35234 0 : new_data = wrapper6->data.mem.buffer;
35235 0 : new_size = wrapper6->data.mem.length;
35236 0 : dirty = new_data != NULL;
35237 :
35238 :
35239 :
35240 :
35241 :
35242 :
35243 :
35244 0 : if (dirty)
35245 : {
35246 : /* The buffer is dirty. */
35247 0 : if (view6.readonly)
35248 : {
35249 0 : Py_XDECREF(resultobj);
35250 0 : resultobj = NULL;
35251 0 : PyErr_SetString(PyExc_ValueError,
35252 : "cannot update read-only buffer");
35253 : }
35254 :
35255 : /* See if we need to truncate the buffer. */
35256 0 : if (resultobj && view6.len != new_size)
35257 : {
35258 0 : if (bytesio6 == NULL)
35259 : {
35260 0 : Py_XDECREF(resultobj);
35261 0 : resultobj = NULL;
35262 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
35263 : }
35264 : else
35265 : {
35266 : PyObject *retval;
35267 0 : PyBuffer_Release(&view6);
35268 : assert(view6.obj == NULL);
35269 0 : retval = PyObject_CallMethod(bytesio6, "truncate",
35270 : "l", (long) new_size);
35271 0 : if (retval == NULL)
35272 : {
35273 0 : Py_XDECREF(resultobj);
35274 : resultobj = NULL;
35275 : }
35276 : else
35277 : {
35278 0 : Py_DECREF(retval);
35279 :
35280 0 : retval = PyObject_CallMethod(bytesio6,
35281 : "getbuffer", NULL);
35282 0 : if (retval == NULL
35283 0 : || PyObject_GetBuffer(retval, &view6,
35284 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
35285 : {
35286 0 : Py_XDECREF(resultobj);
35287 : resultobj = NULL;
35288 : }
35289 :
35290 0 : Py_XDECREF(retval);
35291 :
35292 0 : if (resultobj && view6.len
35293 : != new_size)
35294 : {
35295 0 : Py_XDECREF(resultobj);
35296 0 : resultobj = NULL;
35297 0 : PyErr_Format(PyExc_ValueError,
35298 : "Expected buffer of length %zu, got %zi",
35299 : new_size,
35300 : view6.len);
35301 : }
35302 : }
35303 : }
35304 : }
35305 0 : if (resultobj)
35306 0 : memcpy(view6.buf, new_data, new_size);
35307 : }
35308 :
35309 :
35310 :
35311 : }
35312 :
35313 : /* Free the temporary wrapper, if any. */
35314 0 : if (wrapper6)
35315 0 : gpgme_data_release(wrapper6);
35316 0 : Py_XDECREF (bytesio6);
35317 0 : if (have_view6 && view6.buf)
35318 0 : PyBuffer_Release(&view6);
35319 : }
35320 : return resultobj;
35321 : fail:
35322 : {
35323 : /* See whether we need to update the Python buffer. */
35324 : if (resultobj && wrapper6 && view6.buf)
35325 : {
35326 : int dirty;
35327 : char *new_data = NULL;
35328 : size_t new_size;
35329 :
35330 :
35331 : new_data = wrapper6->data.mem.buffer;
35332 : new_size = wrapper6->data.mem.length;
35333 : dirty = new_data != NULL;
35334 :
35335 :
35336 :
35337 :
35338 :
35339 :
35340 :
35341 : if (dirty)
35342 : {
35343 : /* The buffer is dirty. */
35344 : if (view6.readonly)
35345 : {
35346 : Py_XDECREF(resultobj);
35347 : resultobj = NULL;
35348 : PyErr_SetString(PyExc_ValueError,
35349 : "cannot update read-only buffer");
35350 : }
35351 :
35352 : /* See if we need to truncate the buffer. */
35353 : if (resultobj && view6.len != new_size)
35354 : {
35355 : if (bytesio6 == NULL)
35356 : {
35357 : Py_XDECREF(resultobj);
35358 : resultobj = NULL;
35359 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
35360 : }
35361 : else
35362 : {
35363 : PyObject *retval;
35364 : PyBuffer_Release(&view6);
35365 : assert(view6.obj == NULL);
35366 : retval = PyObject_CallMethod(bytesio6, "truncate",
35367 : "l", (long) new_size);
35368 : if (retval == NULL)
35369 : {
35370 : Py_XDECREF(resultobj);
35371 : resultobj = NULL;
35372 : }
35373 : else
35374 : {
35375 : Py_DECREF(retval);
35376 :
35377 : retval = PyObject_CallMethod(bytesio6,
35378 : "getbuffer", NULL);
35379 : if (retval == NULL
35380 : || PyObject_GetBuffer(retval, &view6,
35381 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
35382 : {
35383 : Py_XDECREF(resultobj);
35384 : resultobj = NULL;
35385 : }
35386 :
35387 : Py_XDECREF(retval);
35388 :
35389 : if (resultobj && view6.len
35390 : != new_size)
35391 : {
35392 : Py_XDECREF(resultobj);
35393 : resultobj = NULL;
35394 : PyErr_Format(PyExc_ValueError,
35395 : "Expected buffer of length %zu, got %zi",
35396 : new_size,
35397 : view6.len);
35398 : }
35399 : }
35400 : }
35401 : }
35402 : if (resultobj)
35403 : memcpy(view6.buf, new_data, new_size);
35404 : }
35405 :
35406 :
35407 :
35408 : }
35409 :
35410 : /* Free the temporary wrapper, if any. */
35411 0 : if (wrapper6)
35412 0 : gpgme_data_release(wrapper6);
35413 0 : Py_XDECREF (bytesio6);
35414 : if (have_view6 && view6.buf)
35415 : PyBuffer_Release(&view6);
35416 : }
35417 : return NULL;
35418 : }
35419 :
35420 :
35421 5 : SWIGINTERN PyObject *_wrap_gpgme_op_interact(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35422 5 : PyObject *resultobj = 0;
35423 5 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35424 5 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
35425 : unsigned int arg3 ;
35426 5 : gpgme_interact_cb_t arg4 = (gpgme_interact_cb_t) 0 ;
35427 5 : void *arg5 = (void *) 0 ;
35428 5 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
35429 5 : void *argp1 = 0 ;
35430 5 : int res1 = 0 ;
35431 5 : void *argp2 = 0 ;
35432 5 : int res2 = 0 ;
35433 : unsigned int val3 ;
35434 5 : int ecode3 = 0 ;
35435 5 : gpgme_data_t wrapper6 = NULL ;
35436 5 : PyObject *bytesio6 = NULL ;
35437 : Py_buffer view6 ;
35438 5 : int have_view6 = 0 ;
35439 5 : PyObject * obj0 = 0 ;
35440 5 : PyObject * obj1 = 0 ;
35441 5 : PyObject * obj2 = 0 ;
35442 5 : PyObject * obj3 = 0 ;
35443 5 : PyObject * obj4 = 0 ;
35444 : gpgme_error_t result;
35445 :
35446 5 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_interact",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35447 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
35448 5 : if (!SWIG_IsOK(res1)) {
35449 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_interact" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35450 : }
35451 5 : arg1 = (gpgme_ctx_t)(argp1);
35452 5 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
35453 5 : if (!SWIG_IsOK(res2)) {
35454 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_interact" "', argument " "2"" of type '" "gpgme_key_t""'");
35455 : }
35456 5 : arg2 = (gpgme_key_t)(argp2);
35457 10 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
35458 5 : if (!SWIG_IsOK(ecode3)) {
35459 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_interact" "', argument " "3"" of type '" "unsigned int""'");
35460 : }
35461 5 : arg3 = (unsigned int)(val3);
35462 : {
35463 5 : if (! PyTuple_Check(obj3))
35464 0 : return PyErr_Format(PyExc_TypeError, "interact callback must be a tuple");
35465 5 : if (PyTuple_Size(obj3) != 2 && PyTuple_Size(obj3) != 3)
35466 0 : return PyErr_Format(PyExc_TypeError,
35467 : "interact callback must be a tuple of size 2 or 3");
35468 :
35469 5 : arg4 = (gpgme_interact_cb_t) _gpg_interact_cb;
35470 5 : arg5 = obj3;
35471 : }
35472 : {
35473 : /* If we create a temporary wrapper6 object, we will store it in
35474 : wrapperN, where N is 6. Here in this fragment, SWIG will
35475 : automatically append 6. */
35476 5 : memset(&view6, 0, sizeof view6);
35477 5 : if (obj4 == Py_None)
35478 0 : arg6 = NULL;
35479 : else {
35480 : PyObject *pypointer;
35481 5 : pypointer = _gpg_obj2gpgme_data_t(obj4, 6, &wrapper6,
35482 : &bytesio6, &view6);
35483 5 : if (pypointer == NULL)
35484 : return NULL;
35485 5 : have_view6 = !! view6.obj;
35486 :
35487 : /* input = obj4, 1 = arg6, 1_descriptor = SWIGTYPE_p_gpgme_data */
35488 :
35489 : /* Following code is from swig's python.swg. */
35490 :
35491 5 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg6, SWIGTYPE_p_gpgme_data,
35492 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
35493 0 : Py_DECREF(pypointer);
35494 : return NULL;
35495 : }
35496 5 : Py_DECREF(pypointer);
35497 : }
35498 : }
35499 : {
35500 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35501 5 : result = gpgme_op_interact(arg1,arg2,arg3,arg4,arg5,arg6);
35502 5 : SWIG_PYTHON_THREAD_END_ALLOW;
35503 : }
35504 : {
35505 5 : resultobj = PyLong_FromLong(result);
35506 : }
35507 : {
35508 : /* See whether we need to update the Python buffer. */
35509 5 : if (resultobj && wrapper6 && view6.buf)
35510 : {
35511 : int dirty;
35512 0 : char *new_data = NULL;
35513 : size_t new_size;
35514 :
35515 :
35516 0 : new_data = wrapper6->data.mem.buffer;
35517 0 : new_size = wrapper6->data.mem.length;
35518 0 : dirty = new_data != NULL;
35519 :
35520 :
35521 :
35522 :
35523 :
35524 :
35525 :
35526 0 : if (dirty)
35527 : {
35528 : /* The buffer is dirty. */
35529 0 : if (view6.readonly)
35530 : {
35531 0 : Py_XDECREF(resultobj);
35532 0 : resultobj = NULL;
35533 0 : PyErr_SetString(PyExc_ValueError,
35534 : "cannot update read-only buffer");
35535 : }
35536 :
35537 : /* See if we need to truncate the buffer. */
35538 0 : if (resultobj && view6.len != new_size)
35539 : {
35540 0 : if (bytesio6 == NULL)
35541 : {
35542 0 : Py_XDECREF(resultobj);
35543 0 : resultobj = NULL;
35544 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
35545 : }
35546 : else
35547 : {
35548 : PyObject *retval;
35549 0 : PyBuffer_Release(&view6);
35550 : assert(view6.obj == NULL);
35551 0 : retval = PyObject_CallMethod(bytesio6, "truncate",
35552 : "l", (long) new_size);
35553 0 : if (retval == NULL)
35554 : {
35555 0 : Py_XDECREF(resultobj);
35556 : resultobj = NULL;
35557 : }
35558 : else
35559 : {
35560 0 : Py_DECREF(retval);
35561 :
35562 0 : retval = PyObject_CallMethod(bytesio6,
35563 : "getbuffer", NULL);
35564 0 : if (retval == NULL
35565 0 : || PyObject_GetBuffer(retval, &view6,
35566 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
35567 : {
35568 0 : Py_XDECREF(resultobj);
35569 : resultobj = NULL;
35570 : }
35571 :
35572 0 : Py_XDECREF(retval);
35573 :
35574 0 : if (resultobj && view6.len
35575 : != new_size)
35576 : {
35577 0 : Py_XDECREF(resultobj);
35578 0 : resultobj = NULL;
35579 0 : PyErr_Format(PyExc_ValueError,
35580 : "Expected buffer of length %zu, got %zi",
35581 : new_size,
35582 : view6.len);
35583 : }
35584 : }
35585 : }
35586 : }
35587 0 : if (resultobj)
35588 0 : memcpy(view6.buf, new_data, new_size);
35589 : }
35590 :
35591 :
35592 :
35593 : }
35594 :
35595 : /* Free the temporary wrapper, if any. */
35596 5 : if (wrapper6)
35597 0 : gpgme_data_release(wrapper6);
35598 5 : Py_XDECREF (bytesio6);
35599 5 : if (have_view6 && view6.buf)
35600 0 : PyBuffer_Release(&view6);
35601 : }
35602 : return resultobj;
35603 : fail:
35604 : {
35605 : /* See whether we need to update the Python buffer. */
35606 : if (resultobj && wrapper6 && view6.buf)
35607 : {
35608 : int dirty;
35609 : char *new_data = NULL;
35610 : size_t new_size;
35611 :
35612 :
35613 : new_data = wrapper6->data.mem.buffer;
35614 : new_size = wrapper6->data.mem.length;
35615 : dirty = new_data != NULL;
35616 :
35617 :
35618 :
35619 :
35620 :
35621 :
35622 :
35623 : if (dirty)
35624 : {
35625 : /* The buffer is dirty. */
35626 : if (view6.readonly)
35627 : {
35628 : Py_XDECREF(resultobj);
35629 : resultobj = NULL;
35630 : PyErr_SetString(PyExc_ValueError,
35631 : "cannot update read-only buffer");
35632 : }
35633 :
35634 : /* See if we need to truncate the buffer. */
35635 : if (resultobj && view6.len != new_size)
35636 : {
35637 : if (bytesio6 == NULL)
35638 : {
35639 : Py_XDECREF(resultobj);
35640 : resultobj = NULL;
35641 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
35642 : }
35643 : else
35644 : {
35645 : PyObject *retval;
35646 : PyBuffer_Release(&view6);
35647 : assert(view6.obj == NULL);
35648 : retval = PyObject_CallMethod(bytesio6, "truncate",
35649 : "l", (long) new_size);
35650 : if (retval == NULL)
35651 : {
35652 : Py_XDECREF(resultobj);
35653 : resultobj = NULL;
35654 : }
35655 : else
35656 : {
35657 : Py_DECREF(retval);
35658 :
35659 : retval = PyObject_CallMethod(bytesio6,
35660 : "getbuffer", NULL);
35661 : if (retval == NULL
35662 : || PyObject_GetBuffer(retval, &view6,
35663 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
35664 : {
35665 : Py_XDECREF(resultobj);
35666 : resultobj = NULL;
35667 : }
35668 :
35669 : Py_XDECREF(retval);
35670 :
35671 : if (resultobj && view6.len
35672 : != new_size)
35673 : {
35674 : Py_XDECREF(resultobj);
35675 : resultobj = NULL;
35676 : PyErr_Format(PyExc_ValueError,
35677 : "Expected buffer of length %zu, got %zi",
35678 : new_size,
35679 : view6.len);
35680 : }
35681 : }
35682 : }
35683 : }
35684 : if (resultobj)
35685 : memcpy(view6.buf, new_data, new_size);
35686 : }
35687 :
35688 :
35689 :
35690 : }
35691 :
35692 : /* Free the temporary wrapper, if any. */
35693 0 : if (wrapper6)
35694 0 : gpgme_data_release(wrapper6);
35695 0 : Py_XDECREF (bytesio6);
35696 : if (have_view6 && view6.buf)
35697 : PyBuffer_Release(&view6);
35698 : }
35699 : return NULL;
35700 : }
35701 :
35702 :
35703 0 : SWIGINTERN PyObject *_wrap_gpgme_op_tofu_policy_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35704 0 : PyObject *resultobj = 0;
35705 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35706 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
35707 : gpgme_tofu_policy_t arg3 ;
35708 0 : void *argp1 = 0 ;
35709 0 : int res1 = 0 ;
35710 0 : void *argp2 = 0 ;
35711 0 : int res2 = 0 ;
35712 : int val3 ;
35713 0 : int ecode3 = 0 ;
35714 0 : PyObject * obj0 = 0 ;
35715 0 : PyObject * obj1 = 0 ;
35716 0 : PyObject * obj2 = 0 ;
35717 : gpgme_error_t result;
35718 :
35719 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_tofu_policy_start",&obj0,&obj1,&obj2)) SWIG_fail;
35720 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
35721 0 : if (!SWIG_IsOK(res1)) {
35722 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_tofu_policy_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35723 : }
35724 0 : arg1 = (gpgme_ctx_t)(argp1);
35725 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
35726 0 : if (!SWIG_IsOK(res2)) {
35727 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_tofu_policy_start" "', argument " "2"" of type '" "gpgme_key_t""'");
35728 : }
35729 0 : arg2 = (gpgme_key_t)(argp2);
35730 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
35731 0 : if (!SWIG_IsOK(ecode3)) {
35732 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_tofu_policy_start" "', argument " "3"" of type '" "gpgme_tofu_policy_t""'");
35733 : }
35734 0 : arg3 = (gpgme_tofu_policy_t)(val3);
35735 : {
35736 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35737 0 : result = gpgme_op_tofu_policy_start(arg1,arg2,arg3);
35738 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35739 : }
35740 : {
35741 0 : resultobj = PyLong_FromLong(result);
35742 : }
35743 0 : return resultobj;
35744 : fail:
35745 : return NULL;
35746 : }
35747 :
35748 :
35749 5 : SWIGINTERN PyObject *_wrap_gpgme_op_tofu_policy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35750 5 : PyObject *resultobj = 0;
35751 5 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35752 5 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
35753 : gpgme_tofu_policy_t arg3 ;
35754 5 : void *argp1 = 0 ;
35755 5 : int res1 = 0 ;
35756 5 : void *argp2 = 0 ;
35757 5 : int res2 = 0 ;
35758 : int val3 ;
35759 5 : int ecode3 = 0 ;
35760 5 : PyObject * obj0 = 0 ;
35761 5 : PyObject * obj1 = 0 ;
35762 5 : PyObject * obj2 = 0 ;
35763 : gpgme_error_t result;
35764 :
35765 5 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_tofu_policy",&obj0,&obj1,&obj2)) SWIG_fail;
35766 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
35767 5 : if (!SWIG_IsOK(res1)) {
35768 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_tofu_policy" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35769 : }
35770 5 : arg1 = (gpgme_ctx_t)(argp1);
35771 5 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
35772 5 : if (!SWIG_IsOK(res2)) {
35773 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_tofu_policy" "', argument " "2"" of type '" "gpgme_key_t""'");
35774 : }
35775 5 : arg2 = (gpgme_key_t)(argp2);
35776 10 : ecode3 = SWIG_AsVal_int(obj2, &val3);
35777 5 : if (!SWIG_IsOK(ecode3)) {
35778 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_tofu_policy" "', argument " "3"" of type '" "gpgme_tofu_policy_t""'");
35779 : }
35780 5 : arg3 = (gpgme_tofu_policy_t)(val3);
35781 : {
35782 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35783 5 : result = gpgme_op_tofu_policy(arg1,arg2,arg3);
35784 5 : SWIG_PYTHON_THREAD_END_ALLOW;
35785 : }
35786 : {
35787 5 : resultobj = PyLong_FromLong(result);
35788 : }
35789 5 : return resultobj;
35790 : fail:
35791 : return NULL;
35792 : }
35793 :
35794 :
35795 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result_truncated_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35796 0 : PyObject *resultobj = 0;
35797 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
35798 : unsigned int arg2 ;
35799 0 : void *argp1 = 0 ;
35800 0 : int res1 = 0 ;
35801 : unsigned int val2 ;
35802 0 : int ecode2 = 0 ;
35803 0 : PyObject * obj0 = 0 ;
35804 0 : PyObject * obj1 = 0 ;
35805 :
35806 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_keylist_result_truncated_set",&obj0,&obj1)) SWIG_fail;
35807 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
35808 0 : if (!SWIG_IsOK(res1)) {
35809 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result_truncated_set" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
35810 : }
35811 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
35812 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
35813 0 : if (!SWIG_IsOK(ecode2)) {
35814 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_keylist_result_truncated_set" "', argument " "2"" of type '" "unsigned int""'");
35815 : }
35816 0 : arg2 = (unsigned int)(val2);
35817 : {
35818 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35819 0 : if (arg1) (arg1)->truncated = arg2;
35820 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35821 : }
35822 0 : resultobj = SWIG_Py_Void();
35823 0 : return resultobj;
35824 : fail:
35825 : return NULL;
35826 : }
35827 :
35828 :
35829 2 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result_truncated_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35830 2 : PyObject *resultobj = 0;
35831 2 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
35832 2 : void *argp1 = 0 ;
35833 2 : int res1 = 0 ;
35834 2 : PyObject * obj0 = 0 ;
35835 : unsigned int result;
35836 :
35837 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_keylist_result_truncated_get",&obj0)) SWIG_fail;
35838 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
35839 2 : if (!SWIG_IsOK(res1)) {
35840 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result_truncated_get" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
35841 : }
35842 2 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
35843 : {
35844 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35845 2 : result = (unsigned int) ((arg1)->truncated);
35846 2 : SWIG_PYTHON_THREAD_END_ALLOW;
35847 : }
35848 2 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
35849 2 : return resultobj;
35850 : fail:
35851 : return NULL;
35852 : }
35853 :
35854 :
35855 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35856 0 : PyObject *resultobj = 0;
35857 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
35858 : unsigned int arg2 ;
35859 0 : void *argp1 = 0 ;
35860 0 : int res1 = 0 ;
35861 : unsigned int val2 ;
35862 0 : int ecode2 = 0 ;
35863 0 : PyObject * obj0 = 0 ;
35864 0 : PyObject * obj1 = 0 ;
35865 :
35866 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_keylist_result__unused_set",&obj0,&obj1)) SWIG_fail;
35867 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
35868 0 : if (!SWIG_IsOK(res1)) {
35869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
35870 : }
35871 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
35872 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
35873 0 : if (!SWIG_IsOK(ecode2)) {
35874 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_keylist_result__unused_set" "', argument " "2"" of type '" "unsigned int""'");
35875 : }
35876 0 : arg2 = (unsigned int)(val2);
35877 : {
35878 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35879 0 : if (arg1) (arg1)->_unused = arg2;
35880 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35881 : }
35882 0 : resultobj = SWIG_Py_Void();
35883 0 : return resultobj;
35884 : fail:
35885 : return NULL;
35886 : }
35887 :
35888 :
35889 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35890 0 : PyObject *resultobj = 0;
35891 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
35892 0 : void *argp1 = 0 ;
35893 0 : int res1 = 0 ;
35894 0 : PyObject * obj0 = 0 ;
35895 : unsigned int result;
35896 :
35897 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_keylist_result__unused_get",&obj0)) SWIG_fail;
35898 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
35899 0 : if (!SWIG_IsOK(res1)) {
35900 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
35901 : }
35902 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
35903 : {
35904 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35905 0 : result = (unsigned int) ((arg1)->_unused);
35906 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35907 : }
35908 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
35909 0 : return resultobj;
35910 : fail:
35911 : return NULL;
35912 : }
35913 :
35914 :
35915 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_keylist_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35916 0 : PyObject *resultobj = 0;
35917 0 : struct _gpgme_op_keylist_result *result = 0 ;
35918 :
35919 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_keylist_result")) SWIG_fail;
35920 : {
35921 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35922 0 : result = (struct _gpgme_op_keylist_result *)calloc(1, sizeof(struct _gpgme_op_keylist_result));
35923 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35924 : }
35925 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_keylist_result, SWIG_POINTER_NEW | 0 );
35926 0 : return resultobj;
35927 : fail:
35928 : return NULL;
35929 : }
35930 :
35931 :
35932 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_keylist_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35933 0 : PyObject *resultobj = 0;
35934 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
35935 0 : void *argp1 = 0 ;
35936 0 : int res1 = 0 ;
35937 0 : PyObject * obj0 = 0 ;
35938 :
35939 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_keylist_result",&obj0)) SWIG_fail;
35940 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, SWIG_POINTER_DISOWN | 0 );
35941 0 : if (!SWIG_IsOK(res1)) {
35942 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_keylist_result" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
35943 : }
35944 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
35945 : {
35946 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35947 0 : free((char *) arg1);
35948 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35949 : }
35950 0 : resultobj = SWIG_Py_Void();
35951 0 : return resultobj;
35952 : fail:
35953 : return NULL;
35954 : }
35955 :
35956 :
35957 29 : SWIGINTERN PyObject *_gpgme_op_keylist_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35958 : PyObject *obj;
35959 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
35960 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_keylist_result, SWIG_NewClientData(obj));
35961 29 : return SWIG_Py_Void();
35962 : }
35963 :
35964 1 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35965 1 : PyObject *resultobj = 0;
35966 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35967 1 : void *argp1 = 0 ;
35968 1 : int res1 = 0 ;
35969 1 : PyObject * obj0 = 0 ;
35970 : gpgme_keylist_result_t result;
35971 :
35972 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_keylist_result",&obj0)) SWIG_fail;
35973 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
35974 1 : if (!SWIG_IsOK(res1)) {
35975 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35976 : }
35977 1 : arg1 = (gpgme_ctx_t)(argp1);
35978 : {
35979 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35980 1 : result = (gpgme_keylist_result_t)gpgme_op_keylist_result(arg1);
35981 1 : SWIG_PYTHON_THREAD_END_ALLOW;
35982 : }
35983 : {
35984 : PyObject *fragile;
35985 1 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_keylist_result,
35986 : 0 );
35987 1 : resultobj = _gpg_wrap_result(fragile, "KeylistResult");
35988 1 : Py_DECREF(fragile);
35989 : }
35990 : return resultobj;
35991 : fail:
35992 : return NULL;
35993 : }
35994 :
35995 :
35996 0 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_ext_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35997 0 : PyObject *resultobj = 0;
35998 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35999 : char **arg2 ;
36000 : int arg3 ;
36001 : int arg4 ;
36002 0 : void *argp1 = 0 ;
36003 0 : int res1 = 0 ;
36004 0 : void *vector2 = NULL ;
36005 : size_t size2 ;
36006 0 : PyObject **pyVector2 = NULL ;
36007 : int val3 ;
36008 0 : int ecode3 = 0 ;
36009 : int val4 ;
36010 0 : int ecode4 = 0 ;
36011 0 : PyObject * obj0 = 0 ;
36012 0 : PyObject * obj1 = 0 ;
36013 0 : PyObject * obj2 = 0 ;
36014 0 : PyObject * obj3 = 0 ;
36015 : gpgme_error_t result;
36016 :
36017 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_keylist_ext_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36018 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
36019 0 : if (!SWIG_IsOK(res1)) {
36020 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
36021 : }
36022 0 : arg1 = (gpgme_ctx_t)(argp1);
36023 : {
36024 : /* Check if is a list */
36025 0 : if (PyList_Check(obj1)) {
36026 : size_t i, j;
36027 0 : size2 = PyList_Size(obj1);
36028 0 : arg2 = (char **) (vector2 = malloc((size2+1) * sizeof(char *)));
36029 0 : pyVector2 = calloc(sizeof *pyVector2, size2);
36030 :
36031 0 : for (i = 0; i < size2; i++) {
36032 0 : PyObject *o = PyList_GetItem(obj1,i);
36033 0 : if (PyUnicode_Check(o))
36034 : {
36035 0 : pyVector2[i] = PyUnicode_AsUTF8String(o);
36036 0 : if (pyVector2[i] == NULL)
36037 : {
36038 0 : free(vector2);
36039 0 : for (j = 0; j < i; j++)
36040 0 : Py_XDECREF(pyVector2[j]);
36041 : return NULL;
36042 : }
36043 0 : arg2[i] = PyBytes_AsString(pyVector2[i]);
36044 : }
36045 0 : else if (PyString_Check(o))
36046 0 : arg2[i] = PyString_AsString(o);
36047 : else {
36048 0 : PyErr_Format(PyExc_TypeError,
36049 : "arg %d: list must contain only str or bytes, got %s "
36050 : "at position %d",
36051 : 2, o->ob_type->tp_name, i);
36052 0 : free(arg2);
36053 0 : return NULL;
36054 : }
36055 : }
36056 0 : arg2[i] = NULL;
36057 : } else {
36058 0 : PyErr_Format(PyExc_TypeError,
36059 : "arg %d: expected a list of str or bytes, got %s",
36060 : 2, obj1->ob_type->tp_name);
36061 0 : return NULL;
36062 : }
36063 : }
36064 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
36065 0 : if (!SWIG_IsOK(ecode3)) {
36066 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_keylist_ext_start" "', argument " "3"" of type '" "int""'");
36067 : }
36068 0 : arg3 = (int)(val3);
36069 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
36070 0 : if (!SWIG_IsOK(ecode4)) {
36071 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_keylist_ext_start" "', argument " "4"" of type '" "int""'");
36072 : }
36073 0 : arg4 = (int)(val4);
36074 : {
36075 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36076 0 : result = gpgme_op_keylist_ext_start(arg1,(char const *(*))arg2,arg3,arg4);
36077 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36078 : }
36079 : {
36080 0 : resultobj = PyLong_FromLong(result);
36081 : }
36082 : {
36083 : size_t i;
36084 0 : free(vector2);
36085 0 : for (i = 0; i < size2; i++)
36086 0 : Py_XDECREF(pyVector2[i]);
36087 : }
36088 : return resultobj;
36089 : fail:
36090 : {
36091 : size_t i;
36092 0 : free(vector2);
36093 0 : for (i = 0; i < size2; i++)
36094 0 : Py_XDECREF(pyVector2[i]);
36095 : }
36096 : return NULL;
36097 : }
36098 :
36099 :
36100 1 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_from_data_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36101 1 : PyObject *resultobj = 0;
36102 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
36103 1 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
36104 : int arg3 ;
36105 1 : void *argp1 = 0 ;
36106 1 : int res1 = 0 ;
36107 1 : gpgme_data_t wrapper2 = NULL ;
36108 1 : PyObject *bytesio2 = NULL ;
36109 : Py_buffer view2 ;
36110 1 : int have_view2 = 0 ;
36111 : int val3 ;
36112 1 : int ecode3 = 0 ;
36113 1 : PyObject * obj0 = 0 ;
36114 1 : PyObject * obj1 = 0 ;
36115 1 : PyObject * obj2 = 0 ;
36116 : gpgme_error_t result;
36117 :
36118 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_keylist_from_data_start",&obj0,&obj1,&obj2)) SWIG_fail;
36119 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
36120 1 : if (!SWIG_IsOK(res1)) {
36121 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_from_data_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
36122 : }
36123 1 : arg1 = (gpgme_ctx_t)(argp1);
36124 : {
36125 : /* If we create a temporary wrapper2 object, we will store it in
36126 : wrapperN, where N is 2. Here in this fragment, SWIG will
36127 : automatically append 2. */
36128 1 : memset(&view2, 0, sizeof view2);
36129 1 : if (obj1 == Py_None)
36130 0 : arg2 = NULL;
36131 : else {
36132 : PyObject *pypointer;
36133 1 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
36134 : &bytesio2, &view2);
36135 1 : if (pypointer == NULL)
36136 : return NULL;
36137 1 : have_view2 = !! view2.obj;
36138 :
36139 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
36140 :
36141 : /* Following code is from swig's python.swg. */
36142 :
36143 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
36144 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
36145 0 : Py_DECREF(pypointer);
36146 : return NULL;
36147 : }
36148 1 : Py_DECREF(pypointer);
36149 : }
36150 : }
36151 2 : ecode3 = SWIG_AsVal_int(obj2, &val3);
36152 1 : if (!SWIG_IsOK(ecode3)) {
36153 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_keylist_from_data_start" "', argument " "3"" of type '" "int""'");
36154 : }
36155 1 : arg3 = (int)(val3);
36156 : {
36157 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36158 1 : result = gpgme_op_keylist_from_data_start(arg1,arg2,arg3);
36159 1 : SWIG_PYTHON_THREAD_END_ALLOW;
36160 : }
36161 : {
36162 1 : resultobj = PyLong_FromLong(result);
36163 : }
36164 : {
36165 : /* See whether we need to update the Python buffer. */
36166 1 : if (resultobj && wrapper2 && view2.buf)
36167 : {
36168 : int dirty;
36169 0 : char *new_data = NULL;
36170 : size_t new_size;
36171 :
36172 :
36173 0 : new_data = wrapper2->data.mem.buffer;
36174 0 : new_size = wrapper2->data.mem.length;
36175 0 : dirty = new_data != NULL;
36176 :
36177 :
36178 :
36179 :
36180 :
36181 :
36182 :
36183 0 : if (dirty)
36184 : {
36185 : /* The buffer is dirty. */
36186 0 : if (view2.readonly)
36187 : {
36188 0 : Py_XDECREF(resultobj);
36189 0 : resultobj = NULL;
36190 0 : PyErr_SetString(PyExc_ValueError,
36191 : "cannot update read-only buffer");
36192 : }
36193 :
36194 : /* See if we need to truncate the buffer. */
36195 0 : if (resultobj && view2.len != new_size)
36196 : {
36197 0 : if (bytesio2 == NULL)
36198 : {
36199 0 : Py_XDECREF(resultobj);
36200 0 : resultobj = NULL;
36201 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
36202 : }
36203 : else
36204 : {
36205 : PyObject *retval;
36206 0 : PyBuffer_Release(&view2);
36207 : assert(view2.obj == NULL);
36208 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
36209 : "l", (long) new_size);
36210 0 : if (retval == NULL)
36211 : {
36212 0 : Py_XDECREF(resultobj);
36213 : resultobj = NULL;
36214 : }
36215 : else
36216 : {
36217 0 : Py_DECREF(retval);
36218 :
36219 0 : retval = PyObject_CallMethod(bytesio2,
36220 : "getbuffer", NULL);
36221 0 : if (retval == NULL
36222 0 : || PyObject_GetBuffer(retval, &view2,
36223 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
36224 : {
36225 0 : Py_XDECREF(resultobj);
36226 : resultobj = NULL;
36227 : }
36228 :
36229 0 : Py_XDECREF(retval);
36230 :
36231 0 : if (resultobj && view2.len
36232 : != new_size)
36233 : {
36234 0 : Py_XDECREF(resultobj);
36235 0 : resultobj = NULL;
36236 0 : PyErr_Format(PyExc_ValueError,
36237 : "Expected buffer of length %zu, got %zi",
36238 : new_size,
36239 : view2.len);
36240 : }
36241 : }
36242 : }
36243 : }
36244 0 : if (resultobj)
36245 0 : memcpy(view2.buf, new_data, new_size);
36246 : }
36247 :
36248 :
36249 :
36250 : }
36251 :
36252 : /* Free the temporary wrapper, if any. */
36253 1 : if (wrapper2)
36254 0 : gpgme_data_release(wrapper2);
36255 1 : Py_XDECREF (bytesio2);
36256 1 : if (have_view2 && view2.buf)
36257 0 : PyBuffer_Release(&view2);
36258 : }
36259 : return resultobj;
36260 : fail:
36261 : {
36262 : /* See whether we need to update the Python buffer. */
36263 : if (resultobj && wrapper2 && view2.buf)
36264 : {
36265 : int dirty;
36266 : char *new_data = NULL;
36267 : size_t new_size;
36268 :
36269 :
36270 : new_data = wrapper2->data.mem.buffer;
36271 : new_size = wrapper2->data.mem.length;
36272 : dirty = new_data != NULL;
36273 :
36274 :
36275 :
36276 :
36277 :
36278 :
36279 :
36280 : if (dirty)
36281 : {
36282 : /* The buffer is dirty. */
36283 : if (view2.readonly)
36284 : {
36285 : Py_XDECREF(resultobj);
36286 : resultobj = NULL;
36287 : PyErr_SetString(PyExc_ValueError,
36288 : "cannot update read-only buffer");
36289 : }
36290 :
36291 : /* See if we need to truncate the buffer. */
36292 : if (resultobj && view2.len != new_size)
36293 : {
36294 : if (bytesio2 == NULL)
36295 : {
36296 : Py_XDECREF(resultobj);
36297 : resultobj = NULL;
36298 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
36299 : }
36300 : else
36301 : {
36302 : PyObject *retval;
36303 : PyBuffer_Release(&view2);
36304 : assert(view2.obj == NULL);
36305 : retval = PyObject_CallMethod(bytesio2, "truncate",
36306 : "l", (long) new_size);
36307 : if (retval == NULL)
36308 : {
36309 : Py_XDECREF(resultobj);
36310 : resultobj = NULL;
36311 : }
36312 : else
36313 : {
36314 : Py_DECREF(retval);
36315 :
36316 : retval = PyObject_CallMethod(bytesio2,
36317 : "getbuffer", NULL);
36318 : if (retval == NULL
36319 : || PyObject_GetBuffer(retval, &view2,
36320 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
36321 : {
36322 : Py_XDECREF(resultobj);
36323 : resultobj = NULL;
36324 : }
36325 :
36326 : Py_XDECREF(retval);
36327 :
36328 : if (resultobj && view2.len
36329 : != new_size)
36330 : {
36331 : Py_XDECREF(resultobj);
36332 : resultobj = NULL;
36333 : PyErr_Format(PyExc_ValueError,
36334 : "Expected buffer of length %zu, got %zi",
36335 : new_size,
36336 : view2.len);
36337 : }
36338 : }
36339 : }
36340 : }
36341 : if (resultobj)
36342 : memcpy(view2.buf, new_data, new_size);
36343 : }
36344 :
36345 :
36346 :
36347 : }
36348 :
36349 : /* Free the temporary wrapper, if any. */
36350 0 : if (wrapper2)
36351 0 : gpgme_data_release(wrapper2);
36352 0 : Py_XDECREF (bytesio2);
36353 0 : if (have_view2 && view2.buf)
36354 0 : PyBuffer_Release(&view2);
36355 : }
36356 : return NULL;
36357 : }
36358 :
36359 :
36360 149 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36361 149 : PyObject *resultobj = 0;
36362 149 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
36363 149 : gpgme_key_t *arg2 = (gpgme_key_t *) 0 ;
36364 149 : void *argp1 = 0 ;
36365 149 : int res1 = 0 ;
36366 149 : void *argp2 = 0 ;
36367 149 : int res2 = 0 ;
36368 149 : PyObject * obj0 = 0 ;
36369 149 : PyObject * obj1 = 0 ;
36370 : gpgme_error_t result;
36371 :
36372 149 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_keylist_next",&obj0,&obj1)) SWIG_fail;
36373 149 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
36374 149 : if (!SWIG_IsOK(res1)) {
36375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_next" "', argument " "1"" of type '" "gpgme_ctx_t""'");
36376 : }
36377 149 : arg1 = (gpgme_ctx_t)(argp1);
36378 149 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
36379 149 : if (!SWIG_IsOK(res2)) {
36380 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_keylist_next" "', argument " "2"" of type '" "gpgme_key_t *""'");
36381 : }
36382 149 : arg2 = (gpgme_key_t *)(argp2);
36383 : {
36384 149 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36385 149 : result = gpgme_op_keylist_next(arg1,arg2);
36386 149 : SWIG_PYTHON_THREAD_END_ALLOW;
36387 : }
36388 : {
36389 149 : resultobj = PyLong_FromLong(result);
36390 : }
36391 149 : return resultobj;
36392 : fail:
36393 : return NULL;
36394 : }
36395 :
36396 :
36397 20 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36398 20 : PyObject *resultobj = 0;
36399 20 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
36400 20 : void *argp1 = 0 ;
36401 20 : int res1 = 0 ;
36402 20 : PyObject * obj0 = 0 ;
36403 : gpgme_error_t result;
36404 :
36405 20 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_keylist_end",&obj0)) SWIG_fail;
36406 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
36407 20 : if (!SWIG_IsOK(res1)) {
36408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_end" "', argument " "1"" of type '" "gpgme_ctx_t""'");
36409 : }
36410 20 : arg1 = (gpgme_ctx_t)(argp1);
36411 : {
36412 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36413 20 : result = gpgme_op_keylist_end(arg1);
36414 20 : SWIG_PYTHON_THREAD_END_ALLOW;
36415 : }
36416 : {
36417 20 : resultobj = PyLong_FromLong(result);
36418 : }
36419 20 : return resultobj;
36420 : fail:
36421 : return NULL;
36422 : }
36423 :
36424 :
36425 0 : SWIGINTERN PyObject *_wrap_gpgme_op_passwd_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36426 0 : PyObject *resultobj = 0;
36427 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
36428 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
36429 : unsigned int arg3 ;
36430 0 : void *argp1 = 0 ;
36431 0 : int res1 = 0 ;
36432 0 : void *argp2 = 0 ;
36433 0 : int res2 = 0 ;
36434 : unsigned int val3 ;
36435 0 : int ecode3 = 0 ;
36436 0 : PyObject * obj0 = 0 ;
36437 0 : PyObject * obj1 = 0 ;
36438 0 : PyObject * obj2 = 0 ;
36439 : gpgme_error_t result;
36440 :
36441 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_passwd_start",&obj0,&obj1,&obj2)) SWIG_fail;
36442 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
36443 0 : if (!SWIG_IsOK(res1)) {
36444 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_passwd_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
36445 : }
36446 0 : arg1 = (gpgme_ctx_t)(argp1);
36447 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
36448 0 : if (!SWIG_IsOK(res2)) {
36449 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_passwd_start" "', argument " "2"" of type '" "gpgme_key_t""'");
36450 : }
36451 0 : arg2 = (gpgme_key_t)(argp2);
36452 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
36453 0 : if (!SWIG_IsOK(ecode3)) {
36454 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_passwd_start" "', argument " "3"" of type '" "unsigned int""'");
36455 : }
36456 0 : arg3 = (unsigned int)(val3);
36457 : {
36458 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36459 0 : result = gpgme_op_passwd_start(arg1,arg2,arg3);
36460 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36461 : }
36462 : {
36463 0 : resultobj = PyLong_FromLong(result);
36464 : }
36465 0 : return resultobj;
36466 : fail:
36467 : return NULL;
36468 : }
36469 :
36470 :
36471 0 : SWIGINTERN PyObject *_wrap_gpgme_op_passwd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36472 0 : PyObject *resultobj = 0;
36473 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
36474 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
36475 : unsigned int arg3 ;
36476 0 : void *argp1 = 0 ;
36477 0 : int res1 = 0 ;
36478 0 : void *argp2 = 0 ;
36479 0 : int res2 = 0 ;
36480 : unsigned int val3 ;
36481 0 : int ecode3 = 0 ;
36482 0 : PyObject * obj0 = 0 ;
36483 0 : PyObject * obj1 = 0 ;
36484 0 : PyObject * obj2 = 0 ;
36485 : gpgme_error_t result;
36486 :
36487 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_passwd",&obj0,&obj1,&obj2)) SWIG_fail;
36488 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
36489 0 : if (!SWIG_IsOK(res1)) {
36490 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_passwd" "', argument " "1"" of type '" "gpgme_ctx_t""'");
36491 : }
36492 0 : arg1 = (gpgme_ctx_t)(argp1);
36493 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
36494 0 : if (!SWIG_IsOK(res2)) {
36495 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_passwd" "', argument " "2"" of type '" "gpgme_key_t""'");
36496 : }
36497 0 : arg2 = (gpgme_key_t)(argp2);
36498 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
36499 0 : if (!SWIG_IsOK(ecode3)) {
36500 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_passwd" "', argument " "3"" of type '" "unsigned int""'");
36501 : }
36502 0 : arg3 = (unsigned int)(val3);
36503 : {
36504 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36505 0 : result = gpgme_op_passwd(arg1,arg2,arg3);
36506 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36507 : }
36508 : {
36509 0 : resultobj = PyLong_FromLong(result);
36510 : }
36511 0 : return resultobj;
36512 : fail:
36513 : return NULL;
36514 : }
36515 :
36516 :
36517 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__refs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36518 0 : PyObject *resultobj = 0;
36519 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36520 : unsigned int arg2 ;
36521 0 : void *argp1 = 0 ;
36522 0 : int res1 = 0 ;
36523 : unsigned int val2 ;
36524 0 : int ecode2 = 0 ;
36525 0 : PyObject * obj0 = 0 ;
36526 0 : PyObject * obj1 = 0 ;
36527 :
36528 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item__refs_set",&obj0,&obj1)) SWIG_fail;
36529 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36530 0 : if (!SWIG_IsOK(res1)) {
36531 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__refs_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36532 : }
36533 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36534 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
36535 0 : if (!SWIG_IsOK(ecode2)) {
36536 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item__refs_set" "', argument " "2"" of type '" "unsigned int""'");
36537 : }
36538 0 : arg2 = (unsigned int)(val2);
36539 : {
36540 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36541 0 : if (arg1) (arg1)->_refs = arg2;
36542 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36543 : }
36544 0 : resultobj = SWIG_Py_Void();
36545 0 : return resultobj;
36546 : fail:
36547 : return NULL;
36548 : }
36549 :
36550 :
36551 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__refs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36552 0 : PyObject *resultobj = 0;
36553 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36554 0 : void *argp1 = 0 ;
36555 0 : int res1 = 0 ;
36556 0 : PyObject * obj0 = 0 ;
36557 : unsigned int result;
36558 :
36559 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__refs_get",&obj0)) SWIG_fail;
36560 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36561 0 : if (!SWIG_IsOK(res1)) {
36562 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__refs_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36563 : }
36564 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36565 : {
36566 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36567 0 : result = (unsigned int) ((arg1)->_refs);
36568 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36569 : }
36570 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36571 0 : return resultobj;
36572 : fail:
36573 : return NULL;
36574 : }
36575 :
36576 :
36577 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36578 0 : PyObject *resultobj = 0;
36579 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36580 0 : char *arg2 = (char *) 0 ;
36581 0 : void *argp1 = 0 ;
36582 0 : int res1 = 0 ;
36583 : int res2 ;
36584 0 : char *buf2 = 0 ;
36585 0 : int alloc2 = 0 ;
36586 0 : PyObject * obj0 = 0 ;
36587 0 : PyObject * obj1 = 0 ;
36588 :
36589 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_keyid_set",&obj0,&obj1)) SWIG_fail;
36590 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36591 0 : if (!SWIG_IsOK(res1)) {
36592 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_keyid_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36593 : }
36594 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36595 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36596 0 : if (!SWIG_IsOK(res2)) {
36597 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_keyid_set" "', argument " "2"" of type '" "char *""'");
36598 : }
36599 0 : arg2 = (char *)(buf2);
36600 : {
36601 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36602 0 : if (arg1->keyid) free((char*)arg1->keyid);
36603 0 : if (arg2) {
36604 0 : size_t size = strlen((const char *)(arg2)) + 1;
36605 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
36606 : } else {
36607 0 : arg1->keyid = 0;
36608 : }
36609 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36610 : }
36611 0 : resultobj = SWIG_Py_Void();
36612 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36613 : return resultobj;
36614 : fail:
36615 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36616 : return NULL;
36617 : }
36618 :
36619 :
36620 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36621 0 : PyObject *resultobj = 0;
36622 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36623 0 : void *argp1 = 0 ;
36624 0 : int res1 = 0 ;
36625 0 : PyObject * obj0 = 0 ;
36626 0 : char *result = 0 ;
36627 :
36628 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_keyid_get",&obj0)) SWIG_fail;
36629 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36630 0 : if (!SWIG_IsOK(res1)) {
36631 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_keyid_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36632 : }
36633 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36634 : {
36635 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36636 0 : result = (char *) ((arg1)->keyid);
36637 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36638 : }
36639 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36640 0 : return resultobj;
36641 : fail:
36642 : return NULL;
36643 : }
36644 :
36645 :
36646 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36647 0 : PyObject *resultobj = 0;
36648 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36649 : char *arg2 ;
36650 0 : void *argp1 = 0 ;
36651 0 : int res1 = 0 ;
36652 : char temp2[16+1] ;
36653 : int res2 ;
36654 0 : PyObject * obj0 = 0 ;
36655 0 : PyObject * obj1 = 0 ;
36656 :
36657 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item__keyid_set",&obj0,&obj1)) SWIG_fail;
36658 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36659 0 : if (!SWIG_IsOK(res1)) {
36660 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__keyid_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36661 : }
36662 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36663 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
36664 0 : if (!SWIG_IsOK(res2)) {
36665 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
36666 : }
36667 0 : arg2 = (char *)(temp2);
36668 : {
36669 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36670 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
36671 : else memset(arg1->_keyid,0,16+1*sizeof(char));
36672 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36673 : }
36674 0 : resultobj = SWIG_Py_Void();
36675 0 : return resultobj;
36676 : fail:
36677 : return NULL;
36678 : }
36679 :
36680 :
36681 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36682 0 : PyObject *resultobj = 0;
36683 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36684 0 : void *argp1 = 0 ;
36685 0 : int res1 = 0 ;
36686 0 : PyObject * obj0 = 0 ;
36687 0 : char *result = 0 ;
36688 :
36689 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__keyid_get",&obj0)) SWIG_fail;
36690 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36691 0 : if (!SWIG_IsOK(res1)) {
36692 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__keyid_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36693 : }
36694 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36695 : {
36696 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36697 0 : result = (char *)(char *) ((arg1)->_keyid);
36698 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36699 : }
36700 : {
36701 0 : size_t size = SWIG_strnlen(result, 16+1);
36702 :
36703 :
36704 :
36705 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
36706 : }
36707 0 : return resultobj;
36708 : fail:
36709 : return NULL;
36710 : }
36711 :
36712 :
36713 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36714 0 : PyObject *resultobj = 0;
36715 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36716 : int arg2 ;
36717 0 : void *argp1 = 0 ;
36718 0 : int res1 = 0 ;
36719 : int val2 ;
36720 0 : int ecode2 = 0 ;
36721 0 : PyObject * obj0 = 0 ;
36722 0 : PyObject * obj1 = 0 ;
36723 :
36724 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_type_set",&obj0,&obj1)) SWIG_fail;
36725 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36726 0 : if (!SWIG_IsOK(res1)) {
36727 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_type_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36728 : }
36729 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36730 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
36731 0 : if (!SWIG_IsOK(ecode2)) {
36732 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item_type_set" "', argument " "2"" of type '" "int""'");
36733 : }
36734 0 : arg2 = (int)(val2);
36735 : {
36736 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36737 0 : if (arg1) (arg1)->type = arg2;
36738 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36739 : }
36740 0 : resultobj = SWIG_Py_Void();
36741 0 : return resultobj;
36742 : fail:
36743 : return NULL;
36744 : }
36745 :
36746 :
36747 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36748 0 : PyObject *resultobj = 0;
36749 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36750 0 : void *argp1 = 0 ;
36751 0 : int res1 = 0 ;
36752 0 : PyObject * obj0 = 0 ;
36753 : int result;
36754 :
36755 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_type_get",&obj0)) SWIG_fail;
36756 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36757 0 : if (!SWIG_IsOK(res1)) {
36758 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_type_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36759 : }
36760 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36761 : {
36762 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36763 0 : result = (int) ((arg1)->type);
36764 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36765 : }
36766 0 : resultobj = SWIG_From_int((int)(result));
36767 0 : return resultobj;
36768 : fail:
36769 : return NULL;
36770 : }
36771 :
36772 :
36773 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_level_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36774 0 : PyObject *resultobj = 0;
36775 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36776 : int arg2 ;
36777 0 : void *argp1 = 0 ;
36778 0 : int res1 = 0 ;
36779 : int val2 ;
36780 0 : int ecode2 = 0 ;
36781 0 : PyObject * obj0 = 0 ;
36782 0 : PyObject * obj1 = 0 ;
36783 :
36784 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_level_set",&obj0,&obj1)) SWIG_fail;
36785 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36786 0 : if (!SWIG_IsOK(res1)) {
36787 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_level_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36788 : }
36789 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36790 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
36791 0 : if (!SWIG_IsOK(ecode2)) {
36792 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item_level_set" "', argument " "2"" of type '" "int""'");
36793 : }
36794 0 : arg2 = (int)(val2);
36795 : {
36796 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36797 0 : if (arg1) (arg1)->level = arg2;
36798 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36799 : }
36800 0 : resultobj = SWIG_Py_Void();
36801 0 : return resultobj;
36802 : fail:
36803 : return NULL;
36804 : }
36805 :
36806 :
36807 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_level_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36808 0 : PyObject *resultobj = 0;
36809 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36810 0 : void *argp1 = 0 ;
36811 0 : int res1 = 0 ;
36812 0 : PyObject * obj0 = 0 ;
36813 : int result;
36814 :
36815 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_level_get",&obj0)) SWIG_fail;
36816 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36817 0 : if (!SWIG_IsOK(res1)) {
36818 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_level_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36819 : }
36820 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36821 : {
36822 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36823 0 : result = (int) ((arg1)->level);
36824 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36825 : }
36826 0 : resultobj = SWIG_From_int((int)(result));
36827 0 : return resultobj;
36828 : fail:
36829 : return NULL;
36830 : }
36831 :
36832 :
36833 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_owner_trust_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36834 0 : PyObject *resultobj = 0;
36835 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36836 0 : char *arg2 = (char *) 0 ;
36837 0 : void *argp1 = 0 ;
36838 0 : int res1 = 0 ;
36839 : int res2 ;
36840 0 : char *buf2 = 0 ;
36841 0 : int alloc2 = 0 ;
36842 0 : PyObject * obj0 = 0 ;
36843 0 : PyObject * obj1 = 0 ;
36844 :
36845 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_owner_trust_set",&obj0,&obj1)) SWIG_fail;
36846 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36847 0 : if (!SWIG_IsOK(res1)) {
36848 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36849 : }
36850 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36851 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36852 0 : if (!SWIG_IsOK(res2)) {
36853 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_owner_trust_set" "', argument " "2"" of type '" "char *""'");
36854 : }
36855 0 : arg2 = (char *)(buf2);
36856 : {
36857 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36858 0 : if (arg1->owner_trust) free((char*)arg1->owner_trust);
36859 0 : if (arg2) {
36860 0 : size_t size = strlen((const char *)(arg2)) + 1;
36861 0 : arg1->owner_trust = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
36862 : } else {
36863 0 : arg1->owner_trust = 0;
36864 : }
36865 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36866 : }
36867 0 : resultobj = SWIG_Py_Void();
36868 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36869 : return resultobj;
36870 : fail:
36871 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36872 : return NULL;
36873 : }
36874 :
36875 :
36876 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_owner_trust_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36877 0 : PyObject *resultobj = 0;
36878 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36879 0 : void *argp1 = 0 ;
36880 0 : int res1 = 0 ;
36881 0 : PyObject * obj0 = 0 ;
36882 0 : char *result = 0 ;
36883 :
36884 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_owner_trust_get",&obj0)) SWIG_fail;
36885 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36886 0 : if (!SWIG_IsOK(res1)) {
36887 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36888 : }
36889 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36890 : {
36891 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36892 0 : result = (char *) ((arg1)->owner_trust);
36893 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36894 : }
36895 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36896 0 : return resultobj;
36897 : fail:
36898 : return NULL;
36899 : }
36900 :
36901 :
36902 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__owner_trust_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36903 0 : PyObject *resultobj = 0;
36904 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36905 : char *arg2 ;
36906 0 : void *argp1 = 0 ;
36907 0 : int res1 = 0 ;
36908 : char temp2[2] ;
36909 : int res2 ;
36910 0 : PyObject * obj0 = 0 ;
36911 0 : PyObject * obj1 = 0 ;
36912 :
36913 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item__owner_trust_set",&obj0,&obj1)) SWIG_fail;
36914 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36915 0 : if (!SWIG_IsOK(res1)) {
36916 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36917 : }
36918 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36919 0 : res2 = SWIG_AsCharArray(obj1, temp2, 2);
36920 0 : if (!SWIG_IsOK(res2)) {
36921 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__owner_trust_set" "', argument " "2"" of type '" "char [2]""'");
36922 : }
36923 0 : arg2 = (char *)(temp2);
36924 : {
36925 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36926 0 : if (arg2) memcpy(arg1->_owner_trust,arg2,2*sizeof(char));
36927 : else memset(arg1->_owner_trust,0,2*sizeof(char));
36928 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36929 : }
36930 0 : resultobj = SWIG_Py_Void();
36931 0 : return resultobj;
36932 : fail:
36933 : return NULL;
36934 : }
36935 :
36936 :
36937 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__owner_trust_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36938 0 : PyObject *resultobj = 0;
36939 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36940 0 : void *argp1 = 0 ;
36941 0 : int res1 = 0 ;
36942 0 : PyObject * obj0 = 0 ;
36943 0 : char *result = 0 ;
36944 :
36945 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__owner_trust_get",&obj0)) SWIG_fail;
36946 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36947 0 : if (!SWIG_IsOK(res1)) {
36948 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36949 : }
36950 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36951 : {
36952 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36953 0 : result = (char *)(char *) ((arg1)->_owner_trust);
36954 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36955 : }
36956 : {
36957 0 : size_t size = SWIG_strnlen(result, 2);
36958 :
36959 :
36960 :
36961 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
36962 : }
36963 0 : return resultobj;
36964 : fail:
36965 : return NULL;
36966 : }
36967 :
36968 :
36969 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36970 0 : PyObject *resultobj = 0;
36971 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
36972 0 : char *arg2 = (char *) 0 ;
36973 0 : void *argp1 = 0 ;
36974 0 : int res1 = 0 ;
36975 : int res2 ;
36976 0 : char *buf2 = 0 ;
36977 0 : int alloc2 = 0 ;
36978 0 : PyObject * obj0 = 0 ;
36979 0 : PyObject * obj1 = 0 ;
36980 :
36981 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_validity_set",&obj0,&obj1)) SWIG_fail;
36982 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
36983 0 : if (!SWIG_IsOK(res1)) {
36984 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_validity_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
36985 : }
36986 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
36987 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36988 0 : if (!SWIG_IsOK(res2)) {
36989 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_validity_set" "', argument " "2"" of type '" "char *""'");
36990 : }
36991 0 : arg2 = (char *)(buf2);
36992 : {
36993 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36994 0 : if (arg1->validity) free((char*)arg1->validity);
36995 0 : if (arg2) {
36996 0 : size_t size = strlen((const char *)(arg2)) + 1;
36997 0 : arg1->validity = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
36998 : } else {
36999 0 : arg1->validity = 0;
37000 : }
37001 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37002 : }
37003 0 : resultobj = SWIG_Py_Void();
37004 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
37005 : return resultobj;
37006 : fail:
37007 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
37008 : return NULL;
37009 : }
37010 :
37011 :
37012 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37013 0 : PyObject *resultobj = 0;
37014 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
37015 0 : void *argp1 = 0 ;
37016 0 : int res1 = 0 ;
37017 0 : PyObject * obj0 = 0 ;
37018 0 : char *result = 0 ;
37019 :
37020 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_validity_get",&obj0)) SWIG_fail;
37021 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37022 0 : if (!SWIG_IsOK(res1)) {
37023 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_validity_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
37024 : }
37025 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
37026 : {
37027 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37028 0 : result = (char *) ((arg1)->validity);
37029 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37030 : }
37031 0 : resultobj = SWIG_FromCharPtr((const char *)result);
37032 0 : return resultobj;
37033 : fail:
37034 : return NULL;
37035 : }
37036 :
37037 :
37038 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37039 0 : PyObject *resultobj = 0;
37040 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
37041 : char *arg2 ;
37042 0 : void *argp1 = 0 ;
37043 0 : int res1 = 0 ;
37044 : char temp2[2] ;
37045 : int res2 ;
37046 0 : PyObject * obj0 = 0 ;
37047 0 : PyObject * obj1 = 0 ;
37048 :
37049 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item__validity_set",&obj0,&obj1)) SWIG_fail;
37050 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37051 0 : if (!SWIG_IsOK(res1)) {
37052 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__validity_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
37053 : }
37054 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
37055 0 : res2 = SWIG_AsCharArray(obj1, temp2, 2);
37056 0 : if (!SWIG_IsOK(res2)) {
37057 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__validity_set" "', argument " "2"" of type '" "char [2]""'");
37058 : }
37059 0 : arg2 = (char *)(temp2);
37060 : {
37061 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37062 0 : if (arg2) memcpy(arg1->_validity,arg2,2*sizeof(char));
37063 : else memset(arg1->_validity,0,2*sizeof(char));
37064 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37065 : }
37066 0 : resultobj = SWIG_Py_Void();
37067 0 : return resultobj;
37068 : fail:
37069 : return NULL;
37070 : }
37071 :
37072 :
37073 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37074 0 : PyObject *resultobj = 0;
37075 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
37076 0 : void *argp1 = 0 ;
37077 0 : int res1 = 0 ;
37078 0 : PyObject * obj0 = 0 ;
37079 0 : char *result = 0 ;
37080 :
37081 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__validity_get",&obj0)) SWIG_fail;
37082 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37083 0 : if (!SWIG_IsOK(res1)) {
37084 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__validity_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
37085 : }
37086 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
37087 : {
37088 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37089 0 : result = (char *)(char *) ((arg1)->_validity);
37090 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37091 : }
37092 : {
37093 0 : size_t size = SWIG_strnlen(result, 2);
37094 :
37095 :
37096 :
37097 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
37098 : }
37099 0 : return resultobj;
37100 : fail:
37101 : return NULL;
37102 : }
37103 :
37104 :
37105 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37106 0 : PyObject *resultobj = 0;
37107 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
37108 0 : char *arg2 = (char *) 0 ;
37109 0 : void *argp1 = 0 ;
37110 0 : int res1 = 0 ;
37111 : int res2 ;
37112 0 : char *buf2 = 0 ;
37113 0 : int alloc2 = 0 ;
37114 0 : PyObject * obj0 = 0 ;
37115 0 : PyObject * obj1 = 0 ;
37116 :
37117 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_name_set",&obj0,&obj1)) SWIG_fail;
37118 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37119 0 : if (!SWIG_IsOK(res1)) {
37120 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_name_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
37121 : }
37122 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
37123 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
37124 0 : if (!SWIG_IsOK(res2)) {
37125 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_name_set" "', argument " "2"" of type '" "char *""'");
37126 : }
37127 0 : arg2 = (char *)(buf2);
37128 : {
37129 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37130 0 : if (arg1->name) free((char*)arg1->name);
37131 0 : if (arg2) {
37132 0 : size_t size = strlen((const char *)(arg2)) + 1;
37133 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
37134 : } else {
37135 0 : arg1->name = 0;
37136 : }
37137 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37138 : }
37139 0 : resultobj = SWIG_Py_Void();
37140 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
37141 : return resultobj;
37142 : fail:
37143 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
37144 : return NULL;
37145 : }
37146 :
37147 :
37148 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37149 0 : PyObject *resultobj = 0;
37150 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
37151 0 : void *argp1 = 0 ;
37152 0 : int res1 = 0 ;
37153 0 : PyObject * obj0 = 0 ;
37154 0 : char *result = 0 ;
37155 :
37156 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_name_get",&obj0)) SWIG_fail;
37157 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37158 0 : if (!SWIG_IsOK(res1)) {
37159 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_name_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
37160 : }
37161 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
37162 : {
37163 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37164 0 : result = (char *) ((arg1)->name);
37165 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37166 : }
37167 0 : resultobj = SWIG_FromCharPtr((const char *)result);
37168 0 : return resultobj;
37169 : fail:
37170 : return NULL;
37171 : }
37172 :
37173 :
37174 0 : SWIGINTERN PyObject *_wrap_new__gpgme_trust_item(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37175 0 : PyObject *resultobj = 0;
37176 0 : struct _gpgme_trust_item *result = 0 ;
37177 :
37178 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_trust_item")) SWIG_fail;
37179 : {
37180 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37181 0 : result = (struct _gpgme_trust_item *)calloc(1, sizeof(struct _gpgme_trust_item));
37182 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37183 : }
37184 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_trust_item, SWIG_POINTER_NEW | 0 );
37185 0 : return resultobj;
37186 : fail:
37187 : return NULL;
37188 : }
37189 :
37190 :
37191 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_trust_item(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37192 0 : PyObject *resultobj = 0;
37193 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
37194 0 : void *argp1 = 0 ;
37195 0 : int res1 = 0 ;
37196 0 : PyObject * obj0 = 0 ;
37197 :
37198 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_trust_item",&obj0)) SWIG_fail;
37199 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, SWIG_POINTER_DISOWN | 0 );
37200 0 : if (!SWIG_IsOK(res1)) {
37201 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_trust_item" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
37202 : }
37203 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
37204 : {
37205 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37206 0 : free((char *) arg1);
37207 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37208 : }
37209 0 : resultobj = SWIG_Py_Void();
37210 0 : return resultobj;
37211 : fail:
37212 : return NULL;
37213 : }
37214 :
37215 :
37216 29 : SWIGINTERN PyObject *_gpgme_trust_item_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37217 : PyObject *obj;
37218 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
37219 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_trust_item, SWIG_NewClientData(obj));
37220 29 : return SWIG_Py_Void();
37221 : }
37222 :
37223 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37224 2 : PyObject *resultobj = 0;
37225 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37226 2 : char *arg2 = (char *) 0 ;
37227 : int arg3 ;
37228 2 : void *argp1 = 0 ;
37229 2 : int res1 = 0 ;
37230 2 : PyObject *encodedInput2 = NULL ;
37231 : int val3 ;
37232 2 : int ecode3 = 0 ;
37233 2 : PyObject * obj0 = 0 ;
37234 2 : PyObject * obj1 = 0 ;
37235 2 : PyObject * obj2 = 0 ;
37236 : gpgme_error_t result;
37237 :
37238 2 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_trustlist_start",&obj0,&obj1,&obj2)) SWIG_fail;
37239 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37240 2 : if (!SWIG_IsOK(res1)) {
37241 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37242 : }
37243 2 : arg1 = (gpgme_ctx_t)(argp1);
37244 : {
37245 2 : if (obj1 == Py_None)
37246 : arg2 = NULL;
37247 2 : else if (PyUnicode_Check(obj1))
37248 : {
37249 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
37250 2 : if (encodedInput2 == NULL)
37251 : return NULL;
37252 2 : arg2 = PyBytes_AsString(encodedInput2);
37253 : }
37254 0 : else if (PyBytes_Check(obj1))
37255 0 : arg2 = PyBytes_AsString(obj1);
37256 : else {
37257 0 : PyErr_Format(PyExc_TypeError,
37258 : "arg %d: expected str, bytes, or None, got %s",
37259 : 2, obj1->ob_type->tp_name);
37260 0 : return NULL;
37261 : }
37262 : }
37263 4 : ecode3 = SWIG_AsVal_int(obj2, &val3);
37264 2 : if (!SWIG_IsOK(ecode3)) {
37265 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_trustlist_start" "', argument " "3"" of type '" "int""'");
37266 : }
37267 2 : arg3 = (int)(val3);
37268 : {
37269 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37270 2 : result = gpgme_op_trustlist_start(arg1,(char const *)arg2,arg3);
37271 2 : SWIG_PYTHON_THREAD_END_ALLOW;
37272 : }
37273 : {
37274 2 : resultobj = PyLong_FromLong(result);
37275 : }
37276 : {
37277 2 : Py_XDECREF(encodedInput2);
37278 : }
37279 : return resultobj;
37280 : fail:
37281 : {
37282 0 : Py_XDECREF(encodedInput2);
37283 : }
37284 : return NULL;
37285 : }
37286 :
37287 :
37288 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37289 2 : PyObject *resultobj = 0;
37290 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37291 2 : gpgme_trust_item_t *arg2 = (gpgme_trust_item_t *) 0 ;
37292 2 : void *argp1 = 0 ;
37293 2 : int res1 = 0 ;
37294 2 : void *argp2 = 0 ;
37295 2 : int res2 = 0 ;
37296 2 : PyObject * obj0 = 0 ;
37297 2 : PyObject * obj1 = 0 ;
37298 : gpgme_error_t result;
37299 :
37300 2 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_trustlist_next",&obj0,&obj1)) SWIG_fail;
37301 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37302 2 : if (!SWIG_IsOK(res1)) {
37303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_next" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37304 : }
37305 2 : arg1 = (gpgme_ctx_t)(argp1);
37306 2 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
37307 2 : if (!SWIG_IsOK(res2)) {
37308 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_trustlist_next" "', argument " "2"" of type '" "gpgme_trust_item_t *""'");
37309 : }
37310 2 : arg2 = (gpgme_trust_item_t *)(argp2);
37311 : {
37312 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37313 2 : result = gpgme_op_trustlist_next(arg1,arg2);
37314 2 : SWIG_PYTHON_THREAD_END_ALLOW;
37315 : }
37316 : {
37317 2 : resultobj = PyLong_FromLong(result);
37318 : }
37319 2 : return resultobj;
37320 : fail:
37321 : return NULL;
37322 : }
37323 :
37324 :
37325 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37326 2 : PyObject *resultobj = 0;
37327 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37328 2 : void *argp1 = 0 ;
37329 2 : int res1 = 0 ;
37330 2 : PyObject * obj0 = 0 ;
37331 : gpgme_error_t result;
37332 :
37333 2 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_trustlist_end",&obj0)) SWIG_fail;
37334 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37335 2 : if (!SWIG_IsOK(res1)) {
37336 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_end" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37337 : }
37338 2 : arg1 = (gpgme_ctx_t)(argp1);
37339 : {
37340 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37341 2 : result = gpgme_op_trustlist_end(arg1);
37342 2 : SWIG_PYTHON_THREAD_END_ALLOW;
37343 : }
37344 : {
37345 2 : resultobj = PyLong_FromLong(result);
37346 : }
37347 2 : return resultobj;
37348 : fail:
37349 : return NULL;
37350 : }
37351 :
37352 :
37353 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37354 0 : PyObject *resultobj = 0;
37355 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
37356 0 : void *argp1 = 0 ;
37357 0 : int res1 = 0 ;
37358 0 : PyObject * obj0 = 0 ;
37359 :
37360 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_ref",&obj0)) SWIG_fail;
37361 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37362 0 : if (!SWIG_IsOK(res1)) {
37363 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_ref" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
37364 : }
37365 0 : arg1 = (gpgme_trust_item_t)(argp1);
37366 : {
37367 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37368 0 : gpgme_trust_item_ref(arg1);
37369 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37370 : }
37371 0 : resultobj = SWIG_Py_Void();
37372 0 : return resultobj;
37373 : fail:
37374 : return NULL;
37375 : }
37376 :
37377 :
37378 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_unref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37379 0 : PyObject *resultobj = 0;
37380 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
37381 0 : void *argp1 = 0 ;
37382 0 : int res1 = 0 ;
37383 0 : PyObject * obj0 = 0 ;
37384 :
37385 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_unref",&obj0)) SWIG_fail;
37386 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37387 0 : if (!SWIG_IsOK(res1)) {
37388 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_unref" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
37389 : }
37390 0 : arg1 = (gpgme_trust_item_t)(argp1);
37391 : {
37392 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37393 0 : gpgme_trust_item_unref(arg1);
37394 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37395 : }
37396 0 : resultobj = SWIG_Py_Void();
37397 0 : return resultobj;
37398 : fail:
37399 : return NULL;
37400 : }
37401 :
37402 :
37403 0 : SWIGINTERN PyObject *_wrap_gpgme_op_getauditlog_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37404 0 : PyObject *resultobj = 0;
37405 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37406 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
37407 : unsigned int arg3 ;
37408 0 : void *argp1 = 0 ;
37409 0 : int res1 = 0 ;
37410 0 : void *argp2 = 0 ;
37411 0 : int res2 = 0 ;
37412 : unsigned int val3 ;
37413 0 : int ecode3 = 0 ;
37414 0 : PyObject * obj0 = 0 ;
37415 0 : PyObject * obj1 = 0 ;
37416 0 : PyObject * obj2 = 0 ;
37417 : gpgme_error_t result;
37418 :
37419 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_getauditlog_start",&obj0,&obj1,&obj2)) SWIG_fail;
37420 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37421 0 : if (!SWIG_IsOK(res1)) {
37422 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_getauditlog_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37423 : }
37424 0 : arg1 = (gpgme_ctx_t)(argp1);
37425 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
37426 0 : if (!SWIG_IsOK(res2)) {
37427 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_getauditlog_start" "', argument " "2"" of type '" "gpgme_data_t""'");
37428 : }
37429 0 : arg2 = (gpgme_data_t)(argp2);
37430 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
37431 0 : if (!SWIG_IsOK(ecode3)) {
37432 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_getauditlog_start" "', argument " "3"" of type '" "unsigned int""'");
37433 : }
37434 0 : arg3 = (unsigned int)(val3);
37435 : {
37436 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37437 0 : result = gpgme_op_getauditlog_start(arg1,arg2,arg3);
37438 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37439 : }
37440 : {
37441 0 : resultobj = PyLong_FromLong(result);
37442 : }
37443 0 : return resultobj;
37444 : fail:
37445 : return NULL;
37446 : }
37447 :
37448 :
37449 0 : SWIGINTERN PyObject *_wrap_gpgme_op_getauditlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37450 0 : PyObject *resultobj = 0;
37451 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37452 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
37453 : unsigned int arg3 ;
37454 0 : void *argp1 = 0 ;
37455 0 : int res1 = 0 ;
37456 0 : void *argp2 = 0 ;
37457 0 : int res2 = 0 ;
37458 : unsigned int val3 ;
37459 0 : int ecode3 = 0 ;
37460 0 : PyObject * obj0 = 0 ;
37461 0 : PyObject * obj1 = 0 ;
37462 0 : PyObject * obj2 = 0 ;
37463 : gpgme_error_t result;
37464 :
37465 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_getauditlog",&obj0,&obj1,&obj2)) SWIG_fail;
37466 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37467 0 : if (!SWIG_IsOK(res1)) {
37468 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_getauditlog" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37469 : }
37470 0 : arg1 = (gpgme_ctx_t)(argp1);
37471 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
37472 0 : if (!SWIG_IsOK(res2)) {
37473 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_getauditlog" "', argument " "2"" of type '" "gpgme_data_t""'");
37474 : }
37475 0 : arg2 = (gpgme_data_t)(argp2);
37476 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
37477 0 : if (!SWIG_IsOK(ecode3)) {
37478 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_getauditlog" "', argument " "3"" of type '" "unsigned int""'");
37479 : }
37480 0 : arg3 = (unsigned int)(val3);
37481 : {
37482 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37483 0 : result = gpgme_op_getauditlog(arg1,arg2,arg3);
37484 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37485 : }
37486 : {
37487 0 : resultobj = PyLong_FromLong(result);
37488 : }
37489 0 : return resultobj;
37490 : fail:
37491 : return NULL;
37492 : }
37493 :
37494 :
37495 0 : SWIGINTERN PyObject *_wrap_gpgme_op_spawn_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37496 0 : PyObject *resultobj = 0;
37497 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37498 0 : char *arg2 = (char *) 0 ;
37499 : char **arg3 ;
37500 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
37501 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
37502 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
37503 : unsigned int arg7 ;
37504 0 : void *argp1 = 0 ;
37505 0 : int res1 = 0 ;
37506 0 : PyObject *encodedInput2 = NULL ;
37507 0 : void *vector3 = NULL ;
37508 : size_t size3 ;
37509 0 : PyObject **pyVector3 = NULL ;
37510 0 : void *argp4 = 0 ;
37511 0 : int res4 = 0 ;
37512 0 : void *argp5 = 0 ;
37513 0 : int res5 = 0 ;
37514 0 : void *argp6 = 0 ;
37515 0 : int res6 = 0 ;
37516 : unsigned int val7 ;
37517 0 : int ecode7 = 0 ;
37518 0 : PyObject * obj0 = 0 ;
37519 0 : PyObject * obj1 = 0 ;
37520 0 : PyObject * obj2 = 0 ;
37521 0 : PyObject * obj3 = 0 ;
37522 0 : PyObject * obj4 = 0 ;
37523 0 : PyObject * obj5 = 0 ;
37524 0 : PyObject * obj6 = 0 ;
37525 : gpgme_error_t result;
37526 :
37527 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_spawn_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
37528 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37529 0 : if (!SWIG_IsOK(res1)) {
37530 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_spawn_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37531 : }
37532 0 : arg1 = (gpgme_ctx_t)(argp1);
37533 : {
37534 0 : if (obj1 == Py_None)
37535 : arg2 = NULL;
37536 0 : else if (PyUnicode_Check(obj1))
37537 : {
37538 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
37539 0 : if (encodedInput2 == NULL)
37540 : return NULL;
37541 0 : arg2 = PyBytes_AsString(encodedInput2);
37542 : }
37543 0 : else if (PyBytes_Check(obj1))
37544 0 : arg2 = PyBytes_AsString(obj1);
37545 : else {
37546 0 : PyErr_Format(PyExc_TypeError,
37547 : "arg %d: expected str, bytes, or None, got %s",
37548 : 2, obj1->ob_type->tp_name);
37549 0 : return NULL;
37550 : }
37551 : }
37552 : {
37553 : /* Check if is a list */
37554 0 : if (PyList_Check(obj2)) {
37555 : size_t i, j;
37556 0 : size3 = PyList_Size(obj2);
37557 0 : arg3 = (char **) (vector3 = malloc((size3+1) * sizeof(char *)));
37558 0 : pyVector3 = calloc(sizeof *pyVector3, size3);
37559 :
37560 0 : for (i = 0; i < size3; i++) {
37561 0 : PyObject *o = PyList_GetItem(obj2,i);
37562 0 : if (PyUnicode_Check(o))
37563 : {
37564 0 : pyVector3[i] = PyUnicode_AsUTF8String(o);
37565 0 : if (pyVector3[i] == NULL)
37566 : {
37567 0 : free(vector3);
37568 0 : for (j = 0; j < i; j++)
37569 0 : Py_XDECREF(pyVector3[j]);
37570 : return NULL;
37571 : }
37572 0 : arg3[i] = PyBytes_AsString(pyVector3[i]);
37573 : }
37574 0 : else if (PyString_Check(o))
37575 0 : arg3[i] = PyString_AsString(o);
37576 : else {
37577 0 : PyErr_Format(PyExc_TypeError,
37578 : "arg %d: list must contain only str or bytes, got %s "
37579 : "at position %d",
37580 : 3, o->ob_type->tp_name, i);
37581 0 : free(arg3);
37582 0 : return NULL;
37583 : }
37584 : }
37585 0 : arg3[i] = NULL;
37586 : } else {
37587 0 : PyErr_Format(PyExc_TypeError,
37588 : "arg %d: expected a list of str or bytes, got %s",
37589 : 3, obj2->ob_type->tp_name);
37590 0 : return NULL;
37591 : }
37592 : }
37593 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_gpgme_data, 0 | 0 );
37594 0 : if (!SWIG_IsOK(res4)) {
37595 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_spawn_start" "', argument " "4"" of type '" "gpgme_data_t""'");
37596 : }
37597 0 : arg4 = (gpgme_data_t)(argp4);
37598 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpgme_data, 0 | 0 );
37599 0 : if (!SWIG_IsOK(res5)) {
37600 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_spawn_start" "', argument " "5"" of type '" "gpgme_data_t""'");
37601 : }
37602 0 : arg5 = (gpgme_data_t)(argp5);
37603 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_gpgme_data, 0 | 0 );
37604 0 : if (!SWIG_IsOK(res6)) {
37605 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_spawn_start" "', argument " "6"" of type '" "gpgme_data_t""'");
37606 : }
37607 0 : arg6 = (gpgme_data_t)(argp6);
37608 0 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
37609 0 : if (!SWIG_IsOK(ecode7)) {
37610 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_spawn_start" "', argument " "7"" of type '" "unsigned int""'");
37611 : }
37612 0 : arg7 = (unsigned int)(val7);
37613 : {
37614 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37615 0 : result = gpgme_op_spawn_start(arg1,(char const *)arg2,(char const *(*))arg3,arg4,arg5,arg6,arg7);
37616 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37617 : }
37618 : {
37619 0 : resultobj = PyLong_FromLong(result);
37620 : }
37621 : {
37622 0 : Py_XDECREF(encodedInput2);
37623 : }
37624 : {
37625 : size_t i;
37626 0 : free(vector3);
37627 0 : for (i = 0; i < size3; i++)
37628 0 : Py_XDECREF(pyVector3[i]);
37629 : }
37630 : return resultobj;
37631 : fail:
37632 : {
37633 0 : Py_XDECREF(encodedInput2);
37634 : }
37635 : {
37636 : size_t i;
37637 0 : free(vector3);
37638 0 : for (i = 0; i < size3; i++)
37639 0 : Py_XDECREF(pyVector3[i]);
37640 : }
37641 : return NULL;
37642 : }
37643 :
37644 :
37645 0 : SWIGINTERN PyObject *_wrap_gpgme_op_spawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37646 0 : PyObject *resultobj = 0;
37647 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37648 0 : char *arg2 = (char *) 0 ;
37649 : char **arg3 ;
37650 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
37651 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
37652 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
37653 : unsigned int arg7 ;
37654 0 : void *argp1 = 0 ;
37655 0 : int res1 = 0 ;
37656 0 : PyObject *encodedInput2 = NULL ;
37657 0 : void *vector3 = NULL ;
37658 : size_t size3 ;
37659 0 : PyObject **pyVector3 = NULL ;
37660 0 : void *argp4 = 0 ;
37661 0 : int res4 = 0 ;
37662 0 : void *argp5 = 0 ;
37663 0 : int res5 = 0 ;
37664 0 : void *argp6 = 0 ;
37665 0 : int res6 = 0 ;
37666 : unsigned int val7 ;
37667 0 : int ecode7 = 0 ;
37668 0 : PyObject * obj0 = 0 ;
37669 0 : PyObject * obj1 = 0 ;
37670 0 : PyObject * obj2 = 0 ;
37671 0 : PyObject * obj3 = 0 ;
37672 0 : PyObject * obj4 = 0 ;
37673 0 : PyObject * obj5 = 0 ;
37674 0 : PyObject * obj6 = 0 ;
37675 : gpgme_error_t result;
37676 :
37677 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_spawn",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
37678 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37679 0 : if (!SWIG_IsOK(res1)) {
37680 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_spawn" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37681 : }
37682 0 : arg1 = (gpgme_ctx_t)(argp1);
37683 : {
37684 0 : if (obj1 == Py_None)
37685 : arg2 = NULL;
37686 0 : else if (PyUnicode_Check(obj1))
37687 : {
37688 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
37689 0 : if (encodedInput2 == NULL)
37690 : return NULL;
37691 0 : arg2 = PyBytes_AsString(encodedInput2);
37692 : }
37693 0 : else if (PyBytes_Check(obj1))
37694 0 : arg2 = PyBytes_AsString(obj1);
37695 : else {
37696 0 : PyErr_Format(PyExc_TypeError,
37697 : "arg %d: expected str, bytes, or None, got %s",
37698 : 2, obj1->ob_type->tp_name);
37699 0 : return NULL;
37700 : }
37701 : }
37702 : {
37703 : /* Check if is a list */
37704 0 : if (PyList_Check(obj2)) {
37705 : size_t i, j;
37706 0 : size3 = PyList_Size(obj2);
37707 0 : arg3 = (char **) (vector3 = malloc((size3+1) * sizeof(char *)));
37708 0 : pyVector3 = calloc(sizeof *pyVector3, size3);
37709 :
37710 0 : for (i = 0; i < size3; i++) {
37711 0 : PyObject *o = PyList_GetItem(obj2,i);
37712 0 : if (PyUnicode_Check(o))
37713 : {
37714 0 : pyVector3[i] = PyUnicode_AsUTF8String(o);
37715 0 : if (pyVector3[i] == NULL)
37716 : {
37717 0 : free(vector3);
37718 0 : for (j = 0; j < i; j++)
37719 0 : Py_XDECREF(pyVector3[j]);
37720 : return NULL;
37721 : }
37722 0 : arg3[i] = PyBytes_AsString(pyVector3[i]);
37723 : }
37724 0 : else if (PyString_Check(o))
37725 0 : arg3[i] = PyString_AsString(o);
37726 : else {
37727 0 : PyErr_Format(PyExc_TypeError,
37728 : "arg %d: list must contain only str or bytes, got %s "
37729 : "at position %d",
37730 : 3, o->ob_type->tp_name, i);
37731 0 : free(arg3);
37732 0 : return NULL;
37733 : }
37734 : }
37735 0 : arg3[i] = NULL;
37736 : } else {
37737 0 : PyErr_Format(PyExc_TypeError,
37738 : "arg %d: expected a list of str or bytes, got %s",
37739 : 3, obj2->ob_type->tp_name);
37740 0 : return NULL;
37741 : }
37742 : }
37743 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_gpgme_data, 0 | 0 );
37744 0 : if (!SWIG_IsOK(res4)) {
37745 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_spawn" "', argument " "4"" of type '" "gpgme_data_t""'");
37746 : }
37747 0 : arg4 = (gpgme_data_t)(argp4);
37748 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpgme_data, 0 | 0 );
37749 0 : if (!SWIG_IsOK(res5)) {
37750 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_spawn" "', argument " "5"" of type '" "gpgme_data_t""'");
37751 : }
37752 0 : arg5 = (gpgme_data_t)(argp5);
37753 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_gpgme_data, 0 | 0 );
37754 0 : if (!SWIG_IsOK(res6)) {
37755 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_spawn" "', argument " "6"" of type '" "gpgme_data_t""'");
37756 : }
37757 0 : arg6 = (gpgme_data_t)(argp6);
37758 0 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
37759 0 : if (!SWIG_IsOK(ecode7)) {
37760 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_spawn" "', argument " "7"" of type '" "unsigned int""'");
37761 : }
37762 0 : arg7 = (unsigned int)(val7);
37763 : {
37764 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37765 0 : result = gpgme_op_spawn(arg1,(char const *)arg2,(char const *(*))arg3,arg4,arg5,arg6,arg7);
37766 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37767 : }
37768 : {
37769 0 : resultobj = PyLong_FromLong(result);
37770 : }
37771 : {
37772 0 : Py_XDECREF(encodedInput2);
37773 : }
37774 : {
37775 : size_t i;
37776 0 : free(vector3);
37777 0 : for (i = 0; i < size3; i++)
37778 0 : Py_XDECREF(pyVector3[i]);
37779 : }
37780 : return resultobj;
37781 : fail:
37782 : {
37783 0 : Py_XDECREF(encodedInput2);
37784 : }
37785 : {
37786 : size_t i;
37787 0 : free(vector3);
37788 0 : for (i = 0; i < size3; i++)
37789 0 : Py_XDECREF(pyVector3[i]);
37790 : }
37791 : return NULL;
37792 : }
37793 :
37794 :
37795 0 : SWIGINTERN PyObject *_wrap_gpgme_op_assuan_transact_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37796 0 : PyObject *resultobj = 0;
37797 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37798 0 : char *arg2 = (char *) 0 ;
37799 0 : gpgme_assuan_data_cb_t arg3 = (gpgme_assuan_data_cb_t) 0 ;
37800 0 : void *arg4 = (void *) 0 ;
37801 0 : gpgme_assuan_inquire_cb_t arg5 = (gpgme_assuan_inquire_cb_t) 0 ;
37802 0 : void *arg6 = (void *) 0 ;
37803 0 : gpgme_assuan_status_cb_t arg7 = (gpgme_assuan_status_cb_t) 0 ;
37804 0 : void *arg8 = (void *) 0 ;
37805 0 : void *argp1 = 0 ;
37806 0 : int res1 = 0 ;
37807 0 : PyObject *encodedInput2 = NULL ;
37808 0 : PyObject * obj0 = 0 ;
37809 0 : PyObject * obj1 = 0 ;
37810 0 : PyObject * obj2 = 0 ;
37811 0 : PyObject * obj3 = 0 ;
37812 0 : PyObject * obj4 = 0 ;
37813 : gpgme_error_t result;
37814 :
37815 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_assuan_transact_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37816 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37817 0 : if (!SWIG_IsOK(res1)) {
37818 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_assuan_transact_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37819 : }
37820 0 : arg1 = (gpgme_ctx_t)(argp1);
37821 : {
37822 0 : if (obj1 == Py_None)
37823 : arg2 = NULL;
37824 0 : else if (PyUnicode_Check(obj1))
37825 : {
37826 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
37827 0 : if (encodedInput2 == NULL)
37828 : return NULL;
37829 0 : arg2 = PyBytes_AsString(encodedInput2);
37830 : }
37831 0 : else if (PyBytes_Check(obj1))
37832 0 : arg2 = PyBytes_AsString(obj1);
37833 : else {
37834 0 : PyErr_Format(PyExc_TypeError,
37835 : "arg %d: expected str, bytes, or None, got %s",
37836 : 2, obj1->ob_type->tp_name);
37837 0 : return NULL;
37838 : }
37839 : }
37840 : {
37841 0 : if (obj2 == Py_None)
37842 : arg3 = arg4 = NULL;
37843 : else
37844 : {
37845 0 : if (! PyTuple_Check(obj2))
37846 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
37847 0 : if (PyTuple_Size(obj2) != 2)
37848 0 : return PyErr_Format(PyExc_TypeError,
37849 : "callback must be a tuple of size 2");
37850 0 : if (! PyCallable_Check(PyTuple_GetItem(obj2, 1)))
37851 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
37852 0 : arg3 = _gpg_assuan_data_cb;
37853 0 : arg4 = obj2;
37854 : }
37855 : }
37856 : {
37857 0 : if (obj3 == Py_None)
37858 : arg5 = arg6 = NULL;
37859 : else
37860 : {
37861 0 : if (! PyTuple_Check(obj3))
37862 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
37863 0 : if (PyTuple_Size(obj3) != 2)
37864 0 : return PyErr_Format(PyExc_TypeError,
37865 : "callback must be a tuple of size 2");
37866 0 : if (! PyCallable_Check(PyTuple_GetItem(obj3, 1)))
37867 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
37868 0 : arg5 = _gpg_assuan_inquire_cb;
37869 0 : arg6 = obj3;
37870 : }
37871 : }
37872 : {
37873 0 : if (obj4 == Py_None)
37874 : arg7 = arg8 = NULL;
37875 : else
37876 : {
37877 0 : if (! PyTuple_Check(obj4))
37878 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
37879 0 : if (PyTuple_Size(obj4) != 2)
37880 0 : return PyErr_Format(PyExc_TypeError,
37881 : "callback must be a tuple of size 2");
37882 0 : if (! PyCallable_Check(PyTuple_GetItem(obj4, 1)))
37883 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
37884 0 : arg7 = _gpg_assuan_status_cb;
37885 0 : arg8 = obj4;
37886 : }
37887 : }
37888 : {
37889 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37890 0 : result = gpgme_op_assuan_transact_start(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
37891 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37892 : }
37893 : {
37894 0 : resultobj = PyLong_FromLong(result);
37895 : }
37896 : {
37897 0 : Py_XDECREF(encodedInput2);
37898 : }
37899 : return resultobj;
37900 : fail:
37901 : {
37902 : Py_XDECREF(encodedInput2);
37903 : }
37904 : return NULL;
37905 : }
37906 :
37907 :
37908 14 : SWIGINTERN PyObject *_wrap_gpgme_op_assuan_transact_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37909 14 : PyObject *resultobj = 0;
37910 14 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37911 14 : char *arg2 = (char *) 0 ;
37912 14 : gpgme_assuan_data_cb_t arg3 = (gpgme_assuan_data_cb_t) 0 ;
37913 14 : void *arg4 = (void *) 0 ;
37914 14 : gpgme_assuan_inquire_cb_t arg5 = (gpgme_assuan_inquire_cb_t) 0 ;
37915 14 : void *arg6 = (void *) 0 ;
37916 14 : gpgme_assuan_status_cb_t arg7 = (gpgme_assuan_status_cb_t) 0 ;
37917 14 : void *arg8 = (void *) 0 ;
37918 14 : gpgme_error_t *arg9 = (gpgme_error_t *) 0 ;
37919 14 : void *argp1 = 0 ;
37920 14 : int res1 = 0 ;
37921 14 : PyObject *encodedInput2 = NULL ;
37922 14 : void *argp9 = 0 ;
37923 14 : int res9 = 0 ;
37924 14 : PyObject * obj0 = 0 ;
37925 14 : PyObject * obj1 = 0 ;
37926 14 : PyObject * obj2 = 0 ;
37927 14 : PyObject * obj3 = 0 ;
37928 14 : PyObject * obj4 = 0 ;
37929 14 : PyObject * obj5 = 0 ;
37930 : gpgme_error_t result;
37931 :
37932 14 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_assuan_transact_ext",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37933 14 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37934 14 : if (!SWIG_IsOK(res1)) {
37935 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_assuan_transact_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37936 : }
37937 14 : arg1 = (gpgme_ctx_t)(argp1);
37938 : {
37939 14 : if (obj1 == Py_None)
37940 : arg2 = NULL;
37941 14 : else if (PyUnicode_Check(obj1))
37942 : {
37943 13 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
37944 13 : if (encodedInput2 == NULL)
37945 : return NULL;
37946 13 : arg2 = PyBytes_AsString(encodedInput2);
37947 : }
37948 1 : else if (PyBytes_Check(obj1))
37949 1 : arg2 = PyBytes_AsString(obj1);
37950 : else {
37951 0 : PyErr_Format(PyExc_TypeError,
37952 : "arg %d: expected str, bytes, or None, got %s",
37953 : 2, obj1->ob_type->tp_name);
37954 0 : return NULL;
37955 : }
37956 : }
37957 : {
37958 14 : if (obj2 == Py_None)
37959 : arg3 = arg4 = NULL;
37960 : else
37961 : {
37962 2 : if (! PyTuple_Check(obj2))
37963 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
37964 2 : if (PyTuple_Size(obj2) != 2)
37965 0 : return PyErr_Format(PyExc_TypeError,
37966 : "callback must be a tuple of size 2");
37967 2 : if (! PyCallable_Check(PyTuple_GetItem(obj2, 1)))
37968 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
37969 2 : arg3 = _gpg_assuan_data_cb;
37970 2 : arg4 = obj2;
37971 : }
37972 : }
37973 : {
37974 14 : if (obj3 == Py_None)
37975 : arg5 = arg6 = NULL;
37976 : else
37977 : {
37978 0 : if (! PyTuple_Check(obj3))
37979 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
37980 0 : if (PyTuple_Size(obj3) != 2)
37981 0 : return PyErr_Format(PyExc_TypeError,
37982 : "callback must be a tuple of size 2");
37983 0 : if (! PyCallable_Check(PyTuple_GetItem(obj3, 1)))
37984 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
37985 0 : arg5 = _gpg_assuan_inquire_cb;
37986 0 : arg6 = obj3;
37987 : }
37988 : }
37989 : {
37990 14 : if (obj4 == Py_None)
37991 : arg7 = arg8 = NULL;
37992 : else
37993 : {
37994 1 : if (! PyTuple_Check(obj4))
37995 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
37996 1 : if (PyTuple_Size(obj4) != 2)
37997 0 : return PyErr_Format(PyExc_TypeError,
37998 : "callback must be a tuple of size 2");
37999 1 : if (! PyCallable_Check(PyTuple_GetItem(obj4, 1)))
38000 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
38001 1 : arg7 = _gpg_assuan_status_cb;
38002 1 : arg8 = obj4;
38003 : }
38004 : }
38005 14 : res9 = SWIG_ConvertPtr(obj5, &argp9,SWIGTYPE_p_gpg_error_t, 0 | 0 );
38006 14 : if (!SWIG_IsOK(res9)) {
38007 0 : SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "gpgme_op_assuan_transact_ext" "', argument " "9"" of type '" "gpgme_error_t *""'");
38008 : }
38009 14 : arg9 = (gpgme_error_t *)(argp9);
38010 : {
38011 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38012 14 : result = gpgme_op_assuan_transact_ext(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
38013 14 : SWIG_PYTHON_THREAD_END_ALLOW;
38014 : }
38015 : {
38016 14 : resultobj = PyLong_FromLong(result);
38017 : }
38018 : {
38019 14 : Py_XDECREF(encodedInput2);
38020 : }
38021 : return resultobj;
38022 : fail:
38023 : {
38024 0 : Py_XDECREF(encodedInput2);
38025 : }
38026 : return NULL;
38027 : }
38028 :
38029 :
38030 0 : SWIGINTERN PyObject *_wrap__gpgme_op_vfs_mount_result_mount_dir_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38031 0 : PyObject *resultobj = 0;
38032 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
38033 0 : char *arg2 = (char *) 0 ;
38034 0 : void *argp1 = 0 ;
38035 0 : int res1 = 0 ;
38036 : int res2 ;
38037 0 : char *buf2 = 0 ;
38038 0 : int alloc2 = 0 ;
38039 0 : PyObject * obj0 = 0 ;
38040 0 : PyObject * obj1 = 0 ;
38041 :
38042 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_vfs_mount_result_mount_dir_set",&obj0,&obj1)) SWIG_fail;
38043 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, 0 | 0 );
38044 0 : if (!SWIG_IsOK(res1)) {
38045 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 *""'");
38046 : }
38047 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
38048 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
38049 0 : if (!SWIG_IsOK(res2)) {
38050 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_vfs_mount_result_mount_dir_set" "', argument " "2"" of type '" "char *""'");
38051 : }
38052 0 : arg2 = (char *)(buf2);
38053 : {
38054 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38055 0 : if (arg1->mount_dir) free((char*)arg1->mount_dir);
38056 0 : if (arg2) {
38057 0 : size_t size = strlen((const char *)(arg2)) + 1;
38058 0 : arg1->mount_dir = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
38059 : } else {
38060 0 : arg1->mount_dir = 0;
38061 : }
38062 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38063 : }
38064 0 : resultobj = SWIG_Py_Void();
38065 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
38066 : return resultobj;
38067 : fail:
38068 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
38069 : return NULL;
38070 : }
38071 :
38072 :
38073 0 : SWIGINTERN PyObject *_wrap__gpgme_op_vfs_mount_result_mount_dir_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38074 0 : PyObject *resultobj = 0;
38075 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
38076 0 : void *argp1 = 0 ;
38077 0 : int res1 = 0 ;
38078 0 : PyObject * obj0 = 0 ;
38079 0 : char *result = 0 ;
38080 :
38081 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_vfs_mount_result_mount_dir_get",&obj0)) SWIG_fail;
38082 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, 0 | 0 );
38083 0 : if (!SWIG_IsOK(res1)) {
38084 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 *""'");
38085 : }
38086 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
38087 : {
38088 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38089 0 : result = (char *) ((arg1)->mount_dir);
38090 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38091 : }
38092 0 : resultobj = SWIG_FromCharPtr((const char *)result);
38093 0 : return resultobj;
38094 : fail:
38095 : return NULL;
38096 : }
38097 :
38098 :
38099 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_vfs_mount_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38100 0 : PyObject *resultobj = 0;
38101 0 : struct _gpgme_op_vfs_mount_result *result = 0 ;
38102 :
38103 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_vfs_mount_result")) SWIG_fail;
38104 : {
38105 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38106 0 : result = (struct _gpgme_op_vfs_mount_result *)calloc(1, sizeof(struct _gpgme_op_vfs_mount_result));
38107 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38108 : }
38109 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_vfs_mount_result, SWIG_POINTER_NEW | 0 );
38110 0 : return resultobj;
38111 : fail:
38112 : return NULL;
38113 : }
38114 :
38115 :
38116 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_vfs_mount_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38117 0 : PyObject *resultobj = 0;
38118 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
38119 0 : void *argp1 = 0 ;
38120 0 : int res1 = 0 ;
38121 0 : PyObject * obj0 = 0 ;
38122 :
38123 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_vfs_mount_result",&obj0)) SWIG_fail;
38124 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, SWIG_POINTER_DISOWN | 0 );
38125 0 : if (!SWIG_IsOK(res1)) {
38126 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 *""'");
38127 : }
38128 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
38129 : {
38130 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38131 0 : free((char *) arg1);
38132 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38133 : }
38134 0 : resultobj = SWIG_Py_Void();
38135 0 : return resultobj;
38136 : fail:
38137 : return NULL;
38138 : }
38139 :
38140 :
38141 29 : SWIGINTERN PyObject *_gpgme_op_vfs_mount_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38142 : PyObject *obj;
38143 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
38144 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_vfs_mount_result, SWIG_NewClientData(obj));
38145 29 : return SWIG_Py_Void();
38146 : }
38147 :
38148 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_mount_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38149 0 : PyObject *resultobj = 0;
38150 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
38151 0 : void *argp1 = 0 ;
38152 0 : int res1 = 0 ;
38153 0 : PyObject * obj0 = 0 ;
38154 : gpgme_vfs_mount_result_t result;
38155 :
38156 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_vfs_mount_result",&obj0)) SWIG_fail;
38157 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
38158 0 : if (!SWIG_IsOK(res1)) {
38159 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_mount_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
38160 : }
38161 0 : arg1 = (gpgme_ctx_t)(argp1);
38162 : {
38163 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38164 0 : result = (gpgme_vfs_mount_result_t)gpgme_op_vfs_mount_result(arg1);
38165 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38166 : }
38167 : {
38168 : PyObject *fragile;
38169 0 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_vfs_mount_result,
38170 : 0 );
38171 0 : resultobj = _gpg_wrap_result(fragile, "VFSMountResult");
38172 0 : Py_DECREF(fragile);
38173 : }
38174 : return resultobj;
38175 : fail:
38176 : return NULL;
38177 : }
38178 :
38179 :
38180 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_mount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38181 0 : PyObject *resultobj = 0;
38182 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
38183 0 : char *arg2 = (char *) 0 ;
38184 0 : char *arg3 = (char *) 0 ;
38185 : unsigned int arg4 ;
38186 0 : gpgme_error_t *arg5 = (gpgme_error_t *) 0 ;
38187 0 : void *argp1 = 0 ;
38188 0 : int res1 = 0 ;
38189 0 : PyObject *encodedInput2 = NULL ;
38190 0 : PyObject *encodedInput3 = NULL ;
38191 : unsigned int val4 ;
38192 0 : int ecode4 = 0 ;
38193 0 : void *argp5 = 0 ;
38194 0 : int res5 = 0 ;
38195 0 : PyObject * obj0 = 0 ;
38196 0 : PyObject * obj1 = 0 ;
38197 0 : PyObject * obj2 = 0 ;
38198 0 : PyObject * obj3 = 0 ;
38199 0 : PyObject * obj4 = 0 ;
38200 : gpgme_error_t result;
38201 :
38202 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_vfs_mount",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38203 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
38204 0 : if (!SWIG_IsOK(res1)) {
38205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_mount" "', argument " "1"" of type '" "gpgme_ctx_t""'");
38206 : }
38207 0 : arg1 = (gpgme_ctx_t)(argp1);
38208 : {
38209 0 : if (obj1 == Py_None)
38210 : arg2 = NULL;
38211 0 : else if (PyUnicode_Check(obj1))
38212 : {
38213 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
38214 0 : if (encodedInput2 == NULL)
38215 : return NULL;
38216 0 : arg2 = PyBytes_AsString(encodedInput2);
38217 : }
38218 0 : else if (PyBytes_Check(obj1))
38219 0 : arg2 = PyBytes_AsString(obj1);
38220 : else {
38221 0 : PyErr_Format(PyExc_TypeError,
38222 : "arg %d: expected str, bytes, or None, got %s",
38223 : 2, obj1->ob_type->tp_name);
38224 0 : return NULL;
38225 : }
38226 : }
38227 : {
38228 0 : if (obj2 == Py_None)
38229 : arg3 = NULL;
38230 0 : else if (PyUnicode_Check(obj2))
38231 : {
38232 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
38233 0 : if (encodedInput3 == NULL)
38234 : return NULL;
38235 0 : arg3 = PyBytes_AsString(encodedInput3);
38236 : }
38237 0 : else if (PyBytes_Check(obj2))
38238 0 : arg3 = PyBytes_AsString(obj2);
38239 : else {
38240 0 : PyErr_Format(PyExc_TypeError,
38241 : "arg %d: expected str, bytes, or None, got %s",
38242 : 3, obj2->ob_type->tp_name);
38243 0 : return NULL;
38244 : }
38245 : }
38246 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
38247 0 : if (!SWIG_IsOK(ecode4)) {
38248 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_vfs_mount" "', argument " "4"" of type '" "unsigned int""'");
38249 : }
38250 0 : arg4 = (unsigned int)(val4);
38251 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpg_error_t, 0 | 0 );
38252 0 : if (!SWIG_IsOK(res5)) {
38253 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_vfs_mount" "', argument " "5"" of type '" "gpgme_error_t *""'");
38254 : }
38255 0 : arg5 = (gpgme_error_t *)(argp5);
38256 : {
38257 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38258 0 : result = gpgme_op_vfs_mount(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
38259 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38260 : }
38261 : {
38262 0 : resultobj = PyLong_FromLong(result);
38263 : }
38264 : {
38265 0 : Py_XDECREF(encodedInput2);
38266 : }
38267 : {
38268 0 : Py_XDECREF(encodedInput3);
38269 : }
38270 : return resultobj;
38271 : fail:
38272 : {
38273 0 : Py_XDECREF(encodedInput2);
38274 : }
38275 : {
38276 0 : Py_XDECREF(encodedInput3);
38277 : }
38278 : return NULL;
38279 : }
38280 :
38281 :
38282 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38283 0 : PyObject *resultobj = 0;
38284 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
38285 : gpgme_key_t *arg2 ;
38286 0 : char *arg3 = (char *) 0 ;
38287 : unsigned int arg4 ;
38288 0 : gpgme_error_t *arg5 = (gpgme_error_t *) 0 ;
38289 0 : void *argp1 = 0 ;
38290 0 : int res1 = 0 ;
38291 0 : PyObject *encodedInput3 = NULL ;
38292 : unsigned int val4 ;
38293 0 : int ecode4 = 0 ;
38294 0 : void *argp5 = 0 ;
38295 0 : int res5 = 0 ;
38296 0 : PyObject * obj0 = 0 ;
38297 0 : PyObject * obj1 = 0 ;
38298 0 : PyObject * obj2 = 0 ;
38299 0 : PyObject * obj3 = 0 ;
38300 0 : PyObject * obj4 = 0 ;
38301 : gpgme_error_t result;
38302 :
38303 : {
38304 0 : arg2 = NULL;
38305 : }
38306 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_vfs_create",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38307 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
38308 0 : if (!SWIG_IsOK(res1)) {
38309 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_create" "', argument " "1"" of type '" "gpgme_ctx_t""'");
38310 : }
38311 0 : arg1 = (gpgme_ctx_t)(argp1);
38312 : {
38313 0 : int i, numb = 0;
38314 0 : if (!PySequence_Check(obj1)) {
38315 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
38316 : 2);
38317 0 : return NULL;
38318 : }
38319 0 : if((numb = PySequence_Length(obj1)) != 0) {
38320 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
38321 0 : for(i=0; i<numb; i++) {
38322 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
38323 :
38324 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
38325 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
38326 :
38327 : /* Following code is from swig's python.swg. */
38328 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
38329 0 : Py_DECREF(pypointer);
38330 0 : PyErr_Format(PyExc_TypeError,
38331 : "arg %d: list must contain only gpgme_key_ts, got %s "
38332 : "at position %d",
38333 0 : 2, pypointer->ob_type->tp_name, i);
38334 0 : free(arg2);
38335 0 : return NULL;
38336 : }
38337 0 : Py_DECREF(pypointer);
38338 : }
38339 0 : arg2[numb] = NULL;
38340 : }
38341 : }
38342 : {
38343 0 : if (obj2 == Py_None)
38344 : arg3 = NULL;
38345 0 : else if (PyUnicode_Check(obj2))
38346 : {
38347 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
38348 0 : if (encodedInput3 == NULL)
38349 : return NULL;
38350 0 : arg3 = PyBytes_AsString(encodedInput3);
38351 : }
38352 0 : else if (PyBytes_Check(obj2))
38353 0 : arg3 = PyBytes_AsString(obj2);
38354 : else {
38355 0 : PyErr_Format(PyExc_TypeError,
38356 : "arg %d: expected str, bytes, or None, got %s",
38357 : 3, obj2->ob_type->tp_name);
38358 0 : return NULL;
38359 : }
38360 : }
38361 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
38362 0 : if (!SWIG_IsOK(ecode4)) {
38363 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_vfs_create" "', argument " "4"" of type '" "unsigned int""'");
38364 : }
38365 0 : arg4 = (unsigned int)(val4);
38366 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpg_error_t, 0 | 0 );
38367 0 : if (!SWIG_IsOK(res5)) {
38368 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_vfs_create" "', argument " "5"" of type '" "gpgme_error_t *""'");
38369 : }
38370 0 : arg5 = (gpgme_error_t *)(argp5);
38371 : {
38372 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38373 0 : result = gpgme_op_vfs_create(arg1,arg2,(char const *)arg3,arg4,arg5);
38374 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38375 : }
38376 : {
38377 0 : resultobj = PyLong_FromLong(result);
38378 : }
38379 : {
38380 0 : if (arg2) free(arg2);
38381 : }
38382 : {
38383 0 : Py_XDECREF(encodedInput3);
38384 : }
38385 : return resultobj;
38386 : fail:
38387 : {
38388 0 : if (arg2) free(arg2);
38389 : }
38390 : {
38391 0 : Py_XDECREF(encodedInput3);
38392 : }
38393 : return NULL;
38394 : }
38395 :
38396 :
38397 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_no_arg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38398 0 : PyObject *resultobj = 0;
38399 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
38400 : unsigned int arg2 ;
38401 0 : void *argp1 = 0 ;
38402 0 : int res1 = 0 ;
38403 : unsigned int val2 ;
38404 0 : int ecode2 = 0 ;
38405 0 : PyObject * obj0 = 0 ;
38406 0 : PyObject * obj1 = 0 ;
38407 :
38408 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_no_arg_set",&obj0,&obj1)) SWIG_fail;
38409 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
38410 0 : if (!SWIG_IsOK(res1)) {
38411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_no_arg_set" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
38412 : }
38413 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
38414 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
38415 0 : if (!SWIG_IsOK(ecode2)) {
38416 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_no_arg_set" "', argument " "2"" of type '" "unsigned int""'");
38417 : }
38418 0 : arg2 = (unsigned int)(val2);
38419 : {
38420 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38421 0 : if (arg1) (arg1)->no_arg = arg2;
38422 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38423 : }
38424 0 : resultobj = SWIG_Py_Void();
38425 0 : return resultobj;
38426 : fail:
38427 : return NULL;
38428 : }
38429 :
38430 :
38431 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_no_arg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38432 0 : PyObject *resultobj = 0;
38433 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
38434 0 : void *argp1 = 0 ;
38435 0 : int res1 = 0 ;
38436 0 : PyObject * obj0 = 0 ;
38437 : unsigned int result;
38438 :
38439 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_no_arg_get",&obj0)) SWIG_fail;
38440 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
38441 0 : if (!SWIG_IsOK(res1)) {
38442 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_no_arg_get" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
38443 : }
38444 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
38445 : {
38446 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38447 0 : result = (unsigned int) ((arg1)->no_arg);
38448 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38449 : }
38450 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
38451 0 : return resultobj;
38452 : fail:
38453 : return NULL;
38454 : }
38455 :
38456 :
38457 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38458 0 : PyObject *resultobj = 0;
38459 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
38460 0 : void *argp1 = 0 ;
38461 0 : int res1 = 0 ;
38462 0 : PyObject * obj0 = 0 ;
38463 0 : gpgme_conf_arg_value *result = 0 ;
38464 :
38465 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_get",&obj0)) SWIG_fail;
38466 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
38467 0 : if (!SWIG_IsOK(res1)) {
38468 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_get" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
38469 : }
38470 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
38471 : {
38472 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38473 0 : result = (gpgme_conf_arg_value *)& ((arg1)->value);
38474 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38475 : }
38476 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38477 0 : return resultobj;
38478 : fail:
38479 : return NULL;
38480 : }
38481 :
38482 :
38483 0 : SWIGINTERN PyObject *_wrap_new_gpgme_conf_arg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38484 0 : PyObject *resultobj = 0;
38485 0 : struct gpgme_conf_arg *result = 0 ;
38486 :
38487 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_conf_arg")) SWIG_fail;
38488 : {
38489 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38490 0 : result = (struct gpgme_conf_arg *)calloc(1, sizeof(struct gpgme_conf_arg));
38491 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38492 : }
38493 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_NEW | 0 );
38494 0 : return resultobj;
38495 : fail:
38496 : return NULL;
38497 : }
38498 :
38499 :
38500 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_arg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38501 0 : PyObject *resultobj = 0;
38502 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
38503 0 : void *argp1 = 0 ;
38504 0 : int res1 = 0 ;
38505 0 : PyObject * obj0 = 0 ;
38506 :
38507 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_conf_arg",&obj0)) SWIG_fail;
38508 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
38509 0 : if (!SWIG_IsOK(res1)) {
38510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_arg" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
38511 : }
38512 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
38513 : {
38514 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38515 0 : free((char *) arg1);
38516 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38517 : }
38518 0 : resultobj = SWIG_Py_Void();
38519 0 : return resultobj;
38520 : fail:
38521 : return NULL;
38522 : }
38523 :
38524 :
38525 29 : SWIGINTERN PyObject *gpgme_conf_arg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38526 : PyObject *obj;
38527 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
38528 58 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_conf_arg, SWIG_NewClientData(obj));
38529 29 : return SWIG_Py_Void();
38530 : }
38531 :
38532 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38533 0 : PyObject *resultobj = 0;
38534 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38535 : unsigned int arg2 ;
38536 0 : void *argp1 = 0 ;
38537 0 : int res1 = 0 ;
38538 : unsigned int val2 ;
38539 0 : int ecode2 = 0 ;
38540 0 : PyObject * obj0 = 0 ;
38541 0 : PyObject * obj1 = 0 ;
38542 :
38543 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_value_count_set",&obj0,&obj1)) SWIG_fail;
38544 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38545 0 : if (!SWIG_IsOK(res1)) {
38546 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_count_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38547 : }
38548 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38549 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
38550 0 : if (!SWIG_IsOK(ecode2)) {
38551 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_count_set" "', argument " "2"" of type '" "unsigned int""'");
38552 : }
38553 0 : arg2 = (unsigned int)(val2);
38554 : {
38555 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38556 0 : if (arg1) (arg1)->count = arg2;
38557 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38558 : }
38559 0 : resultobj = SWIG_Py_Void();
38560 0 : return resultobj;
38561 : fail:
38562 : return NULL;
38563 : }
38564 :
38565 :
38566 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38567 0 : PyObject *resultobj = 0;
38568 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38569 0 : void *argp1 = 0 ;
38570 0 : int res1 = 0 ;
38571 0 : PyObject * obj0 = 0 ;
38572 : unsigned int result;
38573 :
38574 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_count_get",&obj0)) SWIG_fail;
38575 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38576 0 : if (!SWIG_IsOK(res1)) {
38577 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_count_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38578 : }
38579 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38580 : {
38581 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38582 0 : result = (unsigned int) ((arg1)->count);
38583 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38584 : }
38585 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
38586 0 : return resultobj;
38587 : fail:
38588 : return NULL;
38589 : }
38590 :
38591 :
38592 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_uint32_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38593 0 : PyObject *resultobj = 0;
38594 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38595 : unsigned int arg2 ;
38596 0 : void *argp1 = 0 ;
38597 0 : int res1 = 0 ;
38598 : unsigned int val2 ;
38599 0 : int ecode2 = 0 ;
38600 0 : PyObject * obj0 = 0 ;
38601 0 : PyObject * obj1 = 0 ;
38602 :
38603 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_value_uint32_set",&obj0,&obj1)) SWIG_fail;
38604 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38605 0 : if (!SWIG_IsOK(res1)) {
38606 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_uint32_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38607 : }
38608 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38609 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
38610 0 : if (!SWIG_IsOK(ecode2)) {
38611 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_uint32_set" "', argument " "2"" of type '" "unsigned int""'");
38612 : }
38613 0 : arg2 = (unsigned int)(val2);
38614 : {
38615 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38616 0 : if (arg1) (arg1)->uint32 = arg2;
38617 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38618 : }
38619 0 : resultobj = SWIG_Py_Void();
38620 0 : return resultobj;
38621 : fail:
38622 : return NULL;
38623 : }
38624 :
38625 :
38626 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_uint32_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38627 0 : PyObject *resultobj = 0;
38628 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38629 0 : void *argp1 = 0 ;
38630 0 : int res1 = 0 ;
38631 0 : PyObject * obj0 = 0 ;
38632 : unsigned int result;
38633 :
38634 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_uint32_get",&obj0)) SWIG_fail;
38635 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38636 0 : if (!SWIG_IsOK(res1)) {
38637 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_uint32_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38638 : }
38639 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38640 : {
38641 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38642 0 : result = (unsigned int) ((arg1)->uint32);
38643 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38644 : }
38645 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
38646 0 : return resultobj;
38647 : fail:
38648 : return NULL;
38649 : }
38650 :
38651 :
38652 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_int32_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38653 0 : PyObject *resultobj = 0;
38654 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38655 : int arg2 ;
38656 0 : void *argp1 = 0 ;
38657 0 : int res1 = 0 ;
38658 : int val2 ;
38659 0 : int ecode2 = 0 ;
38660 0 : PyObject * obj0 = 0 ;
38661 0 : PyObject * obj1 = 0 ;
38662 :
38663 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_value_int32_set",&obj0,&obj1)) SWIG_fail;
38664 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38665 0 : if (!SWIG_IsOK(res1)) {
38666 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_int32_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38667 : }
38668 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38669 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
38670 0 : if (!SWIG_IsOK(ecode2)) {
38671 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_int32_set" "', argument " "2"" of type '" "int""'");
38672 : }
38673 0 : arg2 = (int)(val2);
38674 : {
38675 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38676 0 : if (arg1) (arg1)->int32 = arg2;
38677 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38678 : }
38679 0 : resultobj = SWIG_Py_Void();
38680 0 : return resultobj;
38681 : fail:
38682 : return NULL;
38683 : }
38684 :
38685 :
38686 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_int32_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38687 0 : PyObject *resultobj = 0;
38688 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38689 0 : void *argp1 = 0 ;
38690 0 : int res1 = 0 ;
38691 0 : PyObject * obj0 = 0 ;
38692 : int result;
38693 :
38694 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_int32_get",&obj0)) SWIG_fail;
38695 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38696 0 : if (!SWIG_IsOK(res1)) {
38697 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_int32_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38698 : }
38699 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38700 : {
38701 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38702 0 : result = (int) ((arg1)->int32);
38703 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38704 : }
38705 0 : resultobj = SWIG_From_int((int)(result));
38706 0 : return resultobj;
38707 : fail:
38708 : return NULL;
38709 : }
38710 :
38711 :
38712 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38713 0 : PyObject *resultobj = 0;
38714 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38715 0 : char *arg2 = (char *) 0 ;
38716 0 : void *argp1 = 0 ;
38717 0 : int res1 = 0 ;
38718 : int res2 ;
38719 0 : char *buf2 = 0 ;
38720 0 : int alloc2 = 0 ;
38721 0 : PyObject * obj0 = 0 ;
38722 0 : PyObject * obj1 = 0 ;
38723 :
38724 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_value_string_set",&obj0,&obj1)) SWIG_fail;
38725 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38726 0 : if (!SWIG_IsOK(res1)) {
38727 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_string_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38728 : }
38729 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38730 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
38731 0 : if (!SWIG_IsOK(res2)) {
38732 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_arg_value_string_set" "', argument " "2"" of type '" "char *""'");
38733 : }
38734 0 : arg2 = (char *)(buf2);
38735 : {
38736 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38737 0 : if (arg1->string) free((char*)arg1->string);
38738 0 : if (arg2) {
38739 0 : size_t size = strlen((const char *)(arg2)) + 1;
38740 0 : arg1->string = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
38741 : } else {
38742 0 : arg1->string = 0;
38743 : }
38744 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38745 : }
38746 0 : resultobj = SWIG_Py_Void();
38747 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
38748 : return resultobj;
38749 : fail:
38750 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
38751 : return NULL;
38752 : }
38753 :
38754 :
38755 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38756 0 : PyObject *resultobj = 0;
38757 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38758 0 : void *argp1 = 0 ;
38759 0 : int res1 = 0 ;
38760 0 : PyObject * obj0 = 0 ;
38761 0 : char *result = 0 ;
38762 :
38763 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_string_get",&obj0)) SWIG_fail;
38764 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
38765 0 : if (!SWIG_IsOK(res1)) {
38766 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_string_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38767 : }
38768 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38769 : {
38770 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38771 0 : result = (char *) ((arg1)->string);
38772 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38773 : }
38774 0 : resultobj = SWIG_FromCharPtr((const char *)result);
38775 0 : return resultobj;
38776 : fail:
38777 : return NULL;
38778 : }
38779 :
38780 :
38781 0 : SWIGINTERN PyObject *_wrap_new_gpgme_conf_arg_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38782 0 : PyObject *resultobj = 0;
38783 0 : gpgme_conf_arg_value *result = 0 ;
38784 :
38785 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_conf_arg_value")) SWIG_fail;
38786 : {
38787 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38788 0 : result = (gpgme_conf_arg_value *)calloc(1, sizeof(gpgme_conf_arg_value));
38789 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38790 : }
38791 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg_value, SWIG_POINTER_NEW | 0 );
38792 0 : return resultobj;
38793 : fail:
38794 : return NULL;
38795 : }
38796 :
38797 :
38798 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_arg_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38799 0 : PyObject *resultobj = 0;
38800 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
38801 0 : void *argp1 = 0 ;
38802 0 : int res1 = 0 ;
38803 0 : PyObject * obj0 = 0 ;
38804 :
38805 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_conf_arg_value",&obj0)) SWIG_fail;
38806 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, SWIG_POINTER_DISOWN | 0 );
38807 0 : if (!SWIG_IsOK(res1)) {
38808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_arg_value" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
38809 : }
38810 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
38811 : {
38812 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38813 0 : free((char *) arg1);
38814 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38815 : }
38816 0 : resultobj = SWIG_Py_Void();
38817 0 : return resultobj;
38818 : fail:
38819 : return NULL;
38820 : }
38821 :
38822 :
38823 29 : SWIGINTERN PyObject *gpgme_conf_arg_value_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38824 : PyObject *obj;
38825 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
38826 58 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_conf_arg_value, SWIG_NewClientData(obj));
38827 29 : return SWIG_Py_Void();
38828 : }
38829 :
38830 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38831 0 : PyObject *resultobj = 0;
38832 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
38833 0 : char *arg2 = (char *) 0 ;
38834 0 : void *argp1 = 0 ;
38835 0 : int res1 = 0 ;
38836 : int res2 ;
38837 0 : char *buf2 = 0 ;
38838 0 : int alloc2 = 0 ;
38839 0 : PyObject * obj0 = 0 ;
38840 0 : PyObject * obj1 = 0 ;
38841 :
38842 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_name_set",&obj0,&obj1)) SWIG_fail;
38843 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
38844 0 : if (!SWIG_IsOK(res1)) {
38845 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_name_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
38846 : }
38847 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
38848 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
38849 0 : if (!SWIG_IsOK(res2)) {
38850 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_name_set" "', argument " "2"" of type '" "char *""'");
38851 : }
38852 0 : arg2 = (char *)(buf2);
38853 : {
38854 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38855 0 : if (arg1->name) free((char*)arg1->name);
38856 0 : if (arg2) {
38857 0 : size_t size = strlen((const char *)(arg2)) + 1;
38858 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
38859 : } else {
38860 0 : arg1->name = 0;
38861 : }
38862 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38863 : }
38864 0 : resultobj = SWIG_Py_Void();
38865 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
38866 : return resultobj;
38867 : fail:
38868 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
38869 : return NULL;
38870 : }
38871 :
38872 :
38873 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38874 0 : PyObject *resultobj = 0;
38875 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
38876 0 : void *argp1 = 0 ;
38877 0 : int res1 = 0 ;
38878 0 : PyObject * obj0 = 0 ;
38879 0 : char *result = 0 ;
38880 :
38881 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_name_get",&obj0)) SWIG_fail;
38882 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
38883 0 : if (!SWIG_IsOK(res1)) {
38884 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_name_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
38885 : }
38886 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
38887 : {
38888 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38889 0 : result = (char *) ((arg1)->name);
38890 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38891 : }
38892 0 : resultobj = SWIG_FromCharPtr((const char *)result);
38893 0 : return resultobj;
38894 : fail:
38895 : return NULL;
38896 : }
38897 :
38898 :
38899 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38900 0 : PyObject *resultobj = 0;
38901 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
38902 : unsigned int arg2 ;
38903 0 : void *argp1 = 0 ;
38904 0 : int res1 = 0 ;
38905 : unsigned int val2 ;
38906 0 : int ecode2 = 0 ;
38907 0 : PyObject * obj0 = 0 ;
38908 0 : PyObject * obj1 = 0 ;
38909 :
38910 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_flags_set",&obj0,&obj1)) SWIG_fail;
38911 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
38912 0 : if (!SWIG_IsOK(res1)) {
38913 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_flags_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
38914 : }
38915 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
38916 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
38917 0 : if (!SWIG_IsOK(ecode2)) {
38918 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_flags_set" "', argument " "2"" of type '" "unsigned int""'");
38919 : }
38920 0 : arg2 = (unsigned int)(val2);
38921 : {
38922 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38923 0 : if (arg1) (arg1)->flags = arg2;
38924 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38925 : }
38926 0 : resultobj = SWIG_Py_Void();
38927 0 : return resultobj;
38928 : fail:
38929 : return NULL;
38930 : }
38931 :
38932 :
38933 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38934 0 : PyObject *resultobj = 0;
38935 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
38936 0 : void *argp1 = 0 ;
38937 0 : int res1 = 0 ;
38938 0 : PyObject * obj0 = 0 ;
38939 : unsigned int result;
38940 :
38941 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_flags_get",&obj0)) SWIG_fail;
38942 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
38943 0 : if (!SWIG_IsOK(res1)) {
38944 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_flags_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
38945 : }
38946 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
38947 : {
38948 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38949 0 : result = (unsigned int) ((arg1)->flags);
38950 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38951 : }
38952 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
38953 0 : return resultobj;
38954 : fail:
38955 : return NULL;
38956 : }
38957 :
38958 :
38959 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_level_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38960 0 : PyObject *resultobj = 0;
38961 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
38962 : gpgme_conf_level_t arg2 ;
38963 0 : void *argp1 = 0 ;
38964 0 : int res1 = 0 ;
38965 : int val2 ;
38966 0 : int ecode2 = 0 ;
38967 0 : PyObject * obj0 = 0 ;
38968 0 : PyObject * obj1 = 0 ;
38969 :
38970 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_level_set",&obj0,&obj1)) SWIG_fail;
38971 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
38972 0 : if (!SWIG_IsOK(res1)) {
38973 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_level_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
38974 : }
38975 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
38976 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
38977 0 : if (!SWIG_IsOK(ecode2)) {
38978 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_level_set" "', argument " "2"" of type '" "gpgme_conf_level_t""'");
38979 : }
38980 0 : arg2 = (gpgme_conf_level_t)(val2);
38981 : {
38982 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38983 0 : if (arg1) (arg1)->level = arg2;
38984 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38985 : }
38986 0 : resultobj = SWIG_Py_Void();
38987 0 : return resultobj;
38988 : fail:
38989 : return NULL;
38990 : }
38991 :
38992 :
38993 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_level_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38994 0 : PyObject *resultobj = 0;
38995 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
38996 0 : void *argp1 = 0 ;
38997 0 : int res1 = 0 ;
38998 0 : PyObject * obj0 = 0 ;
38999 : gpgme_conf_level_t result;
39000 :
39001 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_level_get",&obj0)) SWIG_fail;
39002 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39003 0 : if (!SWIG_IsOK(res1)) {
39004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_level_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39005 : }
39006 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39007 : {
39008 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39009 0 : result = (gpgme_conf_level_t) ((arg1)->level);
39010 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39011 : }
39012 0 : resultobj = SWIG_From_int((int)(result));
39013 0 : return resultobj;
39014 : fail:
39015 : return NULL;
39016 : }
39017 :
39018 :
39019 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39020 0 : PyObject *resultobj = 0;
39021 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39022 0 : char *arg2 = (char *) 0 ;
39023 0 : void *argp1 = 0 ;
39024 0 : int res1 = 0 ;
39025 : int res2 ;
39026 0 : char *buf2 = 0 ;
39027 0 : int alloc2 = 0 ;
39028 0 : PyObject * obj0 = 0 ;
39029 0 : PyObject * obj1 = 0 ;
39030 :
39031 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_description_set",&obj0,&obj1)) SWIG_fail;
39032 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39033 0 : if (!SWIG_IsOK(res1)) {
39034 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39035 : }
39036 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39037 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
39038 0 : if (!SWIG_IsOK(res2)) {
39039 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_description_set" "', argument " "2"" of type '" "char *""'");
39040 : }
39041 0 : arg2 = (char *)(buf2);
39042 : {
39043 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39044 0 : if (arg1->description) free((char*)arg1->description);
39045 0 : if (arg2) {
39046 0 : size_t size = strlen((const char *)(arg2)) + 1;
39047 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
39048 : } else {
39049 0 : arg1->description = 0;
39050 : }
39051 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39052 : }
39053 0 : resultobj = SWIG_Py_Void();
39054 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39055 : return resultobj;
39056 : fail:
39057 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39058 : return NULL;
39059 : }
39060 :
39061 :
39062 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39063 0 : PyObject *resultobj = 0;
39064 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39065 0 : void *argp1 = 0 ;
39066 0 : int res1 = 0 ;
39067 0 : PyObject * obj0 = 0 ;
39068 0 : char *result = 0 ;
39069 :
39070 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_description_get",&obj0)) SWIG_fail;
39071 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39072 0 : if (!SWIG_IsOK(res1)) {
39073 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39074 : }
39075 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39076 : {
39077 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39078 0 : result = (char *) ((arg1)->description);
39079 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39080 : }
39081 0 : resultobj = SWIG_FromCharPtr((const char *)result);
39082 0 : return resultobj;
39083 : fail:
39084 : return NULL;
39085 : }
39086 :
39087 :
39088 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39089 0 : PyObject *resultobj = 0;
39090 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39091 : gpgme_conf_type_t arg2 ;
39092 0 : void *argp1 = 0 ;
39093 0 : int res1 = 0 ;
39094 : int val2 ;
39095 0 : int ecode2 = 0 ;
39096 0 : PyObject * obj0 = 0 ;
39097 0 : PyObject * obj1 = 0 ;
39098 :
39099 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_type_set",&obj0,&obj1)) SWIG_fail;
39100 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39101 0 : if (!SWIG_IsOK(res1)) {
39102 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_type_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39103 : }
39104 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39105 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
39106 0 : if (!SWIG_IsOK(ecode2)) {
39107 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_type_set" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
39108 : }
39109 0 : arg2 = (gpgme_conf_type_t)(val2);
39110 : {
39111 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39112 0 : if (arg1) (arg1)->type = arg2;
39113 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39114 : }
39115 0 : resultobj = SWIG_Py_Void();
39116 0 : return resultobj;
39117 : fail:
39118 : return NULL;
39119 : }
39120 :
39121 :
39122 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39123 0 : PyObject *resultobj = 0;
39124 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39125 0 : void *argp1 = 0 ;
39126 0 : int res1 = 0 ;
39127 0 : PyObject * obj0 = 0 ;
39128 : gpgme_conf_type_t result;
39129 :
39130 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_type_get",&obj0)) SWIG_fail;
39131 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39132 0 : if (!SWIG_IsOK(res1)) {
39133 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_type_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39134 : }
39135 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39136 : {
39137 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39138 0 : result = (gpgme_conf_type_t) ((arg1)->type);
39139 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39140 : }
39141 0 : resultobj = SWIG_From_int((int)(result));
39142 0 : return resultobj;
39143 : fail:
39144 : return NULL;
39145 : }
39146 :
39147 :
39148 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_alt_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39149 0 : PyObject *resultobj = 0;
39150 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39151 : gpgme_conf_type_t arg2 ;
39152 0 : void *argp1 = 0 ;
39153 0 : int res1 = 0 ;
39154 : int val2 ;
39155 0 : int ecode2 = 0 ;
39156 0 : PyObject * obj0 = 0 ;
39157 0 : PyObject * obj1 = 0 ;
39158 :
39159 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_alt_type_set",&obj0,&obj1)) SWIG_fail;
39160 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39161 0 : if (!SWIG_IsOK(res1)) {
39162 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_alt_type_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39163 : }
39164 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39165 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
39166 0 : if (!SWIG_IsOK(ecode2)) {
39167 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_alt_type_set" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
39168 : }
39169 0 : arg2 = (gpgme_conf_type_t)(val2);
39170 : {
39171 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39172 0 : if (arg1) (arg1)->alt_type = arg2;
39173 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39174 : }
39175 0 : resultobj = SWIG_Py_Void();
39176 0 : return resultobj;
39177 : fail:
39178 : return NULL;
39179 : }
39180 :
39181 :
39182 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_alt_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39183 0 : PyObject *resultobj = 0;
39184 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39185 0 : void *argp1 = 0 ;
39186 0 : int res1 = 0 ;
39187 0 : PyObject * obj0 = 0 ;
39188 : gpgme_conf_type_t result;
39189 :
39190 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_alt_type_get",&obj0)) SWIG_fail;
39191 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39192 0 : if (!SWIG_IsOK(res1)) {
39193 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_alt_type_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39194 : }
39195 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39196 : {
39197 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39198 0 : result = (gpgme_conf_type_t) ((arg1)->alt_type);
39199 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39200 : }
39201 0 : resultobj = SWIG_From_int((int)(result));
39202 0 : return resultobj;
39203 : fail:
39204 : return NULL;
39205 : }
39206 :
39207 :
39208 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_argname_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39209 0 : PyObject *resultobj = 0;
39210 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39211 0 : char *arg2 = (char *) 0 ;
39212 0 : void *argp1 = 0 ;
39213 0 : int res1 = 0 ;
39214 : int res2 ;
39215 0 : char *buf2 = 0 ;
39216 0 : int alloc2 = 0 ;
39217 0 : PyObject * obj0 = 0 ;
39218 0 : PyObject * obj1 = 0 ;
39219 :
39220 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_argname_set",&obj0,&obj1)) SWIG_fail;
39221 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39222 0 : if (!SWIG_IsOK(res1)) {
39223 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_argname_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39224 : }
39225 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39226 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
39227 0 : if (!SWIG_IsOK(res2)) {
39228 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_argname_set" "', argument " "2"" of type '" "char *""'");
39229 : }
39230 0 : arg2 = (char *)(buf2);
39231 : {
39232 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39233 0 : if (arg1->argname) free((char*)arg1->argname);
39234 0 : if (arg2) {
39235 0 : size_t size = strlen((const char *)(arg2)) + 1;
39236 0 : arg1->argname = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
39237 : } else {
39238 0 : arg1->argname = 0;
39239 : }
39240 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39241 : }
39242 0 : resultobj = SWIG_Py_Void();
39243 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39244 : return resultobj;
39245 : fail:
39246 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39247 : return NULL;
39248 : }
39249 :
39250 :
39251 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_argname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39252 0 : PyObject *resultobj = 0;
39253 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39254 0 : void *argp1 = 0 ;
39255 0 : int res1 = 0 ;
39256 0 : PyObject * obj0 = 0 ;
39257 0 : char *result = 0 ;
39258 :
39259 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_argname_get",&obj0)) SWIG_fail;
39260 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39261 0 : if (!SWIG_IsOK(res1)) {
39262 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_argname_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39263 : }
39264 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39265 : {
39266 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39267 0 : result = (char *) ((arg1)->argname);
39268 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39269 : }
39270 0 : resultobj = SWIG_FromCharPtr((const char *)result);
39271 0 : return resultobj;
39272 : fail:
39273 : return NULL;
39274 : }
39275 :
39276 :
39277 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39278 0 : PyObject *resultobj = 0;
39279 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39280 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
39281 0 : void *argp1 = 0 ;
39282 0 : int res1 = 0 ;
39283 0 : void *argp2 = 0 ;
39284 0 : int res2 = 0 ;
39285 0 : PyObject * obj0 = 0 ;
39286 0 : PyObject * obj1 = 0 ;
39287 :
39288 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_default_value_set",&obj0,&obj1)) SWIG_fail;
39289 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39290 0 : if (!SWIG_IsOK(res1)) {
39291 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39292 : }
39293 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39294 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
39295 0 : if (!SWIG_IsOK(res2)) {
39296 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_default_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
39297 : }
39298 0 : arg2 = (gpgme_conf_arg_t)(argp2);
39299 : {
39300 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39301 0 : if (arg1) (arg1)->default_value = arg2;
39302 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39303 : }
39304 0 : resultobj = SWIG_Py_Void();
39305 0 : return resultobj;
39306 : fail:
39307 : return NULL;
39308 : }
39309 :
39310 :
39311 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39312 0 : PyObject *resultobj = 0;
39313 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39314 0 : void *argp1 = 0 ;
39315 0 : int res1 = 0 ;
39316 0 : PyObject * obj0 = 0 ;
39317 : gpgme_conf_arg_t result;
39318 :
39319 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_default_value_get",&obj0)) SWIG_fail;
39320 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39321 0 : if (!SWIG_IsOK(res1)) {
39322 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39323 : }
39324 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39325 : {
39326 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39327 0 : result = (gpgme_conf_arg_t) ((arg1)->default_value);
39328 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39329 : }
39330 : {
39331 : int i;
39332 0 : int size = 0;
39333 : gpgme_conf_arg_t curr;
39334 0 : for (curr = result; curr != NULL; curr = curr->next) {
39335 0 : size++;
39336 : }
39337 0 : resultobj = PyList_New(size);
39338 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
39339 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
39340 0 : PyList_SetItem(resultobj, i, o);
39341 : }
39342 : }
39343 : return resultobj;
39344 : fail:
39345 : return NULL;
39346 : }
39347 :
39348 :
39349 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39350 0 : PyObject *resultobj = 0;
39351 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39352 0 : char *arg2 = (char *) 0 ;
39353 0 : void *argp1 = 0 ;
39354 0 : int res1 = 0 ;
39355 : int res2 ;
39356 0 : char *buf2 = 0 ;
39357 0 : int alloc2 = 0 ;
39358 0 : PyObject * obj0 = 0 ;
39359 0 : PyObject * obj1 = 0 ;
39360 :
39361 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_default_description_set",&obj0,&obj1)) SWIG_fail;
39362 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39363 0 : if (!SWIG_IsOK(res1)) {
39364 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39365 : }
39366 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39367 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
39368 0 : if (!SWIG_IsOK(res2)) {
39369 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_default_description_set" "', argument " "2"" of type '" "char *""'");
39370 : }
39371 0 : arg2 = (char *)(buf2);
39372 : {
39373 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39374 0 : if (arg1->default_description) free((char*)arg1->default_description);
39375 0 : if (arg2) {
39376 0 : size_t size = strlen((const char *)(arg2)) + 1;
39377 0 : arg1->default_description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
39378 : } else {
39379 0 : arg1->default_description = 0;
39380 : }
39381 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39382 : }
39383 0 : resultobj = SWIG_Py_Void();
39384 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39385 : return resultobj;
39386 : fail:
39387 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39388 : return NULL;
39389 : }
39390 :
39391 :
39392 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39393 0 : PyObject *resultobj = 0;
39394 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39395 0 : void *argp1 = 0 ;
39396 0 : int res1 = 0 ;
39397 0 : PyObject * obj0 = 0 ;
39398 0 : char *result = 0 ;
39399 :
39400 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_default_description_get",&obj0)) SWIG_fail;
39401 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39402 0 : if (!SWIG_IsOK(res1)) {
39403 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39404 : }
39405 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39406 : {
39407 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39408 0 : result = (char *) ((arg1)->default_description);
39409 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39410 : }
39411 0 : resultobj = SWIG_FromCharPtr((const char *)result);
39412 0 : return resultobj;
39413 : fail:
39414 : return NULL;
39415 : }
39416 :
39417 :
39418 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39419 0 : PyObject *resultobj = 0;
39420 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39421 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
39422 0 : void *argp1 = 0 ;
39423 0 : int res1 = 0 ;
39424 0 : void *argp2 = 0 ;
39425 0 : int res2 = 0 ;
39426 0 : PyObject * obj0 = 0 ;
39427 0 : PyObject * obj1 = 0 ;
39428 :
39429 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_no_arg_value_set",&obj0,&obj1)) SWIG_fail;
39430 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39431 0 : if (!SWIG_IsOK(res1)) {
39432 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39433 : }
39434 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39435 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
39436 0 : if (!SWIG_IsOK(res2)) {
39437 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_no_arg_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
39438 : }
39439 0 : arg2 = (gpgme_conf_arg_t)(argp2);
39440 : {
39441 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39442 0 : if (arg1) (arg1)->no_arg_value = arg2;
39443 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39444 : }
39445 0 : resultobj = SWIG_Py_Void();
39446 0 : return resultobj;
39447 : fail:
39448 : return NULL;
39449 : }
39450 :
39451 :
39452 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39453 0 : PyObject *resultobj = 0;
39454 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39455 0 : void *argp1 = 0 ;
39456 0 : int res1 = 0 ;
39457 0 : PyObject * obj0 = 0 ;
39458 : gpgme_conf_arg_t result;
39459 :
39460 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_no_arg_value_get",&obj0)) SWIG_fail;
39461 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39462 0 : if (!SWIG_IsOK(res1)) {
39463 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39464 : }
39465 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39466 : {
39467 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39468 0 : result = (gpgme_conf_arg_t) ((arg1)->no_arg_value);
39469 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39470 : }
39471 : {
39472 : int i;
39473 0 : int size = 0;
39474 : gpgme_conf_arg_t curr;
39475 0 : for (curr = result; curr != NULL; curr = curr->next) {
39476 0 : size++;
39477 : }
39478 0 : resultobj = PyList_New(size);
39479 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
39480 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
39481 0 : PyList_SetItem(resultobj, i, o);
39482 : }
39483 : }
39484 : return resultobj;
39485 : fail:
39486 : return NULL;
39487 : }
39488 :
39489 :
39490 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39491 0 : PyObject *resultobj = 0;
39492 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39493 0 : char *arg2 = (char *) 0 ;
39494 0 : void *argp1 = 0 ;
39495 0 : int res1 = 0 ;
39496 : int res2 ;
39497 0 : char *buf2 = 0 ;
39498 0 : int alloc2 = 0 ;
39499 0 : PyObject * obj0 = 0 ;
39500 0 : PyObject * obj1 = 0 ;
39501 :
39502 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_no_arg_description_set",&obj0,&obj1)) SWIG_fail;
39503 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39504 0 : if (!SWIG_IsOK(res1)) {
39505 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39506 : }
39507 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39508 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
39509 0 : if (!SWIG_IsOK(res2)) {
39510 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_no_arg_description_set" "', argument " "2"" of type '" "char *""'");
39511 : }
39512 0 : arg2 = (char *)(buf2);
39513 : {
39514 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39515 0 : if (arg1->no_arg_description) free((char*)arg1->no_arg_description);
39516 0 : if (arg2) {
39517 0 : size_t size = strlen((const char *)(arg2)) + 1;
39518 0 : arg1->no_arg_description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
39519 : } else {
39520 0 : arg1->no_arg_description = 0;
39521 : }
39522 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39523 : }
39524 0 : resultobj = SWIG_Py_Void();
39525 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39526 : return resultobj;
39527 : fail:
39528 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39529 : return NULL;
39530 : }
39531 :
39532 :
39533 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39534 0 : PyObject *resultobj = 0;
39535 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39536 0 : void *argp1 = 0 ;
39537 0 : int res1 = 0 ;
39538 0 : PyObject * obj0 = 0 ;
39539 0 : char *result = 0 ;
39540 :
39541 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_no_arg_description_get",&obj0)) SWIG_fail;
39542 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39543 0 : if (!SWIG_IsOK(res1)) {
39544 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39545 : }
39546 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39547 : {
39548 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39549 0 : result = (char *) ((arg1)->no_arg_description);
39550 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39551 : }
39552 0 : resultobj = SWIG_FromCharPtr((const char *)result);
39553 0 : return resultobj;
39554 : fail:
39555 : return NULL;
39556 : }
39557 :
39558 :
39559 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39560 0 : PyObject *resultobj = 0;
39561 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39562 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
39563 0 : void *argp1 = 0 ;
39564 0 : int res1 = 0 ;
39565 0 : void *argp2 = 0 ;
39566 0 : int res2 = 0 ;
39567 0 : PyObject * obj0 = 0 ;
39568 0 : PyObject * obj1 = 0 ;
39569 :
39570 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_value_set",&obj0,&obj1)) SWIG_fail;
39571 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39572 0 : if (!SWIG_IsOK(res1)) {
39573 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39574 : }
39575 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39576 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
39577 0 : if (!SWIG_IsOK(res2)) {
39578 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
39579 : }
39580 0 : arg2 = (gpgme_conf_arg_t)(argp2);
39581 : {
39582 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39583 0 : if (arg1) (arg1)->value = arg2;
39584 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39585 : }
39586 0 : resultobj = SWIG_Py_Void();
39587 0 : return resultobj;
39588 : fail:
39589 : return NULL;
39590 : }
39591 :
39592 :
39593 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39594 0 : PyObject *resultobj = 0;
39595 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39596 0 : void *argp1 = 0 ;
39597 0 : int res1 = 0 ;
39598 0 : PyObject * obj0 = 0 ;
39599 : gpgme_conf_arg_t result;
39600 :
39601 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_value_get",&obj0)) SWIG_fail;
39602 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39603 0 : if (!SWIG_IsOK(res1)) {
39604 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39605 : }
39606 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39607 : {
39608 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39609 0 : result = (gpgme_conf_arg_t) ((arg1)->value);
39610 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39611 : }
39612 : {
39613 : int i;
39614 0 : int size = 0;
39615 : gpgme_conf_arg_t curr;
39616 0 : for (curr = result; curr != NULL; curr = curr->next) {
39617 0 : size++;
39618 : }
39619 0 : resultobj = PyList_New(size);
39620 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
39621 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
39622 0 : PyList_SetItem(resultobj, i, o);
39623 : }
39624 : }
39625 : return resultobj;
39626 : fail:
39627 : return NULL;
39628 : }
39629 :
39630 :
39631 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39632 0 : PyObject *resultobj = 0;
39633 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39634 : int arg2 ;
39635 0 : void *argp1 = 0 ;
39636 0 : int res1 = 0 ;
39637 : int val2 ;
39638 0 : int ecode2 = 0 ;
39639 0 : PyObject * obj0 = 0 ;
39640 0 : PyObject * obj1 = 0 ;
39641 :
39642 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_change_value_set",&obj0,&obj1)) SWIG_fail;
39643 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39644 0 : if (!SWIG_IsOK(res1)) {
39645 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39646 : }
39647 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39648 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
39649 0 : if (!SWIG_IsOK(ecode2)) {
39650 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_change_value_set" "', argument " "2"" of type '" "int""'");
39651 : }
39652 0 : arg2 = (int)(val2);
39653 : {
39654 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39655 0 : if (arg1) (arg1)->change_value = arg2;
39656 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39657 : }
39658 0 : resultobj = SWIG_Py_Void();
39659 0 : return resultobj;
39660 : fail:
39661 : return NULL;
39662 : }
39663 :
39664 :
39665 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39666 0 : PyObject *resultobj = 0;
39667 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39668 0 : void *argp1 = 0 ;
39669 0 : int res1 = 0 ;
39670 0 : PyObject * obj0 = 0 ;
39671 : int result;
39672 :
39673 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_change_value_get",&obj0)) SWIG_fail;
39674 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39675 0 : if (!SWIG_IsOK(res1)) {
39676 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39677 : }
39678 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39679 : {
39680 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39681 0 : result = (int) ((arg1)->change_value);
39682 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39683 : }
39684 0 : resultobj = SWIG_From_int((int)(result));
39685 0 : return resultobj;
39686 : fail:
39687 : return NULL;
39688 : }
39689 :
39690 :
39691 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_new_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39692 0 : PyObject *resultobj = 0;
39693 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39694 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
39695 0 : void *argp1 = 0 ;
39696 0 : int res1 = 0 ;
39697 0 : void *argp2 = 0 ;
39698 0 : int res2 = 0 ;
39699 0 : PyObject * obj0 = 0 ;
39700 0 : PyObject * obj1 = 0 ;
39701 :
39702 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_new_value_set",&obj0,&obj1)) SWIG_fail;
39703 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39704 0 : if (!SWIG_IsOK(res1)) {
39705 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_new_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39706 : }
39707 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39708 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
39709 0 : if (!SWIG_IsOK(res2)) {
39710 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_new_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
39711 : }
39712 0 : arg2 = (gpgme_conf_arg_t)(argp2);
39713 : {
39714 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39715 0 : if (arg1) (arg1)->new_value = arg2;
39716 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39717 : }
39718 0 : resultobj = SWIG_Py_Void();
39719 0 : return resultobj;
39720 : fail:
39721 : return NULL;
39722 : }
39723 :
39724 :
39725 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_new_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39726 0 : PyObject *resultobj = 0;
39727 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39728 0 : void *argp1 = 0 ;
39729 0 : int res1 = 0 ;
39730 0 : PyObject * obj0 = 0 ;
39731 : gpgme_conf_arg_t result;
39732 :
39733 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_new_value_get",&obj0)) SWIG_fail;
39734 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39735 0 : if (!SWIG_IsOK(res1)) {
39736 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_new_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39737 : }
39738 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39739 : {
39740 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39741 0 : result = (gpgme_conf_arg_t) ((arg1)->new_value);
39742 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39743 : }
39744 : {
39745 : int i;
39746 0 : int size = 0;
39747 : gpgme_conf_arg_t curr;
39748 0 : for (curr = result; curr != NULL; curr = curr->next) {
39749 0 : size++;
39750 : }
39751 0 : resultobj = PyList_New(size);
39752 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
39753 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
39754 0 : PyList_SetItem(resultobj, i, o);
39755 : }
39756 : }
39757 : return resultobj;
39758 : fail:
39759 : return NULL;
39760 : }
39761 :
39762 :
39763 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_user_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39764 0 : PyObject *resultobj = 0;
39765 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39766 0 : void *arg2 = (void *) 0 ;
39767 0 : void *argp1 = 0 ;
39768 0 : int res1 = 0 ;
39769 : int res2 ;
39770 0 : PyObject * obj0 = 0 ;
39771 0 : PyObject * obj1 = 0 ;
39772 :
39773 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_user_data_set",&obj0,&obj1)) SWIG_fail;
39774 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39775 0 : if (!SWIG_IsOK(res1)) {
39776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_user_data_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39777 : }
39778 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39779 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
39780 0 : if (!SWIG_IsOK(res2)) {
39781 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_user_data_set" "', argument " "2"" of type '" "void *""'");
39782 : }
39783 : {
39784 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39785 0 : if (arg1) (arg1)->user_data = arg2;
39786 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39787 : }
39788 0 : resultobj = SWIG_Py_Void();
39789 0 : return resultobj;
39790 : fail:
39791 : return NULL;
39792 : }
39793 :
39794 :
39795 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_user_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39796 0 : PyObject *resultobj = 0;
39797 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39798 0 : void *argp1 = 0 ;
39799 0 : int res1 = 0 ;
39800 0 : PyObject * obj0 = 0 ;
39801 0 : void *result = 0 ;
39802 :
39803 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_user_data_get",&obj0)) SWIG_fail;
39804 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
39805 0 : if (!SWIG_IsOK(res1)) {
39806 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_user_data_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39807 : }
39808 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39809 : {
39810 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39811 0 : result = (void *) ((arg1)->user_data);
39812 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39813 : }
39814 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
39815 0 : return resultobj;
39816 : fail:
39817 : return NULL;
39818 : }
39819 :
39820 :
39821 0 : SWIGINTERN PyObject *_wrap_new_gpgme_conf_opt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39822 0 : PyObject *resultobj = 0;
39823 0 : struct gpgme_conf_opt *result = 0 ;
39824 :
39825 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_conf_opt")) SWIG_fail;
39826 : {
39827 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39828 0 : result = (struct gpgme_conf_opt *)calloc(1, sizeof(struct gpgme_conf_opt));
39829 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39830 : }
39831 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_opt, SWIG_POINTER_NEW | 0 );
39832 0 : return resultobj;
39833 : fail:
39834 : return NULL;
39835 : }
39836 :
39837 :
39838 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_opt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39839 0 : PyObject *resultobj = 0;
39840 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
39841 0 : void *argp1 = 0 ;
39842 0 : int res1 = 0 ;
39843 0 : PyObject * obj0 = 0 ;
39844 :
39845 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_conf_opt",&obj0)) SWIG_fail;
39846 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, SWIG_POINTER_DISOWN | 0 );
39847 0 : if (!SWIG_IsOK(res1)) {
39848 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_opt" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
39849 : }
39850 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
39851 : {
39852 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39853 0 : free((char *) arg1);
39854 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39855 : }
39856 0 : resultobj = SWIG_Py_Void();
39857 0 : return resultobj;
39858 : fail:
39859 : return NULL;
39860 : }
39861 :
39862 :
39863 29 : SWIGINTERN PyObject *gpgme_conf_opt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39864 : PyObject *obj;
39865 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
39866 58 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_conf_opt, SWIG_NewClientData(obj));
39867 29 : return SWIG_Py_Void();
39868 : }
39869 :
39870 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp__last_opt_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39871 0 : PyObject *resultobj = 0;
39872 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
39873 0 : gpgme_conf_opt_t *arg2 = (gpgme_conf_opt_t *) 0 ;
39874 0 : void *argp1 = 0 ;
39875 0 : int res1 = 0 ;
39876 0 : void *argp2 = 0 ;
39877 0 : int res2 = 0 ;
39878 0 : PyObject * obj0 = 0 ;
39879 0 : PyObject * obj1 = 0 ;
39880 :
39881 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp__last_opt_p_set",&obj0,&obj1)) SWIG_fail;
39882 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
39883 0 : if (!SWIG_IsOK(res1)) {
39884 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp__last_opt_p_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
39885 : }
39886 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
39887 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_gpgme_conf_opt, 0 | 0 );
39888 0 : if (!SWIG_IsOK(res2)) {
39889 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp__last_opt_p_set" "', argument " "2"" of type '" "gpgme_conf_opt_t *""'");
39890 : }
39891 0 : arg2 = (gpgme_conf_opt_t *)(argp2);
39892 : {
39893 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39894 0 : if (arg1) (arg1)->_last_opt_p = arg2;
39895 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39896 : }
39897 0 : resultobj = SWIG_Py_Void();
39898 0 : return resultobj;
39899 : fail:
39900 : return NULL;
39901 : }
39902 :
39903 :
39904 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp__last_opt_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39905 0 : PyObject *resultobj = 0;
39906 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
39907 0 : void *argp1 = 0 ;
39908 0 : int res1 = 0 ;
39909 0 : PyObject * obj0 = 0 ;
39910 0 : gpgme_conf_opt_t *result = 0 ;
39911 :
39912 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp__last_opt_p_get",&obj0)) SWIG_fail;
39913 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
39914 0 : if (!SWIG_IsOK(res1)) {
39915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp__last_opt_p_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
39916 : }
39917 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
39918 : {
39919 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39920 0 : result = (gpgme_conf_opt_t *) ((arg1)->_last_opt_p);
39921 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39922 : }
39923 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_conf_opt, 0 | 0 );
39924 0 : return resultobj;
39925 : fail:
39926 : return NULL;
39927 : }
39928 :
39929 :
39930 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39931 0 : PyObject *resultobj = 0;
39932 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
39933 0 : char *arg2 = (char *) 0 ;
39934 0 : void *argp1 = 0 ;
39935 0 : int res1 = 0 ;
39936 : int res2 ;
39937 0 : char *buf2 = 0 ;
39938 0 : int alloc2 = 0 ;
39939 0 : PyObject * obj0 = 0 ;
39940 0 : PyObject * obj1 = 0 ;
39941 :
39942 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp_name_set",&obj0,&obj1)) SWIG_fail;
39943 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
39944 0 : if (!SWIG_IsOK(res1)) {
39945 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_name_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
39946 : }
39947 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
39948 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
39949 0 : if (!SWIG_IsOK(res2)) {
39950 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_name_set" "', argument " "2"" of type '" "char *""'");
39951 : }
39952 0 : arg2 = (char *)(buf2);
39953 : {
39954 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39955 0 : if (arg1->name) free((char*)arg1->name);
39956 0 : if (arg2) {
39957 0 : size_t size = strlen((const char *)(arg2)) + 1;
39958 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
39959 : } else {
39960 0 : arg1->name = 0;
39961 : }
39962 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39963 : }
39964 0 : resultobj = SWIG_Py_Void();
39965 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39966 : return resultobj;
39967 : fail:
39968 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
39969 : return NULL;
39970 : }
39971 :
39972 :
39973 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39974 0 : PyObject *resultobj = 0;
39975 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
39976 0 : void *argp1 = 0 ;
39977 0 : int res1 = 0 ;
39978 0 : PyObject * obj0 = 0 ;
39979 0 : char *result = 0 ;
39980 :
39981 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_name_get",&obj0)) SWIG_fail;
39982 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
39983 0 : if (!SWIG_IsOK(res1)) {
39984 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_name_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
39985 : }
39986 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
39987 : {
39988 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39989 0 : result = (char *) ((arg1)->name);
39990 0 : SWIG_PYTHON_THREAD_END_ALLOW;
39991 : }
39992 0 : resultobj = SWIG_FromCharPtr((const char *)result);
39993 0 : return resultobj;
39994 : fail:
39995 : return NULL;
39996 : }
39997 :
39998 :
39999 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40000 0 : PyObject *resultobj = 0;
40001 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
40002 0 : char *arg2 = (char *) 0 ;
40003 0 : void *argp1 = 0 ;
40004 0 : int res1 = 0 ;
40005 : int res2 ;
40006 0 : char *buf2 = 0 ;
40007 0 : int alloc2 = 0 ;
40008 0 : PyObject * obj0 = 0 ;
40009 0 : PyObject * obj1 = 0 ;
40010 :
40011 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp_description_set",&obj0,&obj1)) SWIG_fail;
40012 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
40013 0 : if (!SWIG_IsOK(res1)) {
40014 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_description_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
40015 : }
40016 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
40017 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
40018 0 : if (!SWIG_IsOK(res2)) {
40019 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_description_set" "', argument " "2"" of type '" "char *""'");
40020 : }
40021 0 : arg2 = (char *)(buf2);
40022 : {
40023 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40024 0 : if (arg1->description) free((char*)arg1->description);
40025 0 : if (arg2) {
40026 0 : size_t size = strlen((const char *)(arg2)) + 1;
40027 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
40028 : } else {
40029 0 : arg1->description = 0;
40030 : }
40031 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40032 : }
40033 0 : resultobj = SWIG_Py_Void();
40034 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40035 : return resultobj;
40036 : fail:
40037 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40038 : return NULL;
40039 : }
40040 :
40041 :
40042 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40043 0 : PyObject *resultobj = 0;
40044 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
40045 0 : void *argp1 = 0 ;
40046 0 : int res1 = 0 ;
40047 0 : PyObject * obj0 = 0 ;
40048 0 : char *result = 0 ;
40049 :
40050 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_description_get",&obj0)) SWIG_fail;
40051 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
40052 0 : if (!SWIG_IsOK(res1)) {
40053 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_description_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
40054 : }
40055 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
40056 : {
40057 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40058 0 : result = (char *) ((arg1)->description);
40059 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40060 : }
40061 0 : resultobj = SWIG_FromCharPtr((const char *)result);
40062 0 : return resultobj;
40063 : fail:
40064 : return NULL;
40065 : }
40066 :
40067 :
40068 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_program_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40069 0 : PyObject *resultobj = 0;
40070 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
40071 0 : char *arg2 = (char *) 0 ;
40072 0 : void *argp1 = 0 ;
40073 0 : int res1 = 0 ;
40074 : int res2 ;
40075 0 : char *buf2 = 0 ;
40076 0 : int alloc2 = 0 ;
40077 0 : PyObject * obj0 = 0 ;
40078 0 : PyObject * obj1 = 0 ;
40079 :
40080 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp_program_name_set",&obj0,&obj1)) SWIG_fail;
40081 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
40082 0 : if (!SWIG_IsOK(res1)) {
40083 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_program_name_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
40084 : }
40085 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
40086 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
40087 0 : if (!SWIG_IsOK(res2)) {
40088 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_program_name_set" "', argument " "2"" of type '" "char *""'");
40089 : }
40090 0 : arg2 = (char *)(buf2);
40091 : {
40092 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40093 0 : if (arg1->program_name) free((char*)arg1->program_name);
40094 0 : if (arg2) {
40095 0 : size_t size = strlen((const char *)(arg2)) + 1;
40096 0 : arg1->program_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
40097 : } else {
40098 0 : arg1->program_name = 0;
40099 : }
40100 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40101 : }
40102 0 : resultobj = SWIG_Py_Void();
40103 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40104 : return resultobj;
40105 : fail:
40106 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40107 : return NULL;
40108 : }
40109 :
40110 :
40111 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_program_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40112 0 : PyObject *resultobj = 0;
40113 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
40114 0 : void *argp1 = 0 ;
40115 0 : int res1 = 0 ;
40116 0 : PyObject * obj0 = 0 ;
40117 0 : char *result = 0 ;
40118 :
40119 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_program_name_get",&obj0)) SWIG_fail;
40120 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
40121 0 : if (!SWIG_IsOK(res1)) {
40122 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_program_name_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
40123 : }
40124 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
40125 : {
40126 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40127 0 : result = (char *) ((arg1)->program_name);
40128 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40129 : }
40130 0 : resultobj = SWIG_FromCharPtr((const char *)result);
40131 0 : return resultobj;
40132 : fail:
40133 : return NULL;
40134 : }
40135 :
40136 :
40137 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_options_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40138 0 : PyObject *resultobj = 0;
40139 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
40140 0 : struct gpgme_conf_opt *arg2 = (struct gpgme_conf_opt *) 0 ;
40141 0 : void *argp1 = 0 ;
40142 0 : int res1 = 0 ;
40143 0 : void *argp2 = 0 ;
40144 0 : int res2 = 0 ;
40145 0 : PyObject * obj0 = 0 ;
40146 0 : PyObject * obj1 = 0 ;
40147 :
40148 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp_options_set",&obj0,&obj1)) SWIG_fail;
40149 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
40150 0 : if (!SWIG_IsOK(res1)) {
40151 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_options_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
40152 : }
40153 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
40154 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_opt, SWIG_POINTER_DISOWN | 0 );
40155 0 : if (!SWIG_IsOK(res2)) {
40156 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_options_set" "', argument " "2"" of type '" "struct gpgme_conf_opt *""'");
40157 : }
40158 0 : arg2 = (struct gpgme_conf_opt *)(argp2);
40159 : {
40160 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40161 0 : if (arg1) (arg1)->options = arg2;
40162 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40163 : }
40164 0 : resultobj = SWIG_Py_Void();
40165 0 : return resultobj;
40166 : fail:
40167 : return NULL;
40168 : }
40169 :
40170 :
40171 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_options_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40172 0 : PyObject *resultobj = 0;
40173 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
40174 0 : void *argp1 = 0 ;
40175 0 : int res1 = 0 ;
40176 0 : PyObject * obj0 = 0 ;
40177 0 : struct gpgme_conf_opt *result = 0 ;
40178 :
40179 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_options_get",&obj0)) SWIG_fail;
40180 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
40181 0 : if (!SWIG_IsOK(res1)) {
40182 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_options_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
40183 : }
40184 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
40185 : {
40186 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40187 0 : result = (struct gpgme_conf_opt *) ((arg1)->options);
40188 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40189 : }
40190 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
40191 0 : return resultobj;
40192 : fail:
40193 : return NULL;
40194 : }
40195 :
40196 :
40197 0 : SWIGINTERN PyObject *_wrap_new_gpgme_conf_comp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40198 0 : PyObject *resultobj = 0;
40199 0 : struct gpgme_conf_comp *result = 0 ;
40200 :
40201 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_conf_comp")) SWIG_fail;
40202 : {
40203 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40204 0 : result = (struct gpgme_conf_comp *)calloc(1, sizeof(struct gpgme_conf_comp));
40205 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40206 : }
40207 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_comp, SWIG_POINTER_NEW | 0 );
40208 0 : return resultobj;
40209 : fail:
40210 : return NULL;
40211 : }
40212 :
40213 :
40214 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_comp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40215 0 : PyObject *resultobj = 0;
40216 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
40217 0 : void *argp1 = 0 ;
40218 0 : int res1 = 0 ;
40219 0 : PyObject * obj0 = 0 ;
40220 :
40221 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_conf_comp",&obj0)) SWIG_fail;
40222 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, SWIG_POINTER_DISOWN | 0 );
40223 0 : if (!SWIG_IsOK(res1)) {
40224 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_comp" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
40225 : }
40226 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
40227 : {
40228 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40229 0 : free((char *) arg1);
40230 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40231 : }
40232 0 : resultobj = SWIG_Py_Void();
40233 0 : return resultobj;
40234 : fail:
40235 : return NULL;
40236 : }
40237 :
40238 :
40239 29 : SWIGINTERN PyObject *gpgme_conf_comp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40240 : PyObject *obj;
40241 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
40242 58 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_conf_comp, SWIG_NewClientData(obj));
40243 29 : return SWIG_Py_Void();
40244 : }
40245 :
40246 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_new(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40247 0 : PyObject *resultobj = 0;
40248 0 : gpgme_conf_arg_t *arg1 = (gpgme_conf_arg_t *) 0 ;
40249 : gpgme_conf_type_t arg2 ;
40250 0 : void *arg3 = (void *) 0 ;
40251 0 : void *argp1 = 0 ;
40252 0 : int res1 = 0 ;
40253 : int val2 ;
40254 0 : int ecode2 = 0 ;
40255 : int res3 ;
40256 0 : PyObject * obj0 = 0 ;
40257 0 : PyObject * obj1 = 0 ;
40258 0 : PyObject * obj2 = 0 ;
40259 : gpgme_error_t result;
40260 :
40261 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_conf_arg_new",&obj0,&obj1,&obj2)) SWIG_fail;
40262 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_conf_arg, 0 | 0 );
40263 0 : if (!SWIG_IsOK(res1)) {
40264 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_new" "', argument " "1"" of type '" "gpgme_conf_arg_t *""'");
40265 : }
40266 0 : arg1 = (gpgme_conf_arg_t *)(argp1);
40267 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40268 0 : if (!SWIG_IsOK(ecode2)) {
40269 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_new" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
40270 : }
40271 0 : arg2 = (gpgme_conf_type_t)(val2);
40272 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
40273 0 : if (!SWIG_IsOK(res3)) {
40274 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_conf_arg_new" "', argument " "3"" of type '" "void const *""'");
40275 : }
40276 : {
40277 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40278 0 : result = gpgme_conf_arg_new(arg1,arg2,(void const *)arg3);
40279 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40280 : }
40281 : {
40282 0 : resultobj = PyLong_FromLong(result);
40283 : }
40284 0 : return resultobj;
40285 : fail:
40286 : return NULL;
40287 : }
40288 :
40289 :
40290 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40291 0 : PyObject *resultobj = 0;
40292 0 : gpgme_conf_arg_t arg1 = (gpgme_conf_arg_t) 0 ;
40293 : gpgme_conf_type_t arg2 ;
40294 0 : void *argp1 = 0 ;
40295 0 : int res1 = 0 ;
40296 : int val2 ;
40297 0 : int ecode2 = 0 ;
40298 0 : PyObject * obj0 = 0 ;
40299 0 : PyObject * obj1 = 0 ;
40300 :
40301 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_release",&obj0,&obj1)) SWIG_fail;
40302 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
40303 0 : if (!SWIG_IsOK(res1)) {
40304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_release" "', argument " "1"" of type '" "gpgme_conf_arg_t""'");
40305 : }
40306 0 : arg1 = (gpgme_conf_arg_t)(argp1);
40307 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40308 0 : if (!SWIG_IsOK(ecode2)) {
40309 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_release" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
40310 : }
40311 0 : arg2 = (gpgme_conf_type_t)(val2);
40312 : {
40313 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40314 0 : gpgme_conf_arg_release(arg1,arg2);
40315 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40316 : }
40317 0 : resultobj = SWIG_Py_Void();
40318 0 : return resultobj;
40319 : fail:
40320 : return NULL;
40321 : }
40322 :
40323 :
40324 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40325 0 : PyObject *resultobj = 0;
40326 0 : gpgme_conf_opt_t arg1 = (gpgme_conf_opt_t) 0 ;
40327 : int arg2 ;
40328 0 : gpgme_conf_arg_t arg3 = (gpgme_conf_arg_t) 0 ;
40329 0 : void *argp1 = 0 ;
40330 0 : int res1 = 0 ;
40331 : int val2 ;
40332 0 : int ecode2 = 0 ;
40333 0 : void *argp3 = 0 ;
40334 0 : int res3 = 0 ;
40335 0 : PyObject * obj0 = 0 ;
40336 0 : PyObject * obj1 = 0 ;
40337 0 : PyObject * obj2 = 0 ;
40338 : gpgme_error_t result;
40339 :
40340 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_conf_opt_change",&obj0,&obj1,&obj2)) SWIG_fail;
40341 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
40342 0 : if (!SWIG_IsOK(res1)) {
40343 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change" "', argument " "1"" of type '" "gpgme_conf_opt_t""'");
40344 : }
40345 0 : arg1 = (gpgme_conf_opt_t)(argp1);
40346 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40347 0 : if (!SWIG_IsOK(ecode2)) {
40348 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_change" "', argument " "2"" of type '" "int""'");
40349 : }
40350 0 : arg2 = (int)(val2);
40351 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
40352 0 : if (!SWIG_IsOK(res3)) {
40353 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_conf_opt_change" "', argument " "3"" of type '" "gpgme_conf_arg_t""'");
40354 : }
40355 0 : arg3 = (gpgme_conf_arg_t)(argp3);
40356 : {
40357 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40358 0 : result = gpgme_conf_opt_change(arg1,arg2,arg3);
40359 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40360 : }
40361 : {
40362 0 : resultobj = PyLong_FromLong(result);
40363 : }
40364 0 : return resultobj;
40365 : fail:
40366 : return NULL;
40367 : }
40368 :
40369 :
40370 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40371 0 : PyObject *resultobj = 0;
40372 0 : gpgme_conf_comp_t arg1 = (gpgme_conf_comp_t) 0 ;
40373 0 : void *argp1 = 0 ;
40374 0 : int res1 = 0 ;
40375 0 : PyObject * obj0 = 0 ;
40376 :
40377 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_release",&obj0)) SWIG_fail;
40378 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
40379 0 : if (!SWIG_IsOK(res1)) {
40380 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_release" "', argument " "1"" of type '" "gpgme_conf_comp_t""'");
40381 : }
40382 0 : arg1 = (gpgme_conf_comp_t)(argp1);
40383 : {
40384 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40385 0 : gpgme_conf_release(arg1);
40386 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40387 : }
40388 0 : resultobj = SWIG_Py_Void();
40389 0 : return resultobj;
40390 : fail:
40391 : return NULL;
40392 : }
40393 :
40394 :
40395 0 : SWIGINTERN PyObject *_wrap_gpgme_op_conf_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40396 0 : PyObject *resultobj = 0;
40397 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
40398 0 : gpgme_conf_comp_t *arg2 = (gpgme_conf_comp_t *) 0 ;
40399 0 : void *argp1 = 0 ;
40400 0 : int res1 = 0 ;
40401 0 : void *argp2 = 0 ;
40402 0 : int res2 = 0 ;
40403 0 : PyObject * obj0 = 0 ;
40404 0 : PyObject * obj1 = 0 ;
40405 : gpgme_error_t result;
40406 :
40407 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_conf_load",&obj0,&obj1)) SWIG_fail;
40408 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
40409 0 : if (!SWIG_IsOK(res1)) {
40410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_conf_load" "', argument " "1"" of type '" "gpgme_ctx_t""'");
40411 : }
40412 0 : arg1 = (gpgme_ctx_t)(argp1);
40413 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_gpgme_conf_comp, 0 | 0 );
40414 0 : if (!SWIG_IsOK(res2)) {
40415 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_conf_load" "', argument " "2"" of type '" "gpgme_conf_comp_t *""'");
40416 : }
40417 0 : arg2 = (gpgme_conf_comp_t *)(argp2);
40418 : {
40419 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40420 0 : result = gpgme_op_conf_load(arg1,arg2);
40421 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40422 : }
40423 : {
40424 0 : resultobj = PyLong_FromLong(result);
40425 : }
40426 0 : return resultobj;
40427 : fail:
40428 : return NULL;
40429 : }
40430 :
40431 :
40432 0 : SWIGINTERN PyObject *_wrap_gpgme_op_conf_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40433 0 : PyObject *resultobj = 0;
40434 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
40435 0 : gpgme_conf_comp_t arg2 = (gpgme_conf_comp_t) 0 ;
40436 0 : void *argp1 = 0 ;
40437 0 : int res1 = 0 ;
40438 0 : void *argp2 = 0 ;
40439 0 : int res2 = 0 ;
40440 0 : PyObject * obj0 = 0 ;
40441 0 : PyObject * obj1 = 0 ;
40442 : gpgme_error_t result;
40443 :
40444 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_conf_save",&obj0,&obj1)) SWIG_fail;
40445 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
40446 0 : if (!SWIG_IsOK(res1)) {
40447 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_conf_save" "', argument " "1"" of type '" "gpgme_ctx_t""'");
40448 : }
40449 0 : arg1 = (gpgme_ctx_t)(argp1);
40450 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
40451 0 : if (!SWIG_IsOK(res2)) {
40452 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_conf_save" "', argument " "2"" of type '" "gpgme_conf_comp_t""'");
40453 : }
40454 0 : arg2 = (gpgme_conf_comp_t)(argp2);
40455 : {
40456 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40457 0 : result = gpgme_op_conf_save(arg1,arg2);
40458 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40459 : }
40460 : {
40461 0 : resultobj = PyLong_FromLong(result);
40462 : }
40463 0 : return resultobj;
40464 : fail:
40465 : return NULL;
40466 : }
40467 :
40468 :
40469 0 : SWIGINTERN PyObject *_wrap_gpgme_op_conf_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40470 0 : PyObject *resultobj = 0;
40471 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
40472 0 : char *arg2 = (char *) 0 ;
40473 0 : char **arg3 = (char **) 0 ;
40474 0 : void *argp1 = 0 ;
40475 0 : int res1 = 0 ;
40476 0 : PyObject *encodedInput2 = NULL ;
40477 0 : void *argp3 = 0 ;
40478 0 : int res3 = 0 ;
40479 0 : PyObject * obj0 = 0 ;
40480 0 : PyObject * obj1 = 0 ;
40481 0 : PyObject * obj2 = 0 ;
40482 : gpgme_error_t result;
40483 :
40484 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_conf_dir",&obj0,&obj1,&obj2)) SWIG_fail;
40485 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
40486 0 : if (!SWIG_IsOK(res1)) {
40487 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_conf_dir" "', argument " "1"" of type '" "gpgme_ctx_t""'");
40488 : }
40489 0 : arg1 = (gpgme_ctx_t)(argp1);
40490 : {
40491 0 : if (obj1 == Py_None)
40492 : arg2 = NULL;
40493 0 : else if (PyUnicode_Check(obj1))
40494 : {
40495 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
40496 0 : if (encodedInput2 == NULL)
40497 : return NULL;
40498 0 : arg2 = PyBytes_AsString(encodedInput2);
40499 : }
40500 0 : else if (PyBytes_Check(obj1))
40501 0 : arg2 = PyBytes_AsString(obj1);
40502 : else {
40503 0 : PyErr_Format(PyExc_TypeError,
40504 : "arg %d: expected str, bytes, or None, got %s",
40505 : 2, obj1->ob_type->tp_name);
40506 0 : return NULL;
40507 : }
40508 : }
40509 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_char, 0 | 0 );
40510 0 : if (!SWIG_IsOK(res3)) {
40511 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_op_conf_dir" "', argument " "3"" of type '" "char **""'");
40512 : }
40513 0 : arg3 = (char **)(argp3);
40514 : {
40515 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40516 0 : result = gpgme_op_conf_dir(arg1,(char const *)arg2,arg3);
40517 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40518 : }
40519 : {
40520 0 : resultobj = PyLong_FromLong(result);
40521 : }
40522 : {
40523 0 : Py_XDECREF(encodedInput2);
40524 : }
40525 : return resultobj;
40526 : fail:
40527 : {
40528 0 : Py_XDECREF(encodedInput2);
40529 : }
40530 : return NULL;
40531 : }
40532 :
40533 :
40534 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40535 0 : PyObject *resultobj = 0;
40536 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40537 0 : char *arg2 = (char *) 0 ;
40538 0 : void *argp1 = 0 ;
40539 0 : int res1 = 0 ;
40540 : int res2 ;
40541 0 : char *buf2 = 0 ;
40542 0 : int alloc2 = 0 ;
40543 0 : PyObject * obj0 = 0 ;
40544 0 : PyObject * obj1 = 0 ;
40545 :
40546 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_name_set",&obj0,&obj1)) SWIG_fail;
40547 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40548 0 : if (!SWIG_IsOK(res1)) {
40549 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 *""'");
40550 : }
40551 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40552 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
40553 0 : if (!SWIG_IsOK(res2)) {
40554 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_query_swdb_result_name_set" "', argument " "2"" of type '" "char *""'");
40555 : }
40556 0 : arg2 = (char *)(buf2);
40557 : {
40558 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40559 0 : if (arg1->name) free((char*)arg1->name);
40560 0 : if (arg2) {
40561 0 : size_t size = strlen((const char *)(arg2)) + 1;
40562 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
40563 : } else {
40564 0 : arg1->name = 0;
40565 : }
40566 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40567 : }
40568 0 : resultobj = SWIG_Py_Void();
40569 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40570 : return resultobj;
40571 : fail:
40572 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40573 : return NULL;
40574 : }
40575 :
40576 :
40577 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40578 0 : PyObject *resultobj = 0;
40579 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40580 0 : void *argp1 = 0 ;
40581 0 : int res1 = 0 ;
40582 0 : PyObject * obj0 = 0 ;
40583 0 : char *result = 0 ;
40584 :
40585 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_name_get",&obj0)) SWIG_fail;
40586 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40587 0 : if (!SWIG_IsOK(res1)) {
40588 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 *""'");
40589 : }
40590 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40591 : {
40592 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40593 0 : result = (char *) ((arg1)->name);
40594 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40595 : }
40596 0 : resultobj = SWIG_FromCharPtr((const char *)result);
40597 0 : return resultobj;
40598 : fail:
40599 : return NULL;
40600 : }
40601 :
40602 :
40603 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_iversion_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40604 0 : PyObject *resultobj = 0;
40605 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40606 0 : char *arg2 = (char *) 0 ;
40607 0 : void *argp1 = 0 ;
40608 0 : int res1 = 0 ;
40609 : int res2 ;
40610 0 : char *buf2 = 0 ;
40611 0 : int alloc2 = 0 ;
40612 0 : PyObject * obj0 = 0 ;
40613 0 : PyObject * obj1 = 0 ;
40614 :
40615 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_iversion_set",&obj0,&obj1)) SWIG_fail;
40616 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40617 0 : if (!SWIG_IsOK(res1)) {
40618 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 *""'");
40619 : }
40620 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40621 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
40622 0 : if (!SWIG_IsOK(res2)) {
40623 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_query_swdb_result_iversion_set" "', argument " "2"" of type '" "char *""'");
40624 : }
40625 0 : arg2 = (char *)(buf2);
40626 : {
40627 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40628 0 : if (arg1->iversion) free((char*)arg1->iversion);
40629 0 : if (arg2) {
40630 0 : size_t size = strlen((const char *)(arg2)) + 1;
40631 0 : arg1->iversion = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
40632 : } else {
40633 0 : arg1->iversion = 0;
40634 : }
40635 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40636 : }
40637 0 : resultobj = SWIG_Py_Void();
40638 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40639 : return resultobj;
40640 : fail:
40641 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40642 : return NULL;
40643 : }
40644 :
40645 :
40646 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_iversion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40647 0 : PyObject *resultobj = 0;
40648 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40649 0 : void *argp1 = 0 ;
40650 0 : int res1 = 0 ;
40651 0 : PyObject * obj0 = 0 ;
40652 0 : char *result = 0 ;
40653 :
40654 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_iversion_get",&obj0)) SWIG_fail;
40655 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40656 0 : if (!SWIG_IsOK(res1)) {
40657 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 *""'");
40658 : }
40659 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40660 : {
40661 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40662 0 : result = (char *) ((arg1)->iversion);
40663 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40664 : }
40665 0 : resultobj = SWIG_FromCharPtr((const char *)result);
40666 0 : return resultobj;
40667 : fail:
40668 : return NULL;
40669 : }
40670 :
40671 :
40672 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_created_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40673 0 : PyObject *resultobj = 0;
40674 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40675 : unsigned long arg2 ;
40676 0 : void *argp1 = 0 ;
40677 0 : int res1 = 0 ;
40678 : unsigned long val2 ;
40679 0 : int ecode2 = 0 ;
40680 0 : PyObject * obj0 = 0 ;
40681 0 : PyObject * obj1 = 0 ;
40682 :
40683 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_created_set",&obj0,&obj1)) SWIG_fail;
40684 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40685 0 : if (!SWIG_IsOK(res1)) {
40686 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 *""'");
40687 : }
40688 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40689 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
40690 0 : if (!SWIG_IsOK(ecode2)) {
40691 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_created_set" "', argument " "2"" of type '" "unsigned long""'");
40692 : }
40693 0 : arg2 = (unsigned long)(val2);
40694 : {
40695 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40696 0 : if (arg1) (arg1)->created = arg2;
40697 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40698 : }
40699 0 : resultobj = SWIG_Py_Void();
40700 0 : return resultobj;
40701 : fail:
40702 : return NULL;
40703 : }
40704 :
40705 :
40706 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_created_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40707 0 : PyObject *resultobj = 0;
40708 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40709 0 : void *argp1 = 0 ;
40710 0 : int res1 = 0 ;
40711 0 : PyObject * obj0 = 0 ;
40712 : unsigned long result;
40713 :
40714 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_created_get",&obj0)) SWIG_fail;
40715 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40716 0 : if (!SWIG_IsOK(res1)) {
40717 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 *""'");
40718 : }
40719 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40720 : {
40721 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40722 0 : result = (unsigned long) ((arg1)->created);
40723 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40724 : }
40725 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
40726 0 : return resultobj;
40727 : fail:
40728 : return NULL;
40729 : }
40730 :
40731 :
40732 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_retrieved_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40733 0 : PyObject *resultobj = 0;
40734 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40735 : unsigned long arg2 ;
40736 0 : void *argp1 = 0 ;
40737 0 : int res1 = 0 ;
40738 : unsigned long val2 ;
40739 0 : int ecode2 = 0 ;
40740 0 : PyObject * obj0 = 0 ;
40741 0 : PyObject * obj1 = 0 ;
40742 :
40743 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_retrieved_set",&obj0,&obj1)) SWIG_fail;
40744 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40745 0 : if (!SWIG_IsOK(res1)) {
40746 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 *""'");
40747 : }
40748 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40749 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
40750 0 : if (!SWIG_IsOK(ecode2)) {
40751 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_retrieved_set" "', argument " "2"" of type '" "unsigned long""'");
40752 : }
40753 0 : arg2 = (unsigned long)(val2);
40754 : {
40755 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40756 0 : if (arg1) (arg1)->retrieved = arg2;
40757 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40758 : }
40759 0 : resultobj = SWIG_Py_Void();
40760 0 : return resultobj;
40761 : fail:
40762 : return NULL;
40763 : }
40764 :
40765 :
40766 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_retrieved_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40767 0 : PyObject *resultobj = 0;
40768 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40769 0 : void *argp1 = 0 ;
40770 0 : int res1 = 0 ;
40771 0 : PyObject * obj0 = 0 ;
40772 : unsigned long result;
40773 :
40774 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_retrieved_get",&obj0)) SWIG_fail;
40775 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40776 0 : if (!SWIG_IsOK(res1)) {
40777 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 *""'");
40778 : }
40779 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40780 : {
40781 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40782 0 : result = (unsigned long) ((arg1)->retrieved);
40783 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40784 : }
40785 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
40786 0 : return resultobj;
40787 : fail:
40788 : return NULL;
40789 : }
40790 :
40791 :
40792 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_warning_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40793 0 : PyObject *resultobj = 0;
40794 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40795 : unsigned int arg2 ;
40796 0 : void *argp1 = 0 ;
40797 0 : int res1 = 0 ;
40798 : unsigned int val2 ;
40799 0 : int ecode2 = 0 ;
40800 0 : PyObject * obj0 = 0 ;
40801 0 : PyObject * obj1 = 0 ;
40802 :
40803 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_warning_set",&obj0,&obj1)) SWIG_fail;
40804 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40805 0 : if (!SWIG_IsOK(res1)) {
40806 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 *""'");
40807 : }
40808 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40809 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
40810 0 : if (!SWIG_IsOK(ecode2)) {
40811 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_warning_set" "', argument " "2"" of type '" "unsigned int""'");
40812 : }
40813 0 : arg2 = (unsigned int)(val2);
40814 : {
40815 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40816 0 : if (arg1) (arg1)->warning = arg2;
40817 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40818 : }
40819 0 : resultobj = SWIG_Py_Void();
40820 0 : return resultobj;
40821 : fail:
40822 : return NULL;
40823 : }
40824 :
40825 :
40826 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_warning_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40827 0 : PyObject *resultobj = 0;
40828 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40829 0 : void *argp1 = 0 ;
40830 0 : int res1 = 0 ;
40831 0 : PyObject * obj0 = 0 ;
40832 : unsigned int result;
40833 :
40834 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_warning_get",&obj0)) SWIG_fail;
40835 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40836 0 : if (!SWIG_IsOK(res1)) {
40837 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 *""'");
40838 : }
40839 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40840 : {
40841 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40842 0 : result = (unsigned int) ((arg1)->warning);
40843 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40844 : }
40845 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
40846 0 : return resultobj;
40847 : fail:
40848 : return NULL;
40849 : }
40850 :
40851 :
40852 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_update_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40853 0 : PyObject *resultobj = 0;
40854 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40855 : unsigned int arg2 ;
40856 0 : void *argp1 = 0 ;
40857 0 : int res1 = 0 ;
40858 : unsigned int val2 ;
40859 0 : int ecode2 = 0 ;
40860 0 : PyObject * obj0 = 0 ;
40861 0 : PyObject * obj1 = 0 ;
40862 :
40863 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_update_set",&obj0,&obj1)) SWIG_fail;
40864 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40865 0 : if (!SWIG_IsOK(res1)) {
40866 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 *""'");
40867 : }
40868 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40869 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
40870 0 : if (!SWIG_IsOK(ecode2)) {
40871 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_update_set" "', argument " "2"" of type '" "unsigned int""'");
40872 : }
40873 0 : arg2 = (unsigned int)(val2);
40874 : {
40875 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40876 0 : if (arg1) (arg1)->update = arg2;
40877 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40878 : }
40879 0 : resultobj = SWIG_Py_Void();
40880 0 : return resultobj;
40881 : fail:
40882 : return NULL;
40883 : }
40884 :
40885 :
40886 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_update_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40887 0 : PyObject *resultobj = 0;
40888 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40889 0 : void *argp1 = 0 ;
40890 0 : int res1 = 0 ;
40891 0 : PyObject * obj0 = 0 ;
40892 : unsigned int result;
40893 :
40894 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_update_get",&obj0)) SWIG_fail;
40895 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40896 0 : if (!SWIG_IsOK(res1)) {
40897 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 *""'");
40898 : }
40899 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40900 : {
40901 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40902 0 : result = (unsigned int) ((arg1)->update);
40903 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40904 : }
40905 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
40906 0 : return resultobj;
40907 : fail:
40908 : return NULL;
40909 : }
40910 :
40911 :
40912 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_urgent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40913 0 : PyObject *resultobj = 0;
40914 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40915 : unsigned int arg2 ;
40916 0 : void *argp1 = 0 ;
40917 0 : int res1 = 0 ;
40918 : unsigned int val2 ;
40919 0 : int ecode2 = 0 ;
40920 0 : PyObject * obj0 = 0 ;
40921 0 : PyObject * obj1 = 0 ;
40922 :
40923 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_urgent_set",&obj0,&obj1)) SWIG_fail;
40924 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40925 0 : if (!SWIG_IsOK(res1)) {
40926 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 *""'");
40927 : }
40928 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40929 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
40930 0 : if (!SWIG_IsOK(ecode2)) {
40931 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_urgent_set" "', argument " "2"" of type '" "unsigned int""'");
40932 : }
40933 0 : arg2 = (unsigned int)(val2);
40934 : {
40935 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40936 0 : if (arg1) (arg1)->urgent = arg2;
40937 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40938 : }
40939 0 : resultobj = SWIG_Py_Void();
40940 0 : return resultobj;
40941 : fail:
40942 : return NULL;
40943 : }
40944 :
40945 :
40946 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_urgent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40947 0 : PyObject *resultobj = 0;
40948 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40949 0 : void *argp1 = 0 ;
40950 0 : int res1 = 0 ;
40951 0 : PyObject * obj0 = 0 ;
40952 : unsigned int result;
40953 :
40954 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_urgent_get",&obj0)) SWIG_fail;
40955 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40956 0 : if (!SWIG_IsOK(res1)) {
40957 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 *""'");
40958 : }
40959 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40960 : {
40961 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40962 0 : result = (unsigned int) ((arg1)->urgent);
40963 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40964 : }
40965 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
40966 0 : return resultobj;
40967 : fail:
40968 : return NULL;
40969 : }
40970 :
40971 :
40972 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_noinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40973 0 : PyObject *resultobj = 0;
40974 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
40975 : unsigned int arg2 ;
40976 0 : void *argp1 = 0 ;
40977 0 : int res1 = 0 ;
40978 : unsigned int val2 ;
40979 0 : int ecode2 = 0 ;
40980 0 : PyObject * obj0 = 0 ;
40981 0 : PyObject * obj1 = 0 ;
40982 :
40983 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_noinfo_set",&obj0,&obj1)) SWIG_fail;
40984 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
40985 0 : if (!SWIG_IsOK(res1)) {
40986 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 *""'");
40987 : }
40988 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
40989 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
40990 0 : if (!SWIG_IsOK(ecode2)) {
40991 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_noinfo_set" "', argument " "2"" of type '" "unsigned int""'");
40992 : }
40993 0 : arg2 = (unsigned int)(val2);
40994 : {
40995 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40996 0 : if (arg1) (arg1)->noinfo = arg2;
40997 0 : SWIG_PYTHON_THREAD_END_ALLOW;
40998 : }
40999 0 : resultobj = SWIG_Py_Void();
41000 0 : return resultobj;
41001 : fail:
41002 : return NULL;
41003 : }
41004 :
41005 :
41006 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_noinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41007 0 : PyObject *resultobj = 0;
41008 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41009 0 : void *argp1 = 0 ;
41010 0 : int res1 = 0 ;
41011 0 : PyObject * obj0 = 0 ;
41012 : unsigned int result;
41013 :
41014 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_noinfo_get",&obj0)) SWIG_fail;
41015 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41016 0 : if (!SWIG_IsOK(res1)) {
41017 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 *""'");
41018 : }
41019 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41020 : {
41021 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41022 0 : result = (unsigned int) ((arg1)->noinfo);
41023 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41024 : }
41025 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
41026 0 : return resultobj;
41027 : fail:
41028 : return NULL;
41029 : }
41030 :
41031 :
41032 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_unknown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41033 0 : PyObject *resultobj = 0;
41034 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41035 : unsigned int arg2 ;
41036 0 : void *argp1 = 0 ;
41037 0 : int res1 = 0 ;
41038 : unsigned int val2 ;
41039 0 : int ecode2 = 0 ;
41040 0 : PyObject * obj0 = 0 ;
41041 0 : PyObject * obj1 = 0 ;
41042 :
41043 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_unknown_set",&obj0,&obj1)) SWIG_fail;
41044 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41045 0 : if (!SWIG_IsOK(res1)) {
41046 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 *""'");
41047 : }
41048 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41049 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
41050 0 : if (!SWIG_IsOK(ecode2)) {
41051 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_unknown_set" "', argument " "2"" of type '" "unsigned int""'");
41052 : }
41053 0 : arg2 = (unsigned int)(val2);
41054 : {
41055 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41056 0 : if (arg1) (arg1)->unknown = arg2;
41057 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41058 : }
41059 0 : resultobj = SWIG_Py_Void();
41060 0 : return resultobj;
41061 : fail:
41062 : return NULL;
41063 : }
41064 :
41065 :
41066 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_unknown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41067 0 : PyObject *resultobj = 0;
41068 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41069 0 : void *argp1 = 0 ;
41070 0 : int res1 = 0 ;
41071 0 : PyObject * obj0 = 0 ;
41072 : unsigned int result;
41073 :
41074 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_unknown_get",&obj0)) SWIG_fail;
41075 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41076 0 : if (!SWIG_IsOK(res1)) {
41077 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 *""'");
41078 : }
41079 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41080 : {
41081 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41082 0 : result = (unsigned int) ((arg1)->unknown);
41083 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41084 : }
41085 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
41086 0 : return resultobj;
41087 : fail:
41088 : return NULL;
41089 : }
41090 :
41091 :
41092 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_tooold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41093 0 : PyObject *resultobj = 0;
41094 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41095 : unsigned int arg2 ;
41096 0 : void *argp1 = 0 ;
41097 0 : int res1 = 0 ;
41098 : unsigned int val2 ;
41099 0 : int ecode2 = 0 ;
41100 0 : PyObject * obj0 = 0 ;
41101 0 : PyObject * obj1 = 0 ;
41102 :
41103 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_tooold_set",&obj0,&obj1)) SWIG_fail;
41104 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41105 0 : if (!SWIG_IsOK(res1)) {
41106 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 *""'");
41107 : }
41108 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41109 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
41110 0 : if (!SWIG_IsOK(ecode2)) {
41111 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_tooold_set" "', argument " "2"" of type '" "unsigned int""'");
41112 : }
41113 0 : arg2 = (unsigned int)(val2);
41114 : {
41115 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41116 0 : if (arg1) (arg1)->tooold = arg2;
41117 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41118 : }
41119 0 : resultobj = SWIG_Py_Void();
41120 0 : return resultobj;
41121 : fail:
41122 : return NULL;
41123 : }
41124 :
41125 :
41126 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_tooold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41127 0 : PyObject *resultobj = 0;
41128 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41129 0 : void *argp1 = 0 ;
41130 0 : int res1 = 0 ;
41131 0 : PyObject * obj0 = 0 ;
41132 : unsigned int result;
41133 :
41134 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_tooold_get",&obj0)) SWIG_fail;
41135 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41136 0 : if (!SWIG_IsOK(res1)) {
41137 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 *""'");
41138 : }
41139 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41140 : {
41141 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41142 0 : result = (unsigned int) ((arg1)->tooold);
41143 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41144 : }
41145 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
41146 0 : return resultobj;
41147 : fail:
41148 : return NULL;
41149 : }
41150 :
41151 :
41152 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_error_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41153 0 : PyObject *resultobj = 0;
41154 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41155 : unsigned int arg2 ;
41156 0 : void *argp1 = 0 ;
41157 0 : int res1 = 0 ;
41158 : unsigned int val2 ;
41159 0 : int ecode2 = 0 ;
41160 0 : PyObject * obj0 = 0 ;
41161 0 : PyObject * obj1 = 0 ;
41162 :
41163 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_error_set",&obj0,&obj1)) SWIG_fail;
41164 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41165 0 : if (!SWIG_IsOK(res1)) {
41166 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 *""'");
41167 : }
41168 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41169 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
41170 0 : if (!SWIG_IsOK(ecode2)) {
41171 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_error_set" "', argument " "2"" of type '" "unsigned int""'");
41172 : }
41173 0 : arg2 = (unsigned int)(val2);
41174 : {
41175 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41176 0 : if (arg1) (arg1)->error = arg2;
41177 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41178 : }
41179 0 : resultobj = SWIG_Py_Void();
41180 0 : return resultobj;
41181 : fail:
41182 : return NULL;
41183 : }
41184 :
41185 :
41186 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_error_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41187 0 : PyObject *resultobj = 0;
41188 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41189 0 : void *argp1 = 0 ;
41190 0 : int res1 = 0 ;
41191 0 : PyObject * obj0 = 0 ;
41192 : unsigned int result;
41193 :
41194 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_error_get",&obj0)) SWIG_fail;
41195 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41196 0 : if (!SWIG_IsOK(res1)) {
41197 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 *""'");
41198 : }
41199 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41200 : {
41201 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41202 0 : result = (unsigned int) ((arg1)->error);
41203 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41204 : }
41205 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
41206 0 : return resultobj;
41207 : fail:
41208 : return NULL;
41209 : }
41210 :
41211 :
41212 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result__reserved_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41213 0 : PyObject *resultobj = 0;
41214 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41215 : unsigned int arg2 ;
41216 0 : void *argp1 = 0 ;
41217 0 : int res1 = 0 ;
41218 : unsigned int val2 ;
41219 0 : int ecode2 = 0 ;
41220 0 : PyObject * obj0 = 0 ;
41221 0 : PyObject * obj1 = 0 ;
41222 :
41223 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result__reserved_set",&obj0,&obj1)) SWIG_fail;
41224 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41225 0 : if (!SWIG_IsOK(res1)) {
41226 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 *""'");
41227 : }
41228 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41229 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
41230 0 : if (!SWIG_IsOK(ecode2)) {
41231 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result__reserved_set" "', argument " "2"" of type '" "unsigned int""'");
41232 : }
41233 0 : arg2 = (unsigned int)(val2);
41234 : {
41235 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41236 0 : if (arg1) (arg1)->_reserved = arg2;
41237 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41238 : }
41239 0 : resultobj = SWIG_Py_Void();
41240 0 : return resultobj;
41241 : fail:
41242 : return NULL;
41243 : }
41244 :
41245 :
41246 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result__reserved_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41247 0 : PyObject *resultobj = 0;
41248 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41249 0 : void *argp1 = 0 ;
41250 0 : int res1 = 0 ;
41251 0 : PyObject * obj0 = 0 ;
41252 : unsigned int result;
41253 :
41254 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result__reserved_get",&obj0)) SWIG_fail;
41255 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41256 0 : if (!SWIG_IsOK(res1)) {
41257 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 *""'");
41258 : }
41259 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41260 : {
41261 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41262 0 : result = (unsigned int) ((arg1)->_reserved);
41263 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41264 : }
41265 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
41266 0 : return resultobj;
41267 : fail:
41268 : return NULL;
41269 : }
41270 :
41271 :
41272 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41273 0 : PyObject *resultobj = 0;
41274 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41275 0 : char *arg2 = (char *) 0 ;
41276 0 : void *argp1 = 0 ;
41277 0 : int res1 = 0 ;
41278 : int res2 ;
41279 0 : char *buf2 = 0 ;
41280 0 : int alloc2 = 0 ;
41281 0 : PyObject * obj0 = 0 ;
41282 0 : PyObject * obj1 = 0 ;
41283 :
41284 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_version_set",&obj0,&obj1)) SWIG_fail;
41285 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41286 0 : if (!SWIG_IsOK(res1)) {
41287 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 *""'");
41288 : }
41289 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41290 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
41291 0 : if (!SWIG_IsOK(res2)) {
41292 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_query_swdb_result_version_set" "', argument " "2"" of type '" "char *""'");
41293 : }
41294 0 : arg2 = (char *)(buf2);
41295 : {
41296 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41297 0 : if (arg1->version) free((char*)arg1->version);
41298 0 : if (arg2) {
41299 0 : size_t size = strlen((const char *)(arg2)) + 1;
41300 0 : arg1->version = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
41301 : } else {
41302 0 : arg1->version = 0;
41303 : }
41304 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41305 : }
41306 0 : resultobj = SWIG_Py_Void();
41307 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
41308 : return resultobj;
41309 : fail:
41310 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
41311 : return NULL;
41312 : }
41313 :
41314 :
41315 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41316 0 : PyObject *resultobj = 0;
41317 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41318 0 : void *argp1 = 0 ;
41319 0 : int res1 = 0 ;
41320 0 : PyObject * obj0 = 0 ;
41321 0 : char *result = 0 ;
41322 :
41323 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_version_get",&obj0)) SWIG_fail;
41324 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41325 0 : if (!SWIG_IsOK(res1)) {
41326 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 *""'");
41327 : }
41328 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41329 : {
41330 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41331 0 : result = (char *) ((arg1)->version);
41332 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41333 : }
41334 0 : resultobj = SWIG_FromCharPtr((const char *)result);
41335 0 : return resultobj;
41336 : fail:
41337 : return NULL;
41338 : }
41339 :
41340 :
41341 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_reldate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41342 0 : PyObject *resultobj = 0;
41343 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41344 : unsigned long arg2 ;
41345 0 : void *argp1 = 0 ;
41346 0 : int res1 = 0 ;
41347 : unsigned long val2 ;
41348 0 : int ecode2 = 0 ;
41349 0 : PyObject * obj0 = 0 ;
41350 0 : PyObject * obj1 = 0 ;
41351 :
41352 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_reldate_set",&obj0,&obj1)) SWIG_fail;
41353 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41354 0 : if (!SWIG_IsOK(res1)) {
41355 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 *""'");
41356 : }
41357 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41358 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41359 0 : if (!SWIG_IsOK(ecode2)) {
41360 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_reldate_set" "', argument " "2"" of type '" "unsigned long""'");
41361 : }
41362 0 : arg2 = (unsigned long)(val2);
41363 : {
41364 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41365 0 : if (arg1) (arg1)->reldate = arg2;
41366 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41367 : }
41368 0 : resultobj = SWIG_Py_Void();
41369 0 : return resultobj;
41370 : fail:
41371 : return NULL;
41372 : }
41373 :
41374 :
41375 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_reldate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41376 0 : PyObject *resultobj = 0;
41377 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41378 0 : void *argp1 = 0 ;
41379 0 : int res1 = 0 ;
41380 0 : PyObject * obj0 = 0 ;
41381 : unsigned long result;
41382 :
41383 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_reldate_get",&obj0)) SWIG_fail;
41384 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41385 0 : if (!SWIG_IsOK(res1)) {
41386 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 *""'");
41387 : }
41388 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41389 : {
41390 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41391 0 : result = (unsigned long) ((arg1)->reldate);
41392 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41393 : }
41394 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
41395 0 : return resultobj;
41396 : fail:
41397 : return NULL;
41398 : }
41399 :
41400 :
41401 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_query_swdb_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41402 0 : PyObject *resultobj = 0;
41403 0 : struct _gpgme_op_query_swdb_result *result = 0 ;
41404 :
41405 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_query_swdb_result")) SWIG_fail;
41406 : {
41407 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41408 0 : result = (struct _gpgme_op_query_swdb_result *)calloc(1, sizeof(struct _gpgme_op_query_swdb_result));
41409 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41410 : }
41411 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_query_swdb_result, SWIG_POINTER_NEW | 0 );
41412 0 : return resultobj;
41413 : fail:
41414 : return NULL;
41415 : }
41416 :
41417 :
41418 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_query_swdb_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41419 0 : PyObject *resultobj = 0;
41420 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
41421 0 : void *argp1 = 0 ;
41422 0 : int res1 = 0 ;
41423 0 : PyObject * obj0 = 0 ;
41424 :
41425 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_query_swdb_result",&obj0)) SWIG_fail;
41426 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, SWIG_POINTER_DISOWN | 0 );
41427 0 : if (!SWIG_IsOK(res1)) {
41428 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 *""'");
41429 : }
41430 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
41431 : {
41432 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41433 0 : free((char *) arg1);
41434 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41435 : }
41436 0 : resultobj = SWIG_Py_Void();
41437 0 : return resultobj;
41438 : fail:
41439 : return NULL;
41440 : }
41441 :
41442 :
41443 29 : SWIGINTERN PyObject *_gpgme_op_query_swdb_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41444 : PyObject *obj;
41445 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
41446 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_query_swdb_result, SWIG_NewClientData(obj));
41447 29 : return SWIG_Py_Void();
41448 : }
41449 :
41450 0 : SWIGINTERN PyObject *_wrap_gpgme_op_query_swdb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41451 0 : PyObject *resultobj = 0;
41452 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
41453 0 : char *arg2 = (char *) 0 ;
41454 0 : char *arg3 = (char *) 0 ;
41455 : unsigned int arg4 ;
41456 0 : void *argp1 = 0 ;
41457 0 : int res1 = 0 ;
41458 0 : PyObject *encodedInput2 = NULL ;
41459 0 : PyObject *encodedInput3 = NULL ;
41460 : unsigned int val4 ;
41461 0 : int ecode4 = 0 ;
41462 0 : PyObject * obj0 = 0 ;
41463 0 : PyObject * obj1 = 0 ;
41464 0 : PyObject * obj2 = 0 ;
41465 0 : PyObject * obj3 = 0 ;
41466 : gpgme_error_t result;
41467 :
41468 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_query_swdb",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41469 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
41470 0 : if (!SWIG_IsOK(res1)) {
41471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_query_swdb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
41472 : }
41473 0 : arg1 = (gpgme_ctx_t)(argp1);
41474 : {
41475 0 : if (obj1 == Py_None)
41476 : arg2 = NULL;
41477 0 : else if (PyUnicode_Check(obj1))
41478 : {
41479 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
41480 0 : if (encodedInput2 == NULL)
41481 : return NULL;
41482 0 : arg2 = PyBytes_AsString(encodedInput2);
41483 : }
41484 0 : else if (PyBytes_Check(obj1))
41485 0 : arg2 = PyBytes_AsString(obj1);
41486 : else {
41487 0 : PyErr_Format(PyExc_TypeError,
41488 : "arg %d: expected str, bytes, or None, got %s",
41489 : 2, obj1->ob_type->tp_name);
41490 0 : return NULL;
41491 : }
41492 : }
41493 : {
41494 0 : if (obj2 == Py_None)
41495 : arg3 = NULL;
41496 0 : else if (PyUnicode_Check(obj2))
41497 : {
41498 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
41499 0 : if (encodedInput3 == NULL)
41500 : return NULL;
41501 0 : arg3 = PyBytes_AsString(encodedInput3);
41502 : }
41503 0 : else if (PyBytes_Check(obj2))
41504 0 : arg3 = PyBytes_AsString(obj2);
41505 : else {
41506 0 : PyErr_Format(PyExc_TypeError,
41507 : "arg %d: expected str, bytes, or None, got %s",
41508 : 3, obj2->ob_type->tp_name);
41509 0 : return NULL;
41510 : }
41511 : }
41512 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
41513 0 : if (!SWIG_IsOK(ecode4)) {
41514 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_query_swdb" "', argument " "4"" of type '" "unsigned int""'");
41515 : }
41516 0 : arg4 = (unsigned int)(val4);
41517 : {
41518 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41519 0 : result = gpgme_op_query_swdb(arg1,(char const *)arg2,(char const *)arg3,arg4);
41520 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41521 : }
41522 : {
41523 0 : resultobj = PyLong_FromLong(result);
41524 : }
41525 : {
41526 0 : Py_XDECREF(encodedInput2);
41527 : }
41528 : {
41529 0 : Py_XDECREF(encodedInput3);
41530 : }
41531 : return resultobj;
41532 : fail:
41533 : {
41534 0 : Py_XDECREF(encodedInput2);
41535 : }
41536 : {
41537 0 : Py_XDECREF(encodedInput3);
41538 : }
41539 : return NULL;
41540 : }
41541 :
41542 :
41543 0 : SWIGINTERN PyObject *_wrap_gpgme_op_query_swdb_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41544 0 : PyObject *resultobj = 0;
41545 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
41546 0 : void *argp1 = 0 ;
41547 0 : int res1 = 0 ;
41548 0 : PyObject * obj0 = 0 ;
41549 : gpgme_query_swdb_result_t result;
41550 :
41551 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_query_swdb_result",&obj0)) SWIG_fail;
41552 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
41553 0 : if (!SWIG_IsOK(res1)) {
41554 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_query_swdb_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
41555 : }
41556 0 : arg1 = (gpgme_ctx_t)(argp1);
41557 : {
41558 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41559 0 : result = (gpgme_query_swdb_result_t)gpgme_op_query_swdb_result(arg1);
41560 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41561 : }
41562 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
41563 0 : return resultobj;
41564 : fail:
41565 : return NULL;
41566 : }
41567 :
41568 :
41569 0 : SWIGINTERN PyObject *_wrap_gpgme_set_global_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41570 0 : PyObject *resultobj = 0;
41571 0 : char *arg1 = (char *) 0 ;
41572 0 : char *arg2 = (char *) 0 ;
41573 0 : PyObject *encodedInput1 = NULL ;
41574 0 : PyObject *encodedInput2 = NULL ;
41575 0 : PyObject * obj0 = 0 ;
41576 0 : PyObject * obj1 = 0 ;
41577 : int result;
41578 :
41579 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_global_flag",&obj0,&obj1)) SWIG_fail;
41580 : {
41581 0 : if (obj0 == Py_None)
41582 : arg1 = NULL;
41583 0 : else if (PyUnicode_Check(obj0))
41584 : {
41585 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
41586 0 : if (encodedInput1 == NULL)
41587 : return NULL;
41588 0 : arg1 = PyBytes_AsString(encodedInput1);
41589 : }
41590 0 : else if (PyBytes_Check(obj0))
41591 0 : arg1 = PyBytes_AsString(obj0);
41592 : else {
41593 0 : PyErr_Format(PyExc_TypeError,
41594 : "arg %d: expected str, bytes, or None, got %s",
41595 : 1, obj0->ob_type->tp_name);
41596 0 : return NULL;
41597 : }
41598 : }
41599 : {
41600 0 : if (obj1 == Py_None)
41601 : arg2 = NULL;
41602 0 : else if (PyUnicode_Check(obj1))
41603 : {
41604 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
41605 0 : if (encodedInput2 == NULL)
41606 : return NULL;
41607 0 : arg2 = PyBytes_AsString(encodedInput2);
41608 : }
41609 0 : else if (PyBytes_Check(obj1))
41610 0 : arg2 = PyBytes_AsString(obj1);
41611 : else {
41612 0 : PyErr_Format(PyExc_TypeError,
41613 : "arg %d: expected str, bytes, or None, got %s",
41614 : 2, obj1->ob_type->tp_name);
41615 0 : return NULL;
41616 : }
41617 : }
41618 : {
41619 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41620 0 : result = (int)gpgme_set_global_flag((char const *)arg1,(char const *)arg2);
41621 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41622 : }
41623 0 : resultobj = SWIG_From_int((int)(result));
41624 : {
41625 0 : Py_XDECREF(encodedInput1);
41626 : }
41627 : {
41628 0 : Py_XDECREF(encodedInput2);
41629 : }
41630 : return resultobj;
41631 : fail:
41632 : {
41633 : Py_XDECREF(encodedInput1);
41634 : }
41635 : {
41636 : Py_XDECREF(encodedInput2);
41637 : }
41638 : return NULL;
41639 : }
41640 :
41641 :
41642 29 : SWIGINTERN PyObject *_wrap_gpgme_check_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41643 29 : PyObject *resultobj = 0;
41644 29 : char *arg1 = (char *) 0 ;
41645 29 : PyObject *encodedInput1 = NULL ;
41646 29 : PyObject * obj0 = 0 ;
41647 29 : char *result = 0 ;
41648 :
41649 29 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_check_version",&obj0)) SWIG_fail;
41650 : {
41651 29 : if (obj0 == Py_None)
41652 : arg1 = NULL;
41653 0 : else if (PyUnicode_Check(obj0))
41654 : {
41655 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
41656 0 : if (encodedInput1 == NULL)
41657 : return NULL;
41658 0 : arg1 = PyBytes_AsString(encodedInput1);
41659 : }
41660 0 : else if (PyBytes_Check(obj0))
41661 0 : arg1 = PyBytes_AsString(obj0);
41662 : else {
41663 0 : PyErr_Format(PyExc_TypeError,
41664 : "arg %d: expected str, bytes, or None, got %s",
41665 : 1, obj0->ob_type->tp_name);
41666 0 : return NULL;
41667 : }
41668 : }
41669 : {
41670 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41671 29 : result = (char *)gpgme_check_version((char const *)arg1);
41672 29 : SWIG_PYTHON_THREAD_END_ALLOW;
41673 : }
41674 29 : resultobj = SWIG_FromCharPtr((const char *)result);
41675 : {
41676 29 : Py_XDECREF(encodedInput1);
41677 : }
41678 : return resultobj;
41679 : fail:
41680 : {
41681 : Py_XDECREF(encodedInput1);
41682 : }
41683 : return NULL;
41684 : }
41685 :
41686 :
41687 0 : SWIGINTERN PyObject *_wrap_gpgme_check_version_internal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41688 0 : PyObject *resultobj = 0;
41689 0 : char *arg1 = (char *) 0 ;
41690 : size_t arg2 ;
41691 0 : PyObject *encodedInput1 = NULL ;
41692 : size_t val2 ;
41693 0 : int ecode2 = 0 ;
41694 0 : PyObject * obj0 = 0 ;
41695 0 : PyObject * obj1 = 0 ;
41696 0 : char *result = 0 ;
41697 :
41698 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_check_version_internal",&obj0,&obj1)) SWIG_fail;
41699 : {
41700 0 : if (obj0 == Py_None)
41701 : arg1 = NULL;
41702 0 : else if (PyUnicode_Check(obj0))
41703 : {
41704 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
41705 0 : if (encodedInput1 == NULL)
41706 : return NULL;
41707 0 : arg1 = PyBytes_AsString(encodedInput1);
41708 : }
41709 0 : else if (PyBytes_Check(obj0))
41710 0 : arg1 = PyBytes_AsString(obj0);
41711 : else {
41712 0 : PyErr_Format(PyExc_TypeError,
41713 : "arg %d: expected str, bytes, or None, got %s",
41714 : 1, obj0->ob_type->tp_name);
41715 0 : return NULL;
41716 : }
41717 : }
41718 0 : ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41719 0 : if (!SWIG_IsOK(ecode2)) {
41720 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_check_version_internal" "', argument " "2"" of type '" "size_t""'");
41721 : }
41722 0 : arg2 = (size_t)(val2);
41723 : {
41724 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41725 0 : result = (char *)gpgme_check_version_internal((char const *)arg1,arg2);
41726 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41727 : }
41728 0 : resultobj = SWIG_FromCharPtr((const char *)result);
41729 : {
41730 0 : Py_XDECREF(encodedInput1);
41731 : }
41732 : return resultobj;
41733 : fail:
41734 : {
41735 0 : Py_XDECREF(encodedInput1);
41736 : }
41737 : return NULL;
41738 : }
41739 :
41740 :
41741 0 : SWIGINTERN PyObject *_wrap_gpgme_get_dirinfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41742 0 : PyObject *resultobj = 0;
41743 0 : char *arg1 = (char *) 0 ;
41744 0 : PyObject *encodedInput1 = NULL ;
41745 0 : PyObject * obj0 = 0 ;
41746 0 : char *result = 0 ;
41747 :
41748 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_dirinfo",&obj0)) SWIG_fail;
41749 : {
41750 0 : if (obj0 == Py_None)
41751 : arg1 = NULL;
41752 0 : else if (PyUnicode_Check(obj0))
41753 : {
41754 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
41755 0 : if (encodedInput1 == NULL)
41756 : return NULL;
41757 0 : arg1 = PyBytes_AsString(encodedInput1);
41758 : }
41759 0 : else if (PyBytes_Check(obj0))
41760 0 : arg1 = PyBytes_AsString(obj0);
41761 : else {
41762 0 : PyErr_Format(PyExc_TypeError,
41763 : "arg %d: expected str, bytes, or None, got %s",
41764 : 1, obj0->ob_type->tp_name);
41765 0 : return NULL;
41766 : }
41767 : }
41768 : {
41769 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41770 0 : result = (char *)gpgme_get_dirinfo((char const *)arg1);
41771 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41772 : }
41773 0 : resultobj = SWIG_FromCharPtr((const char *)result);
41774 : {
41775 0 : Py_XDECREF(encodedInput1);
41776 : }
41777 : return resultobj;
41778 : fail:
41779 : {
41780 : Py_XDECREF(encodedInput1);
41781 : }
41782 : return NULL;
41783 : }
41784 :
41785 :
41786 0 : SWIGINTERN PyObject *_wrap_gpgme_get_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41787 0 : PyObject *resultobj = 0;
41788 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
41789 0 : void *argp1 = 0 ;
41790 0 : int res1 = 0 ;
41791 0 : PyObject * obj0 = 0 ;
41792 : gpgme_error_t result;
41793 :
41794 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_engine_info",&obj0)) SWIG_fail;
41795 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
41796 0 : if (!SWIG_IsOK(res1)) {
41797 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_engine_info" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
41798 : }
41799 0 : arg1 = (gpgme_engine_info_t *)(argp1);
41800 : {
41801 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41802 0 : result = gpgme_get_engine_info(arg1);
41803 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41804 : }
41805 : {
41806 0 : resultobj = PyLong_FromLong(result);
41807 : }
41808 0 : return resultobj;
41809 : fail:
41810 : return NULL;
41811 : }
41812 :
41813 :
41814 0 : SWIGINTERN PyObject *_wrap_gpgme_set_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41815 0 : PyObject *resultobj = 0;
41816 : gpgme_protocol_t arg1 ;
41817 0 : char *arg2 = (char *) 0 ;
41818 0 : char *arg3 = (char *) 0 ;
41819 : int val1 ;
41820 0 : int ecode1 = 0 ;
41821 0 : PyObject *encodedInput2 = NULL ;
41822 0 : PyObject *encodedInput3 = NULL ;
41823 0 : PyObject * obj0 = 0 ;
41824 0 : PyObject * obj1 = 0 ;
41825 0 : PyObject * obj2 = 0 ;
41826 : gpgme_error_t result;
41827 :
41828 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_engine_info",&obj0,&obj1,&obj2)) SWIG_fail;
41829 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
41830 0 : if (!SWIG_IsOK(ecode1)) {
41831 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_set_engine_info" "', argument " "1"" of type '" "gpgme_protocol_t""'");
41832 : }
41833 0 : arg1 = (gpgme_protocol_t)(val1);
41834 : {
41835 0 : if (obj1 == Py_None)
41836 : arg2 = NULL;
41837 0 : else if (PyUnicode_Check(obj1))
41838 : {
41839 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
41840 0 : if (encodedInput2 == NULL)
41841 : return NULL;
41842 0 : arg2 = PyBytes_AsString(encodedInput2);
41843 : }
41844 0 : else if (PyBytes_Check(obj1))
41845 0 : arg2 = PyBytes_AsString(obj1);
41846 : else {
41847 0 : PyErr_Format(PyExc_TypeError,
41848 : "arg %d: expected str, bytes, or None, got %s",
41849 : 2, obj1->ob_type->tp_name);
41850 0 : return NULL;
41851 : }
41852 : }
41853 : {
41854 0 : if (obj2 == Py_None)
41855 : arg3 = NULL;
41856 0 : else if (PyUnicode_Check(obj2))
41857 : {
41858 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
41859 0 : if (encodedInput3 == NULL)
41860 : return NULL;
41861 0 : arg3 = PyBytes_AsString(encodedInput3);
41862 : }
41863 0 : else if (PyBytes_Check(obj2))
41864 0 : arg3 = PyBytes_AsString(obj2);
41865 : else {
41866 0 : PyErr_Format(PyExc_TypeError,
41867 : "arg %d: expected str, bytes, or None, got %s",
41868 : 3, obj2->ob_type->tp_name);
41869 0 : return NULL;
41870 : }
41871 : }
41872 : {
41873 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41874 0 : result = gpgme_set_engine_info(arg1,(char const *)arg2,(char const *)arg3);
41875 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41876 : }
41877 : {
41878 0 : resultobj = PyLong_FromLong(result);
41879 : }
41880 : {
41881 0 : Py_XDECREF(encodedInput2);
41882 : }
41883 : {
41884 0 : Py_XDECREF(encodedInput3);
41885 : }
41886 : return resultobj;
41887 : fail:
41888 : {
41889 : Py_XDECREF(encodedInput2);
41890 : }
41891 : {
41892 : Py_XDECREF(encodedInput3);
41893 : }
41894 : return NULL;
41895 : }
41896 :
41897 :
41898 90 : SWIGINTERN PyObject *_wrap_gpgme_engine_check_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41899 90 : PyObject *resultobj = 0;
41900 : gpgme_protocol_t arg1 ;
41901 : int val1 ;
41902 90 : int ecode1 = 0 ;
41903 90 : PyObject * obj0 = 0 ;
41904 : gpgme_error_t result;
41905 :
41906 90 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_engine_check_version",&obj0)) SWIG_fail;
41907 180 : ecode1 = SWIG_AsVal_int(obj0, &val1);
41908 90 : if (!SWIG_IsOK(ecode1)) {
41909 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_engine_check_version" "', argument " "1"" of type '" "gpgme_protocol_t""'");
41910 : }
41911 90 : arg1 = (gpgme_protocol_t)(val1);
41912 : {
41913 90 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41914 90 : result = gpgme_engine_check_version(arg1);
41915 90 : SWIG_PYTHON_THREAD_END_ALLOW;
41916 : }
41917 : {
41918 90 : resultobj = PyLong_FromLong(result);
41919 : }
41920 90 : return resultobj;
41921 : fail:
41922 : return NULL;
41923 : }
41924 :
41925 :
41926 0 : SWIGINTERN PyObject *_wrap_gpgme_result_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41927 0 : PyObject *resultobj = 0;
41928 0 : void *arg1 = (void *) 0 ;
41929 : int res1 ;
41930 0 : PyObject * obj0 = 0 ;
41931 :
41932 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_result_ref",&obj0)) SWIG_fail;
41933 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
41934 0 : if (!SWIG_IsOK(res1)) {
41935 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_result_ref" "', argument " "1"" of type '" "void *""'");
41936 : }
41937 : {
41938 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41939 0 : gpgme_result_ref(arg1);
41940 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41941 : }
41942 0 : resultobj = SWIG_Py_Void();
41943 0 : return resultobj;
41944 : fail:
41945 : return NULL;
41946 : }
41947 :
41948 :
41949 0 : SWIGINTERN PyObject *_wrap_gpgme_result_unref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41950 0 : PyObject *resultobj = 0;
41951 0 : void *arg1 = (void *) 0 ;
41952 : int res1 ;
41953 0 : PyObject * obj0 = 0 ;
41954 :
41955 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_result_unref",&obj0)) SWIG_fail;
41956 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
41957 0 : if (!SWIG_IsOK(res1)) {
41958 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_result_unref" "', argument " "1"" of type '" "void *""'");
41959 : }
41960 : {
41961 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41962 0 : gpgme_result_unref(arg1);
41963 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41964 : }
41965 0 : resultobj = SWIG_Py_Void();
41966 0 : return resultobj;
41967 : fail:
41968 : return NULL;
41969 : }
41970 :
41971 :
41972 0 : SWIGINTERN PyObject *_wrap_gpgme_pubkey_algo_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41973 0 : PyObject *resultobj = 0;
41974 0 : gpgme_subkey_t arg1 = (gpgme_subkey_t) 0 ;
41975 0 : void *argp1 = 0 ;
41976 0 : int res1 = 0 ;
41977 0 : PyObject * obj0 = 0 ;
41978 0 : char *result = 0 ;
41979 :
41980 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_pubkey_algo_string",&obj0)) SWIG_fail;
41981 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
41982 0 : if (!SWIG_IsOK(res1)) {
41983 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_pubkey_algo_string" "', argument " "1"" of type '" "gpgme_subkey_t""'");
41984 : }
41985 0 : arg1 = (gpgme_subkey_t)(argp1);
41986 : {
41987 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41988 0 : result = (char *)gpgme_pubkey_algo_string(arg1);
41989 0 : SWIG_PYTHON_THREAD_END_ALLOW;
41990 : }
41991 0 : resultobj = SWIG_FromCharPtr((const char *)result);
41992 0 : gpgme_free(result);
41993 0 : return resultobj;
41994 : fail:
41995 : return NULL;
41996 : }
41997 :
41998 :
41999 0 : SWIGINTERN PyObject *_wrap_gpgme_pubkey_algo_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42000 0 : PyObject *resultobj = 0;
42001 : gpgme_pubkey_algo_t arg1 ;
42002 : int val1 ;
42003 0 : int ecode1 = 0 ;
42004 0 : PyObject * obj0 = 0 ;
42005 0 : char *result = 0 ;
42006 :
42007 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_pubkey_algo_name",&obj0)) SWIG_fail;
42008 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
42009 0 : if (!SWIG_IsOK(ecode1)) {
42010 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_pubkey_algo_name" "', argument " "1"" of type '" "gpgme_pubkey_algo_t""'");
42011 : }
42012 0 : arg1 = (gpgme_pubkey_algo_t)(val1);
42013 : {
42014 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42015 0 : result = (char *)gpgme_pubkey_algo_name(arg1);
42016 0 : SWIG_PYTHON_THREAD_END_ALLOW;
42017 : }
42018 0 : resultobj = SWIG_FromCharPtr((const char *)result);
42019 0 : return resultobj;
42020 : fail:
42021 : return NULL;
42022 : }
42023 :
42024 :
42025 0 : SWIGINTERN PyObject *_wrap_gpgme_hash_algo_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42026 0 : PyObject *resultobj = 0;
42027 : gpgme_hash_algo_t arg1 ;
42028 : int val1 ;
42029 0 : int ecode1 = 0 ;
42030 0 : PyObject * obj0 = 0 ;
42031 0 : char *result = 0 ;
42032 :
42033 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_hash_algo_name",&obj0)) SWIG_fail;
42034 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
42035 0 : if (!SWIG_IsOK(ecode1)) {
42036 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_hash_algo_name" "', argument " "1"" of type '" "gpgme_hash_algo_t""'");
42037 : }
42038 0 : arg1 = (gpgme_hash_algo_t)(val1);
42039 : {
42040 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42041 0 : result = (char *)gpgme_hash_algo_name(arg1);
42042 0 : SWIG_PYTHON_THREAD_END_ALLOW;
42043 : }
42044 0 : resultobj = SWIG_FromCharPtr((const char *)result);
42045 0 : return resultobj;
42046 : fail:
42047 : return NULL;
42048 : }
42049 :
42050 :
42051 0 : SWIGINTERN PyObject *_wrap_gpgme_addrspec_from_uid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42052 0 : PyObject *resultobj = 0;
42053 0 : char *arg1 = (char *) 0 ;
42054 0 : PyObject *encodedInput1 = NULL ;
42055 0 : PyObject * obj0 = 0 ;
42056 0 : char *result = 0 ;
42057 :
42058 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_addrspec_from_uid",&obj0)) SWIG_fail;
42059 : {
42060 0 : if (obj0 == Py_None)
42061 : arg1 = NULL;
42062 0 : else if (PyUnicode_Check(obj0))
42063 : {
42064 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
42065 0 : if (encodedInput1 == NULL)
42066 : return NULL;
42067 0 : arg1 = PyBytes_AsString(encodedInput1);
42068 : }
42069 0 : else if (PyBytes_Check(obj0))
42070 0 : arg1 = PyBytes_AsString(obj0);
42071 : else {
42072 0 : PyErr_Format(PyExc_TypeError,
42073 : "arg %d: expected str, bytes, or None, got %s",
42074 : 1, obj0->ob_type->tp_name);
42075 0 : return NULL;
42076 : }
42077 : }
42078 : {
42079 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42080 0 : result = (char *)gpgme_addrspec_from_uid((char const *)arg1);
42081 0 : SWIG_PYTHON_THREAD_END_ALLOW;
42082 : }
42083 0 : resultobj = SWIG_FromCharPtr((const char *)result);
42084 : {
42085 0 : Py_XDECREF(encodedInput1);
42086 : }
42087 0 : gpgme_free(result);
42088 0 : return resultobj;
42089 : fail:
42090 : {
42091 : Py_XDECREF(encodedInput1);
42092 : }
42093 : return NULL;
42094 : }
42095 :
42096 :
42097 0 : SWIGINTERN PyObject *_wrap_gpgme_op_edit_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42098 0 : PyObject *resultobj = 0;
42099 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
42100 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
42101 0 : gpgme_edit_cb_t arg3 = (gpgme_edit_cb_t) 0 ;
42102 0 : void *arg4 = (void *) 0 ;
42103 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
42104 0 : void *argp1 = 0 ;
42105 0 : int res1 = 0 ;
42106 0 : void *argp2 = 0 ;
42107 0 : int res2 = 0 ;
42108 : int res4 ;
42109 0 : gpgme_data_t wrapper5 = NULL ;
42110 0 : PyObject *bytesio5 = NULL ;
42111 : Py_buffer view5 ;
42112 0 : int have_view5 = 0 ;
42113 0 : PyObject * obj0 = 0 ;
42114 0 : PyObject * obj1 = 0 ;
42115 0 : PyObject * obj2 = 0 ;
42116 0 : PyObject * obj3 = 0 ;
42117 0 : PyObject * obj4 = 0 ;
42118 : gpgme_error_t result;
42119 :
42120 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_edit_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42121 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
42122 0 : if (!SWIG_IsOK(res1)) {
42123 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_edit_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
42124 : }
42125 0 : arg1 = (gpgme_ctx_t)(argp1);
42126 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
42127 0 : if (!SWIG_IsOK(res2)) {
42128 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_edit_start" "', argument " "2"" of type '" "gpgme_key_t""'");
42129 : }
42130 0 : arg2 = (gpgme_key_t)(argp2);
42131 : {
42132 0 : int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t);
42133 0 : if (!SWIG_IsOK(res)) {
42134 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_op_edit_start" "', argument " "3"" of type '" "gpgme_edit_cb_t""'");
42135 : }
42136 : }
42137 0 : res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
42138 0 : if (!SWIG_IsOK(res4)) {
42139 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_edit_start" "', argument " "4"" of type '" "void *""'");
42140 : }
42141 : {
42142 : /* If we create a temporary wrapper5 object, we will store it in
42143 : wrapperN, where N is 5. Here in this fragment, SWIG will
42144 : automatically append 5. */
42145 0 : memset(&view5, 0, sizeof view5);
42146 0 : if (obj4 == Py_None)
42147 0 : arg5 = NULL;
42148 : else {
42149 : PyObject *pypointer;
42150 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
42151 : &bytesio5, &view5);
42152 0 : if (pypointer == NULL)
42153 : return NULL;
42154 0 : have_view5 = !! view5.obj;
42155 :
42156 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
42157 :
42158 : /* Following code is from swig's python.swg. */
42159 :
42160 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
42161 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
42162 0 : Py_DECREF(pypointer);
42163 : return NULL;
42164 : }
42165 0 : Py_DECREF(pypointer);
42166 : }
42167 : }
42168 : {
42169 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42170 0 : result = gpgme_op_edit_start(arg1,arg2,arg3,arg4,arg5);
42171 0 : SWIG_PYTHON_THREAD_END_ALLOW;
42172 : }
42173 : {
42174 0 : resultobj = PyLong_FromLong(result);
42175 : }
42176 : {
42177 : /* See whether we need to update the Python buffer. */
42178 0 : if (resultobj && wrapper5 && view5.buf)
42179 : {
42180 : int dirty;
42181 0 : char *new_data = NULL;
42182 : size_t new_size;
42183 :
42184 :
42185 0 : new_data = wrapper5->data.mem.buffer;
42186 0 : new_size = wrapper5->data.mem.length;
42187 0 : dirty = new_data != NULL;
42188 :
42189 :
42190 :
42191 :
42192 :
42193 :
42194 :
42195 0 : if (dirty)
42196 : {
42197 : /* The buffer is dirty. */
42198 0 : if (view5.readonly)
42199 : {
42200 0 : Py_XDECREF(resultobj);
42201 0 : resultobj = NULL;
42202 0 : PyErr_SetString(PyExc_ValueError,
42203 : "cannot update read-only buffer");
42204 : }
42205 :
42206 : /* See if we need to truncate the buffer. */
42207 0 : if (resultobj && view5.len != new_size)
42208 : {
42209 0 : if (bytesio5 == NULL)
42210 : {
42211 0 : Py_XDECREF(resultobj);
42212 0 : resultobj = NULL;
42213 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
42214 : }
42215 : else
42216 : {
42217 : PyObject *retval;
42218 0 : PyBuffer_Release(&view5);
42219 : assert(view5.obj == NULL);
42220 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
42221 : "l", (long) new_size);
42222 0 : if (retval == NULL)
42223 : {
42224 0 : Py_XDECREF(resultobj);
42225 : resultobj = NULL;
42226 : }
42227 : else
42228 : {
42229 0 : Py_DECREF(retval);
42230 :
42231 0 : retval = PyObject_CallMethod(bytesio5,
42232 : "getbuffer", NULL);
42233 0 : if (retval == NULL
42234 0 : || PyObject_GetBuffer(retval, &view5,
42235 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
42236 : {
42237 0 : Py_XDECREF(resultobj);
42238 : resultobj = NULL;
42239 : }
42240 :
42241 0 : Py_XDECREF(retval);
42242 :
42243 0 : if (resultobj && view5.len
42244 : != new_size)
42245 : {
42246 0 : Py_XDECREF(resultobj);
42247 0 : resultobj = NULL;
42248 0 : PyErr_Format(PyExc_ValueError,
42249 : "Expected buffer of length %zu, got %zi",
42250 : new_size,
42251 : view5.len);
42252 : }
42253 : }
42254 : }
42255 : }
42256 0 : if (resultobj)
42257 0 : memcpy(view5.buf, new_data, new_size);
42258 : }
42259 :
42260 :
42261 :
42262 : }
42263 :
42264 : /* Free the temporary wrapper, if any. */
42265 0 : if (wrapper5)
42266 0 : gpgme_data_release(wrapper5);
42267 0 : Py_XDECREF (bytesio5);
42268 0 : if (have_view5 && view5.buf)
42269 0 : PyBuffer_Release(&view5);
42270 : }
42271 : return resultobj;
42272 : fail:
42273 : {
42274 : /* See whether we need to update the Python buffer. */
42275 : if (resultobj && wrapper5 && view5.buf)
42276 : {
42277 : int dirty;
42278 : char *new_data = NULL;
42279 : size_t new_size;
42280 :
42281 :
42282 : new_data = wrapper5->data.mem.buffer;
42283 : new_size = wrapper5->data.mem.length;
42284 : dirty = new_data != NULL;
42285 :
42286 :
42287 :
42288 :
42289 :
42290 :
42291 :
42292 : if (dirty)
42293 : {
42294 : /* The buffer is dirty. */
42295 : if (view5.readonly)
42296 : {
42297 : Py_XDECREF(resultobj);
42298 : resultobj = NULL;
42299 : PyErr_SetString(PyExc_ValueError,
42300 : "cannot update read-only buffer");
42301 : }
42302 :
42303 : /* See if we need to truncate the buffer. */
42304 : if (resultobj && view5.len != new_size)
42305 : {
42306 : if (bytesio5 == NULL)
42307 : {
42308 : Py_XDECREF(resultobj);
42309 : resultobj = NULL;
42310 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
42311 : }
42312 : else
42313 : {
42314 : PyObject *retval;
42315 : PyBuffer_Release(&view5);
42316 : assert(view5.obj == NULL);
42317 : retval = PyObject_CallMethod(bytesio5, "truncate",
42318 : "l", (long) new_size);
42319 : if (retval == NULL)
42320 : {
42321 : Py_XDECREF(resultobj);
42322 : resultobj = NULL;
42323 : }
42324 : else
42325 : {
42326 : Py_DECREF(retval);
42327 :
42328 : retval = PyObject_CallMethod(bytesio5,
42329 : "getbuffer", NULL);
42330 : if (retval == NULL
42331 : || PyObject_GetBuffer(retval, &view5,
42332 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
42333 : {
42334 : Py_XDECREF(resultobj);
42335 : resultobj = NULL;
42336 : }
42337 :
42338 : Py_XDECREF(retval);
42339 :
42340 : if (resultobj && view5.len
42341 : != new_size)
42342 : {
42343 : Py_XDECREF(resultobj);
42344 : resultobj = NULL;
42345 : PyErr_Format(PyExc_ValueError,
42346 : "Expected buffer of length %zu, got %zi",
42347 : new_size,
42348 : view5.len);
42349 : }
42350 : }
42351 : }
42352 : }
42353 : if (resultobj)
42354 : memcpy(view5.buf, new_data, new_size);
42355 : }
42356 :
42357 :
42358 :
42359 : }
42360 :
42361 : /* Free the temporary wrapper, if any. */
42362 0 : if (wrapper5)
42363 0 : gpgme_data_release(wrapper5);
42364 0 : Py_XDECREF (bytesio5);
42365 : if (have_view5 && view5.buf)
42366 : PyBuffer_Release(&view5);
42367 : }
42368 : return NULL;
42369 : }
42370 :
42371 :
42372 0 : SWIGINTERN PyObject *_wrap_gpgme_op_edit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42373 0 : PyObject *resultobj = 0;
42374 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
42375 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
42376 0 : gpgme_edit_cb_t arg3 = (gpgme_edit_cb_t) 0 ;
42377 0 : void *arg4 = (void *) 0 ;
42378 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
42379 0 : void *argp1 = 0 ;
42380 0 : int res1 = 0 ;
42381 0 : void *argp2 = 0 ;
42382 0 : int res2 = 0 ;
42383 : int res4 ;
42384 0 : gpgme_data_t wrapper5 = NULL ;
42385 0 : PyObject *bytesio5 = NULL ;
42386 : Py_buffer view5 ;
42387 0 : int have_view5 = 0 ;
42388 0 : PyObject * obj0 = 0 ;
42389 0 : PyObject * obj1 = 0 ;
42390 0 : PyObject * obj2 = 0 ;
42391 0 : PyObject * obj3 = 0 ;
42392 0 : PyObject * obj4 = 0 ;
42393 : gpgme_error_t result;
42394 :
42395 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_edit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42396 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
42397 0 : if (!SWIG_IsOK(res1)) {
42398 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_edit" "', argument " "1"" of type '" "gpgme_ctx_t""'");
42399 : }
42400 0 : arg1 = (gpgme_ctx_t)(argp1);
42401 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
42402 0 : if (!SWIG_IsOK(res2)) {
42403 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_edit" "', argument " "2"" of type '" "gpgme_key_t""'");
42404 : }
42405 0 : arg2 = (gpgme_key_t)(argp2);
42406 : {
42407 0 : int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t);
42408 0 : if (!SWIG_IsOK(res)) {
42409 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_op_edit" "', argument " "3"" of type '" "gpgme_edit_cb_t""'");
42410 : }
42411 : }
42412 0 : res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
42413 0 : if (!SWIG_IsOK(res4)) {
42414 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_edit" "', argument " "4"" of type '" "void *""'");
42415 : }
42416 : {
42417 : /* If we create a temporary wrapper5 object, we will store it in
42418 : wrapperN, where N is 5. Here in this fragment, SWIG will
42419 : automatically append 5. */
42420 0 : memset(&view5, 0, sizeof view5);
42421 0 : if (obj4 == Py_None)
42422 0 : arg5 = NULL;
42423 : else {
42424 : PyObject *pypointer;
42425 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
42426 : &bytesio5, &view5);
42427 0 : if (pypointer == NULL)
42428 : return NULL;
42429 0 : have_view5 = !! view5.obj;
42430 :
42431 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
42432 :
42433 : /* Following code is from swig's python.swg. */
42434 :
42435 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
42436 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
42437 0 : Py_DECREF(pypointer);
42438 : return NULL;
42439 : }
42440 0 : Py_DECREF(pypointer);
42441 : }
42442 : }
42443 : {
42444 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42445 0 : result = gpgme_op_edit(arg1,arg2,arg3,arg4,arg5);
42446 0 : SWIG_PYTHON_THREAD_END_ALLOW;
42447 : }
42448 : {
42449 0 : resultobj = PyLong_FromLong(result);
42450 : }
42451 : {
42452 : /* See whether we need to update the Python buffer. */
42453 0 : if (resultobj && wrapper5 && view5.buf)
42454 : {
42455 : int dirty;
42456 0 : char *new_data = NULL;
42457 : size_t new_size;
42458 :
42459 :
42460 0 : new_data = wrapper5->data.mem.buffer;
42461 0 : new_size = wrapper5->data.mem.length;
42462 0 : dirty = new_data != NULL;
42463 :
42464 :
42465 :
42466 :
42467 :
42468 :
42469 :
42470 0 : if (dirty)
42471 : {
42472 : /* The buffer is dirty. */
42473 0 : if (view5.readonly)
42474 : {
42475 0 : Py_XDECREF(resultobj);
42476 0 : resultobj = NULL;
42477 0 : PyErr_SetString(PyExc_ValueError,
42478 : "cannot update read-only buffer");
42479 : }
42480 :
42481 : /* See if we need to truncate the buffer. */
42482 0 : if (resultobj && view5.len != new_size)
42483 : {
42484 0 : if (bytesio5 == NULL)
42485 : {
42486 0 : Py_XDECREF(resultobj);
42487 0 : resultobj = NULL;
42488 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
42489 : }
42490 : else
42491 : {
42492 : PyObject *retval;
42493 0 : PyBuffer_Release(&view5);
42494 : assert(view5.obj == NULL);
42495 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
42496 : "l", (long) new_size);
42497 0 : if (retval == NULL)
42498 : {
42499 0 : Py_XDECREF(resultobj);
42500 : resultobj = NULL;
42501 : }
42502 : else
42503 : {
42504 0 : Py_DECREF(retval);
42505 :
42506 0 : retval = PyObject_CallMethod(bytesio5,
42507 : "getbuffer", NULL);
42508 0 : if (retval == NULL
42509 0 : || PyObject_GetBuffer(retval, &view5,
42510 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
42511 : {
42512 0 : Py_XDECREF(resultobj);
42513 : resultobj = NULL;
42514 : }
42515 :
42516 0 : Py_XDECREF(retval);
42517 :
42518 0 : if (resultobj && view5.len
42519 : != new_size)
42520 : {
42521 0 : Py_XDECREF(resultobj);
42522 0 : resultobj = NULL;
42523 0 : PyErr_Format(PyExc_ValueError,
42524 : "Expected buffer of length %zu, got %zi",
42525 : new_size,
42526 : view5.len);
42527 : }
42528 : }
42529 : }
42530 : }
42531 0 : if (resultobj)
42532 0 : memcpy(view5.buf, new_data, new_size);
42533 : }
42534 :
42535 :
42536 :
42537 : }
42538 :
42539 : /* Free the temporary wrapper, if any. */
42540 0 : if (wrapper5)
42541 0 : gpgme_data_release(wrapper5);
42542 0 : Py_XDECREF (bytesio5);
42543 0 : if (have_view5 && view5.buf)
42544 0 : PyBuffer_Release(&view5);
42545 : }
42546 : return resultobj;
42547 : fail:
42548 : {
42549 : /* See whether we need to update the Python buffer. */
42550 : if (resultobj && wrapper5 && view5.buf)
42551 : {
42552 : int dirty;
42553 : char *new_data = NULL;
42554 : size_t new_size;
42555 :
42556 :
42557 : new_data = wrapper5->data.mem.buffer;
42558 : new_size = wrapper5->data.mem.length;
42559 : dirty = new_data != NULL;
42560 :
42561 :
42562 :
42563 :
42564 :
42565 :
42566 :
42567 : if (dirty)
42568 : {
42569 : /* The buffer is dirty. */
42570 : if (view5.readonly)
42571 : {
42572 : Py_XDECREF(resultobj);
42573 : resultobj = NULL;
42574 : PyErr_SetString(PyExc_ValueError,
42575 : "cannot update read-only buffer");
42576 : }
42577 :
42578 : /* See if we need to truncate the buffer. */
42579 : if (resultobj && view5.len != new_size)
42580 : {
42581 : if (bytesio5 == NULL)
42582 : {
42583 : Py_XDECREF(resultobj);
42584 : resultobj = NULL;
42585 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
42586 : }
42587 : else
42588 : {
42589 : PyObject *retval;
42590 : PyBuffer_Release(&view5);
42591 : assert(view5.obj == NULL);
42592 : retval = PyObject_CallMethod(bytesio5, "truncate",
42593 : "l", (long) new_size);
42594 : if (retval == NULL)
42595 : {
42596 : Py_XDECREF(resultobj);
42597 : resultobj = NULL;
42598 : }
42599 : else
42600 : {
42601 : Py_DECREF(retval);
42602 :
42603 : retval = PyObject_CallMethod(bytesio5,
42604 : "getbuffer", NULL);
42605 : if (retval == NULL
42606 : || PyObject_GetBuffer(retval, &view5,
42607 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
42608 : {
42609 : Py_XDECREF(resultobj);
42610 : resultobj = NULL;
42611 : }
42612 :
42613 : Py_XDECREF(retval);
42614 :
42615 : if (resultobj && view5.len
42616 : != new_size)
42617 : {
42618 : Py_XDECREF(resultobj);
42619 : resultobj = NULL;
42620 : PyErr_Format(PyExc_ValueError,
42621 : "Expected buffer of length %zu, got %zi",
42622 : new_size,
42623 : view5.len);
42624 : }
42625 : }
42626 : }
42627 : }
42628 : if (resultobj)
42629 : memcpy(view5.buf, new_data, new_size);
42630 : }
42631 :
42632 :
42633 :
42634 : }
42635 :
42636 : /* Free the temporary wrapper, if any. */
42637 0 : if (wrapper5)
42638 0 : gpgme_data_release(wrapper5);
42639 0 : Py_XDECREF (bytesio5);
42640 : if (have_view5 && view5.buf)
42641 : PyBuffer_Release(&view5);
42642 : }
42643 : return NULL;
42644 : }
42645 :
42646 :
42647 0 : SWIGINTERN PyObject *_wrap_gpgme_op_card_edit_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42648 0 : PyObject *resultobj = 0;
42649 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
42650 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
42651 0 : gpgme_edit_cb_t arg3 = (gpgme_edit_cb_t) 0 ;
42652 0 : void *arg4 = (void *) 0 ;
42653 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
42654 0 : void *argp1 = 0 ;
42655 0 : int res1 = 0 ;
42656 0 : void *argp2 = 0 ;
42657 0 : int res2 = 0 ;
42658 : int res4 ;
42659 0 : gpgme_data_t wrapper5 = NULL ;
42660 0 : PyObject *bytesio5 = NULL ;
42661 : Py_buffer view5 ;
42662 0 : int have_view5 = 0 ;
42663 0 : PyObject * obj0 = 0 ;
42664 0 : PyObject * obj1 = 0 ;
42665 0 : PyObject * obj2 = 0 ;
42666 0 : PyObject * obj3 = 0 ;
42667 0 : PyObject * obj4 = 0 ;
42668 : gpgme_error_t result;
42669 :
42670 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_card_edit_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42671 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
42672 0 : if (!SWIG_IsOK(res1)) {
42673 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_card_edit_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
42674 : }
42675 0 : arg1 = (gpgme_ctx_t)(argp1);
42676 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
42677 0 : if (!SWIG_IsOK(res2)) {
42678 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_card_edit_start" "', argument " "2"" of type '" "gpgme_key_t""'");
42679 : }
42680 0 : arg2 = (gpgme_key_t)(argp2);
42681 : {
42682 0 : int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t);
42683 0 : if (!SWIG_IsOK(res)) {
42684 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_op_card_edit_start" "', argument " "3"" of type '" "gpgme_edit_cb_t""'");
42685 : }
42686 : }
42687 0 : res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
42688 0 : if (!SWIG_IsOK(res4)) {
42689 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_card_edit_start" "', argument " "4"" of type '" "void *""'");
42690 : }
42691 : {
42692 : /* If we create a temporary wrapper5 object, we will store it in
42693 : wrapperN, where N is 5. Here in this fragment, SWIG will
42694 : automatically append 5. */
42695 0 : memset(&view5, 0, sizeof view5);
42696 0 : if (obj4 == Py_None)
42697 0 : arg5 = NULL;
42698 : else {
42699 : PyObject *pypointer;
42700 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
42701 : &bytesio5, &view5);
42702 0 : if (pypointer == NULL)
42703 : return NULL;
42704 0 : have_view5 = !! view5.obj;
42705 :
42706 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
42707 :
42708 : /* Following code is from swig's python.swg. */
42709 :
42710 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
42711 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
42712 0 : Py_DECREF(pypointer);
42713 : return NULL;
42714 : }
42715 0 : Py_DECREF(pypointer);
42716 : }
42717 : }
42718 : {
42719 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42720 0 : result = gpgme_op_card_edit_start(arg1,arg2,arg3,arg4,arg5);
42721 0 : SWIG_PYTHON_THREAD_END_ALLOW;
42722 : }
42723 : {
42724 0 : resultobj = PyLong_FromLong(result);
42725 : }
42726 : {
42727 : /* See whether we need to update the Python buffer. */
42728 0 : if (resultobj && wrapper5 && view5.buf)
42729 : {
42730 : int dirty;
42731 0 : char *new_data = NULL;
42732 : size_t new_size;
42733 :
42734 :
42735 0 : new_data = wrapper5->data.mem.buffer;
42736 0 : new_size = wrapper5->data.mem.length;
42737 0 : dirty = new_data != NULL;
42738 :
42739 :
42740 :
42741 :
42742 :
42743 :
42744 :
42745 0 : if (dirty)
42746 : {
42747 : /* The buffer is dirty. */
42748 0 : if (view5.readonly)
42749 : {
42750 0 : Py_XDECREF(resultobj);
42751 0 : resultobj = NULL;
42752 0 : PyErr_SetString(PyExc_ValueError,
42753 : "cannot update read-only buffer");
42754 : }
42755 :
42756 : /* See if we need to truncate the buffer. */
42757 0 : if (resultobj && view5.len != new_size)
42758 : {
42759 0 : if (bytesio5 == NULL)
42760 : {
42761 0 : Py_XDECREF(resultobj);
42762 0 : resultobj = NULL;
42763 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
42764 : }
42765 : else
42766 : {
42767 : PyObject *retval;
42768 0 : PyBuffer_Release(&view5);
42769 : assert(view5.obj == NULL);
42770 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
42771 : "l", (long) new_size);
42772 0 : if (retval == NULL)
42773 : {
42774 0 : Py_XDECREF(resultobj);
42775 : resultobj = NULL;
42776 : }
42777 : else
42778 : {
42779 0 : Py_DECREF(retval);
42780 :
42781 0 : retval = PyObject_CallMethod(bytesio5,
42782 : "getbuffer", NULL);
42783 0 : if (retval == NULL
42784 0 : || PyObject_GetBuffer(retval, &view5,
42785 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
42786 : {
42787 0 : Py_XDECREF(resultobj);
42788 : resultobj = NULL;
42789 : }
42790 :
42791 0 : Py_XDECREF(retval);
42792 :
42793 0 : if (resultobj && view5.len
42794 : != new_size)
42795 : {
42796 0 : Py_XDECREF(resultobj);
42797 0 : resultobj = NULL;
42798 0 : PyErr_Format(PyExc_ValueError,
42799 : "Expected buffer of length %zu, got %zi",
42800 : new_size,
42801 : view5.len);
42802 : }
42803 : }
42804 : }
42805 : }
42806 0 : if (resultobj)
42807 0 : memcpy(view5.buf, new_data, new_size);
42808 : }
42809 :
42810 :
42811 :
42812 : }
42813 :
42814 : /* Free the temporary wrapper, if any. */
42815 0 : if (wrapper5)
42816 0 : gpgme_data_release(wrapper5);
42817 0 : Py_XDECREF (bytesio5);
42818 0 : if (have_view5 && view5.buf)
42819 0 : PyBuffer_Release(&view5);
42820 : }
42821 : return resultobj;
42822 : fail:
42823 : {
42824 : /* See whether we need to update the Python buffer. */
42825 : if (resultobj && wrapper5 && view5.buf)
42826 : {
42827 : int dirty;
42828 : char *new_data = NULL;
42829 : size_t new_size;
42830 :
42831 :
42832 : new_data = wrapper5->data.mem.buffer;
42833 : new_size = wrapper5->data.mem.length;
42834 : dirty = new_data != NULL;
42835 :
42836 :
42837 :
42838 :
42839 :
42840 :
42841 :
42842 : if (dirty)
42843 : {
42844 : /* The buffer is dirty. */
42845 : if (view5.readonly)
42846 : {
42847 : Py_XDECREF(resultobj);
42848 : resultobj = NULL;
42849 : PyErr_SetString(PyExc_ValueError,
42850 : "cannot update read-only buffer");
42851 : }
42852 :
42853 : /* See if we need to truncate the buffer. */
42854 : if (resultobj && view5.len != new_size)
42855 : {
42856 : if (bytesio5 == NULL)
42857 : {
42858 : Py_XDECREF(resultobj);
42859 : resultobj = NULL;
42860 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
42861 : }
42862 : else
42863 : {
42864 : PyObject *retval;
42865 : PyBuffer_Release(&view5);
42866 : assert(view5.obj == NULL);
42867 : retval = PyObject_CallMethod(bytesio5, "truncate",
42868 : "l", (long) new_size);
42869 : if (retval == NULL)
42870 : {
42871 : Py_XDECREF(resultobj);
42872 : resultobj = NULL;
42873 : }
42874 : else
42875 : {
42876 : Py_DECREF(retval);
42877 :
42878 : retval = PyObject_CallMethod(bytesio5,
42879 : "getbuffer", NULL);
42880 : if (retval == NULL
42881 : || PyObject_GetBuffer(retval, &view5,
42882 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
42883 : {
42884 : Py_XDECREF(resultobj);
42885 : resultobj = NULL;
42886 : }
42887 :
42888 : Py_XDECREF(retval);
42889 :
42890 : if (resultobj && view5.len
42891 : != new_size)
42892 : {
42893 : Py_XDECREF(resultobj);
42894 : resultobj = NULL;
42895 : PyErr_Format(PyExc_ValueError,
42896 : "Expected buffer of length %zu, got %zi",
42897 : new_size,
42898 : view5.len);
42899 : }
42900 : }
42901 : }
42902 : }
42903 : if (resultobj)
42904 : memcpy(view5.buf, new_data, new_size);
42905 : }
42906 :
42907 :
42908 :
42909 : }
42910 :
42911 : /* Free the temporary wrapper, if any. */
42912 0 : if (wrapper5)
42913 0 : gpgme_data_release(wrapper5);
42914 0 : Py_XDECREF (bytesio5);
42915 : if (have_view5 && view5.buf)
42916 : PyBuffer_Release(&view5);
42917 : }
42918 : return NULL;
42919 : }
42920 :
42921 :
42922 0 : SWIGINTERN PyObject *_wrap_gpgme_op_card_edit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42923 0 : PyObject *resultobj = 0;
42924 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
42925 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
42926 0 : gpgme_edit_cb_t arg3 = (gpgme_edit_cb_t) 0 ;
42927 0 : void *arg4 = (void *) 0 ;
42928 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
42929 0 : void *argp1 = 0 ;
42930 0 : int res1 = 0 ;
42931 0 : void *argp2 = 0 ;
42932 0 : int res2 = 0 ;
42933 : int res4 ;
42934 0 : gpgme_data_t wrapper5 = NULL ;
42935 0 : PyObject *bytesio5 = NULL ;
42936 : Py_buffer view5 ;
42937 0 : int have_view5 = 0 ;
42938 0 : PyObject * obj0 = 0 ;
42939 0 : PyObject * obj1 = 0 ;
42940 0 : PyObject * obj2 = 0 ;
42941 0 : PyObject * obj3 = 0 ;
42942 0 : PyObject * obj4 = 0 ;
42943 : gpgme_error_t result;
42944 :
42945 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_card_edit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42946 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
42947 0 : if (!SWIG_IsOK(res1)) {
42948 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_card_edit" "', argument " "1"" of type '" "gpgme_ctx_t""'");
42949 : }
42950 0 : arg1 = (gpgme_ctx_t)(argp1);
42951 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
42952 0 : if (!SWIG_IsOK(res2)) {
42953 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_card_edit" "', argument " "2"" of type '" "gpgme_key_t""'");
42954 : }
42955 0 : arg2 = (gpgme_key_t)(argp2);
42956 : {
42957 0 : int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t);
42958 0 : if (!SWIG_IsOK(res)) {
42959 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_op_card_edit" "', argument " "3"" of type '" "gpgme_edit_cb_t""'");
42960 : }
42961 : }
42962 0 : res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
42963 0 : if (!SWIG_IsOK(res4)) {
42964 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_card_edit" "', argument " "4"" of type '" "void *""'");
42965 : }
42966 : {
42967 : /* If we create a temporary wrapper5 object, we will store it in
42968 : wrapperN, where N is 5. Here in this fragment, SWIG will
42969 : automatically append 5. */
42970 0 : memset(&view5, 0, sizeof view5);
42971 0 : if (obj4 == Py_None)
42972 0 : arg5 = NULL;
42973 : else {
42974 : PyObject *pypointer;
42975 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
42976 : &bytesio5, &view5);
42977 0 : if (pypointer == NULL)
42978 : return NULL;
42979 0 : have_view5 = !! view5.obj;
42980 :
42981 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
42982 :
42983 : /* Following code is from swig's python.swg. */
42984 :
42985 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
42986 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
42987 0 : Py_DECREF(pypointer);
42988 : return NULL;
42989 : }
42990 0 : Py_DECREF(pypointer);
42991 : }
42992 : }
42993 : {
42994 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42995 0 : result = gpgme_op_card_edit(arg1,arg2,arg3,arg4,arg5);
42996 0 : SWIG_PYTHON_THREAD_END_ALLOW;
42997 : }
42998 : {
42999 0 : resultobj = PyLong_FromLong(result);
43000 : }
43001 : {
43002 : /* See whether we need to update the Python buffer. */
43003 0 : if (resultobj && wrapper5 && view5.buf)
43004 : {
43005 : int dirty;
43006 0 : char *new_data = NULL;
43007 : size_t new_size;
43008 :
43009 :
43010 0 : new_data = wrapper5->data.mem.buffer;
43011 0 : new_size = wrapper5->data.mem.length;
43012 0 : dirty = new_data != NULL;
43013 :
43014 :
43015 :
43016 :
43017 :
43018 :
43019 :
43020 0 : if (dirty)
43021 : {
43022 : /* The buffer is dirty. */
43023 0 : if (view5.readonly)
43024 : {
43025 0 : Py_XDECREF(resultobj);
43026 0 : resultobj = NULL;
43027 0 : PyErr_SetString(PyExc_ValueError,
43028 : "cannot update read-only buffer");
43029 : }
43030 :
43031 : /* See if we need to truncate the buffer. */
43032 0 : if (resultobj && view5.len != new_size)
43033 : {
43034 0 : if (bytesio5 == NULL)
43035 : {
43036 0 : Py_XDECREF(resultobj);
43037 0 : resultobj = NULL;
43038 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
43039 : }
43040 : else
43041 : {
43042 : PyObject *retval;
43043 0 : PyBuffer_Release(&view5);
43044 : assert(view5.obj == NULL);
43045 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
43046 : "l", (long) new_size);
43047 0 : if (retval == NULL)
43048 : {
43049 0 : Py_XDECREF(resultobj);
43050 : resultobj = NULL;
43051 : }
43052 : else
43053 : {
43054 0 : Py_DECREF(retval);
43055 :
43056 0 : retval = PyObject_CallMethod(bytesio5,
43057 : "getbuffer", NULL);
43058 0 : if (retval == NULL
43059 0 : || PyObject_GetBuffer(retval, &view5,
43060 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
43061 : {
43062 0 : Py_XDECREF(resultobj);
43063 : resultobj = NULL;
43064 : }
43065 :
43066 0 : Py_XDECREF(retval);
43067 :
43068 0 : if (resultobj && view5.len
43069 : != new_size)
43070 : {
43071 0 : Py_XDECREF(resultobj);
43072 0 : resultobj = NULL;
43073 0 : PyErr_Format(PyExc_ValueError,
43074 : "Expected buffer of length %zu, got %zi",
43075 : new_size,
43076 : view5.len);
43077 : }
43078 : }
43079 : }
43080 : }
43081 0 : if (resultobj)
43082 0 : memcpy(view5.buf, new_data, new_size);
43083 : }
43084 :
43085 :
43086 :
43087 : }
43088 :
43089 : /* Free the temporary wrapper, if any. */
43090 0 : if (wrapper5)
43091 0 : gpgme_data_release(wrapper5);
43092 0 : Py_XDECREF (bytesio5);
43093 0 : if (have_view5 && view5.buf)
43094 0 : PyBuffer_Release(&view5);
43095 : }
43096 : return resultobj;
43097 : fail:
43098 : {
43099 : /* See whether we need to update the Python buffer. */
43100 : if (resultobj && wrapper5 && view5.buf)
43101 : {
43102 : int dirty;
43103 : char *new_data = NULL;
43104 : size_t new_size;
43105 :
43106 :
43107 : new_data = wrapper5->data.mem.buffer;
43108 : new_size = wrapper5->data.mem.length;
43109 : dirty = new_data != NULL;
43110 :
43111 :
43112 :
43113 :
43114 :
43115 :
43116 :
43117 : if (dirty)
43118 : {
43119 : /* The buffer is dirty. */
43120 : if (view5.readonly)
43121 : {
43122 : Py_XDECREF(resultobj);
43123 : resultobj = NULL;
43124 : PyErr_SetString(PyExc_ValueError,
43125 : "cannot update read-only buffer");
43126 : }
43127 :
43128 : /* See if we need to truncate the buffer. */
43129 : if (resultobj && view5.len != new_size)
43130 : {
43131 : if (bytesio5 == NULL)
43132 : {
43133 : Py_XDECREF(resultobj);
43134 : resultobj = NULL;
43135 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
43136 : }
43137 : else
43138 : {
43139 : PyObject *retval;
43140 : PyBuffer_Release(&view5);
43141 : assert(view5.obj == NULL);
43142 : retval = PyObject_CallMethod(bytesio5, "truncate",
43143 : "l", (long) new_size);
43144 : if (retval == NULL)
43145 : {
43146 : Py_XDECREF(resultobj);
43147 : resultobj = NULL;
43148 : }
43149 : else
43150 : {
43151 : Py_DECREF(retval);
43152 :
43153 : retval = PyObject_CallMethod(bytesio5,
43154 : "getbuffer", NULL);
43155 : if (retval == NULL
43156 : || PyObject_GetBuffer(retval, &view5,
43157 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
43158 : {
43159 : Py_XDECREF(resultobj);
43160 : resultobj = NULL;
43161 : }
43162 :
43163 : Py_XDECREF(retval);
43164 :
43165 : if (resultobj && view5.len
43166 : != new_size)
43167 : {
43168 : Py_XDECREF(resultobj);
43169 : resultobj = NULL;
43170 : PyErr_Format(PyExc_ValueError,
43171 : "Expected buffer of length %zu, got %zi",
43172 : new_size,
43173 : view5.len);
43174 : }
43175 : }
43176 : }
43177 : }
43178 : if (resultobj)
43179 : memcpy(view5.buf, new_data, new_size);
43180 : }
43181 :
43182 :
43183 :
43184 : }
43185 :
43186 : /* Free the temporary wrapper, if any. */
43187 0 : if (wrapper5)
43188 0 : gpgme_data_release(wrapper5);
43189 0 : Py_XDECREF (bytesio5);
43190 : if (have_view5 && view5.buf)
43191 : PyBuffer_Release(&view5);
43192 : }
43193 : return NULL;
43194 : }
43195 :
43196 :
43197 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sig_status(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43198 0 : PyObject *resultobj = 0;
43199 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
43200 : int arg2 ;
43201 0 : _gpgme_sig_stat_t *arg3 = (_gpgme_sig_stat_t *) 0 ;
43202 0 : time_t *arg4 = (time_t *) 0 ;
43203 0 : void *argp1 = 0 ;
43204 0 : int res1 = 0 ;
43205 : int val2 ;
43206 0 : int ecode2 = 0 ;
43207 0 : void *argp3 = 0 ;
43208 0 : int res3 = 0 ;
43209 0 : void *argp4 = 0 ;
43210 0 : int res4 = 0 ;
43211 0 : PyObject * obj0 = 0 ;
43212 0 : PyObject * obj1 = 0 ;
43213 0 : PyObject * obj2 = 0 ;
43214 0 : PyObject * obj3 = 0 ;
43215 0 : char *result = 0 ;
43216 :
43217 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_get_sig_status",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43218 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
43219 0 : if (!SWIG_IsOK(res1)) {
43220 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sig_status" "', argument " "1"" of type '" "gpgme_ctx_t""'");
43221 : }
43222 0 : arg1 = (gpgme_ctx_t)(argp1);
43223 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43224 0 : if (!SWIG_IsOK(ecode2)) {
43225 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_get_sig_status" "', argument " "2"" of type '" "int""'");
43226 : }
43227 0 : arg2 = (int)(val2);
43228 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__gpgme_sig_stat_t, 0 | 0 );
43229 0 : if (!SWIG_IsOK(res3)) {
43230 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_sig_status" "', argument " "3"" of type '" "_gpgme_sig_stat_t *""'");
43231 : }
43232 0 : arg3 = (_gpgme_sig_stat_t *)(argp3);
43233 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_time_t, 0 | 0 );
43234 0 : if (!SWIG_IsOK(res4)) {
43235 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_get_sig_status" "', argument " "4"" of type '" "time_t *""'");
43236 : }
43237 0 : arg4 = (time_t *)(argp4);
43238 : {
43239 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43240 0 : result = (char *)gpgme_get_sig_status(arg1,arg2,arg3,arg4);
43241 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43242 : }
43243 0 : resultobj = SWIG_FromCharPtr((const char *)result);
43244 0 : return resultobj;
43245 : fail:
43246 : return NULL;
43247 : }
43248 :
43249 :
43250 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sig_ulong_attr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43251 0 : PyObject *resultobj = 0;
43252 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
43253 : int arg2 ;
43254 : _gpgme_attr_t arg3 ;
43255 : int arg4 ;
43256 0 : void *argp1 = 0 ;
43257 0 : int res1 = 0 ;
43258 : int val2 ;
43259 0 : int ecode2 = 0 ;
43260 : int val3 ;
43261 0 : int ecode3 = 0 ;
43262 : int val4 ;
43263 0 : int ecode4 = 0 ;
43264 0 : PyObject * obj0 = 0 ;
43265 0 : PyObject * obj1 = 0 ;
43266 0 : PyObject * obj2 = 0 ;
43267 0 : PyObject * obj3 = 0 ;
43268 : unsigned long result;
43269 :
43270 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_get_sig_ulong_attr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43271 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
43272 0 : if (!SWIG_IsOK(res1)) {
43273 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sig_ulong_attr" "', argument " "1"" of type '" "gpgme_ctx_t""'");
43274 : }
43275 0 : arg1 = (gpgme_ctx_t)(argp1);
43276 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43277 0 : if (!SWIG_IsOK(ecode2)) {
43278 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_get_sig_ulong_attr" "', argument " "2"" of type '" "int""'");
43279 : }
43280 0 : arg2 = (int)(val2);
43281 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
43282 0 : if (!SWIG_IsOK(ecode3)) {
43283 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_get_sig_ulong_attr" "', argument " "3"" of type '" "_gpgme_attr_t""'");
43284 : }
43285 0 : arg3 = (_gpgme_attr_t)(val3);
43286 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
43287 0 : if (!SWIG_IsOK(ecode4)) {
43288 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_get_sig_ulong_attr" "', argument " "4"" of type '" "int""'");
43289 : }
43290 0 : arg4 = (int)(val4);
43291 : {
43292 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43293 0 : result = (unsigned long)gpgme_get_sig_ulong_attr(arg1,arg2,arg3,arg4);
43294 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43295 : }
43296 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
43297 0 : return resultobj;
43298 : fail:
43299 : return NULL;
43300 : }
43301 :
43302 :
43303 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sig_string_attr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43304 0 : PyObject *resultobj = 0;
43305 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
43306 : int arg2 ;
43307 : _gpgme_attr_t arg3 ;
43308 : int arg4 ;
43309 0 : void *argp1 = 0 ;
43310 0 : int res1 = 0 ;
43311 : int val2 ;
43312 0 : int ecode2 = 0 ;
43313 : int val3 ;
43314 0 : int ecode3 = 0 ;
43315 : int val4 ;
43316 0 : int ecode4 = 0 ;
43317 0 : PyObject * obj0 = 0 ;
43318 0 : PyObject * obj1 = 0 ;
43319 0 : PyObject * obj2 = 0 ;
43320 0 : PyObject * obj3 = 0 ;
43321 0 : char *result = 0 ;
43322 :
43323 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_get_sig_string_attr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43324 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
43325 0 : if (!SWIG_IsOK(res1)) {
43326 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sig_string_attr" "', argument " "1"" of type '" "gpgme_ctx_t""'");
43327 : }
43328 0 : arg1 = (gpgme_ctx_t)(argp1);
43329 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43330 0 : if (!SWIG_IsOK(ecode2)) {
43331 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_get_sig_string_attr" "', argument " "2"" of type '" "int""'");
43332 : }
43333 0 : arg2 = (int)(val2);
43334 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
43335 0 : if (!SWIG_IsOK(ecode3)) {
43336 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_get_sig_string_attr" "', argument " "3"" of type '" "_gpgme_attr_t""'");
43337 : }
43338 0 : arg3 = (_gpgme_attr_t)(val3);
43339 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
43340 0 : if (!SWIG_IsOK(ecode4)) {
43341 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_get_sig_string_attr" "', argument " "4"" of type '" "int""'");
43342 : }
43343 0 : arg4 = (int)(val4);
43344 : {
43345 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43346 0 : result = (char *)gpgme_get_sig_string_attr(arg1,arg2,arg3,arg4);
43347 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43348 : }
43349 0 : resultobj = SWIG_FromCharPtr((const char *)result);
43350 0 : return resultobj;
43351 : fail:
43352 : return NULL;
43353 : }
43354 :
43355 :
43356 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sig_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43357 0 : PyObject *resultobj = 0;
43358 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
43359 : int arg2 ;
43360 0 : gpgme_key_t *arg3 = (gpgme_key_t *) 0 ;
43361 0 : void *argp1 = 0 ;
43362 0 : int res1 = 0 ;
43363 : int val2 ;
43364 0 : int ecode2 = 0 ;
43365 0 : void *argp3 = 0 ;
43366 0 : int res3 = 0 ;
43367 0 : PyObject * obj0 = 0 ;
43368 0 : PyObject * obj1 = 0 ;
43369 0 : PyObject * obj2 = 0 ;
43370 : gpgme_error_t result;
43371 :
43372 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_sig_key",&obj0,&obj1,&obj2)) SWIG_fail;
43373 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
43374 0 : if (!SWIG_IsOK(res1)) {
43375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sig_key" "', argument " "1"" of type '" "gpgme_ctx_t""'");
43376 : }
43377 0 : arg1 = (gpgme_ctx_t)(argp1);
43378 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43379 0 : if (!SWIG_IsOK(ecode2)) {
43380 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_get_sig_key" "', argument " "2"" of type '" "int""'");
43381 : }
43382 0 : arg2 = (int)(val2);
43383 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
43384 0 : if (!SWIG_IsOK(res3)) {
43385 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_sig_key" "', argument " "3"" of type '" "gpgme_key_t *""'");
43386 : }
43387 0 : arg3 = (gpgme_key_t *)(argp3);
43388 : {
43389 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43390 0 : result = gpgme_get_sig_key(arg1,arg2,arg3);
43391 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43392 : }
43393 : {
43394 0 : resultobj = PyLong_FromLong(result);
43395 : }
43396 0 : return resultobj;
43397 : fail:
43398 : return NULL;
43399 : }
43400 :
43401 :
43402 0 : SWIGINTERN PyObject *_wrap_gpgme_data_new_with_read_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43403 0 : PyObject *resultobj = 0;
43404 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
43405 0 : int (*arg2)(void *,char *,size_t,size_t *) = (int (*)(void *,char *,size_t,size_t *)) 0 ;
43406 0 : void *arg3 = (void *) 0 ;
43407 0 : void *argp1 = 0 ;
43408 0 : int res1 = 0 ;
43409 : int res3 ;
43410 0 : PyObject * obj0 = 0 ;
43411 0 : PyObject * obj1 = 0 ;
43412 0 : PyObject * obj2 = 0 ;
43413 : gpgme_error_t result;
43414 :
43415 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_new_with_read_cb",&obj0,&obj1,&obj2)) SWIG_fail;
43416 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
43417 0 : if (!SWIG_IsOK(res1)) {
43418 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_with_read_cb" "', argument " "1"" of type '" "gpgme_data_t *""'");
43419 : }
43420 0 : arg1 = (gpgme_data_t *)(argp1);
43421 : {
43422 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_char_size_t_p_size_t__int);
43423 0 : if (!SWIG_IsOK(res)) {
43424 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_new_with_read_cb" "', argument " "2"" of type '" "int (*)(void *,char *,size_t,size_t *)""'");
43425 : }
43426 : }
43427 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
43428 0 : if (!SWIG_IsOK(res3)) {
43429 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_data_new_with_read_cb" "', argument " "3"" of type '" "void *""'");
43430 : }
43431 : {
43432 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43433 0 : result = gpgme_data_new_with_read_cb(arg1,arg2,arg3);
43434 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43435 : }
43436 : {
43437 0 : resultobj = PyLong_FromLong(result);
43438 : }
43439 0 : return resultobj;
43440 : fail:
43441 : return NULL;
43442 : }
43443 :
43444 :
43445 0 : SWIGINTERN PyObject *_wrap_gpgme_key_get_string_attr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43446 0 : PyObject *resultobj = 0;
43447 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
43448 : _gpgme_attr_t arg2 ;
43449 0 : void *arg3 = (void *) 0 ;
43450 : int arg4 ;
43451 0 : void *argp1 = 0 ;
43452 0 : int res1 = 0 ;
43453 : int val2 ;
43454 0 : int ecode2 = 0 ;
43455 : int res3 ;
43456 : int val4 ;
43457 0 : int ecode4 = 0 ;
43458 0 : PyObject * obj0 = 0 ;
43459 0 : PyObject * obj1 = 0 ;
43460 0 : PyObject * obj2 = 0 ;
43461 0 : PyObject * obj3 = 0 ;
43462 0 : char *result = 0 ;
43463 :
43464 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_key_get_string_attr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43465 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
43466 0 : if (!SWIG_IsOK(res1)) {
43467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_get_string_attr" "', argument " "1"" of type '" "gpgme_key_t""'");
43468 : }
43469 0 : arg1 = (gpgme_key_t)(argp1);
43470 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43471 0 : if (!SWIG_IsOK(ecode2)) {
43472 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_key_get_string_attr" "', argument " "2"" of type '" "_gpgme_attr_t""'");
43473 : }
43474 0 : arg2 = (_gpgme_attr_t)(val2);
43475 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
43476 0 : if (!SWIG_IsOK(res3)) {
43477 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_key_get_string_attr" "', argument " "3"" of type '" "void const *""'");
43478 : }
43479 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
43480 0 : if (!SWIG_IsOK(ecode4)) {
43481 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_key_get_string_attr" "', argument " "4"" of type '" "int""'");
43482 : }
43483 0 : arg4 = (int)(val4);
43484 : {
43485 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43486 0 : result = (char *)gpgme_key_get_string_attr(arg1,arg2,(void const *)arg3,arg4);
43487 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43488 : }
43489 0 : resultobj = SWIG_FromCharPtr((const char *)result);
43490 0 : return resultobj;
43491 : fail:
43492 : return NULL;
43493 : }
43494 :
43495 :
43496 0 : SWIGINTERN PyObject *_wrap_gpgme_key_get_ulong_attr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43497 0 : PyObject *resultobj = 0;
43498 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
43499 : _gpgme_attr_t arg2 ;
43500 0 : void *arg3 = (void *) 0 ;
43501 : int arg4 ;
43502 0 : void *argp1 = 0 ;
43503 0 : int res1 = 0 ;
43504 : int val2 ;
43505 0 : int ecode2 = 0 ;
43506 : int res3 ;
43507 : int val4 ;
43508 0 : int ecode4 = 0 ;
43509 0 : PyObject * obj0 = 0 ;
43510 0 : PyObject * obj1 = 0 ;
43511 0 : PyObject * obj2 = 0 ;
43512 0 : PyObject * obj3 = 0 ;
43513 : unsigned long result;
43514 :
43515 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_key_get_ulong_attr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43516 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
43517 0 : if (!SWIG_IsOK(res1)) {
43518 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_get_ulong_attr" "', argument " "1"" of type '" "gpgme_key_t""'");
43519 : }
43520 0 : arg1 = (gpgme_key_t)(argp1);
43521 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43522 0 : if (!SWIG_IsOK(ecode2)) {
43523 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_key_get_ulong_attr" "', argument " "2"" of type '" "_gpgme_attr_t""'");
43524 : }
43525 0 : arg2 = (_gpgme_attr_t)(val2);
43526 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
43527 0 : if (!SWIG_IsOK(res3)) {
43528 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_key_get_ulong_attr" "', argument " "3"" of type '" "void const *""'");
43529 : }
43530 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
43531 0 : if (!SWIG_IsOK(ecode4)) {
43532 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_key_get_ulong_attr" "', argument " "4"" of type '" "int""'");
43533 : }
43534 0 : arg4 = (int)(val4);
43535 : {
43536 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43537 0 : result = (unsigned long)gpgme_key_get_ulong_attr(arg1,arg2,(void const *)arg3,arg4);
43538 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43539 : }
43540 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
43541 0 : return resultobj;
43542 : fail:
43543 : return NULL;
43544 : }
43545 :
43546 :
43547 0 : SWIGINTERN PyObject *_wrap_gpgme_key_sig_get_string_attr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43548 0 : PyObject *resultobj = 0;
43549 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
43550 : int arg2 ;
43551 : _gpgme_attr_t arg3 ;
43552 0 : void *arg4 = (void *) 0 ;
43553 : int arg5 ;
43554 0 : void *argp1 = 0 ;
43555 0 : int res1 = 0 ;
43556 : int val2 ;
43557 0 : int ecode2 = 0 ;
43558 : int val3 ;
43559 0 : int ecode3 = 0 ;
43560 : int res4 ;
43561 : int val5 ;
43562 0 : int ecode5 = 0 ;
43563 0 : PyObject * obj0 = 0 ;
43564 0 : PyObject * obj1 = 0 ;
43565 0 : PyObject * obj2 = 0 ;
43566 0 : PyObject * obj3 = 0 ;
43567 0 : PyObject * obj4 = 0 ;
43568 0 : char *result = 0 ;
43569 :
43570 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_key_sig_get_string_attr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43571 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
43572 0 : if (!SWIG_IsOK(res1)) {
43573 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_sig_get_string_attr" "', argument " "1"" of type '" "gpgme_key_t""'");
43574 : }
43575 0 : arg1 = (gpgme_key_t)(argp1);
43576 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43577 0 : if (!SWIG_IsOK(ecode2)) {
43578 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_key_sig_get_string_attr" "', argument " "2"" of type '" "int""'");
43579 : }
43580 0 : arg2 = (int)(val2);
43581 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
43582 0 : if (!SWIG_IsOK(ecode3)) {
43583 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_key_sig_get_string_attr" "', argument " "3"" of type '" "_gpgme_attr_t""'");
43584 : }
43585 0 : arg3 = (_gpgme_attr_t)(val3);
43586 0 : res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
43587 0 : if (!SWIG_IsOK(res4)) {
43588 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_key_sig_get_string_attr" "', argument " "4"" of type '" "void const *""'");
43589 : }
43590 0 : ecode5 = SWIG_AsVal_int(obj4, &val5);
43591 0 : if (!SWIG_IsOK(ecode5)) {
43592 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_key_sig_get_string_attr" "', argument " "5"" of type '" "int""'");
43593 : }
43594 0 : arg5 = (int)(val5);
43595 : {
43596 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43597 0 : result = (char *)gpgme_key_sig_get_string_attr(arg1,arg2,arg3,(void const *)arg4,arg5);
43598 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43599 : }
43600 0 : resultobj = SWIG_FromCharPtr((const char *)result);
43601 0 : return resultobj;
43602 : fail:
43603 : return NULL;
43604 : }
43605 :
43606 :
43607 0 : SWIGINTERN PyObject *_wrap_gpgme_key_sig_get_ulong_attr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43608 0 : PyObject *resultobj = 0;
43609 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
43610 : int arg2 ;
43611 : _gpgme_attr_t arg3 ;
43612 0 : void *arg4 = (void *) 0 ;
43613 : int arg5 ;
43614 0 : void *argp1 = 0 ;
43615 0 : int res1 = 0 ;
43616 : int val2 ;
43617 0 : int ecode2 = 0 ;
43618 : int val3 ;
43619 0 : int ecode3 = 0 ;
43620 : int res4 ;
43621 : int val5 ;
43622 0 : int ecode5 = 0 ;
43623 0 : PyObject * obj0 = 0 ;
43624 0 : PyObject * obj1 = 0 ;
43625 0 : PyObject * obj2 = 0 ;
43626 0 : PyObject * obj3 = 0 ;
43627 0 : PyObject * obj4 = 0 ;
43628 : unsigned long result;
43629 :
43630 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_key_sig_get_ulong_attr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43631 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
43632 0 : if (!SWIG_IsOK(res1)) {
43633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_sig_get_ulong_attr" "', argument " "1"" of type '" "gpgme_key_t""'");
43634 : }
43635 0 : arg1 = (gpgme_key_t)(argp1);
43636 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43637 0 : if (!SWIG_IsOK(ecode2)) {
43638 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_key_sig_get_ulong_attr" "', argument " "2"" of type '" "int""'");
43639 : }
43640 0 : arg2 = (int)(val2);
43641 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
43642 0 : if (!SWIG_IsOK(ecode3)) {
43643 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_key_sig_get_ulong_attr" "', argument " "3"" of type '" "_gpgme_attr_t""'");
43644 : }
43645 0 : arg3 = (_gpgme_attr_t)(val3);
43646 0 : res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
43647 0 : if (!SWIG_IsOK(res4)) {
43648 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_key_sig_get_ulong_attr" "', argument " "4"" of type '" "void const *""'");
43649 : }
43650 0 : ecode5 = SWIG_AsVal_int(obj4, &val5);
43651 0 : if (!SWIG_IsOK(ecode5)) {
43652 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_key_sig_get_ulong_attr" "', argument " "5"" of type '" "int""'");
43653 : }
43654 0 : arg5 = (int)(val5);
43655 : {
43656 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43657 0 : result = (unsigned long)gpgme_key_sig_get_ulong_attr(arg1,arg2,arg3,(void const *)arg4,arg5);
43658 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43659 : }
43660 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
43661 0 : return resultobj;
43662 : fail:
43663 : return NULL;
43664 : }
43665 :
43666 :
43667 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43668 0 : PyObject *resultobj = 0;
43669 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
43670 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
43671 0 : int *arg3 = (int *) 0 ;
43672 0 : void *argp1 = 0 ;
43673 0 : int res1 = 0 ;
43674 0 : gpgme_data_t wrapper2 = NULL ;
43675 0 : PyObject *bytesio2 = NULL ;
43676 : Py_buffer view2 ;
43677 0 : int have_view2 = 0 ;
43678 0 : void *argp3 = 0 ;
43679 0 : int res3 = 0 ;
43680 0 : PyObject * obj0 = 0 ;
43681 0 : PyObject * obj1 = 0 ;
43682 0 : PyObject * obj2 = 0 ;
43683 : gpgme_error_t result;
43684 :
43685 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_import_ext",&obj0,&obj1,&obj2)) SWIG_fail;
43686 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
43687 0 : if (!SWIG_IsOK(res1)) {
43688 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
43689 : }
43690 0 : arg1 = (gpgme_ctx_t)(argp1);
43691 : {
43692 : /* If we create a temporary wrapper2 object, we will store it in
43693 : wrapperN, where N is 2. Here in this fragment, SWIG will
43694 : automatically append 2. */
43695 0 : memset(&view2, 0, sizeof view2);
43696 0 : if (obj1 == Py_None)
43697 0 : arg2 = NULL;
43698 : else {
43699 : PyObject *pypointer;
43700 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
43701 : &bytesio2, &view2);
43702 0 : if (pypointer == NULL)
43703 : return NULL;
43704 0 : have_view2 = !! view2.obj;
43705 :
43706 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
43707 :
43708 : /* Following code is from swig's python.swg. */
43709 :
43710 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
43711 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
43712 0 : Py_DECREF(pypointer);
43713 : return NULL;
43714 : }
43715 0 : Py_DECREF(pypointer);
43716 : }
43717 : }
43718 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
43719 0 : if (!SWIG_IsOK(res3)) {
43720 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_op_import_ext" "', argument " "3"" of type '" "int *""'");
43721 : }
43722 0 : arg3 = (int *)(argp3);
43723 : {
43724 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43725 0 : result = gpgme_op_import_ext(arg1,arg2,arg3);
43726 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43727 : }
43728 : {
43729 0 : resultobj = PyLong_FromLong(result);
43730 : }
43731 : {
43732 : /* See whether we need to update the Python buffer. */
43733 0 : if (resultobj && wrapper2 && view2.buf)
43734 : {
43735 : int dirty;
43736 0 : char *new_data = NULL;
43737 : size_t new_size;
43738 :
43739 :
43740 0 : new_data = wrapper2->data.mem.buffer;
43741 0 : new_size = wrapper2->data.mem.length;
43742 0 : dirty = new_data != NULL;
43743 :
43744 :
43745 :
43746 :
43747 :
43748 :
43749 :
43750 0 : if (dirty)
43751 : {
43752 : /* The buffer is dirty. */
43753 0 : if (view2.readonly)
43754 : {
43755 0 : Py_XDECREF(resultobj);
43756 0 : resultobj = NULL;
43757 0 : PyErr_SetString(PyExc_ValueError,
43758 : "cannot update read-only buffer");
43759 : }
43760 :
43761 : /* See if we need to truncate the buffer. */
43762 0 : if (resultobj && view2.len != new_size)
43763 : {
43764 0 : if (bytesio2 == NULL)
43765 : {
43766 0 : Py_XDECREF(resultobj);
43767 0 : resultobj = NULL;
43768 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
43769 : }
43770 : else
43771 : {
43772 : PyObject *retval;
43773 0 : PyBuffer_Release(&view2);
43774 : assert(view2.obj == NULL);
43775 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
43776 : "l", (long) new_size);
43777 0 : if (retval == NULL)
43778 : {
43779 0 : Py_XDECREF(resultobj);
43780 : resultobj = NULL;
43781 : }
43782 : else
43783 : {
43784 0 : Py_DECREF(retval);
43785 :
43786 0 : retval = PyObject_CallMethod(bytesio2,
43787 : "getbuffer", NULL);
43788 0 : if (retval == NULL
43789 0 : || PyObject_GetBuffer(retval, &view2,
43790 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
43791 : {
43792 0 : Py_XDECREF(resultobj);
43793 : resultobj = NULL;
43794 : }
43795 :
43796 0 : Py_XDECREF(retval);
43797 :
43798 0 : if (resultobj && view2.len
43799 : != new_size)
43800 : {
43801 0 : Py_XDECREF(resultobj);
43802 0 : resultobj = NULL;
43803 0 : PyErr_Format(PyExc_ValueError,
43804 : "Expected buffer of length %zu, got %zi",
43805 : new_size,
43806 : view2.len);
43807 : }
43808 : }
43809 : }
43810 : }
43811 0 : if (resultobj)
43812 0 : memcpy(view2.buf, new_data, new_size);
43813 : }
43814 :
43815 :
43816 :
43817 : }
43818 :
43819 : /* Free the temporary wrapper, if any. */
43820 0 : if (wrapper2)
43821 0 : gpgme_data_release(wrapper2);
43822 0 : Py_XDECREF (bytesio2);
43823 0 : if (have_view2 && view2.buf)
43824 0 : PyBuffer_Release(&view2);
43825 : }
43826 : return resultobj;
43827 : fail:
43828 : {
43829 : /* See whether we need to update the Python buffer. */
43830 : if (resultobj && wrapper2 && view2.buf)
43831 : {
43832 : int dirty;
43833 : char *new_data = NULL;
43834 : size_t new_size;
43835 :
43836 :
43837 : new_data = wrapper2->data.mem.buffer;
43838 : new_size = wrapper2->data.mem.length;
43839 : dirty = new_data != NULL;
43840 :
43841 :
43842 :
43843 :
43844 :
43845 :
43846 :
43847 : if (dirty)
43848 : {
43849 : /* The buffer is dirty. */
43850 : if (view2.readonly)
43851 : {
43852 : Py_XDECREF(resultobj);
43853 : resultobj = NULL;
43854 : PyErr_SetString(PyExc_ValueError,
43855 : "cannot update read-only buffer");
43856 : }
43857 :
43858 : /* See if we need to truncate the buffer. */
43859 : if (resultobj && view2.len != new_size)
43860 : {
43861 : if (bytesio2 == NULL)
43862 : {
43863 : Py_XDECREF(resultobj);
43864 : resultobj = NULL;
43865 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
43866 : }
43867 : else
43868 : {
43869 : PyObject *retval;
43870 : PyBuffer_Release(&view2);
43871 : assert(view2.obj == NULL);
43872 : retval = PyObject_CallMethod(bytesio2, "truncate",
43873 : "l", (long) new_size);
43874 : if (retval == NULL)
43875 : {
43876 : Py_XDECREF(resultobj);
43877 : resultobj = NULL;
43878 : }
43879 : else
43880 : {
43881 : Py_DECREF(retval);
43882 :
43883 : retval = PyObject_CallMethod(bytesio2,
43884 : "getbuffer", NULL);
43885 : if (retval == NULL
43886 : || PyObject_GetBuffer(retval, &view2,
43887 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
43888 : {
43889 : Py_XDECREF(resultobj);
43890 : resultobj = NULL;
43891 : }
43892 :
43893 : Py_XDECREF(retval);
43894 :
43895 : if (resultobj && view2.len
43896 : != new_size)
43897 : {
43898 : Py_XDECREF(resultobj);
43899 : resultobj = NULL;
43900 : PyErr_Format(PyExc_ValueError,
43901 : "Expected buffer of length %zu, got %zi",
43902 : new_size,
43903 : view2.len);
43904 : }
43905 : }
43906 : }
43907 : }
43908 : if (resultobj)
43909 : memcpy(view2.buf, new_data, new_size);
43910 : }
43911 :
43912 :
43913 :
43914 : }
43915 :
43916 : /* Free the temporary wrapper, if any. */
43917 0 : if (wrapper2)
43918 0 : gpgme_data_release(wrapper2);
43919 0 : Py_XDECREF (bytesio2);
43920 0 : if (have_view2 && view2.buf)
43921 0 : PyBuffer_Release(&view2);
43922 : }
43923 : return NULL;
43924 : }
43925 :
43926 :
43927 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43928 0 : PyObject *resultobj = 0;
43929 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
43930 0 : void *argp1 = 0 ;
43931 0 : int res1 = 0 ;
43932 0 : PyObject * obj0 = 0 ;
43933 :
43934 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_release",&obj0)) SWIG_fail;
43935 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
43936 0 : if (!SWIG_IsOK(res1)) {
43937 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_release" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
43938 : }
43939 0 : arg1 = (gpgme_trust_item_t)(argp1);
43940 : {
43941 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43942 0 : gpgme_trust_item_release(arg1);
43943 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43944 : }
43945 0 : resultobj = SWIG_Py_Void();
43946 0 : return resultobj;
43947 : fail:
43948 : return NULL;
43949 : }
43950 :
43951 :
43952 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_get_string_attr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43953 0 : PyObject *resultobj = 0;
43954 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
43955 : _gpgme_attr_t arg2 ;
43956 0 : void *arg3 = (void *) 0 ;
43957 : int arg4 ;
43958 0 : void *argp1 = 0 ;
43959 0 : int res1 = 0 ;
43960 : int val2 ;
43961 0 : int ecode2 = 0 ;
43962 : int res3 ;
43963 : int val4 ;
43964 0 : int ecode4 = 0 ;
43965 0 : PyObject * obj0 = 0 ;
43966 0 : PyObject * obj1 = 0 ;
43967 0 : PyObject * obj2 = 0 ;
43968 0 : PyObject * obj3 = 0 ;
43969 0 : char *result = 0 ;
43970 :
43971 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_trust_item_get_string_attr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43972 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
43973 0 : if (!SWIG_IsOK(res1)) {
43974 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_get_string_attr" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
43975 : }
43976 0 : arg1 = (gpgme_trust_item_t)(argp1);
43977 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43978 0 : if (!SWIG_IsOK(ecode2)) {
43979 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_trust_item_get_string_attr" "', argument " "2"" of type '" "_gpgme_attr_t""'");
43980 : }
43981 0 : arg2 = (_gpgme_attr_t)(val2);
43982 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
43983 0 : if (!SWIG_IsOK(res3)) {
43984 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_trust_item_get_string_attr" "', argument " "3"" of type '" "void const *""'");
43985 : }
43986 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
43987 0 : if (!SWIG_IsOK(ecode4)) {
43988 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_trust_item_get_string_attr" "', argument " "4"" of type '" "int""'");
43989 : }
43990 0 : arg4 = (int)(val4);
43991 : {
43992 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43993 0 : result = (char *)gpgme_trust_item_get_string_attr(arg1,arg2,(void const *)arg3,arg4);
43994 0 : SWIG_PYTHON_THREAD_END_ALLOW;
43995 : }
43996 0 : resultobj = SWIG_FromCharPtr((const char *)result);
43997 0 : return resultobj;
43998 : fail:
43999 : return NULL;
44000 : }
44001 :
44002 :
44003 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_get_int_attr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44004 0 : PyObject *resultobj = 0;
44005 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
44006 : _gpgme_attr_t arg2 ;
44007 0 : void *arg3 = (void *) 0 ;
44008 : int arg4 ;
44009 0 : void *argp1 = 0 ;
44010 0 : int res1 = 0 ;
44011 : int val2 ;
44012 0 : int ecode2 = 0 ;
44013 : int res3 ;
44014 : int val4 ;
44015 0 : int ecode4 = 0 ;
44016 0 : PyObject * obj0 = 0 ;
44017 0 : PyObject * obj1 = 0 ;
44018 0 : PyObject * obj2 = 0 ;
44019 0 : PyObject * obj3 = 0 ;
44020 : int result;
44021 :
44022 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_trust_item_get_int_attr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44023 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
44024 0 : if (!SWIG_IsOK(res1)) {
44025 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_get_int_attr" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
44026 : }
44027 0 : arg1 = (gpgme_trust_item_t)(argp1);
44028 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44029 0 : if (!SWIG_IsOK(ecode2)) {
44030 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_trust_item_get_int_attr" "', argument " "2"" of type '" "_gpgme_attr_t""'");
44031 : }
44032 0 : arg2 = (_gpgme_attr_t)(val2);
44033 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
44034 0 : if (!SWIG_IsOK(res3)) {
44035 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_trust_item_get_int_attr" "', argument " "3"" of type '" "void const *""'");
44036 : }
44037 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
44038 0 : if (!SWIG_IsOK(ecode4)) {
44039 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_trust_item_get_int_attr" "', argument " "4"" of type '" "int""'");
44040 : }
44041 0 : arg4 = (int)(val4);
44042 : {
44043 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44044 0 : result = (int)gpgme_trust_item_get_int_attr(arg1,arg2,(void const *)arg3,arg4);
44045 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44046 : }
44047 0 : resultobj = SWIG_From_int((int)(result));
44048 0 : return resultobj;
44049 : fail:
44050 : return NULL;
44051 : }
44052 :
44053 :
44054 0 : SWIGINTERN PyObject *_wrap__gpgme_op_assuan_result_err_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44055 0 : PyObject *resultobj = 0;
44056 0 : struct _gpgme_op_assuan_result *arg1 = (struct _gpgme_op_assuan_result *) 0 ;
44057 : gpgme_error_t arg2 ;
44058 0 : void *argp1 = 0 ;
44059 0 : int res1 = 0 ;
44060 0 : PyObject * obj0 = 0 ;
44061 0 : PyObject * obj1 = 0 ;
44062 :
44063 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_assuan_result_err_set",&obj0,&obj1)) SWIG_fail;
44064 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_assuan_result, 0 | 0 );
44065 0 : if (!SWIG_IsOK(res1)) {
44066 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_assuan_result_err_set" "', argument " "1"" of type '" "struct _gpgme_op_assuan_result *""'");
44067 : }
44068 0 : arg1 = (struct _gpgme_op_assuan_result *)(argp1);
44069 : {
44070 0 : if (PyLong_Check(obj1))
44071 0 : arg2 = PyLong_AsLong(obj1);
44072 :
44073 : else if (PyInt_Check(obj1))
44074 : arg2 = PyInt_AsLong(obj1);
44075 :
44076 : else
44077 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
44078 : }
44079 : {
44080 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44081 0 : if (arg1) (arg1)->err = arg2;
44082 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44083 : }
44084 0 : resultobj = SWIG_Py_Void();
44085 0 : return resultobj;
44086 : fail:
44087 : return NULL;
44088 : }
44089 :
44090 :
44091 0 : SWIGINTERN PyObject *_wrap__gpgme_op_assuan_result_err_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44092 0 : PyObject *resultobj = 0;
44093 0 : struct _gpgme_op_assuan_result *arg1 = (struct _gpgme_op_assuan_result *) 0 ;
44094 0 : void *argp1 = 0 ;
44095 0 : int res1 = 0 ;
44096 0 : PyObject * obj0 = 0 ;
44097 : gpgme_error_t result;
44098 :
44099 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_assuan_result_err_get",&obj0)) SWIG_fail;
44100 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_assuan_result, 0 | 0 );
44101 0 : if (!SWIG_IsOK(res1)) {
44102 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_assuan_result_err_get" "', argument " "1"" of type '" "struct _gpgme_op_assuan_result *""'");
44103 : }
44104 0 : arg1 = (struct _gpgme_op_assuan_result *)(argp1);
44105 : {
44106 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44107 0 : result = ((arg1)->err);
44108 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44109 : }
44110 : {
44111 0 : resultobj = PyLong_FromLong(result);
44112 : }
44113 0 : return resultobj;
44114 : fail:
44115 : return NULL;
44116 : }
44117 :
44118 :
44119 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_assuan_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44120 0 : PyObject *resultobj = 0;
44121 0 : struct _gpgme_op_assuan_result *result = 0 ;
44122 :
44123 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_assuan_result")) SWIG_fail;
44124 : {
44125 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44126 0 : result = (struct _gpgme_op_assuan_result *)calloc(1, sizeof(struct _gpgme_op_assuan_result));
44127 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44128 : }
44129 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_assuan_result, SWIG_POINTER_NEW | 0 );
44130 0 : return resultobj;
44131 : fail:
44132 : return NULL;
44133 : }
44134 :
44135 :
44136 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_assuan_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44137 0 : PyObject *resultobj = 0;
44138 0 : struct _gpgme_op_assuan_result *arg1 = (struct _gpgme_op_assuan_result *) 0 ;
44139 0 : void *argp1 = 0 ;
44140 0 : int res1 = 0 ;
44141 0 : PyObject * obj0 = 0 ;
44142 :
44143 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_assuan_result",&obj0)) SWIG_fail;
44144 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_assuan_result, SWIG_POINTER_DISOWN | 0 );
44145 0 : if (!SWIG_IsOK(res1)) {
44146 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_assuan_result" "', argument " "1"" of type '" "struct _gpgme_op_assuan_result *""'");
44147 : }
44148 0 : arg1 = (struct _gpgme_op_assuan_result *)(argp1);
44149 : {
44150 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44151 0 : free((char *) arg1);
44152 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44153 : }
44154 0 : resultobj = SWIG_Py_Void();
44155 0 : return resultobj;
44156 : fail:
44157 : return NULL;
44158 : }
44159 :
44160 :
44161 29 : SWIGINTERN PyObject *_gpgme_op_assuan_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44162 : PyObject *obj;
44163 29 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
44164 58 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_assuan_result, SWIG_NewClientData(obj));
44165 29 : return SWIG_Py_Void();
44166 : }
44167 :
44168 0 : SWIGINTERN PyObject *_wrap_gpgme_op_assuan_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44169 0 : PyObject *resultobj = 0;
44170 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
44171 0 : void *argp1 = 0 ;
44172 0 : int res1 = 0 ;
44173 0 : PyObject * obj0 = 0 ;
44174 : gpgme_assuan_result_t result;
44175 :
44176 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_assuan_result",&obj0)) SWIG_fail;
44177 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
44178 0 : if (!SWIG_IsOK(res1)) {
44179 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_assuan_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
44180 : }
44181 0 : arg1 = (gpgme_ctx_t)(argp1);
44182 : {
44183 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44184 0 : result = (gpgme_assuan_result_t)gpgme_op_assuan_result(arg1);
44185 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44186 : }
44187 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_assuan_result, 0 | 0 );
44188 0 : return resultobj;
44189 : fail:
44190 : return NULL;
44191 : }
44192 :
44193 :
44194 0 : SWIGINTERN PyObject *_wrap_gpgme_op_assuan_transact(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44195 0 : PyObject *resultobj = 0;
44196 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
44197 0 : char *arg2 = (char *) 0 ;
44198 0 : gpgme_assuan_data_cb_t arg3 = (gpgme_assuan_data_cb_t) 0 ;
44199 0 : void *arg4 = (void *) 0 ;
44200 0 : gpgme_assuan_inquire_cb_t arg5 = (gpgme_assuan_inquire_cb_t) 0 ;
44201 0 : void *arg6 = (void *) 0 ;
44202 0 : gpgme_assuan_status_cb_t arg7 = (gpgme_assuan_status_cb_t) 0 ;
44203 0 : void *arg8 = (void *) 0 ;
44204 0 : void *argp1 = 0 ;
44205 0 : int res1 = 0 ;
44206 0 : PyObject *encodedInput2 = NULL ;
44207 : int res8 ;
44208 0 : PyObject * obj0 = 0 ;
44209 0 : PyObject * obj1 = 0 ;
44210 0 : PyObject * obj2 = 0 ;
44211 0 : PyObject * obj3 = 0 ;
44212 0 : PyObject * obj4 = 0 ;
44213 0 : PyObject * obj5 = 0 ;
44214 : gpgme_error_t result;
44215 :
44216 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_assuan_transact",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44217 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
44218 0 : if (!SWIG_IsOK(res1)) {
44219 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_assuan_transact" "', argument " "1"" of type '" "gpgme_ctx_t""'");
44220 : }
44221 0 : arg1 = (gpgme_ctx_t)(argp1);
44222 : {
44223 0 : if (obj1 == Py_None)
44224 : arg2 = NULL;
44225 0 : else if (PyUnicode_Check(obj1))
44226 : {
44227 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
44228 0 : if (encodedInput2 == NULL)
44229 : return NULL;
44230 0 : arg2 = PyBytes_AsString(encodedInput2);
44231 : }
44232 0 : else if (PyBytes_Check(obj1))
44233 0 : arg2 = PyBytes_AsString(obj1);
44234 : else {
44235 0 : PyErr_Format(PyExc_TypeError,
44236 : "arg %d: expected str, bytes, or None, got %s",
44237 : 2, obj1->ob_type->tp_name);
44238 0 : return NULL;
44239 : }
44240 : }
44241 : {
44242 0 : if (obj2 == Py_None)
44243 : arg3 = arg4 = NULL;
44244 : else
44245 : {
44246 0 : if (! PyTuple_Check(obj2))
44247 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
44248 0 : if (PyTuple_Size(obj2) != 2)
44249 0 : return PyErr_Format(PyExc_TypeError,
44250 : "callback must be a tuple of size 2");
44251 0 : if (! PyCallable_Check(PyTuple_GetItem(obj2, 1)))
44252 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
44253 0 : arg3 = _gpg_assuan_data_cb;
44254 0 : arg4 = obj2;
44255 : }
44256 : }
44257 : {
44258 0 : if (obj3 == Py_None)
44259 : arg5 = arg6 = NULL;
44260 : else
44261 : {
44262 0 : if (! PyTuple_Check(obj3))
44263 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
44264 0 : if (PyTuple_Size(obj3) != 2)
44265 0 : return PyErr_Format(PyExc_TypeError,
44266 : "callback must be a tuple of size 2");
44267 0 : if (! PyCallable_Check(PyTuple_GetItem(obj3, 1)))
44268 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
44269 0 : arg5 = _gpg_assuan_inquire_cb;
44270 0 : arg6 = obj3;
44271 : }
44272 : }
44273 : {
44274 0 : int res = SWIG_ConvertFunctionPtr(obj4, (void**)(&arg7), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t);
44275 0 : if (!SWIG_IsOK(res)) {
44276 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_op_assuan_transact" "', argument " "7"" of type '" "gpgme_assuan_status_cb_t""'");
44277 : }
44278 : }
44279 0 : res8 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg8), 0, 0);
44280 0 : if (!SWIG_IsOK(res8)) {
44281 0 : SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "gpgme_op_assuan_transact" "', argument " "8"" of type '" "void *""'");
44282 : }
44283 : {
44284 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44285 0 : result = gpgme_op_assuan_transact(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
44286 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44287 : }
44288 : {
44289 0 : resultobj = PyLong_FromLong(result);
44290 : }
44291 : {
44292 0 : Py_XDECREF(encodedInput2);
44293 : }
44294 : return resultobj;
44295 : fail:
44296 : {
44297 0 : Py_XDECREF(encodedInput2);
44298 : }
44299 : return NULL;
44300 : }
44301 :
44302 :
44303 84 : SWIGINTERN PyObject *_wrap_new_gpgme_ctx_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44304 84 : PyObject *resultobj = 0;
44305 84 : gpgme_ctx_t *result = 0 ;
44306 :
44307 84 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_ctx_t_p")) SWIG_fail;
44308 : {
44309 84 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44310 84 : result = (gpgme_ctx_t *)new_gpgme_ctx_t_p();
44311 84 : SWIG_PYTHON_THREAD_END_ALLOW;
44312 : }
44313 84 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_context, 0 | 0 );
44314 84 : return resultobj;
44315 : fail:
44316 : return NULL;
44317 : }
44318 :
44319 :
44320 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_ctx_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44321 0 : PyObject *resultobj = 0;
44322 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
44323 0 : void *argp1 = 0 ;
44324 0 : int res1 = 0 ;
44325 0 : PyObject * obj0 = 0 ;
44326 0 : gpgme_ctx_t *result = 0 ;
44327 :
44328 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_ctx_t_p",&obj0)) SWIG_fail;
44329 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
44330 0 : if (!SWIG_IsOK(res1)) {
44331 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_ctx_t_p" "', argument " "1"" of type '" "gpgme_ctx_t""'");
44332 : }
44333 0 : arg1 = (gpgme_ctx_t)(argp1);
44334 : {
44335 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44336 0 : result = (gpgme_ctx_t *)copy_gpgme_ctx_t_p(arg1);
44337 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44338 : }
44339 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_context, 0 | 0 );
44340 0 : return resultobj;
44341 : fail:
44342 : return NULL;
44343 : }
44344 :
44345 :
44346 84 : SWIGINTERN PyObject *_wrap_delete_gpgme_ctx_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44347 84 : PyObject *resultobj = 0;
44348 84 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
44349 84 : void *argp1 = 0 ;
44350 84 : int res1 = 0 ;
44351 84 : PyObject * obj0 = 0 ;
44352 :
44353 84 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_ctx_t_p",&obj0)) SWIG_fail;
44354 84 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
44355 84 : if (!SWIG_IsOK(res1)) {
44356 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_ctx_t_p" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
44357 : }
44358 84 : arg1 = (gpgme_ctx_t *)(argp1);
44359 : {
44360 84 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44361 84 : delete_gpgme_ctx_t_p(arg1);
44362 84 : SWIG_PYTHON_THREAD_END_ALLOW;
44363 : }
44364 84 : resultobj = SWIG_Py_Void();
44365 84 : return resultobj;
44366 : fail:
44367 : return NULL;
44368 : }
44369 :
44370 :
44371 0 : SWIGINTERN PyObject *_wrap_gpgme_ctx_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44372 0 : PyObject *resultobj = 0;
44373 0 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
44374 0 : gpgme_ctx_t arg2 = (gpgme_ctx_t) 0 ;
44375 0 : void *argp1 = 0 ;
44376 0 : int res1 = 0 ;
44377 0 : void *argp2 = 0 ;
44378 0 : int res2 = 0 ;
44379 0 : PyObject * obj0 = 0 ;
44380 0 : PyObject * obj1 = 0 ;
44381 :
44382 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_ctx_t_p_assign",&obj0,&obj1)) SWIG_fail;
44383 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
44384 0 : if (!SWIG_IsOK(res1)) {
44385 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_t_p_assign" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
44386 : }
44387 0 : arg1 = (gpgme_ctx_t *)(argp1);
44388 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_context, 0 | 0 );
44389 0 : if (!SWIG_IsOK(res2)) {
44390 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_ctx_t_p_assign" "', argument " "2"" of type '" "gpgme_ctx_t""'");
44391 : }
44392 0 : arg2 = (gpgme_ctx_t)(argp2);
44393 : {
44394 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44395 0 : gpgme_ctx_t_p_assign(arg1,arg2);
44396 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44397 : }
44398 0 : resultobj = SWIG_Py_Void();
44399 0 : return resultobj;
44400 : fail:
44401 : return NULL;
44402 : }
44403 :
44404 :
44405 84 : SWIGINTERN PyObject *_wrap_gpgme_ctx_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44406 84 : PyObject *resultobj = 0;
44407 84 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
44408 84 : void *argp1 = 0 ;
44409 84 : int res1 = 0 ;
44410 84 : PyObject * obj0 = 0 ;
44411 : gpgme_ctx_t result;
44412 :
44413 84 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_ctx_t_p_value",&obj0)) SWIG_fail;
44414 84 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
44415 84 : if (!SWIG_IsOK(res1)) {
44416 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_t_p_value" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
44417 : }
44418 84 : arg1 = (gpgme_ctx_t *)(argp1);
44419 : {
44420 84 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44421 84 : result = (gpgme_ctx_t)gpgme_ctx_t_p_value(arg1);
44422 84 : SWIG_PYTHON_THREAD_END_ALLOW;
44423 : }
44424 84 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
44425 84 : return resultobj;
44426 : fail:
44427 : return NULL;
44428 : }
44429 :
44430 :
44431 109 : SWIGINTERN PyObject *_wrap_new_gpgme_data_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44432 109 : PyObject *resultobj = 0;
44433 109 : gpgme_data_t *result = 0 ;
44434 :
44435 109 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_data_t_p")) SWIG_fail;
44436 : {
44437 109 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44438 109 : result = (gpgme_data_t *)new_gpgme_data_t_p();
44439 109 : SWIG_PYTHON_THREAD_END_ALLOW;
44440 : }
44441 109 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_data, 0 | 0 );
44442 109 : return resultobj;
44443 : fail:
44444 : return NULL;
44445 : }
44446 :
44447 :
44448 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_data_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44449 0 : PyObject *resultobj = 0;
44450 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
44451 0 : void *argp1 = 0 ;
44452 0 : int res1 = 0 ;
44453 0 : PyObject * obj0 = 0 ;
44454 0 : gpgme_data_t *result = 0 ;
44455 :
44456 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_data_t_p",&obj0)) SWIG_fail;
44457 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
44458 0 : if (!SWIG_IsOK(res1)) {
44459 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_data_t_p" "', argument " "1"" of type '" "gpgme_data_t""'");
44460 : }
44461 0 : arg1 = (gpgme_data_t)(argp1);
44462 : {
44463 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44464 0 : result = (gpgme_data_t *)copy_gpgme_data_t_p(arg1);
44465 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44466 : }
44467 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_data, 0 | 0 );
44468 0 : return resultobj;
44469 : fail:
44470 : return NULL;
44471 : }
44472 :
44473 :
44474 109 : SWIGINTERN PyObject *_wrap_delete_gpgme_data_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44475 109 : PyObject *resultobj = 0;
44476 109 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
44477 109 : void *argp1 = 0 ;
44478 109 : int res1 = 0 ;
44479 109 : PyObject * obj0 = 0 ;
44480 :
44481 109 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_data_t_p",&obj0)) SWIG_fail;
44482 109 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
44483 109 : if (!SWIG_IsOK(res1)) {
44484 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_data_t_p" "', argument " "1"" of type '" "gpgme_data_t *""'");
44485 : }
44486 109 : arg1 = (gpgme_data_t *)(argp1);
44487 : {
44488 109 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44489 109 : delete_gpgme_data_t_p(arg1);
44490 109 : SWIG_PYTHON_THREAD_END_ALLOW;
44491 : }
44492 109 : resultobj = SWIG_Py_Void();
44493 109 : return resultobj;
44494 : fail:
44495 : return NULL;
44496 : }
44497 :
44498 :
44499 0 : SWIGINTERN PyObject *_wrap_gpgme_data_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44500 0 : PyObject *resultobj = 0;
44501 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
44502 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
44503 0 : void *argp1 = 0 ;
44504 0 : int res1 = 0 ;
44505 0 : void *argp2 = 0 ;
44506 0 : int res2 = 0 ;
44507 0 : PyObject * obj0 = 0 ;
44508 0 : PyObject * obj1 = 0 ;
44509 :
44510 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_t_p_assign",&obj0,&obj1)) SWIG_fail;
44511 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
44512 0 : if (!SWIG_IsOK(res1)) {
44513 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_t_p_assign" "', argument " "1"" of type '" "gpgme_data_t *""'");
44514 : }
44515 0 : arg1 = (gpgme_data_t *)(argp1);
44516 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
44517 0 : if (!SWIG_IsOK(res2)) {
44518 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_t_p_assign" "', argument " "2"" of type '" "gpgme_data_t""'");
44519 : }
44520 0 : arg2 = (gpgme_data_t)(argp2);
44521 : {
44522 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44523 0 : gpgme_data_t_p_assign(arg1,arg2);
44524 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44525 : }
44526 0 : resultobj = SWIG_Py_Void();
44527 0 : return resultobj;
44528 : fail:
44529 : return NULL;
44530 : }
44531 :
44532 :
44533 109 : SWIGINTERN PyObject *_wrap_gpgme_data_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44534 109 : PyObject *resultobj = 0;
44535 109 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
44536 109 : void *argp1 = 0 ;
44537 109 : int res1 = 0 ;
44538 109 : PyObject * obj0 = 0 ;
44539 : gpgme_data_t result;
44540 :
44541 109 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_t_p_value",&obj0)) SWIG_fail;
44542 109 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
44543 109 : if (!SWIG_IsOK(res1)) {
44544 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_t_p_value" "', argument " "1"" of type '" "gpgme_data_t *""'");
44545 : }
44546 109 : arg1 = (gpgme_data_t *)(argp1);
44547 : {
44548 109 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44549 109 : result = (gpgme_data_t)gpgme_data_t_p_value(arg1);
44550 109 : SWIG_PYTHON_THREAD_END_ALLOW;
44551 : }
44552 109 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data, 0 | 0 );
44553 109 : return resultobj;
44554 : fail:
44555 : return NULL;
44556 : }
44557 :
44558 :
44559 241 : SWIGINTERN PyObject *_wrap_new_gpgme_key_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44560 241 : PyObject *resultobj = 0;
44561 241 : gpgme_key_t *result = 0 ;
44562 :
44563 241 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_key_t_p")) SWIG_fail;
44564 : {
44565 241 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44566 241 : result = (gpgme_key_t *)new_gpgme_key_t_p();
44567 241 : SWIG_PYTHON_THREAD_END_ALLOW;
44568 : }
44569 241 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_key, 0 | 0 );
44570 241 : return resultobj;
44571 : fail:
44572 : return NULL;
44573 : }
44574 :
44575 :
44576 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_key_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44577 0 : PyObject *resultobj = 0;
44578 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
44579 0 : void *argp1 = 0 ;
44580 0 : int res1 = 0 ;
44581 0 : PyObject * obj0 = 0 ;
44582 0 : gpgme_key_t *result = 0 ;
44583 :
44584 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_key_t_p",&obj0)) SWIG_fail;
44585 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
44586 0 : if (!SWIG_IsOK(res1)) {
44587 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_key_t_p" "', argument " "1"" of type '" "gpgme_key_t""'");
44588 : }
44589 0 : arg1 = (gpgme_key_t)(argp1);
44590 : {
44591 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44592 0 : result = (gpgme_key_t *)copy_gpgme_key_t_p(arg1);
44593 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44594 : }
44595 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_key, 0 | 0 );
44596 0 : return resultobj;
44597 : fail:
44598 : return NULL;
44599 : }
44600 :
44601 :
44602 239 : SWIGINTERN PyObject *_wrap_delete_gpgme_key_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44603 239 : PyObject *resultobj = 0;
44604 239 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
44605 239 : void *argp1 = 0 ;
44606 239 : int res1 = 0 ;
44607 239 : PyObject * obj0 = 0 ;
44608 :
44609 239 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_key_t_p",&obj0)) SWIG_fail;
44610 239 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
44611 239 : if (!SWIG_IsOK(res1)) {
44612 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_key_t_p" "', argument " "1"" of type '" "gpgme_key_t *""'");
44613 : }
44614 239 : arg1 = (gpgme_key_t *)(argp1);
44615 : {
44616 239 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44617 239 : delete_gpgme_key_t_p(arg1);
44618 239 : SWIG_PYTHON_THREAD_END_ALLOW;
44619 : }
44620 239 : resultobj = SWIG_Py_Void();
44621 239 : return resultobj;
44622 : fail:
44623 : return NULL;
44624 : }
44625 :
44626 :
44627 0 : SWIGINTERN PyObject *_wrap_gpgme_key_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44628 0 : PyObject *resultobj = 0;
44629 0 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
44630 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
44631 0 : void *argp1 = 0 ;
44632 0 : int res1 = 0 ;
44633 0 : void *argp2 = 0 ;
44634 0 : int res2 = 0 ;
44635 0 : PyObject * obj0 = 0 ;
44636 0 : PyObject * obj1 = 0 ;
44637 :
44638 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_key_t_p_assign",&obj0,&obj1)) SWIG_fail;
44639 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
44640 0 : if (!SWIG_IsOK(res1)) {
44641 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_t_p_assign" "', argument " "1"" of type '" "gpgme_key_t *""'");
44642 : }
44643 0 : arg1 = (gpgme_key_t *)(argp1);
44644 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
44645 0 : if (!SWIG_IsOK(res2)) {
44646 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_key_t_p_assign" "', argument " "2"" of type '" "gpgme_key_t""'");
44647 : }
44648 0 : arg2 = (gpgme_key_t)(argp2);
44649 : {
44650 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44651 0 : gpgme_key_t_p_assign(arg1,arg2);
44652 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44653 : }
44654 0 : resultobj = SWIG_Py_Void();
44655 0 : return resultobj;
44656 : fail:
44657 : return NULL;
44658 : }
44659 :
44660 :
44661 221 : SWIGINTERN PyObject *_wrap_gpgme_key_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44662 221 : PyObject *resultobj = 0;
44663 221 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
44664 221 : void *argp1 = 0 ;
44665 221 : int res1 = 0 ;
44666 221 : PyObject * obj0 = 0 ;
44667 : gpgme_key_t result;
44668 :
44669 221 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_t_p_value",&obj0)) SWIG_fail;
44670 221 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
44671 221 : if (!SWIG_IsOK(res1)) {
44672 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_t_p_value" "', argument " "1"" of type '" "gpgme_key_t *""'");
44673 : }
44674 221 : arg1 = (gpgme_key_t *)(argp1);
44675 : {
44676 221 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44677 221 : result = (gpgme_key_t)gpgme_key_t_p_value(arg1);
44678 221 : SWIG_PYTHON_THREAD_END_ALLOW;
44679 : }
44680 221 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
44681 221 : return resultobj;
44682 : fail:
44683 : return NULL;
44684 : }
44685 :
44686 :
44687 17 : SWIGINTERN PyObject *_wrap_new_gpgme_error_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44688 17 : PyObject *resultobj = 0;
44689 17 : gpgme_error_t *result = 0 ;
44690 :
44691 17 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_error_t_p")) SWIG_fail;
44692 : {
44693 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44694 17 : result = (gpgme_error_t *)new_gpgme_error_t_p();
44695 17 : SWIG_PYTHON_THREAD_END_ALLOW;
44696 : }
44697 17 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpg_error_t, 0 | 0 );
44698 17 : return resultobj;
44699 : fail:
44700 : return NULL;
44701 : }
44702 :
44703 :
44704 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_error_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44705 0 : PyObject *resultobj = 0;
44706 : gpgme_error_t arg1 ;
44707 0 : PyObject * obj0 = 0 ;
44708 0 : gpgme_error_t *result = 0 ;
44709 :
44710 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_error_t_p",&obj0)) SWIG_fail;
44711 : {
44712 0 : if (PyLong_Check(obj0))
44713 0 : arg1 = PyLong_AsLong(obj0);
44714 :
44715 : else if (PyInt_Check(obj0))
44716 : arg1 = PyInt_AsLong(obj0);
44717 :
44718 : else
44719 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
44720 : }
44721 : {
44722 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44723 0 : result = (gpgme_error_t *)copy_gpgme_error_t_p(arg1);
44724 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44725 : }
44726 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpg_error_t, 0 | 0 );
44727 0 : return resultobj;
44728 : fail:
44729 : return NULL;
44730 : }
44731 :
44732 :
44733 11 : SWIGINTERN PyObject *_wrap_delete_gpgme_error_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44734 11 : PyObject *resultobj = 0;
44735 11 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
44736 11 : void *argp1 = 0 ;
44737 11 : int res1 = 0 ;
44738 11 : PyObject * obj0 = 0 ;
44739 :
44740 11 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_error_t_p",&obj0)) SWIG_fail;
44741 11 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
44742 11 : if (!SWIG_IsOK(res1)) {
44743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_error_t_p" "', argument " "1"" of type '" "gpgme_error_t *""'");
44744 : }
44745 11 : arg1 = (gpgme_error_t *)(argp1);
44746 : {
44747 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44748 11 : delete_gpgme_error_t_p(arg1);
44749 11 : SWIG_PYTHON_THREAD_END_ALLOW;
44750 : }
44751 11 : resultobj = SWIG_Py_Void();
44752 11 : return resultobj;
44753 : fail:
44754 : return NULL;
44755 : }
44756 :
44757 :
44758 0 : SWIGINTERN PyObject *_wrap_gpgme_error_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44759 0 : PyObject *resultobj = 0;
44760 0 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
44761 : gpgme_error_t arg2 ;
44762 0 : void *argp1 = 0 ;
44763 0 : int res1 = 0 ;
44764 0 : PyObject * obj0 = 0 ;
44765 0 : PyObject * obj1 = 0 ;
44766 :
44767 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_error_t_p_assign",&obj0,&obj1)) SWIG_fail;
44768 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
44769 0 : if (!SWIG_IsOK(res1)) {
44770 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_error_t_p_assign" "', argument " "1"" of type '" "gpgme_error_t *""'");
44771 : }
44772 0 : arg1 = (gpgme_error_t *)(argp1);
44773 : {
44774 0 : if (PyLong_Check(obj1))
44775 0 : arg2 = PyLong_AsLong(obj1);
44776 :
44777 : else if (PyInt_Check(obj1))
44778 : arg2 = PyInt_AsLong(obj1);
44779 :
44780 : else
44781 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
44782 : }
44783 : {
44784 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44785 0 : gpgme_error_t_p_assign(arg1,arg2);
44786 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44787 : }
44788 0 : resultobj = SWIG_Py_Void();
44789 0 : return resultobj;
44790 : fail:
44791 : return NULL;
44792 : }
44793 :
44794 :
44795 11 : SWIGINTERN PyObject *_wrap_gpgme_error_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44796 11 : PyObject *resultobj = 0;
44797 11 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
44798 11 : void *argp1 = 0 ;
44799 11 : int res1 = 0 ;
44800 11 : PyObject * obj0 = 0 ;
44801 : gpgme_error_t result;
44802 :
44803 11 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error_t_p_value",&obj0)) SWIG_fail;
44804 11 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
44805 11 : if (!SWIG_IsOK(res1)) {
44806 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_error_t_p_value" "', argument " "1"" of type '" "gpgme_error_t *""'");
44807 : }
44808 11 : arg1 = (gpgme_error_t *)(argp1);
44809 : {
44810 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44811 11 : result = gpgme_error_t_p_value(arg1);
44812 11 : SWIG_PYTHON_THREAD_END_ALLOW;
44813 : }
44814 : {
44815 11 : resultobj = PyLong_FromLong(result);
44816 : }
44817 11 : return resultobj;
44818 : fail:
44819 : return NULL;
44820 : }
44821 :
44822 :
44823 2 : SWIGINTERN PyObject *_wrap_new_gpgme_trust_item_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44824 2 : PyObject *resultobj = 0;
44825 2 : gpgme_trust_item_t *result = 0 ;
44826 :
44827 2 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_trust_item_t_p")) SWIG_fail;
44828 : {
44829 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44830 2 : result = (gpgme_trust_item_t *)new_gpgme_trust_item_t_p();
44831 2 : SWIG_PYTHON_THREAD_END_ALLOW;
44832 : }
44833 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
44834 2 : return resultobj;
44835 : fail:
44836 : return NULL;
44837 : }
44838 :
44839 :
44840 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_trust_item_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44841 0 : PyObject *resultobj = 0;
44842 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
44843 0 : void *argp1 = 0 ;
44844 0 : int res1 = 0 ;
44845 0 : PyObject * obj0 = 0 ;
44846 0 : gpgme_trust_item_t *result = 0 ;
44847 :
44848 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_trust_item_t_p",&obj0)) SWIG_fail;
44849 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
44850 0 : if (!SWIG_IsOK(res1)) {
44851 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_trust_item_t_p" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
44852 : }
44853 0 : arg1 = (gpgme_trust_item_t)(argp1);
44854 : {
44855 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44856 0 : result = (gpgme_trust_item_t *)copy_gpgme_trust_item_t_p(arg1);
44857 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44858 : }
44859 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
44860 0 : return resultobj;
44861 : fail:
44862 : return NULL;
44863 : }
44864 :
44865 :
44866 2 : SWIGINTERN PyObject *_wrap_delete_gpgme_trust_item_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44867 2 : PyObject *resultobj = 0;
44868 2 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
44869 2 : void *argp1 = 0 ;
44870 2 : int res1 = 0 ;
44871 2 : PyObject * obj0 = 0 ;
44872 :
44873 2 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_trust_item_t_p",&obj0)) SWIG_fail;
44874 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
44875 2 : if (!SWIG_IsOK(res1)) {
44876 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_trust_item_t_p" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
44877 : }
44878 2 : arg1 = (gpgme_trust_item_t *)(argp1);
44879 : {
44880 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44881 2 : delete_gpgme_trust_item_t_p(arg1);
44882 2 : SWIG_PYTHON_THREAD_END_ALLOW;
44883 : }
44884 2 : resultobj = SWIG_Py_Void();
44885 2 : return resultobj;
44886 : fail:
44887 : return NULL;
44888 : }
44889 :
44890 :
44891 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44892 0 : PyObject *resultobj = 0;
44893 0 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
44894 0 : gpgme_trust_item_t arg2 = (gpgme_trust_item_t) 0 ;
44895 0 : void *argp1 = 0 ;
44896 0 : int res1 = 0 ;
44897 0 : void *argp2 = 0 ;
44898 0 : int res2 = 0 ;
44899 0 : PyObject * obj0 = 0 ;
44900 0 : PyObject * obj1 = 0 ;
44901 :
44902 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_trust_item_t_p_assign",&obj0,&obj1)) SWIG_fail;
44903 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
44904 0 : if (!SWIG_IsOK(res1)) {
44905 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_t_p_assign" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
44906 : }
44907 0 : arg1 = (gpgme_trust_item_t *)(argp1);
44908 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
44909 0 : if (!SWIG_IsOK(res2)) {
44910 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_trust_item_t_p_assign" "', argument " "2"" of type '" "gpgme_trust_item_t""'");
44911 : }
44912 0 : arg2 = (gpgme_trust_item_t)(argp2);
44913 : {
44914 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44915 0 : gpgme_trust_item_t_p_assign(arg1,arg2);
44916 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44917 : }
44918 0 : resultobj = SWIG_Py_Void();
44919 0 : return resultobj;
44920 : fail:
44921 : return NULL;
44922 : }
44923 :
44924 :
44925 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44926 0 : PyObject *resultobj = 0;
44927 0 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
44928 0 : void *argp1 = 0 ;
44929 0 : int res1 = 0 ;
44930 0 : PyObject * obj0 = 0 ;
44931 : gpgme_trust_item_t result;
44932 :
44933 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_t_p_value",&obj0)) SWIG_fail;
44934 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
44935 0 : if (!SWIG_IsOK(res1)) {
44936 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_t_p_value" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
44937 : }
44938 0 : arg1 = (gpgme_trust_item_t *)(argp1);
44939 : {
44940 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44941 0 : result = (gpgme_trust_item_t)gpgme_trust_item_t_p_value(arg1);
44942 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44943 : }
44944 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
44945 0 : return resultobj;
44946 : fail:
44947 : return NULL;
44948 : }
44949 :
44950 :
44951 0 : SWIGINTERN PyObject *_wrap_new_gpgme_engine_info_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44952 0 : PyObject *resultobj = 0;
44953 0 : gpgme_engine_info_t *result = 0 ;
44954 :
44955 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_engine_info_t_p")) SWIG_fail;
44956 : {
44957 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44958 0 : result = (gpgme_engine_info_t *)new_gpgme_engine_info_t_p();
44959 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44960 : }
44961 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
44962 0 : return resultobj;
44963 : fail:
44964 : return NULL;
44965 : }
44966 :
44967 :
44968 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_engine_info_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44969 0 : PyObject *resultobj = 0;
44970 0 : gpgme_engine_info_t arg1 = (gpgme_engine_info_t) 0 ;
44971 0 : void *argp1 = 0 ;
44972 0 : int res1 = 0 ;
44973 0 : PyObject * obj0 = 0 ;
44974 0 : gpgme_engine_info_t *result = 0 ;
44975 :
44976 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_engine_info_t_p",&obj0)) SWIG_fail;
44977 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
44978 0 : if (!SWIG_IsOK(res1)) {
44979 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_engine_info_t_p" "', argument " "1"" of type '" "gpgme_engine_info_t""'");
44980 : }
44981 0 : arg1 = (gpgme_engine_info_t)(argp1);
44982 : {
44983 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44984 0 : result = (gpgme_engine_info_t *)copy_gpgme_engine_info_t_p(arg1);
44985 0 : SWIG_PYTHON_THREAD_END_ALLOW;
44986 : }
44987 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
44988 0 : return resultobj;
44989 : fail:
44990 : return NULL;
44991 : }
44992 :
44993 :
44994 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_engine_info_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44995 0 : PyObject *resultobj = 0;
44996 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
44997 0 : void *argp1 = 0 ;
44998 0 : int res1 = 0 ;
44999 0 : PyObject * obj0 = 0 ;
45000 :
45001 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_engine_info_t_p",&obj0)) SWIG_fail;
45002 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
45003 0 : if (!SWIG_IsOK(res1)) {
45004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_engine_info_t_p" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
45005 : }
45006 0 : arg1 = (gpgme_engine_info_t *)(argp1);
45007 : {
45008 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45009 0 : delete_gpgme_engine_info_t_p(arg1);
45010 0 : SWIG_PYTHON_THREAD_END_ALLOW;
45011 : }
45012 0 : resultobj = SWIG_Py_Void();
45013 0 : return resultobj;
45014 : fail:
45015 : return NULL;
45016 : }
45017 :
45018 :
45019 0 : SWIGINTERN PyObject *_wrap_gpgme_engine_info_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45020 0 : PyObject *resultobj = 0;
45021 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
45022 0 : gpgme_engine_info_t arg2 = (gpgme_engine_info_t) 0 ;
45023 0 : void *argp1 = 0 ;
45024 0 : int res1 = 0 ;
45025 0 : void *argp2 = 0 ;
45026 0 : int res2 = 0 ;
45027 0 : PyObject * obj0 = 0 ;
45028 0 : PyObject * obj1 = 0 ;
45029 :
45030 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_engine_info_t_p_assign",&obj0,&obj1)) SWIG_fail;
45031 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
45032 0 : if (!SWIG_IsOK(res1)) {
45033 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_engine_info_t_p_assign" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
45034 : }
45035 0 : arg1 = (gpgme_engine_info_t *)(argp1);
45036 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
45037 0 : if (!SWIG_IsOK(res2)) {
45038 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_engine_info_t_p_assign" "', argument " "2"" of type '" "gpgme_engine_info_t""'");
45039 : }
45040 0 : arg2 = (gpgme_engine_info_t)(argp2);
45041 : {
45042 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45043 0 : gpgme_engine_info_t_p_assign(arg1,arg2);
45044 0 : SWIG_PYTHON_THREAD_END_ALLOW;
45045 : }
45046 0 : resultobj = SWIG_Py_Void();
45047 0 : return resultobj;
45048 : fail:
45049 : return NULL;
45050 : }
45051 :
45052 :
45053 0 : SWIGINTERN PyObject *_wrap_gpgme_engine_info_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45054 0 : PyObject *resultobj = 0;
45055 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
45056 0 : void *argp1 = 0 ;
45057 0 : int res1 = 0 ;
45058 0 : PyObject * obj0 = 0 ;
45059 : gpgme_engine_info_t result;
45060 :
45061 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_engine_info_t_p_value",&obj0)) SWIG_fail;
45062 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
45063 0 : if (!SWIG_IsOK(res1)) {
45064 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_engine_info_t_p_value" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
45065 : }
45066 0 : arg1 = (gpgme_engine_info_t *)(argp1);
45067 : {
45068 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45069 0 : result = (gpgme_engine_info_t)gpgme_engine_info_t_p_value(arg1);
45070 0 : SWIG_PYTHON_THREAD_END_ALLOW;
45071 : }
45072 : {
45073 : int i;
45074 0 : int size = 0;
45075 : gpgme_engine_info_t curr;
45076 0 : for (curr = result; curr != NULL; curr = curr->next) {
45077 0 : size++;
45078 : }
45079 0 : resultobj = PyList_New(size);
45080 0 : if (resultobj == NULL)
45081 : return NULL; /* raise */
45082 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
45083 : PyObject *fragile, *o;
45084 0 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_engine_info,
45085 : 0 );
45086 0 : if (fragile == NULL)
45087 : {
45088 0 : Py_DECREF(resultobj);
45089 : return NULL; /* raise */
45090 : }
45091 0 : o = _gpg_wrap_result(fragile, "EngineInfo");
45092 0 : Py_DECREF(fragile);
45093 0 : if (o == NULL)
45094 : {
45095 0 : Py_DECREF(resultobj);
45096 : return NULL; /* raise */
45097 : }
45098 0 : PyList_SetItem(resultobj, i, o);
45099 : }
45100 : }
45101 : return resultobj;
45102 : fail:
45103 : return NULL;
45104 : }
45105 :
45106 :
45107 1 : SWIGINTERN PyObject *_wrap_fdopen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45108 1 : PyObject *resultobj = 0;
45109 : int arg1 ;
45110 1 : char *arg2 = (char *) 0 ;
45111 : int val1 ;
45112 1 : int ecode1 = 0 ;
45113 1 : PyObject *encodedInput2 = NULL ;
45114 1 : PyObject * obj0 = 0 ;
45115 1 : PyObject * obj1 = 0 ;
45116 1 : FILE *result = 0 ;
45117 :
45118 1 : if (!PyArg_ParseTuple(args,(char *)"OO:fdopen",&obj0,&obj1)) SWIG_fail;
45119 2 : ecode1 = SWIG_AsVal_int(obj0, &val1);
45120 1 : if (!SWIG_IsOK(ecode1)) {
45121 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fdopen" "', argument " "1"" of type '" "int""'");
45122 : }
45123 1 : arg1 = (int)(val1);
45124 : {
45125 1 : if (obj1 == Py_None)
45126 : arg2 = NULL;
45127 1 : else if (PyUnicode_Check(obj1))
45128 : {
45129 1 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
45130 1 : if (encodedInput2 == NULL)
45131 : return NULL;
45132 1 : arg2 = PyBytes_AsString(encodedInput2);
45133 : }
45134 0 : else if (PyBytes_Check(obj1))
45135 0 : arg2 = PyBytes_AsString(obj1);
45136 : else {
45137 0 : PyErr_Format(PyExc_TypeError,
45138 : "arg %d: expected str, bytes, or None, got %s",
45139 : 2, obj1->ob_type->tp_name);
45140 0 : return NULL;
45141 : }
45142 : }
45143 : {
45144 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45145 1 : result = (FILE *)fdopen(arg1,(char const *)arg2);
45146 1 : SWIG_PYTHON_THREAD_END_ALLOW;
45147 : }
45148 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0 );
45149 : {
45150 1 : Py_XDECREF(encodedInput2);
45151 : }
45152 : return resultobj;
45153 : fail:
45154 : {
45155 : Py_XDECREF(encodedInput2);
45156 : }
45157 : return NULL;
45158 : }
45159 :
45160 :
45161 0 : SWIGINTERN int Swig_var_gpg_in_tree_build_set(PyObject *_val) {
45162 : {
45163 : int val;
45164 0 : int res = SWIG_AsVal_int(_val, &val);
45165 0 : if (!SWIG_IsOK(res)) {
45166 0 : SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gpg_in_tree_build""' of type '""int""'");
45167 : }
45168 0 : gpg_in_tree_build = (int)(val);
45169 : }
45170 0 : return 0;
45171 : fail:
45172 0 : return 1;
45173 : }
45174 :
45175 :
45176 29 : SWIGINTERN PyObject *Swig_var_gpg_in_tree_build_get(void) {
45177 29 : PyObject *pyobj = 0;
45178 :
45179 58 : pyobj = SWIG_From_int((int)(gpg_in_tree_build));
45180 29 : return pyobj;
45181 : }
45182 :
45183 :
45184 13 : SWIGINTERN PyObject *_wrap_gpg_raise_callback_exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45185 13 : PyObject *resultobj = 0;
45186 13 : PyObject *arg1 = (PyObject *) 0 ;
45187 13 : PyObject * obj0 = 0 ;
45188 13 : PyObject *result = 0 ;
45189 :
45190 13 : if (!PyArg_ParseTuple(args,(char *)"O:gpg_raise_callback_exception",&obj0)) SWIG_fail;
45191 13 : arg1 = obj0;
45192 : {
45193 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45194 13 : result = (PyObject *)gpg_raise_callback_exception(arg1);
45195 13 : SWIG_PYTHON_THREAD_END_ALLOW;
45196 : }
45197 13 : resultobj = result;
45198 13 : return resultobj;
45199 : fail:
45200 : return NULL;
45201 : }
45202 :
45203 :
45204 163 : SWIGINTERN PyObject *_wrap_gpg_set_passphrase_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45205 163 : PyObject *resultobj = 0;
45206 163 : PyObject *arg1 = (PyObject *) 0 ;
45207 163 : PyObject *arg2 = (PyObject *) 0 ;
45208 163 : PyObject * obj0 = 0 ;
45209 163 : PyObject * obj1 = 0 ;
45210 163 : PyObject *result = 0 ;
45211 :
45212 163 : if (!PyArg_ParseTuple(args,(char *)"OO:gpg_set_passphrase_cb",&obj0,&obj1)) SWIG_fail;
45213 163 : arg1 = obj0;
45214 163 : arg2 = obj1;
45215 : {
45216 163 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45217 163 : result = (PyObject *)gpg_set_passphrase_cb(arg1,arg2);
45218 163 : SWIG_PYTHON_THREAD_END_ALLOW;
45219 : }
45220 163 : resultobj = result;
45221 163 : return resultobj;
45222 : fail:
45223 : return NULL;
45224 : }
45225 :
45226 :
45227 139 : SWIGINTERN PyObject *_wrap_gpg_set_progress_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45228 139 : PyObject *resultobj = 0;
45229 139 : PyObject *arg1 = (PyObject *) 0 ;
45230 139 : PyObject *arg2 = (PyObject *) 0 ;
45231 139 : PyObject * obj0 = 0 ;
45232 139 : PyObject * obj1 = 0 ;
45233 139 : PyObject *result = 0 ;
45234 :
45235 139 : if (!PyArg_ParseTuple(args,(char *)"OO:gpg_set_progress_cb",&obj0,&obj1)) SWIG_fail;
45236 139 : arg1 = obj0;
45237 139 : arg2 = obj1;
45238 : {
45239 139 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45240 139 : result = (PyObject *)gpg_set_progress_cb(arg1,arg2);
45241 139 : SWIG_PYTHON_THREAD_END_ALLOW;
45242 : }
45243 139 : resultobj = result;
45244 139 : return resultobj;
45245 : fail:
45246 : return NULL;
45247 : }
45248 :
45249 :
45250 139 : SWIGINTERN PyObject *_wrap_gpg_set_status_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45251 139 : PyObject *resultobj = 0;
45252 139 : PyObject *arg1 = (PyObject *) 0 ;
45253 139 : PyObject *arg2 = (PyObject *) 0 ;
45254 139 : PyObject * obj0 = 0 ;
45255 139 : PyObject * obj1 = 0 ;
45256 139 : PyObject *result = 0 ;
45257 :
45258 139 : if (!PyArg_ParseTuple(args,(char *)"OO:gpg_set_status_cb",&obj0,&obj1)) SWIG_fail;
45259 139 : arg1 = obj0;
45260 139 : arg2 = obj1;
45261 : {
45262 139 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45263 139 : result = (PyObject *)gpg_set_status_cb(arg1,arg2);
45264 139 : SWIG_PYTHON_THREAD_END_ALLOW;
45265 : }
45266 139 : resultobj = result;
45267 139 : return resultobj;
45268 : fail:
45269 : return NULL;
45270 : }
45271 :
45272 :
45273 10 : SWIGINTERN PyObject *_wrap_gpg_data_new_from_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45274 10 : PyObject *resultobj = 0;
45275 10 : PyObject *arg1 = (PyObject *) 0 ;
45276 10 : PyObject *arg2 = (PyObject *) 0 ;
45277 10 : gpgme_data_t *arg3 = (gpgme_data_t *) 0 ;
45278 10 : void *argp3 = 0 ;
45279 10 : int res3 = 0 ;
45280 10 : PyObject * obj0 = 0 ;
45281 10 : PyObject * obj1 = 0 ;
45282 10 : PyObject * obj2 = 0 ;
45283 10 : PyObject *result = 0 ;
45284 :
45285 10 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpg_data_new_from_cbs",&obj0,&obj1,&obj2)) SWIG_fail;
45286 10 : arg1 = obj0;
45287 10 : arg2 = obj1;
45288 10 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
45289 10 : if (!SWIG_IsOK(res3)) {
45290 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpg_data_new_from_cbs" "', argument " "3"" of type '" "gpgme_data_t *""'");
45291 : }
45292 10 : arg3 = (gpgme_data_t *)(argp3);
45293 : {
45294 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45295 10 : result = (PyObject *)gpg_data_new_from_cbs(arg1,arg2,arg3);
45296 10 : SWIG_PYTHON_THREAD_END_ALLOW;
45297 : }
45298 10 : resultobj = result;
45299 10 : return resultobj;
45300 : fail:
45301 : return NULL;
45302 : }
45303 :
45304 :
45305 : static PyMethodDef SwigMethods[] = {
45306 : { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
45307 : { (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"},
45308 : { (char *)"gpgme_data_seek", _wrap_gpgme_data_seek, METH_VARARGS, (char *)"gpgme_data_seek(dh, offset, whence) -> off_t"},
45309 : { (char *)"_gpgme_sig_notation_name_set", _wrap__gpgme_sig_notation_name_set, METH_VARARGS, (char *)"_gpgme_sig_notation_name_set(self, name)"},
45310 : { (char *)"_gpgme_sig_notation_name_get", _wrap__gpgme_sig_notation_name_get, METH_VARARGS, (char *)"_gpgme_sig_notation_name_get(self) -> char *"},
45311 : { (char *)"_gpgme_sig_notation_value_set", _wrap__gpgme_sig_notation_value_set, METH_VARARGS, (char *)"_gpgme_sig_notation_value_set(self, value)"},
45312 : { (char *)"_gpgme_sig_notation_value_get", _wrap__gpgme_sig_notation_value_get, METH_VARARGS, (char *)"_gpgme_sig_notation_value_get(self) -> char *"},
45313 : { (char *)"_gpgme_sig_notation_flags_set", _wrap__gpgme_sig_notation_flags_set, METH_VARARGS, (char *)"_gpgme_sig_notation_flags_set(self, flags)"},
45314 : { (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"},
45315 : { (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)"},
45316 : { (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"},
45317 : { (char *)"_gpgme_sig_notation_critical_set", _wrap__gpgme_sig_notation_critical_set, METH_VARARGS, (char *)"_gpgme_sig_notation_critical_set(self, critical)"},
45318 : { (char *)"_gpgme_sig_notation_critical_get", _wrap__gpgme_sig_notation_critical_get, METH_VARARGS, (char *)"_gpgme_sig_notation_critical_get(self) -> unsigned int"},
45319 : { (char *)"new__gpgme_sig_notation", _wrap_new__gpgme_sig_notation, METH_VARARGS, (char *)"new__gpgme_sig_notation() -> _gpgme_sig_notation"},
45320 : { (char *)"delete__gpgme_sig_notation", _wrap_delete__gpgme_sig_notation, METH_VARARGS, (char *)"delete__gpgme_sig_notation(self)"},
45321 : { (char *)"_gpgme_sig_notation_swigregister", _gpgme_sig_notation_swigregister, METH_VARARGS, NULL},
45322 : { (char *)"gpgme_err_make", _wrap_gpgme_err_make, METH_VARARGS, (char *)"gpgme_err_make(source, code) -> gpgme_error_t"},
45323 : { (char *)"gpgme_error", _wrap_gpgme_error, METH_VARARGS, (char *)"gpgme_error(code) -> gpgme_error_t"},
45324 : { (char *)"gpgme_err_code", _wrap_gpgme_err_code, METH_VARARGS, (char *)"gpgme_err_code(err) -> gpgme_err_code_t"},
45325 : { (char *)"gpgme_err_source", _wrap_gpgme_err_source, METH_VARARGS, (char *)"gpgme_err_source(err) -> gpgme_err_source_t"},
45326 : { (char *)"gpgme_strerror", _wrap_gpgme_strerror, METH_VARARGS, (char *)"gpgme_strerror(err) -> char const *"},
45327 : { (char *)"gpgme_strerror_r", _wrap_gpgme_strerror_r, METH_VARARGS, (char *)"gpgme_strerror_r(err, buf) -> int"},
45328 : { (char *)"gpgme_strsource", _wrap_gpgme_strsource, METH_VARARGS, (char *)"gpgme_strsource(err) -> char const *"},
45329 : { (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"},
45330 : { (char *)"gpgme_err_code_to_errno", _wrap_gpgme_err_code_to_errno, METH_VARARGS, (char *)"gpgme_err_code_to_errno(code) -> int"},
45331 : { (char *)"gpgme_err_code_from_syserror", _wrap_gpgme_err_code_from_syserror, METH_VARARGS, (char *)"gpgme_err_code_from_syserror() -> gpgme_err_code_t"},
45332 : { (char *)"gpgme_err_set_errno", _wrap_gpgme_err_set_errno, METH_VARARGS, (char *)"gpgme_err_set_errno(err)"},
45333 : { (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"},
45334 : { (char *)"gpgme_error_from_errno", _wrap_gpgme_error_from_errno, METH_VARARGS, (char *)"gpgme_error_from_errno(err) -> gpgme_error_t"},
45335 : { (char *)"gpgme_error_from_syserror", _wrap_gpgme_error_from_syserror, METH_VARARGS, (char *)"gpgme_error_from_syserror() -> gpgme_error_t"},
45336 : { (char *)"_gpgme_engine_info_protocol_set", _wrap__gpgme_engine_info_protocol_set, METH_VARARGS, (char *)"_gpgme_engine_info_protocol_set(self, protocol)"},
45337 : { (char *)"_gpgme_engine_info_protocol_get", _wrap__gpgme_engine_info_protocol_get, METH_VARARGS, (char *)"_gpgme_engine_info_protocol_get(self) -> gpgme_protocol_t"},
45338 : { (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)"},
45339 : { (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 *"},
45340 : { (char *)"_gpgme_engine_info_version_set", _wrap__gpgme_engine_info_version_set, METH_VARARGS, (char *)"_gpgme_engine_info_version_set(self, version)"},
45341 : { (char *)"_gpgme_engine_info_version_get", _wrap__gpgme_engine_info_version_get, METH_VARARGS, (char *)"_gpgme_engine_info_version_get(self) -> char *"},
45342 : { (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)"},
45343 : { (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 *"},
45344 : { (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)"},
45345 : { (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 *"},
45346 : { (char *)"new__gpgme_engine_info", _wrap_new__gpgme_engine_info, METH_VARARGS, (char *)"new__gpgme_engine_info() -> _gpgme_engine_info"},
45347 : { (char *)"delete__gpgme_engine_info", _wrap_delete__gpgme_engine_info, METH_VARARGS, (char *)"delete__gpgme_engine_info(self)"},
45348 : { (char *)"_gpgme_engine_info_swigregister", _gpgme_engine_info_swigregister, METH_VARARGS, NULL},
45349 : { (char *)"_gpgme_tofu_info_validity_set", _wrap__gpgme_tofu_info_validity_set, METH_VARARGS, (char *)"_gpgme_tofu_info_validity_set(self, validity)"},
45350 : { (char *)"_gpgme_tofu_info_validity_get", _wrap__gpgme_tofu_info_validity_get, METH_VARARGS, (char *)"_gpgme_tofu_info_validity_get(self) -> unsigned int"},
45351 : { (char *)"_gpgme_tofu_info_policy_set", _wrap__gpgme_tofu_info_policy_set, METH_VARARGS, (char *)"_gpgme_tofu_info_policy_set(self, policy)"},
45352 : { (char *)"_gpgme_tofu_info_policy_get", _wrap__gpgme_tofu_info_policy_get, METH_VARARGS, (char *)"_gpgme_tofu_info_policy_get(self) -> unsigned int"},
45353 : { (char *)"_gpgme_tofu_info__rfu_set", _wrap__gpgme_tofu_info__rfu_set, METH_VARARGS, (char *)"_gpgme_tofu_info__rfu_set(self, _rfu)"},
45354 : { (char *)"_gpgme_tofu_info__rfu_get", _wrap__gpgme_tofu_info__rfu_get, METH_VARARGS, (char *)"_gpgme_tofu_info__rfu_get(self) -> unsigned int"},
45355 : { (char *)"_gpgme_tofu_info_signcount_set", _wrap__gpgme_tofu_info_signcount_set, METH_VARARGS, (char *)"_gpgme_tofu_info_signcount_set(self, signcount)"},
45356 : { (char *)"_gpgme_tofu_info_signcount_get", _wrap__gpgme_tofu_info_signcount_get, METH_VARARGS, (char *)"_gpgme_tofu_info_signcount_get(self) -> unsigned short"},
45357 : { (char *)"_gpgme_tofu_info_encrcount_set", _wrap__gpgme_tofu_info_encrcount_set, METH_VARARGS, (char *)"_gpgme_tofu_info_encrcount_set(self, encrcount)"},
45358 : { (char *)"_gpgme_tofu_info_encrcount_get", _wrap__gpgme_tofu_info_encrcount_get, METH_VARARGS, (char *)"_gpgme_tofu_info_encrcount_get(self) -> unsigned short"},
45359 : { (char *)"_gpgme_tofu_info_signfirst_set", _wrap__gpgme_tofu_info_signfirst_set, METH_VARARGS, (char *)"_gpgme_tofu_info_signfirst_set(self, signfirst)"},
45360 : { (char *)"_gpgme_tofu_info_signfirst_get", _wrap__gpgme_tofu_info_signfirst_get, METH_VARARGS, (char *)"_gpgme_tofu_info_signfirst_get(self) -> unsigned long"},
45361 : { (char *)"_gpgme_tofu_info_signlast_set", _wrap__gpgme_tofu_info_signlast_set, METH_VARARGS, (char *)"_gpgme_tofu_info_signlast_set(self, signlast)"},
45362 : { (char *)"_gpgme_tofu_info_signlast_get", _wrap__gpgme_tofu_info_signlast_get, METH_VARARGS, (char *)"_gpgme_tofu_info_signlast_get(self) -> unsigned long"},
45363 : { (char *)"_gpgme_tofu_info_encrfirst_set", _wrap__gpgme_tofu_info_encrfirst_set, METH_VARARGS, (char *)"_gpgme_tofu_info_encrfirst_set(self, encrfirst)"},
45364 : { (char *)"_gpgme_tofu_info_encrfirst_get", _wrap__gpgme_tofu_info_encrfirst_get, METH_VARARGS, (char *)"_gpgme_tofu_info_encrfirst_get(self) -> unsigned long"},
45365 : { (char *)"_gpgme_tofu_info_encrlast_set", _wrap__gpgme_tofu_info_encrlast_set, METH_VARARGS, (char *)"_gpgme_tofu_info_encrlast_set(self, encrlast)"},
45366 : { (char *)"_gpgme_tofu_info_encrlast_get", _wrap__gpgme_tofu_info_encrlast_get, METH_VARARGS, (char *)"_gpgme_tofu_info_encrlast_get(self) -> unsigned long"},
45367 : { (char *)"_gpgme_tofu_info_description_set", _wrap__gpgme_tofu_info_description_set, METH_VARARGS, (char *)"_gpgme_tofu_info_description_set(self, description)"},
45368 : { (char *)"_gpgme_tofu_info_description_get", _wrap__gpgme_tofu_info_description_get, METH_VARARGS, (char *)"_gpgme_tofu_info_description_get(self) -> char *"},
45369 : { (char *)"new__gpgme_tofu_info", _wrap_new__gpgme_tofu_info, METH_VARARGS, (char *)"new__gpgme_tofu_info() -> _gpgme_tofu_info"},
45370 : { (char *)"delete__gpgme_tofu_info", _wrap_delete__gpgme_tofu_info, METH_VARARGS, (char *)"delete__gpgme_tofu_info(self)"},
45371 : { (char *)"_gpgme_tofu_info_swigregister", _gpgme_tofu_info_swigregister, METH_VARARGS, NULL},
45372 : { (char *)"_gpgme_subkey_revoked_set", _wrap__gpgme_subkey_revoked_set, METH_VARARGS, (char *)"_gpgme_subkey_revoked_set(self, revoked)"},
45373 : { (char *)"_gpgme_subkey_revoked_get", _wrap__gpgme_subkey_revoked_get, METH_VARARGS, (char *)"_gpgme_subkey_revoked_get(self) -> unsigned int"},
45374 : { (char *)"_gpgme_subkey_expired_set", _wrap__gpgme_subkey_expired_set, METH_VARARGS, (char *)"_gpgme_subkey_expired_set(self, expired)"},
45375 : { (char *)"_gpgme_subkey_expired_get", _wrap__gpgme_subkey_expired_get, METH_VARARGS, (char *)"_gpgme_subkey_expired_get(self) -> unsigned int"},
45376 : { (char *)"_gpgme_subkey_disabled_set", _wrap__gpgme_subkey_disabled_set, METH_VARARGS, (char *)"_gpgme_subkey_disabled_set(self, disabled)"},
45377 : { (char *)"_gpgme_subkey_disabled_get", _wrap__gpgme_subkey_disabled_get, METH_VARARGS, (char *)"_gpgme_subkey_disabled_get(self) -> unsigned int"},
45378 : { (char *)"_gpgme_subkey_invalid_set", _wrap__gpgme_subkey_invalid_set, METH_VARARGS, (char *)"_gpgme_subkey_invalid_set(self, invalid)"},
45379 : { (char *)"_gpgme_subkey_invalid_get", _wrap__gpgme_subkey_invalid_get, METH_VARARGS, (char *)"_gpgme_subkey_invalid_get(self) -> unsigned int"},
45380 : { (char *)"_gpgme_subkey_can_encrypt_set", _wrap__gpgme_subkey_can_encrypt_set, METH_VARARGS, (char *)"_gpgme_subkey_can_encrypt_set(self, can_encrypt)"},
45381 : { (char *)"_gpgme_subkey_can_encrypt_get", _wrap__gpgme_subkey_can_encrypt_get, METH_VARARGS, (char *)"_gpgme_subkey_can_encrypt_get(self) -> unsigned int"},
45382 : { (char *)"_gpgme_subkey_can_sign_set", _wrap__gpgme_subkey_can_sign_set, METH_VARARGS, (char *)"_gpgme_subkey_can_sign_set(self, can_sign)"},
45383 : { (char *)"_gpgme_subkey_can_sign_get", _wrap__gpgme_subkey_can_sign_get, METH_VARARGS, (char *)"_gpgme_subkey_can_sign_get(self) -> unsigned int"},
45384 : { (char *)"_gpgme_subkey_can_certify_set", _wrap__gpgme_subkey_can_certify_set, METH_VARARGS, (char *)"_gpgme_subkey_can_certify_set(self, can_certify)"},
45385 : { (char *)"_gpgme_subkey_can_certify_get", _wrap__gpgme_subkey_can_certify_get, METH_VARARGS, (char *)"_gpgme_subkey_can_certify_get(self) -> unsigned int"},
45386 : { (char *)"_gpgme_subkey_secret_set", _wrap__gpgme_subkey_secret_set, METH_VARARGS, (char *)"_gpgme_subkey_secret_set(self, secret)"},
45387 : { (char *)"_gpgme_subkey_secret_get", _wrap__gpgme_subkey_secret_get, METH_VARARGS, (char *)"_gpgme_subkey_secret_get(self) -> unsigned int"},
45388 : { (char *)"_gpgme_subkey_can_authenticate_set", _wrap__gpgme_subkey_can_authenticate_set, METH_VARARGS, (char *)"_gpgme_subkey_can_authenticate_set(self, can_authenticate)"},
45389 : { (char *)"_gpgme_subkey_can_authenticate_get", _wrap__gpgme_subkey_can_authenticate_get, METH_VARARGS, (char *)"_gpgme_subkey_can_authenticate_get(self) -> unsigned int"},
45390 : { (char *)"_gpgme_subkey_is_qualified_set", _wrap__gpgme_subkey_is_qualified_set, METH_VARARGS, (char *)"_gpgme_subkey_is_qualified_set(self, is_qualified)"},
45391 : { (char *)"_gpgme_subkey_is_qualified_get", _wrap__gpgme_subkey_is_qualified_get, METH_VARARGS, (char *)"_gpgme_subkey_is_qualified_get(self) -> unsigned int"},
45392 : { (char *)"_gpgme_subkey_is_cardkey_set", _wrap__gpgme_subkey_is_cardkey_set, METH_VARARGS, (char *)"_gpgme_subkey_is_cardkey_set(self, is_cardkey)"},
45393 : { (char *)"_gpgme_subkey_is_cardkey_get", _wrap__gpgme_subkey_is_cardkey_get, METH_VARARGS, (char *)"_gpgme_subkey_is_cardkey_get(self) -> unsigned int"},
45394 : { (char *)"_gpgme_subkey_is_de_vs_set", _wrap__gpgme_subkey_is_de_vs_set, METH_VARARGS, (char *)"_gpgme_subkey_is_de_vs_set(self, is_de_vs)"},
45395 : { (char *)"_gpgme_subkey_is_de_vs_get", _wrap__gpgme_subkey_is_de_vs_get, METH_VARARGS, (char *)"_gpgme_subkey_is_de_vs_get(self) -> unsigned int"},
45396 : { (char *)"_gpgme_subkey__unused_set", _wrap__gpgme_subkey__unused_set, METH_VARARGS, (char *)"_gpgme_subkey__unused_set(self, _unused)"},
45397 : { (char *)"_gpgme_subkey__unused_get", _wrap__gpgme_subkey__unused_get, METH_VARARGS, (char *)"_gpgme_subkey__unused_get(self) -> unsigned int"},
45398 : { (char *)"_gpgme_subkey_pubkey_algo_set", _wrap__gpgme_subkey_pubkey_algo_set, METH_VARARGS, (char *)"_gpgme_subkey_pubkey_algo_set(self, pubkey_algo)"},
45399 : { (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"},
45400 : { (char *)"_gpgme_subkey_length_set", _wrap__gpgme_subkey_length_set, METH_VARARGS, (char *)"_gpgme_subkey_length_set(self, length)"},
45401 : { (char *)"_gpgme_subkey_length_get", _wrap__gpgme_subkey_length_get, METH_VARARGS, (char *)"_gpgme_subkey_length_get(self) -> unsigned int"},
45402 : { (char *)"_gpgme_subkey_keyid_set", _wrap__gpgme_subkey_keyid_set, METH_VARARGS, (char *)"_gpgme_subkey_keyid_set(self, keyid)"},
45403 : { (char *)"_gpgme_subkey_keyid_get", _wrap__gpgme_subkey_keyid_get, METH_VARARGS, (char *)"_gpgme_subkey_keyid_get(self) -> char *"},
45404 : { (char *)"_gpgme_subkey__keyid_set", _wrap__gpgme_subkey__keyid_set, METH_VARARGS, (char *)"_gpgme_subkey__keyid_set(self, _keyid)"},
45405 : { (char *)"_gpgme_subkey__keyid_get", _wrap__gpgme_subkey__keyid_get, METH_VARARGS, (char *)"_gpgme_subkey__keyid_get(self) -> char [16+1]"},
45406 : { (char *)"_gpgme_subkey_fpr_set", _wrap__gpgme_subkey_fpr_set, METH_VARARGS, (char *)"_gpgme_subkey_fpr_set(self, fpr)"},
45407 : { (char *)"_gpgme_subkey_fpr_get", _wrap__gpgme_subkey_fpr_get, METH_VARARGS, (char *)"_gpgme_subkey_fpr_get(self) -> char *"},
45408 : { (char *)"_gpgme_subkey_timestamp_set", _wrap__gpgme_subkey_timestamp_set, METH_VARARGS, (char *)"_gpgme_subkey_timestamp_set(self, timestamp)"},
45409 : { (char *)"_gpgme_subkey_timestamp_get", _wrap__gpgme_subkey_timestamp_get, METH_VARARGS, (char *)"_gpgme_subkey_timestamp_get(self) -> long"},
45410 : { (char *)"_gpgme_subkey_expires_set", _wrap__gpgme_subkey_expires_set, METH_VARARGS, (char *)"_gpgme_subkey_expires_set(self, expires)"},
45411 : { (char *)"_gpgme_subkey_expires_get", _wrap__gpgme_subkey_expires_get, METH_VARARGS, (char *)"_gpgme_subkey_expires_get(self) -> long"},
45412 : { (char *)"_gpgme_subkey_card_number_set", _wrap__gpgme_subkey_card_number_set, METH_VARARGS, (char *)"_gpgme_subkey_card_number_set(self, card_number)"},
45413 : { (char *)"_gpgme_subkey_card_number_get", _wrap__gpgme_subkey_card_number_get, METH_VARARGS, (char *)"_gpgme_subkey_card_number_get(self) -> char *"},
45414 : { (char *)"_gpgme_subkey_curve_set", _wrap__gpgme_subkey_curve_set, METH_VARARGS, (char *)"_gpgme_subkey_curve_set(self, curve)"},
45415 : { (char *)"_gpgme_subkey_curve_get", _wrap__gpgme_subkey_curve_get, METH_VARARGS, (char *)"_gpgme_subkey_curve_get(self) -> char *"},
45416 : { (char *)"_gpgme_subkey_keygrip_set", _wrap__gpgme_subkey_keygrip_set, METH_VARARGS, (char *)"_gpgme_subkey_keygrip_set(self, keygrip)"},
45417 : { (char *)"_gpgme_subkey_keygrip_get", _wrap__gpgme_subkey_keygrip_get, METH_VARARGS, (char *)"_gpgme_subkey_keygrip_get(self) -> char *"},
45418 : { (char *)"new__gpgme_subkey", _wrap_new__gpgme_subkey, METH_VARARGS, (char *)"new__gpgme_subkey() -> _gpgme_subkey"},
45419 : { (char *)"delete__gpgme_subkey", _wrap_delete__gpgme_subkey, METH_VARARGS, (char *)"delete__gpgme_subkey(self)"},
45420 : { (char *)"_gpgme_subkey_swigregister", _gpgme_subkey_swigregister, METH_VARARGS, NULL},
45421 : { (char *)"_gpgme_key_sig_revoked_set", _wrap__gpgme_key_sig_revoked_set, METH_VARARGS, (char *)"_gpgme_key_sig_revoked_set(self, revoked)"},
45422 : { (char *)"_gpgme_key_sig_revoked_get", _wrap__gpgme_key_sig_revoked_get, METH_VARARGS, (char *)"_gpgme_key_sig_revoked_get(self) -> unsigned int"},
45423 : { (char *)"_gpgme_key_sig_expired_set", _wrap__gpgme_key_sig_expired_set, METH_VARARGS, (char *)"_gpgme_key_sig_expired_set(self, expired)"},
45424 : { (char *)"_gpgme_key_sig_expired_get", _wrap__gpgme_key_sig_expired_get, METH_VARARGS, (char *)"_gpgme_key_sig_expired_get(self) -> unsigned int"},
45425 : { (char *)"_gpgme_key_sig_invalid_set", _wrap__gpgme_key_sig_invalid_set, METH_VARARGS, (char *)"_gpgme_key_sig_invalid_set(self, invalid)"},
45426 : { (char *)"_gpgme_key_sig_invalid_get", _wrap__gpgme_key_sig_invalid_get, METH_VARARGS, (char *)"_gpgme_key_sig_invalid_get(self) -> unsigned int"},
45427 : { (char *)"_gpgme_key_sig_exportable_set", _wrap__gpgme_key_sig_exportable_set, METH_VARARGS, (char *)"_gpgme_key_sig_exportable_set(self, exportable)"},
45428 : { (char *)"_gpgme_key_sig_exportable_get", _wrap__gpgme_key_sig_exportable_get, METH_VARARGS, (char *)"_gpgme_key_sig_exportable_get(self) -> unsigned int"},
45429 : { (char *)"_gpgme_key_sig__unused_set", _wrap__gpgme_key_sig__unused_set, METH_VARARGS, (char *)"_gpgme_key_sig__unused_set(self, _unused)"},
45430 : { (char *)"_gpgme_key_sig__unused_get", _wrap__gpgme_key_sig__unused_get, METH_VARARGS, (char *)"_gpgme_key_sig__unused_get(self) -> unsigned int"},
45431 : { (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)"},
45432 : { (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"},
45433 : { (char *)"_gpgme_key_sig_keyid_set", _wrap__gpgme_key_sig_keyid_set, METH_VARARGS, (char *)"_gpgme_key_sig_keyid_set(self, keyid)"},
45434 : { (char *)"_gpgme_key_sig_keyid_get", _wrap__gpgme_key_sig_keyid_get, METH_VARARGS, (char *)"_gpgme_key_sig_keyid_get(self) -> char *"},
45435 : { (char *)"_gpgme_key_sig__keyid_set", _wrap__gpgme_key_sig__keyid_set, METH_VARARGS, (char *)"_gpgme_key_sig__keyid_set(self, _keyid)"},
45436 : { (char *)"_gpgme_key_sig__keyid_get", _wrap__gpgme_key_sig__keyid_get, METH_VARARGS, (char *)"_gpgme_key_sig__keyid_get(self) -> char [16+1]"},
45437 : { (char *)"_gpgme_key_sig_timestamp_set", _wrap__gpgme_key_sig_timestamp_set, METH_VARARGS, (char *)"_gpgme_key_sig_timestamp_set(self, timestamp)"},
45438 : { (char *)"_gpgme_key_sig_timestamp_get", _wrap__gpgme_key_sig_timestamp_get, METH_VARARGS, (char *)"_gpgme_key_sig_timestamp_get(self) -> long"},
45439 : { (char *)"_gpgme_key_sig_expires_set", _wrap__gpgme_key_sig_expires_set, METH_VARARGS, (char *)"_gpgme_key_sig_expires_set(self, expires)"},
45440 : { (char *)"_gpgme_key_sig_expires_get", _wrap__gpgme_key_sig_expires_get, METH_VARARGS, (char *)"_gpgme_key_sig_expires_get(self) -> long"},
45441 : { (char *)"_gpgme_key_sig_status_set", _wrap__gpgme_key_sig_status_set, METH_VARARGS, (char *)"_gpgme_key_sig_status_set(self, status)"},
45442 : { (char *)"_gpgme_key_sig_status_get", _wrap__gpgme_key_sig_status_get, METH_VARARGS, (char *)"_gpgme_key_sig_status_get(self) -> gpgme_error_t"},
45443 : { (char *)"_gpgme_key_sig__obsolete_class_set", _wrap__gpgme_key_sig__obsolete_class_set, METH_VARARGS, (char *)"_gpgme_key_sig__obsolete_class_set(self, _obsolete_class)"},
45444 : { (char *)"_gpgme_key_sig__obsolete_class_get", _wrap__gpgme_key_sig__obsolete_class_get, METH_VARARGS, (char *)"_gpgme_key_sig__obsolete_class_get(self) -> unsigned int"},
45445 : { (char *)"_gpgme_key_sig_uid_set", _wrap__gpgme_key_sig_uid_set, METH_VARARGS, (char *)"_gpgme_key_sig_uid_set(self, uid)"},
45446 : { (char *)"_gpgme_key_sig_uid_get", _wrap__gpgme_key_sig_uid_get, METH_VARARGS, (char *)"_gpgme_key_sig_uid_get(self) -> char *"},
45447 : { (char *)"_gpgme_key_sig_name_set", _wrap__gpgme_key_sig_name_set, METH_VARARGS, (char *)"_gpgme_key_sig_name_set(self, name)"},
45448 : { (char *)"_gpgme_key_sig_name_get", _wrap__gpgme_key_sig_name_get, METH_VARARGS, (char *)"_gpgme_key_sig_name_get(self) -> char *"},
45449 : { (char *)"_gpgme_key_sig_email_set", _wrap__gpgme_key_sig_email_set, METH_VARARGS, (char *)"_gpgme_key_sig_email_set(self, email)"},
45450 : { (char *)"_gpgme_key_sig_email_get", _wrap__gpgme_key_sig_email_get, METH_VARARGS, (char *)"_gpgme_key_sig_email_get(self) -> char *"},
45451 : { (char *)"_gpgme_key_sig_comment_set", _wrap__gpgme_key_sig_comment_set, METH_VARARGS, (char *)"_gpgme_key_sig_comment_set(self, comment)"},
45452 : { (char *)"_gpgme_key_sig_comment_get", _wrap__gpgme_key_sig_comment_get, METH_VARARGS, (char *)"_gpgme_key_sig_comment_get(self) -> char *"},
45453 : { (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)"},
45454 : { (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"},
45455 : { (char *)"_gpgme_key_sig_notations_set", _wrap__gpgme_key_sig_notations_set, METH_VARARGS, (char *)"_gpgme_key_sig_notations_set(self, notations)"},
45456 : { (char *)"_gpgme_key_sig_notations_get", _wrap__gpgme_key_sig_notations_get, METH_VARARGS, (char *)"_gpgme_key_sig_notations_get(self) -> _gpgme_sig_notation"},
45457 : { (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)"},
45458 : { (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"},
45459 : { (char *)"new__gpgme_key_sig", _wrap_new__gpgme_key_sig, METH_VARARGS, (char *)"new__gpgme_key_sig() -> _gpgme_key_sig"},
45460 : { (char *)"delete__gpgme_key_sig", _wrap_delete__gpgme_key_sig, METH_VARARGS, (char *)"delete__gpgme_key_sig(self)"},
45461 : { (char *)"_gpgme_key_sig_swigregister", _gpgme_key_sig_swigregister, METH_VARARGS, NULL},
45462 : { (char *)"_gpgme_user_id_revoked_set", _wrap__gpgme_user_id_revoked_set, METH_VARARGS, (char *)"_gpgme_user_id_revoked_set(self, revoked)"},
45463 : { (char *)"_gpgme_user_id_revoked_get", _wrap__gpgme_user_id_revoked_get, METH_VARARGS, (char *)"_gpgme_user_id_revoked_get(self) -> unsigned int"},
45464 : { (char *)"_gpgme_user_id_invalid_set", _wrap__gpgme_user_id_invalid_set, METH_VARARGS, (char *)"_gpgme_user_id_invalid_set(self, invalid)"},
45465 : { (char *)"_gpgme_user_id_invalid_get", _wrap__gpgme_user_id_invalid_get, METH_VARARGS, (char *)"_gpgme_user_id_invalid_get(self) -> unsigned int"},
45466 : { (char *)"_gpgme_user_id__unused_set", _wrap__gpgme_user_id__unused_set, METH_VARARGS, (char *)"_gpgme_user_id__unused_set(self, _unused)"},
45467 : { (char *)"_gpgme_user_id__unused_get", _wrap__gpgme_user_id__unused_get, METH_VARARGS, (char *)"_gpgme_user_id__unused_get(self) -> unsigned int"},
45468 : { (char *)"_gpgme_user_id_origin_set", _wrap__gpgme_user_id_origin_set, METH_VARARGS, (char *)"_gpgme_user_id_origin_set(self, origin)"},
45469 : { (char *)"_gpgme_user_id_origin_get", _wrap__gpgme_user_id_origin_get, METH_VARARGS, (char *)"_gpgme_user_id_origin_get(self) -> unsigned int"},
45470 : { (char *)"_gpgme_user_id_validity_set", _wrap__gpgme_user_id_validity_set, METH_VARARGS, (char *)"_gpgme_user_id_validity_set(self, validity)"},
45471 : { (char *)"_gpgme_user_id_validity_get", _wrap__gpgme_user_id_validity_get, METH_VARARGS, (char *)"_gpgme_user_id_validity_get(self) -> gpgme_validity_t"},
45472 : { (char *)"_gpgme_user_id_uid_set", _wrap__gpgme_user_id_uid_set, METH_VARARGS, (char *)"_gpgme_user_id_uid_set(self, uid)"},
45473 : { (char *)"_gpgme_user_id_uid_get", _wrap__gpgme_user_id_uid_get, METH_VARARGS, (char *)"_gpgme_user_id_uid_get(self) -> char *"},
45474 : { (char *)"_gpgme_user_id_name_set", _wrap__gpgme_user_id_name_set, METH_VARARGS, (char *)"_gpgme_user_id_name_set(self, name)"},
45475 : { (char *)"_gpgme_user_id_name_get", _wrap__gpgme_user_id_name_get, METH_VARARGS, (char *)"_gpgme_user_id_name_get(self) -> char *"},
45476 : { (char *)"_gpgme_user_id_email_set", _wrap__gpgme_user_id_email_set, METH_VARARGS, (char *)"_gpgme_user_id_email_set(self, email)"},
45477 : { (char *)"_gpgme_user_id_email_get", _wrap__gpgme_user_id_email_get, METH_VARARGS, (char *)"_gpgme_user_id_email_get(self) -> char *"},
45478 : { (char *)"_gpgme_user_id_comment_set", _wrap__gpgme_user_id_comment_set, METH_VARARGS, (char *)"_gpgme_user_id_comment_set(self, comment)"},
45479 : { (char *)"_gpgme_user_id_comment_get", _wrap__gpgme_user_id_comment_get, METH_VARARGS, (char *)"_gpgme_user_id_comment_get(self) -> char *"},
45480 : { (char *)"_gpgme_user_id_signatures_set", _wrap__gpgme_user_id_signatures_set, METH_VARARGS, (char *)"_gpgme_user_id_signatures_set(self, signatures)"},
45481 : { (char *)"_gpgme_user_id_signatures_get", _wrap__gpgme_user_id_signatures_get, METH_VARARGS, (char *)"_gpgme_user_id_signatures_get(self) -> _gpgme_key_sig"},
45482 : { (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)"},
45483 : { (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"},
45484 : { (char *)"_gpgme_user_id_address_set", _wrap__gpgme_user_id_address_set, METH_VARARGS, (char *)"_gpgme_user_id_address_set(self, address)"},
45485 : { (char *)"_gpgme_user_id_address_get", _wrap__gpgme_user_id_address_get, METH_VARARGS, (char *)"_gpgme_user_id_address_get(self) -> char *"},
45486 : { (char *)"_gpgme_user_id_tofu_set", _wrap__gpgme_user_id_tofu_set, METH_VARARGS, (char *)"_gpgme_user_id_tofu_set(self, tofu)"},
45487 : { (char *)"_gpgme_user_id_tofu_get", _wrap__gpgme_user_id_tofu_get, METH_VARARGS, (char *)"_gpgme_user_id_tofu_get(self) -> _gpgme_tofu_info"},
45488 : { (char *)"_gpgme_user_id_last_update_set", _wrap__gpgme_user_id_last_update_set, METH_VARARGS, (char *)"_gpgme_user_id_last_update_set(self, last_update)"},
45489 : { (char *)"_gpgme_user_id_last_update_get", _wrap__gpgme_user_id_last_update_get, METH_VARARGS, (char *)"_gpgme_user_id_last_update_get(self) -> unsigned long"},
45490 : { (char *)"new__gpgme_user_id", _wrap_new__gpgme_user_id, METH_VARARGS, (char *)"new__gpgme_user_id() -> _gpgme_user_id"},
45491 : { (char *)"delete__gpgme_user_id", _wrap_delete__gpgme_user_id, METH_VARARGS, (char *)"delete__gpgme_user_id(self)"},
45492 : { (char *)"_gpgme_user_id_swigregister", _gpgme_user_id_swigregister, METH_VARARGS, NULL},
45493 : { (char *)"_gpgme_key__refs_set", _wrap__gpgme_key__refs_set, METH_VARARGS, (char *)"_gpgme_key__refs_set(self, _refs)"},
45494 : { (char *)"_gpgme_key__refs_get", _wrap__gpgme_key__refs_get, METH_VARARGS, (char *)"_gpgme_key__refs_get(self) -> unsigned int"},
45495 : { (char *)"_gpgme_key_revoked_set", _wrap__gpgme_key_revoked_set, METH_VARARGS, (char *)"_gpgme_key_revoked_set(self, revoked)"},
45496 : { (char *)"_gpgme_key_revoked_get", _wrap__gpgme_key_revoked_get, METH_VARARGS, (char *)"_gpgme_key_revoked_get(self) -> unsigned int"},
45497 : { (char *)"_gpgme_key_expired_set", _wrap__gpgme_key_expired_set, METH_VARARGS, (char *)"_gpgme_key_expired_set(self, expired)"},
45498 : { (char *)"_gpgme_key_expired_get", _wrap__gpgme_key_expired_get, METH_VARARGS, (char *)"_gpgme_key_expired_get(self) -> unsigned int"},
45499 : { (char *)"_gpgme_key_disabled_set", _wrap__gpgme_key_disabled_set, METH_VARARGS, (char *)"_gpgme_key_disabled_set(self, disabled)"},
45500 : { (char *)"_gpgme_key_disabled_get", _wrap__gpgme_key_disabled_get, METH_VARARGS, (char *)"_gpgme_key_disabled_get(self) -> unsigned int"},
45501 : { (char *)"_gpgme_key_invalid_set", _wrap__gpgme_key_invalid_set, METH_VARARGS, (char *)"_gpgme_key_invalid_set(self, invalid)"},
45502 : { (char *)"_gpgme_key_invalid_get", _wrap__gpgme_key_invalid_get, METH_VARARGS, (char *)"_gpgme_key_invalid_get(self) -> unsigned int"},
45503 : { (char *)"_gpgme_key_can_encrypt_set", _wrap__gpgme_key_can_encrypt_set, METH_VARARGS, (char *)"_gpgme_key_can_encrypt_set(self, can_encrypt)"},
45504 : { (char *)"_gpgme_key_can_encrypt_get", _wrap__gpgme_key_can_encrypt_get, METH_VARARGS, (char *)"_gpgme_key_can_encrypt_get(self) -> unsigned int"},
45505 : { (char *)"_gpgme_key_can_sign_set", _wrap__gpgme_key_can_sign_set, METH_VARARGS, (char *)"_gpgme_key_can_sign_set(self, can_sign)"},
45506 : { (char *)"_gpgme_key_can_sign_get", _wrap__gpgme_key_can_sign_get, METH_VARARGS, (char *)"_gpgme_key_can_sign_get(self) -> unsigned int"},
45507 : { (char *)"_gpgme_key_can_certify_set", _wrap__gpgme_key_can_certify_set, METH_VARARGS, (char *)"_gpgme_key_can_certify_set(self, can_certify)"},
45508 : { (char *)"_gpgme_key_can_certify_get", _wrap__gpgme_key_can_certify_get, METH_VARARGS, (char *)"_gpgme_key_can_certify_get(self) -> unsigned int"},
45509 : { (char *)"_gpgme_key_secret_set", _wrap__gpgme_key_secret_set, METH_VARARGS, (char *)"_gpgme_key_secret_set(self, secret)"},
45510 : { (char *)"_gpgme_key_secret_get", _wrap__gpgme_key_secret_get, METH_VARARGS, (char *)"_gpgme_key_secret_get(self) -> unsigned int"},
45511 : { (char *)"_gpgme_key_can_authenticate_set", _wrap__gpgme_key_can_authenticate_set, METH_VARARGS, (char *)"_gpgme_key_can_authenticate_set(self, can_authenticate)"},
45512 : { (char *)"_gpgme_key_can_authenticate_get", _wrap__gpgme_key_can_authenticate_get, METH_VARARGS, (char *)"_gpgme_key_can_authenticate_get(self) -> unsigned int"},
45513 : { (char *)"_gpgme_key_is_qualified_set", _wrap__gpgme_key_is_qualified_set, METH_VARARGS, (char *)"_gpgme_key_is_qualified_set(self, is_qualified)"},
45514 : { (char *)"_gpgme_key_is_qualified_get", _wrap__gpgme_key_is_qualified_get, METH_VARARGS, (char *)"_gpgme_key_is_qualified_get(self) -> unsigned int"},
45515 : { (char *)"_gpgme_key__unused_set", _wrap__gpgme_key__unused_set, METH_VARARGS, (char *)"_gpgme_key__unused_set(self, _unused)"},
45516 : { (char *)"_gpgme_key__unused_get", _wrap__gpgme_key__unused_get, METH_VARARGS, (char *)"_gpgme_key__unused_get(self) -> unsigned int"},
45517 : { (char *)"_gpgme_key_origin_set", _wrap__gpgme_key_origin_set, METH_VARARGS, (char *)"_gpgme_key_origin_set(self, origin)"},
45518 : { (char *)"_gpgme_key_origin_get", _wrap__gpgme_key_origin_get, METH_VARARGS, (char *)"_gpgme_key_origin_get(self) -> unsigned int"},
45519 : { (char *)"_gpgme_key_protocol_set", _wrap__gpgme_key_protocol_set, METH_VARARGS, (char *)"_gpgme_key_protocol_set(self, protocol)"},
45520 : { (char *)"_gpgme_key_protocol_get", _wrap__gpgme_key_protocol_get, METH_VARARGS, (char *)"_gpgme_key_protocol_get(self) -> gpgme_protocol_t"},
45521 : { (char *)"_gpgme_key_issuer_serial_set", _wrap__gpgme_key_issuer_serial_set, METH_VARARGS, (char *)"_gpgme_key_issuer_serial_set(self, issuer_serial)"},
45522 : { (char *)"_gpgme_key_issuer_serial_get", _wrap__gpgme_key_issuer_serial_get, METH_VARARGS, (char *)"_gpgme_key_issuer_serial_get(self) -> char *"},
45523 : { (char *)"_gpgme_key_issuer_name_set", _wrap__gpgme_key_issuer_name_set, METH_VARARGS, (char *)"_gpgme_key_issuer_name_set(self, issuer_name)"},
45524 : { (char *)"_gpgme_key_issuer_name_get", _wrap__gpgme_key_issuer_name_get, METH_VARARGS, (char *)"_gpgme_key_issuer_name_get(self) -> char *"},
45525 : { (char *)"_gpgme_key_chain_id_set", _wrap__gpgme_key_chain_id_set, METH_VARARGS, (char *)"_gpgme_key_chain_id_set(self, chain_id)"},
45526 : { (char *)"_gpgme_key_chain_id_get", _wrap__gpgme_key_chain_id_get, METH_VARARGS, (char *)"_gpgme_key_chain_id_get(self) -> char *"},
45527 : { (char *)"_gpgme_key_owner_trust_set", _wrap__gpgme_key_owner_trust_set, METH_VARARGS, (char *)"_gpgme_key_owner_trust_set(self, owner_trust)"},
45528 : { (char *)"_gpgme_key_owner_trust_get", _wrap__gpgme_key_owner_trust_get, METH_VARARGS, (char *)"_gpgme_key_owner_trust_get(self) -> gpgme_validity_t"},
45529 : { (char *)"_gpgme_key_subkeys_set", _wrap__gpgme_key_subkeys_set, METH_VARARGS, (char *)"_gpgme_key_subkeys_set(self, subkeys)"},
45530 : { (char *)"_gpgme_key_subkeys_get", _wrap__gpgme_key_subkeys_get, METH_VARARGS, (char *)"_gpgme_key_subkeys_get(self) -> _gpgme_subkey"},
45531 : { (char *)"_gpgme_key_uids_set", _wrap__gpgme_key_uids_set, METH_VARARGS, (char *)"_gpgme_key_uids_set(self, uids)"},
45532 : { (char *)"_gpgme_key_uids_get", _wrap__gpgme_key_uids_get, METH_VARARGS, (char *)"_gpgme_key_uids_get(self) -> _gpgme_user_id"},
45533 : { (char *)"_gpgme_key__last_subkey_set", _wrap__gpgme_key__last_subkey_set, METH_VARARGS, (char *)"_gpgme_key__last_subkey_set(self, _last_subkey)"},
45534 : { (char *)"_gpgme_key__last_subkey_get", _wrap__gpgme_key__last_subkey_get, METH_VARARGS, (char *)"_gpgme_key__last_subkey_get(self) -> _gpgme_subkey"},
45535 : { (char *)"_gpgme_key__last_uid_set", _wrap__gpgme_key__last_uid_set, METH_VARARGS, (char *)"_gpgme_key__last_uid_set(self, _last_uid)"},
45536 : { (char *)"_gpgme_key__last_uid_get", _wrap__gpgme_key__last_uid_get, METH_VARARGS, (char *)"_gpgme_key__last_uid_get(self) -> _gpgme_user_id"},
45537 : { (char *)"_gpgme_key_keylist_mode_set", _wrap__gpgme_key_keylist_mode_set, METH_VARARGS, (char *)"_gpgme_key_keylist_mode_set(self, keylist_mode)"},
45538 : { (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"},
45539 : { (char *)"_gpgme_key_fpr_set", _wrap__gpgme_key_fpr_set, METH_VARARGS, (char *)"_gpgme_key_fpr_set(self, fpr)"},
45540 : { (char *)"_gpgme_key_fpr_get", _wrap__gpgme_key_fpr_get, METH_VARARGS, (char *)"_gpgme_key_fpr_get(self) -> char *"},
45541 : { (char *)"_gpgme_key_last_update_set", _wrap__gpgme_key_last_update_set, METH_VARARGS, (char *)"_gpgme_key_last_update_set(self, last_update)"},
45542 : { (char *)"_gpgme_key_last_update_get", _wrap__gpgme_key_last_update_get, METH_VARARGS, (char *)"_gpgme_key_last_update_get(self) -> unsigned long"},
45543 : { (char *)"new__gpgme_key", _wrap_new__gpgme_key, METH_VARARGS, (char *)"new__gpgme_key() -> _gpgme_key"},
45544 : { (char *)"delete__gpgme_key", _wrap_delete__gpgme_key, METH_VARARGS, (char *)"delete__gpgme_key(self)"},
45545 : { (char *)"_gpgme_key_swigregister", _gpgme_key_swigregister, METH_VARARGS, NULL},
45546 : { (char *)"_gpgme_invalid_key_fpr_set", _wrap__gpgme_invalid_key_fpr_set, METH_VARARGS, (char *)"_gpgme_invalid_key_fpr_set(self, fpr)"},
45547 : { (char *)"_gpgme_invalid_key_fpr_get", _wrap__gpgme_invalid_key_fpr_get, METH_VARARGS, (char *)"_gpgme_invalid_key_fpr_get(self) -> char *"},
45548 : { (char *)"_gpgme_invalid_key_reason_set", _wrap__gpgme_invalid_key_reason_set, METH_VARARGS, (char *)"_gpgme_invalid_key_reason_set(self, reason)"},
45549 : { (char *)"_gpgme_invalid_key_reason_get", _wrap__gpgme_invalid_key_reason_get, METH_VARARGS, (char *)"_gpgme_invalid_key_reason_get(self) -> gpgme_error_t"},
45550 : { (char *)"new__gpgme_invalid_key", _wrap_new__gpgme_invalid_key, METH_VARARGS, (char *)"new__gpgme_invalid_key() -> _gpgme_invalid_key"},
45551 : { (char *)"delete__gpgme_invalid_key", _wrap_delete__gpgme_invalid_key, METH_VARARGS, (char *)"delete__gpgme_invalid_key(self)"},
45552 : { (char *)"_gpgme_invalid_key_swigregister", _gpgme_invalid_key_swigregister, METH_VARARGS, NULL},
45553 : { (char *)"gpgme_new", _wrap_gpgme_new, METH_VARARGS, (char *)"gpgme_new(ctx) -> gpgme_error_t"},
45554 : { (char *)"gpgme_release", _wrap_gpgme_release, METH_VARARGS, (char *)"gpgme_release(ctx)"},
45555 : { (char *)"gpgme_set_ctx_flag", _wrap_gpgme_set_ctx_flag, METH_VARARGS, (char *)"gpgme_set_ctx_flag(ctx, name, value) -> gpgme_error_t"},
45556 : { (char *)"gpgme_get_ctx_flag", _wrap_gpgme_get_ctx_flag, METH_VARARGS, (char *)"gpgme_get_ctx_flag(ctx, name) -> char const *"},
45557 : { (char *)"gpgme_set_protocol", _wrap_gpgme_set_protocol, METH_VARARGS, (char *)"gpgme_set_protocol(ctx, proto) -> gpgme_error_t"},
45558 : { (char *)"gpgme_get_protocol", _wrap_gpgme_get_protocol, METH_VARARGS, (char *)"gpgme_get_protocol(ctx) -> gpgme_protocol_t"},
45559 : { (char *)"gpgme_set_sub_protocol", _wrap_gpgme_set_sub_protocol, METH_VARARGS, (char *)"gpgme_set_sub_protocol(ctx, proto) -> gpgme_error_t"},
45560 : { (char *)"gpgme_get_sub_protocol", _wrap_gpgme_get_sub_protocol, METH_VARARGS, (char *)"gpgme_get_sub_protocol(ctx) -> gpgme_protocol_t"},
45561 : { (char *)"gpgme_get_protocol_name", _wrap_gpgme_get_protocol_name, METH_VARARGS, (char *)"gpgme_get_protocol_name(proto) -> char const *"},
45562 : { (char *)"gpgme_set_armor", _wrap_gpgme_set_armor, METH_VARARGS, (char *)"gpgme_set_armor(ctx, yes)"},
45563 : { (char *)"gpgme_get_armor", _wrap_gpgme_get_armor, METH_VARARGS, (char *)"gpgme_get_armor(ctx) -> int"},
45564 : { (char *)"gpgme_set_textmode", _wrap_gpgme_set_textmode, METH_VARARGS, (char *)"gpgme_set_textmode(ctx, yes)"},
45565 : { (char *)"gpgme_get_textmode", _wrap_gpgme_get_textmode, METH_VARARGS, (char *)"gpgme_get_textmode(ctx) -> int"},
45566 : { (char *)"gpgme_set_offline", _wrap_gpgme_set_offline, METH_VARARGS, (char *)"gpgme_set_offline(ctx, yes)"},
45567 : { (char *)"gpgme_get_offline", _wrap_gpgme_get_offline, METH_VARARGS, (char *)"gpgme_get_offline(ctx) -> int"},
45568 : { (char *)"gpgme_set_include_certs", _wrap_gpgme_set_include_certs, METH_VARARGS, (char *)"gpgme_set_include_certs(ctx, nr_of_certs)"},
45569 : { (char *)"gpgme_get_include_certs", _wrap_gpgme_get_include_certs, METH_VARARGS, (char *)"gpgme_get_include_certs(ctx) -> int"},
45570 : { (char *)"gpgme_set_keylist_mode", _wrap_gpgme_set_keylist_mode, METH_VARARGS, (char *)"gpgme_set_keylist_mode(ctx, mode) -> gpgme_error_t"},
45571 : { (char *)"gpgme_get_keylist_mode", _wrap_gpgme_get_keylist_mode, METH_VARARGS, (char *)"gpgme_get_keylist_mode(ctx) -> gpgme_keylist_mode_t"},
45572 : { (char *)"gpgme_set_pinentry_mode", _wrap_gpgme_set_pinentry_mode, METH_VARARGS, (char *)"gpgme_set_pinentry_mode(ctx, mode) -> gpgme_error_t"},
45573 : { (char *)"gpgme_get_pinentry_mode", _wrap_gpgme_get_pinentry_mode, METH_VARARGS, (char *)"gpgme_get_pinentry_mode(ctx) -> gpgme_pinentry_mode_t"},
45574 : { (char *)"gpgme_set_passphrase_cb", _wrap_gpgme_set_passphrase_cb, METH_VARARGS, (char *)"gpgme_set_passphrase_cb(ctx, cb, hook_value)"},
45575 : { (char *)"gpgme_get_passphrase_cb", _wrap_gpgme_get_passphrase_cb, METH_VARARGS, (char *)"gpgme_get_passphrase_cb(ctx, cb, hook_value)"},
45576 : { (char *)"gpgme_set_progress_cb", _wrap_gpgme_set_progress_cb, METH_VARARGS, (char *)"gpgme_set_progress_cb(c, cb, hook_value)"},
45577 : { (char *)"gpgme_get_progress_cb", _wrap_gpgme_get_progress_cb, METH_VARARGS, (char *)"gpgme_get_progress_cb(ctx, cb, hook_value)"},
45578 : { (char *)"gpgme_set_status_cb", _wrap_gpgme_set_status_cb, METH_VARARGS, (char *)"gpgme_set_status_cb(c, cb, hook_value)"},
45579 : { (char *)"gpgme_get_status_cb", _wrap_gpgme_get_status_cb, METH_VARARGS, (char *)"gpgme_get_status_cb(ctx, cb, hook_value)"},
45580 : { (char *)"gpgme_set_locale", _wrap_gpgme_set_locale, METH_VARARGS, (char *)"gpgme_set_locale(ctx, category, value) -> gpgme_error_t"},
45581 : { (char *)"gpgme_ctx_get_engine_info", _wrap_gpgme_ctx_get_engine_info, METH_VARARGS, (char *)"gpgme_ctx_get_engine_info(ctx) -> _gpgme_engine_info"},
45582 : { (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"},
45583 : { (char *)"gpgme_signers_clear", _wrap_gpgme_signers_clear, METH_VARARGS, (char *)"gpgme_signers_clear(ctx)"},
45584 : { (char *)"gpgme_signers_add", _wrap_gpgme_signers_add, METH_VARARGS, (char *)"gpgme_signers_add(ctx, key) -> gpgme_error_t"},
45585 : { (char *)"gpgme_signers_count", _wrap_gpgme_signers_count, METH_VARARGS, (char *)"gpgme_signers_count(ctx) -> unsigned int"},
45586 : { (char *)"gpgme_signers_enum", _wrap_gpgme_signers_enum, METH_VARARGS, (char *)"gpgme_signers_enum(ctx, seq) -> _gpgme_key"},
45587 : { (char *)"gpgme_sig_notation_clear", _wrap_gpgme_sig_notation_clear, METH_VARARGS, (char *)"gpgme_sig_notation_clear(ctx)"},
45588 : { (char *)"gpgme_sig_notation_add", _wrap_gpgme_sig_notation_add, METH_VARARGS, (char *)"gpgme_sig_notation_add(ctx, name, value, flags) -> gpgme_error_t"},
45589 : { (char *)"gpgme_sig_notation_get", _wrap_gpgme_sig_notation_get, METH_VARARGS, (char *)"gpgme_sig_notation_get(ctx) -> _gpgme_sig_notation"},
45590 : { (char *)"gpgme_set_sender", _wrap_gpgme_set_sender, METH_VARARGS, (char *)"gpgme_set_sender(ctx, address) -> gpgme_error_t"},
45591 : { (char *)"gpgme_get_sender", _wrap_gpgme_get_sender, METH_VARARGS, (char *)"gpgme_get_sender(ctx) -> char const *"},
45592 : { (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)"},
45593 : { (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"},
45594 : { (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)"},
45595 : { (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"},
45596 : { (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"},
45597 : { (char *)"delete_gpgme_io_event_done_data", _wrap_delete_gpgme_io_event_done_data, METH_VARARGS, (char *)"delete_gpgme_io_event_done_data(self)"},
45598 : { (char *)"gpgme_io_event_done_data_swigregister", gpgme_io_event_done_data_swigregister, METH_VARARGS, NULL},
45599 : { (char *)"gpgme_io_cbs_add_set", _wrap_gpgme_io_cbs_add_set, METH_VARARGS, (char *)"gpgme_io_cbs_add_set(self, add)"},
45600 : { (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"},
45601 : { (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)"},
45602 : { (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 *"},
45603 : { (char *)"gpgme_io_cbs_remove_set", _wrap_gpgme_io_cbs_remove_set, METH_VARARGS, (char *)"gpgme_io_cbs_remove_set(self, remove)"},
45604 : { (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"},
45605 : { (char *)"gpgme_io_cbs_event_set", _wrap_gpgme_io_cbs_event_set, METH_VARARGS, (char *)"gpgme_io_cbs_event_set(self, event)"},
45606 : { (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"},
45607 : { (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)"},
45608 : { (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 *"},
45609 : { (char *)"new_gpgme_io_cbs", _wrap_new_gpgme_io_cbs, METH_VARARGS, (char *)"new_gpgme_io_cbs() -> gpgme_io_cbs"},
45610 : { (char *)"delete_gpgme_io_cbs", _wrap_delete_gpgme_io_cbs, METH_VARARGS, (char *)"delete_gpgme_io_cbs(self)"},
45611 : { (char *)"gpgme_io_cbs_swigregister", gpgme_io_cbs_swigregister, METH_VARARGS, NULL},
45612 : { (char *)"gpgme_set_io_cbs", _wrap_gpgme_set_io_cbs, METH_VARARGS, (char *)"gpgme_set_io_cbs(ctx, io_cbs)"},
45613 : { (char *)"gpgme_get_io_cbs", _wrap_gpgme_get_io_cbs, METH_VARARGS, (char *)"gpgme_get_io_cbs(ctx, io_cbs)"},
45614 : { (char *)"gpgme_io_read", _wrap_gpgme_io_read, METH_VARARGS, (char *)"gpgme_io_read(fd, buffer, count) -> ssize_t"},
45615 : { (char *)"gpgme_io_write", _wrap_gpgme_io_write, METH_VARARGS, (char *)"gpgme_io_write(fd, buffer, count) -> ssize_t"},
45616 : { (char *)"gpgme_io_writen", _wrap_gpgme_io_writen, METH_VARARGS, (char *)"gpgme_io_writen(fd, buffer, count) -> int"},
45617 : { (char *)"gpgme_wait", _wrap_gpgme_wait, METH_VARARGS, (char *)"gpgme_wait(ctx, status, hang) -> gpgme_ctx_t"},
45618 : { (char *)"gpgme_wait_ext", _wrap_gpgme_wait_ext, METH_VARARGS, (char *)"gpgme_wait_ext(ctx, status, op_err, hang) -> gpgme_ctx_t"},
45619 : { (char *)"gpgme_cancel", _wrap_gpgme_cancel, METH_VARARGS, (char *)"gpgme_cancel(ctx) -> gpgme_error_t"},
45620 : { (char *)"gpgme_cancel_async", _wrap_gpgme_cancel_async, METH_VARARGS, (char *)"gpgme_cancel_async(ctx) -> gpgme_error_t"},
45621 : { (char *)"gpgme_data_cbs_read_set", _wrap_gpgme_data_cbs_read_set, METH_VARARGS, (char *)"gpgme_data_cbs_read_set(self, read)"},
45622 : { (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"},
45623 : { (char *)"gpgme_data_cbs_write_set", _wrap_gpgme_data_cbs_write_set, METH_VARARGS, (char *)"gpgme_data_cbs_write_set(self, write)"},
45624 : { (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"},
45625 : { (char *)"gpgme_data_cbs_seek_set", _wrap_gpgme_data_cbs_seek_set, METH_VARARGS, (char *)"gpgme_data_cbs_seek_set(self, seek)"},
45626 : { (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"},
45627 : { (char *)"gpgme_data_cbs_release_set", _wrap_gpgme_data_cbs_release_set, METH_VARARGS, (char *)"gpgme_data_cbs_release_set(self, release)"},
45628 : { (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"},
45629 : { (char *)"new_gpgme_data_cbs", _wrap_new_gpgme_data_cbs, METH_VARARGS, (char *)"new_gpgme_data_cbs() -> gpgme_data_cbs"},
45630 : { (char *)"delete_gpgme_data_cbs", _wrap_delete_gpgme_data_cbs, METH_VARARGS, (char *)"delete_gpgme_data_cbs(self)"},
45631 : { (char *)"gpgme_data_cbs_swigregister", gpgme_data_cbs_swigregister, METH_VARARGS, NULL},
45632 : { (char *)"gpgme_data_read", _wrap_gpgme_data_read, METH_VARARGS, (char *)"gpgme_data_read(dh, buffer) -> ssize_t"},
45633 : { (char *)"gpgme_data_write", _wrap_gpgme_data_write, METH_VARARGS, (char *)"gpgme_data_write(dh, buffer) -> ssize_t"},
45634 : { (char *)"gpgme_data_new", _wrap_gpgme_data_new, METH_VARARGS, (char *)"gpgme_data_new(r_dh) -> gpgme_error_t"},
45635 : { (char *)"gpgme_data_release", _wrap_gpgme_data_release, METH_VARARGS, (char *)"gpgme_data_release(dh)"},
45636 : { (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"},
45637 : { (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 *"},
45638 : { (char *)"gpgme_free", _wrap_gpgme_free, METH_VARARGS, (char *)"gpgme_free(buffer)"},
45639 : { (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"},
45640 : { (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"},
45641 : { (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"},
45642 : { (char *)"gpgme_data_new_from_estream", _wrap_gpgme_data_new_from_estream, METH_VARARGS, (char *)"gpgme_data_new_from_estream(r_dh, stream) -> gpgme_error_t"},
45643 : { (char *)"gpgme_data_get_encoding", _wrap_gpgme_data_get_encoding, METH_VARARGS, (char *)"gpgme_data_get_encoding(dh) -> gpgme_data_encoding_t"},
45644 : { (char *)"gpgme_data_set_encoding", _wrap_gpgme_data_set_encoding, METH_VARARGS, (char *)"gpgme_data_set_encoding(dh, enc) -> gpgme_error_t"},
45645 : { (char *)"gpgme_data_get_file_name", _wrap_gpgme_data_get_file_name, METH_VARARGS, (char *)"gpgme_data_get_file_name(dh) -> char *"},
45646 : { (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"},
45647 : { (char *)"gpgme_data_set_flag", _wrap_gpgme_data_set_flag, METH_VARARGS, (char *)"gpgme_data_set_flag(dh, name, value) -> gpg_error_t"},
45648 : { (char *)"gpgme_data_identify", _wrap_gpgme_data_identify, METH_VARARGS, (char *)"gpgme_data_identify(dh, reserved) -> gpgme_data_type_t"},
45649 : { (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"},
45650 : { (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"},
45651 : { (char *)"gpgme_data_rewind", _wrap_gpgme_data_rewind, METH_VARARGS, (char *)"gpgme_data_rewind(dh) -> gpgme_error_t"},
45652 : { (char *)"gpgme_get_key", _wrap_gpgme_get_key, METH_VARARGS, (char *)"gpgme_get_key(ctx, fpr, r_key, secret) -> gpgme_error_t"},
45653 : { (char *)"gpgme_key_from_uid", _wrap_gpgme_key_from_uid, METH_VARARGS, (char *)"gpgme_key_from_uid(key, name) -> gpgme_error_t"},
45654 : { (char *)"gpgme_key_ref", _wrap_gpgme_key_ref, METH_VARARGS, (char *)"gpgme_key_ref(key)"},
45655 : { (char *)"gpgme_key_unref", _wrap_gpgme_key_unref, METH_VARARGS, (char *)"gpgme_key_unref(key)"},
45656 : { (char *)"gpgme_key_release", _wrap_gpgme_key_release, METH_VARARGS, (char *)"gpgme_key_release(key)"},
45657 : { (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)"},
45658 : { (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"},
45659 : { (char *)"new__gpgme_op_encrypt_result", _wrap_new__gpgme_op_encrypt_result, METH_VARARGS, (char *)"new__gpgme_op_encrypt_result() -> _gpgme_op_encrypt_result"},
45660 : { (char *)"delete__gpgme_op_encrypt_result", _wrap_delete__gpgme_op_encrypt_result, METH_VARARGS, (char *)"delete__gpgme_op_encrypt_result(self)"},
45661 : { (char *)"_gpgme_op_encrypt_result_swigregister", _gpgme_op_encrypt_result_swigregister, METH_VARARGS, NULL},
45662 : { (char *)"gpgme_op_encrypt_result", _wrap_gpgme_op_encrypt_result, METH_VARARGS, (char *)"gpgme_op_encrypt_result(ctx) -> _gpgme_op_encrypt_result"},
45663 : { (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"},
45664 : { (char *)"gpgme_op_encrypt", _wrap_gpgme_op_encrypt, METH_VARARGS, (char *)"gpgme_op_encrypt(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
45665 : { (char *)"gpgme_op_encrypt_ext_start", _wrap_gpgme_op_encrypt_ext_start, METH_VARARGS, (char *)"gpgme_op_encrypt_ext_start(ctx, recp, recpstring, flags, plain, cipher) -> gpgme_error_t"},
45666 : { (char *)"gpgme_op_encrypt_ext", _wrap_gpgme_op_encrypt_ext, METH_VARARGS, (char *)"gpgme_op_encrypt_ext(ctx, recp, recpstring, flags, plain, cipher) -> gpgme_error_t"},
45667 : { (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"},
45668 : { (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"},
45669 : { (char *)"gpgme_op_encrypt_sign_ext_start", _wrap_gpgme_op_encrypt_sign_ext_start, METH_VARARGS, (char *)"gpgme_op_encrypt_sign_ext_start(ctx, recp, recpstring, flags, plain, cipher) -> gpgme_error_t"},
45670 : { (char *)"gpgme_op_encrypt_sign_ext", _wrap_gpgme_op_encrypt_sign_ext, METH_VARARGS, (char *)"gpgme_op_encrypt_sign_ext(ctx, recp, recpstring, flags, plain, cipher) -> gpgme_error_t"},
45671 : { (char *)"_gpgme_recipient_keyid_set", _wrap__gpgme_recipient_keyid_set, METH_VARARGS, (char *)"_gpgme_recipient_keyid_set(self, keyid)"},
45672 : { (char *)"_gpgme_recipient_keyid_get", _wrap__gpgme_recipient_keyid_get, METH_VARARGS, (char *)"_gpgme_recipient_keyid_get(self) -> char *"},
45673 : { (char *)"_gpgme_recipient__keyid_set", _wrap__gpgme_recipient__keyid_set, METH_VARARGS, (char *)"_gpgme_recipient__keyid_set(self, _keyid)"},
45674 : { (char *)"_gpgme_recipient__keyid_get", _wrap__gpgme_recipient__keyid_get, METH_VARARGS, (char *)"_gpgme_recipient__keyid_get(self) -> char [16+1]"},
45675 : { (char *)"_gpgme_recipient_pubkey_algo_set", _wrap__gpgme_recipient_pubkey_algo_set, METH_VARARGS, (char *)"_gpgme_recipient_pubkey_algo_set(self, pubkey_algo)"},
45676 : { (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"},
45677 : { (char *)"_gpgme_recipient_status_set", _wrap__gpgme_recipient_status_set, METH_VARARGS, (char *)"_gpgme_recipient_status_set(self, status)"},
45678 : { (char *)"_gpgme_recipient_status_get", _wrap__gpgme_recipient_status_get, METH_VARARGS, (char *)"_gpgme_recipient_status_get(self) -> gpgme_error_t"},
45679 : { (char *)"new__gpgme_recipient", _wrap_new__gpgme_recipient, METH_VARARGS, (char *)"new__gpgme_recipient() -> _gpgme_recipient"},
45680 : { (char *)"delete__gpgme_recipient", _wrap_delete__gpgme_recipient, METH_VARARGS, (char *)"delete__gpgme_recipient(self)"},
45681 : { (char *)"_gpgme_recipient_swigregister", _gpgme_recipient_swigregister, METH_VARARGS, NULL},
45682 : { (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)"},
45683 : { (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 *"},
45684 : { (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)"},
45685 : { (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"},
45686 : { (char *)"_gpgme_op_decrypt_result_is_de_vs_set", _wrap__gpgme_op_decrypt_result_is_de_vs_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_is_de_vs_set(self, is_de_vs)"},
45687 : { (char *)"_gpgme_op_decrypt_result_is_de_vs_get", _wrap__gpgme_op_decrypt_result_is_de_vs_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_is_de_vs_get(self) -> unsigned int"},
45688 : { (char *)"_gpgme_op_decrypt_result_is_mime_set", _wrap__gpgme_op_decrypt_result_is_mime_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_is_mime_set(self, is_mime)"},
45689 : { (char *)"_gpgme_op_decrypt_result_is_mime_get", _wrap__gpgme_op_decrypt_result_is_mime_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_is_mime_get(self) -> unsigned int"},
45690 : { (char *)"_gpgme_op_decrypt_result_legacy_cipher_nomdc_set", _wrap__gpgme_op_decrypt_result_legacy_cipher_nomdc_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_legacy_cipher_nomdc_set(self, legacy_cipher_nomdc)"},
45691 : { (char *)"_gpgme_op_decrypt_result_legacy_cipher_nomdc_get", _wrap__gpgme_op_decrypt_result_legacy_cipher_nomdc_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_legacy_cipher_nomdc_get(self) -> unsigned int"},
45692 : { (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)"},
45693 : { (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"},
45694 : { (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)"},
45695 : { (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"},
45696 : { (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)"},
45697 : { (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 *"},
45698 : { (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)"},
45699 : { (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 *"},
45700 : { (char *)"_gpgme_op_decrypt_result_symkey_algo_set", _wrap__gpgme_op_decrypt_result_symkey_algo_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_symkey_algo_set(self, symkey_algo)"},
45701 : { (char *)"_gpgme_op_decrypt_result_symkey_algo_get", _wrap__gpgme_op_decrypt_result_symkey_algo_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_symkey_algo_get(self) -> char *"},
45702 : { (char *)"new__gpgme_op_decrypt_result", _wrap_new__gpgme_op_decrypt_result, METH_VARARGS, (char *)"new__gpgme_op_decrypt_result() -> _gpgme_op_decrypt_result"},
45703 : { (char *)"delete__gpgme_op_decrypt_result", _wrap_delete__gpgme_op_decrypt_result, METH_VARARGS, (char *)"delete__gpgme_op_decrypt_result(self)"},
45704 : { (char *)"_gpgme_op_decrypt_result_swigregister", _gpgme_op_decrypt_result_swigregister, METH_VARARGS, NULL},
45705 : { (char *)"gpgme_op_decrypt_result", _wrap_gpgme_op_decrypt_result, METH_VARARGS, (char *)"gpgme_op_decrypt_result(ctx) -> _gpgme_op_decrypt_result"},
45706 : { (char *)"gpgme_op_decrypt_start", _wrap_gpgme_op_decrypt_start, METH_VARARGS, (char *)"gpgme_op_decrypt_start(ctx, cipher, plain) -> gpgme_error_t"},
45707 : { (char *)"gpgme_op_decrypt", _wrap_gpgme_op_decrypt, METH_VARARGS, (char *)"gpgme_op_decrypt(ctx, cipher, plain) -> gpgme_error_t"},
45708 : { (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"},
45709 : { (char *)"gpgme_op_decrypt_verify", _wrap_gpgme_op_decrypt_verify, METH_VARARGS, (char *)"gpgme_op_decrypt_verify(ctx, cipher, plain) -> gpgme_error_t"},
45710 : { (char *)"gpgme_op_decrypt_ext_start", _wrap_gpgme_op_decrypt_ext_start, METH_VARARGS, (char *)"gpgme_op_decrypt_ext_start(ctx, flags, cipher, plain) -> gpgme_error_t"},
45711 : { (char *)"gpgme_op_decrypt_ext", _wrap_gpgme_op_decrypt_ext, METH_VARARGS, (char *)"gpgme_op_decrypt_ext(ctx, flags, cipher, plain) -> gpgme_error_t"},
45712 : { (char *)"_gpgme_new_signature_type_set", _wrap__gpgme_new_signature_type_set, METH_VARARGS, (char *)"_gpgme_new_signature_type_set(self, type)"},
45713 : { (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"},
45714 : { (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)"},
45715 : { (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"},
45716 : { (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)"},
45717 : { (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"},
45718 : { (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)"},
45719 : { (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"},
45720 : { (char *)"_gpgme_new_signature_timestamp_set", _wrap__gpgme_new_signature_timestamp_set, METH_VARARGS, (char *)"_gpgme_new_signature_timestamp_set(self, timestamp)"},
45721 : { (char *)"_gpgme_new_signature_timestamp_get", _wrap__gpgme_new_signature_timestamp_get, METH_VARARGS, (char *)"_gpgme_new_signature_timestamp_get(self) -> long"},
45722 : { (char *)"_gpgme_new_signature_fpr_set", _wrap__gpgme_new_signature_fpr_set, METH_VARARGS, (char *)"_gpgme_new_signature_fpr_set(self, fpr)"},
45723 : { (char *)"_gpgme_new_signature_fpr_get", _wrap__gpgme_new_signature_fpr_get, METH_VARARGS, (char *)"_gpgme_new_signature_fpr_get(self) -> char *"},
45724 : { (char *)"_gpgme_new_signature__obsolete_class_2_set", _wrap__gpgme_new_signature__obsolete_class_2_set, METH_VARARGS, (char *)"_gpgme_new_signature__obsolete_class_2_set(self, _obsolete_class_2)"},
45725 : { (char *)"_gpgme_new_signature__obsolete_class_2_get", _wrap__gpgme_new_signature__obsolete_class_2_get, METH_VARARGS, (char *)"_gpgme_new_signature__obsolete_class_2_get(self) -> unsigned int"},
45726 : { (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)"},
45727 : { (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"},
45728 : { (char *)"new__gpgme_new_signature", _wrap_new__gpgme_new_signature, METH_VARARGS, (char *)"new__gpgme_new_signature() -> _gpgme_new_signature"},
45729 : { (char *)"delete__gpgme_new_signature", _wrap_delete__gpgme_new_signature, METH_VARARGS, (char *)"delete__gpgme_new_signature(self)"},
45730 : { (char *)"_gpgme_new_signature_swigregister", _gpgme_new_signature_swigregister, METH_VARARGS, NULL},
45731 : { (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)"},
45732 : { (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"},
45733 : { (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)"},
45734 : { (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"},
45735 : { (char *)"new__gpgme_op_sign_result", _wrap_new__gpgme_op_sign_result, METH_VARARGS, (char *)"new__gpgme_op_sign_result() -> _gpgme_op_sign_result"},
45736 : { (char *)"delete__gpgme_op_sign_result", _wrap_delete__gpgme_op_sign_result, METH_VARARGS, (char *)"delete__gpgme_op_sign_result(self)"},
45737 : { (char *)"_gpgme_op_sign_result_swigregister", _gpgme_op_sign_result_swigregister, METH_VARARGS, NULL},
45738 : { (char *)"gpgme_op_sign_result", _wrap_gpgme_op_sign_result, METH_VARARGS, (char *)"gpgme_op_sign_result(ctx) -> _gpgme_op_sign_result"},
45739 : { (char *)"gpgme_op_sign_start", _wrap_gpgme_op_sign_start, METH_VARARGS, (char *)"gpgme_op_sign_start(ctx, plain, sig, mode) -> gpgme_error_t"},
45740 : { (char *)"gpgme_op_sign", _wrap_gpgme_op_sign, METH_VARARGS, (char *)"gpgme_op_sign(ctx, plain, sig, mode) -> gpgme_error_t"},
45741 : { (char *)"_gpgme_signature_summary_set", _wrap__gpgme_signature_summary_set, METH_VARARGS, (char *)"_gpgme_signature_summary_set(self, summary)"},
45742 : { (char *)"_gpgme_signature_summary_get", _wrap__gpgme_signature_summary_get, METH_VARARGS, (char *)"_gpgme_signature_summary_get(self) -> gpgme_sigsum_t"},
45743 : { (char *)"_gpgme_signature_fpr_set", _wrap__gpgme_signature_fpr_set, METH_VARARGS, (char *)"_gpgme_signature_fpr_set(self, fpr)"},
45744 : { (char *)"_gpgme_signature_fpr_get", _wrap__gpgme_signature_fpr_get, METH_VARARGS, (char *)"_gpgme_signature_fpr_get(self) -> char *"},
45745 : { (char *)"_gpgme_signature_status_set", _wrap__gpgme_signature_status_set, METH_VARARGS, (char *)"_gpgme_signature_status_set(self, status)"},
45746 : { (char *)"_gpgme_signature_status_get", _wrap__gpgme_signature_status_get, METH_VARARGS, (char *)"_gpgme_signature_status_get(self) -> gpgme_error_t"},
45747 : { (char *)"_gpgme_signature_notations_set", _wrap__gpgme_signature_notations_set, METH_VARARGS, (char *)"_gpgme_signature_notations_set(self, notations)"},
45748 : { (char *)"_gpgme_signature_notations_get", _wrap__gpgme_signature_notations_get, METH_VARARGS, (char *)"_gpgme_signature_notations_get(self) -> _gpgme_sig_notation"},
45749 : { (char *)"_gpgme_signature_timestamp_set", _wrap__gpgme_signature_timestamp_set, METH_VARARGS, (char *)"_gpgme_signature_timestamp_set(self, timestamp)"},
45750 : { (char *)"_gpgme_signature_timestamp_get", _wrap__gpgme_signature_timestamp_get, METH_VARARGS, (char *)"_gpgme_signature_timestamp_get(self) -> unsigned long"},
45751 : { (char *)"_gpgme_signature_exp_timestamp_set", _wrap__gpgme_signature_exp_timestamp_set, METH_VARARGS, (char *)"_gpgme_signature_exp_timestamp_set(self, exp_timestamp)"},
45752 : { (char *)"_gpgme_signature_exp_timestamp_get", _wrap__gpgme_signature_exp_timestamp_get, METH_VARARGS, (char *)"_gpgme_signature_exp_timestamp_get(self) -> unsigned long"},
45753 : { (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)"},
45754 : { (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"},
45755 : { (char *)"_gpgme_signature_pka_trust_set", _wrap__gpgme_signature_pka_trust_set, METH_VARARGS, (char *)"_gpgme_signature_pka_trust_set(self, pka_trust)"},
45756 : { (char *)"_gpgme_signature_pka_trust_get", _wrap__gpgme_signature_pka_trust_get, METH_VARARGS, (char *)"_gpgme_signature_pka_trust_get(self) -> unsigned int"},
45757 : { (char *)"_gpgme_signature_chain_model_set", _wrap__gpgme_signature_chain_model_set, METH_VARARGS, (char *)"_gpgme_signature_chain_model_set(self, chain_model)"},
45758 : { (char *)"_gpgme_signature_chain_model_get", _wrap__gpgme_signature_chain_model_get, METH_VARARGS, (char *)"_gpgme_signature_chain_model_get(self) -> unsigned int"},
45759 : { (char *)"_gpgme_signature_is_de_vs_set", _wrap__gpgme_signature_is_de_vs_set, METH_VARARGS, (char *)"_gpgme_signature_is_de_vs_set(self, is_de_vs)"},
45760 : { (char *)"_gpgme_signature_is_de_vs_get", _wrap__gpgme_signature_is_de_vs_get, METH_VARARGS, (char *)"_gpgme_signature_is_de_vs_get(self) -> unsigned int"},
45761 : { (char *)"_gpgme_signature__unused_set", _wrap__gpgme_signature__unused_set, METH_VARARGS, (char *)"_gpgme_signature__unused_set(self, _unused)"},
45762 : { (char *)"_gpgme_signature__unused_get", _wrap__gpgme_signature__unused_get, METH_VARARGS, (char *)"_gpgme_signature__unused_get(self) -> int"},
45763 : { (char *)"_gpgme_signature_validity_set", _wrap__gpgme_signature_validity_set, METH_VARARGS, (char *)"_gpgme_signature_validity_set(self, validity)"},
45764 : { (char *)"_gpgme_signature_validity_get", _wrap__gpgme_signature_validity_get, METH_VARARGS, (char *)"_gpgme_signature_validity_get(self) -> gpgme_validity_t"},
45765 : { (char *)"_gpgme_signature_validity_reason_set", _wrap__gpgme_signature_validity_reason_set, METH_VARARGS, (char *)"_gpgme_signature_validity_reason_set(self, validity_reason)"},
45766 : { (char *)"_gpgme_signature_validity_reason_get", _wrap__gpgme_signature_validity_reason_get, METH_VARARGS, (char *)"_gpgme_signature_validity_reason_get(self) -> gpgme_error_t"},
45767 : { (char *)"_gpgme_signature_pubkey_algo_set", _wrap__gpgme_signature_pubkey_algo_set, METH_VARARGS, (char *)"_gpgme_signature_pubkey_algo_set(self, pubkey_algo)"},
45768 : { (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"},
45769 : { (char *)"_gpgme_signature_hash_algo_set", _wrap__gpgme_signature_hash_algo_set, METH_VARARGS, (char *)"_gpgme_signature_hash_algo_set(self, hash_algo)"},
45770 : { (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"},
45771 : { (char *)"_gpgme_signature_pka_address_set", _wrap__gpgme_signature_pka_address_set, METH_VARARGS, (char *)"_gpgme_signature_pka_address_set(self, pka_address)"},
45772 : { (char *)"_gpgme_signature_pka_address_get", _wrap__gpgme_signature_pka_address_get, METH_VARARGS, (char *)"_gpgme_signature_pka_address_get(self) -> char *"},
45773 : { (char *)"_gpgme_signature_key_set", _wrap__gpgme_signature_key_set, METH_VARARGS, (char *)"_gpgme_signature_key_set(self, key)"},
45774 : { (char *)"_gpgme_signature_key_get", _wrap__gpgme_signature_key_get, METH_VARARGS, (char *)"_gpgme_signature_key_get(self) -> _gpgme_key"},
45775 : { (char *)"new__gpgme_signature", _wrap_new__gpgme_signature, METH_VARARGS, (char *)"new__gpgme_signature() -> _gpgme_signature"},
45776 : { (char *)"delete__gpgme_signature", _wrap_delete__gpgme_signature, METH_VARARGS, (char *)"delete__gpgme_signature(self)"},
45777 : { (char *)"_gpgme_signature_swigregister", _gpgme_signature_swigregister, METH_VARARGS, NULL},
45778 : { (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)"},
45779 : { (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"},
45780 : { (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)"},
45781 : { (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 *"},
45782 : { (char *)"_gpgme_op_verify_result_is_mime_set", _wrap__gpgme_op_verify_result_is_mime_set, METH_VARARGS, (char *)"_gpgme_op_verify_result_is_mime_set(self, is_mime)"},
45783 : { (char *)"_gpgme_op_verify_result_is_mime_get", _wrap__gpgme_op_verify_result_is_mime_get, METH_VARARGS, (char *)"_gpgme_op_verify_result_is_mime_get(self) -> unsigned int"},
45784 : { (char *)"_gpgme_op_verify_result__unused_set", _wrap__gpgme_op_verify_result__unused_set, METH_VARARGS, (char *)"_gpgme_op_verify_result__unused_set(self, _unused)"},
45785 : { (char *)"_gpgme_op_verify_result__unused_get", _wrap__gpgme_op_verify_result__unused_get, METH_VARARGS, (char *)"_gpgme_op_verify_result__unused_get(self) -> unsigned int"},
45786 : { (char *)"new__gpgme_op_verify_result", _wrap_new__gpgme_op_verify_result, METH_VARARGS, (char *)"new__gpgme_op_verify_result() -> _gpgme_op_verify_result"},
45787 : { (char *)"delete__gpgme_op_verify_result", _wrap_delete__gpgme_op_verify_result, METH_VARARGS, (char *)"delete__gpgme_op_verify_result(self)"},
45788 : { (char *)"_gpgme_op_verify_result_swigregister", _gpgme_op_verify_result_swigregister, METH_VARARGS, NULL},
45789 : { (char *)"gpgme_op_verify_result", _wrap_gpgme_op_verify_result, METH_VARARGS, (char *)"gpgme_op_verify_result(ctx) -> _gpgme_op_verify_result"},
45790 : { (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"},
45791 : { (char *)"gpgme_op_verify", _wrap_gpgme_op_verify, METH_VARARGS, (char *)"gpgme_op_verify(ctx, sig, signed_text, plaintext) -> gpgme_error_t"},
45792 : { (char *)"_gpgme_import_status_fpr_set", _wrap__gpgme_import_status_fpr_set, METH_VARARGS, (char *)"_gpgme_import_status_fpr_set(self, fpr)"},
45793 : { (char *)"_gpgme_import_status_fpr_get", _wrap__gpgme_import_status_fpr_get, METH_VARARGS, (char *)"_gpgme_import_status_fpr_get(self) -> char *"},
45794 : { (char *)"_gpgme_import_status_result_set", _wrap__gpgme_import_status_result_set, METH_VARARGS, (char *)"_gpgme_import_status_result_set(self, result)"},
45795 : { (char *)"_gpgme_import_status_result_get", _wrap__gpgme_import_status_result_get, METH_VARARGS, (char *)"_gpgme_import_status_result_get(self) -> gpgme_error_t"},
45796 : { (char *)"_gpgme_import_status_status_set", _wrap__gpgme_import_status_status_set, METH_VARARGS, (char *)"_gpgme_import_status_status_set(self, status)"},
45797 : { (char *)"_gpgme_import_status_status_get", _wrap__gpgme_import_status_status_get, METH_VARARGS, (char *)"_gpgme_import_status_status_get(self) -> unsigned int"},
45798 : { (char *)"new__gpgme_import_status", _wrap_new__gpgme_import_status, METH_VARARGS, (char *)"new__gpgme_import_status() -> _gpgme_import_status"},
45799 : { (char *)"delete__gpgme_import_status", _wrap_delete__gpgme_import_status, METH_VARARGS, (char *)"delete__gpgme_import_status(self)"},
45800 : { (char *)"_gpgme_import_status_swigregister", _gpgme_import_status_swigregister, METH_VARARGS, NULL},
45801 : { (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)"},
45802 : { (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"},
45803 : { (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)"},
45804 : { (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"},
45805 : { (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)"},
45806 : { (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"},
45807 : { (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)"},
45808 : { (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"},
45809 : { (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)"},
45810 : { (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"},
45811 : { (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)"},
45812 : { (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"},
45813 : { (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)"},
45814 : { (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"},
45815 : { (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)"},
45816 : { (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"},
45817 : { (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)"},
45818 : { (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"},
45819 : { (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)"},
45820 : { (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"},
45821 : { (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)"},
45822 : { (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"},
45823 : { (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)"},
45824 : { (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"},
45825 : { (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)"},
45826 : { (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"},
45827 : { (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)"},
45828 : { (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"},
45829 : { (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)"},
45830 : { (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"},
45831 : { (char *)"_gpgme_op_import_result_skipped_v3_keys_set", _wrap__gpgme_op_import_result_skipped_v3_keys_set, METH_VARARGS, (char *)"_gpgme_op_import_result_skipped_v3_keys_set(self, skipped_v3_keys)"},
45832 : { (char *)"_gpgme_op_import_result_skipped_v3_keys_get", _wrap__gpgme_op_import_result_skipped_v3_keys_get, METH_VARARGS, (char *)"_gpgme_op_import_result_skipped_v3_keys_get(self) -> int"},
45833 : { (char *)"new__gpgme_op_import_result", _wrap_new__gpgme_op_import_result, METH_VARARGS, (char *)"new__gpgme_op_import_result() -> _gpgme_op_import_result"},
45834 : { (char *)"delete__gpgme_op_import_result", _wrap_delete__gpgme_op_import_result, METH_VARARGS, (char *)"delete__gpgme_op_import_result(self)"},
45835 : { (char *)"_gpgme_op_import_result_swigregister", _gpgme_op_import_result_swigregister, METH_VARARGS, NULL},
45836 : { (char *)"gpgme_op_import_result", _wrap_gpgme_op_import_result, METH_VARARGS, (char *)"gpgme_op_import_result(ctx) -> _gpgme_op_import_result"},
45837 : { (char *)"gpgme_op_import_start", _wrap_gpgme_op_import_start, METH_VARARGS, (char *)"gpgme_op_import_start(ctx, keydata) -> gpgme_error_t"},
45838 : { (char *)"gpgme_op_import", _wrap_gpgme_op_import, METH_VARARGS, (char *)"gpgme_op_import(ctx, keydata) -> gpgme_error_t"},
45839 : { (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"},
45840 : { (char *)"gpgme_op_import_keys", _wrap_gpgme_op_import_keys, METH_VARARGS, (char *)"gpgme_op_import_keys(ctx, keys) -> gpgme_error_t"},
45841 : { (char *)"gpgme_op_export_start", _wrap_gpgme_op_export_start, METH_VARARGS, (char *)"gpgme_op_export_start(ctx, pattern, mode, keydata) -> gpgme_error_t"},
45842 : { (char *)"gpgme_op_export", _wrap_gpgme_op_export, METH_VARARGS, (char *)"gpgme_op_export(ctx, pattern, mode, keydata) -> gpgme_error_t"},
45843 : { (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"},
45844 : { (char *)"gpgme_op_export_ext", _wrap_gpgme_op_export_ext, METH_VARARGS, (char *)"gpgme_op_export_ext(ctx, pattern, mode, keydata) -> gpgme_error_t"},
45845 : { (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"},
45846 : { (char *)"gpgme_op_export_keys", _wrap_gpgme_op_export_keys, METH_VARARGS, (char *)"gpgme_op_export_keys(ctx, keys, mode, keydata) -> gpgme_error_t"},
45847 : { (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)"},
45848 : { (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"},
45849 : { (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)"},
45850 : { (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"},
45851 : { (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)"},
45852 : { (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"},
45853 : { (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)"},
45854 : { (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"},
45855 : { (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)"},
45856 : { (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 *"},
45857 : { (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)"},
45858 : { (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"},
45859 : { (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)"},
45860 : { (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"},
45861 : { (char *)"new__gpgme_op_genkey_result", _wrap_new__gpgme_op_genkey_result, METH_VARARGS, (char *)"new__gpgme_op_genkey_result() -> _gpgme_op_genkey_result"},
45862 : { (char *)"delete__gpgme_op_genkey_result", _wrap_delete__gpgme_op_genkey_result, METH_VARARGS, (char *)"delete__gpgme_op_genkey_result(self)"},
45863 : { (char *)"_gpgme_op_genkey_result_swigregister", _gpgme_op_genkey_result_swigregister, METH_VARARGS, NULL},
45864 : { (char *)"gpgme_op_genkey_start", _wrap_gpgme_op_genkey_start, METH_VARARGS, (char *)"gpgme_op_genkey_start(ctx, parms, pubkey, seckey) -> gpgme_error_t"},
45865 : { (char *)"gpgme_op_genkey", _wrap_gpgme_op_genkey, METH_VARARGS, (char *)"gpgme_op_genkey(ctx, parms, pubkey, seckey) -> gpgme_error_t"},
45866 : { (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"},
45867 : { (char *)"gpgme_op_createkey", _wrap_gpgme_op_createkey, METH_VARARGS, (char *)"gpgme_op_createkey(ctx, userid, algo, reserved, expires, certkey, flags) -> gpgme_error_t"},
45868 : { (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"},
45869 : { (char *)"gpgme_op_createsubkey", _wrap_gpgme_op_createsubkey, METH_VARARGS, (char *)"gpgme_op_createsubkey(ctx, key, algo, reserved, expires, flags) -> gpgme_error_t"},
45870 : { (char *)"gpgme_op_adduid_start", _wrap_gpgme_op_adduid_start, METH_VARARGS, (char *)"gpgme_op_adduid_start(ctx, key, userid, reserved) -> gpgme_error_t"},
45871 : { (char *)"gpgme_op_adduid", _wrap_gpgme_op_adduid, METH_VARARGS, (char *)"gpgme_op_adduid(ctx, key, userid, reserved) -> gpgme_error_t"},
45872 : { (char *)"gpgme_op_revuid_start", _wrap_gpgme_op_revuid_start, METH_VARARGS, (char *)"gpgme_op_revuid_start(ctx, key, userid, reserved) -> gpgme_error_t"},
45873 : { (char *)"gpgme_op_revuid", _wrap_gpgme_op_revuid, METH_VARARGS, (char *)"gpgme_op_revuid(ctx, key, userid, reserved) -> gpgme_error_t"},
45874 : { (char *)"gpgme_op_set_uid_flag_start", _wrap_gpgme_op_set_uid_flag_start, METH_VARARGS, (char *)"gpgme_op_set_uid_flag_start(ctx, key, userid, name, value) -> gpgme_error_t"},
45875 : { (char *)"gpgme_op_set_uid_flag", _wrap_gpgme_op_set_uid_flag, METH_VARARGS, (char *)"gpgme_op_set_uid_flag(ctx, key, userid, name, value) -> gpgme_error_t"},
45876 : { (char *)"gpgme_op_genkey_result", _wrap_gpgme_op_genkey_result, METH_VARARGS, (char *)"gpgme_op_genkey_result(ctx) -> _gpgme_op_genkey_result"},
45877 : { (char *)"gpgme_op_delete_start", _wrap_gpgme_op_delete_start, METH_VARARGS, (char *)"gpgme_op_delete_start(ctx, key, allow_secret) -> gpgme_error_t"},
45878 : { (char *)"gpgme_op_delete", _wrap_gpgme_op_delete, METH_VARARGS, (char *)"gpgme_op_delete(ctx, key, allow_secret) -> gpgme_error_t"},
45879 : { (char *)"gpgme_op_delete_ext_start", _wrap_gpgme_op_delete_ext_start, METH_VARARGS, (char *)"gpgme_op_delete_ext_start(ctx, key, flags) -> gpgme_error_t"},
45880 : { (char *)"gpgme_op_delete_ext", _wrap_gpgme_op_delete_ext, METH_VARARGS, (char *)"gpgme_op_delete_ext(ctx, key, flags) -> gpgme_error_t"},
45881 : { (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"},
45882 : { (char *)"gpgme_op_keysign", _wrap_gpgme_op_keysign, METH_VARARGS, (char *)"gpgme_op_keysign(ctx, key, userid, expires, flags) -> gpgme_error_t"},
45883 : { (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"},
45884 : { (char *)"gpgme_op_interact", _wrap_gpgme_op_interact, METH_VARARGS, (char *)"gpgme_op_interact(ctx, key, flags, fnc, out) -> gpgme_error_t"},
45885 : { (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"},
45886 : { (char *)"gpgme_op_tofu_policy", _wrap_gpgme_op_tofu_policy, METH_VARARGS, (char *)"gpgme_op_tofu_policy(ctx, key, policy) -> gpgme_error_t"},
45887 : { (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)"},
45888 : { (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"},
45889 : { (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)"},
45890 : { (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"},
45891 : { (char *)"new__gpgme_op_keylist_result", _wrap_new__gpgme_op_keylist_result, METH_VARARGS, (char *)"new__gpgme_op_keylist_result() -> _gpgme_op_keylist_result"},
45892 : { (char *)"delete__gpgme_op_keylist_result", _wrap_delete__gpgme_op_keylist_result, METH_VARARGS, (char *)"delete__gpgme_op_keylist_result(self)"},
45893 : { (char *)"_gpgme_op_keylist_result_swigregister", _gpgme_op_keylist_result_swigregister, METH_VARARGS, NULL},
45894 : { (char *)"gpgme_op_keylist_result", _wrap_gpgme_op_keylist_result, METH_VARARGS, (char *)"gpgme_op_keylist_result(ctx) -> _gpgme_op_keylist_result"},
45895 : { (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"},
45896 : { (char *)"gpgme_op_keylist_from_data_start", _wrap_gpgme_op_keylist_from_data_start, METH_VARARGS, (char *)"gpgme_op_keylist_from_data_start(ctx, data, reserved) -> gpgme_error_t"},
45897 : { (char *)"gpgme_op_keylist_next", _wrap_gpgme_op_keylist_next, METH_VARARGS, (char *)"gpgme_op_keylist_next(ctx, r_key) -> gpgme_error_t"},
45898 : { (char *)"gpgme_op_keylist_end", _wrap_gpgme_op_keylist_end, METH_VARARGS, (char *)"gpgme_op_keylist_end(ctx) -> gpgme_error_t"},
45899 : { (char *)"gpgme_op_passwd_start", _wrap_gpgme_op_passwd_start, METH_VARARGS, (char *)"gpgme_op_passwd_start(ctx, key, flags) -> gpgme_error_t"},
45900 : { (char *)"gpgme_op_passwd", _wrap_gpgme_op_passwd, METH_VARARGS, (char *)"gpgme_op_passwd(ctx, key, flags) -> gpgme_error_t"},
45901 : { (char *)"_gpgme_trust_item__refs_set", _wrap__gpgme_trust_item__refs_set, METH_VARARGS, (char *)"_gpgme_trust_item__refs_set(self, _refs)"},
45902 : { (char *)"_gpgme_trust_item__refs_get", _wrap__gpgme_trust_item__refs_get, METH_VARARGS, (char *)"_gpgme_trust_item__refs_get(self) -> unsigned int"},
45903 : { (char *)"_gpgme_trust_item_keyid_set", _wrap__gpgme_trust_item_keyid_set, METH_VARARGS, (char *)"_gpgme_trust_item_keyid_set(self, keyid)"},
45904 : { (char *)"_gpgme_trust_item_keyid_get", _wrap__gpgme_trust_item_keyid_get, METH_VARARGS, (char *)"_gpgme_trust_item_keyid_get(self) -> char *"},
45905 : { (char *)"_gpgme_trust_item__keyid_set", _wrap__gpgme_trust_item__keyid_set, METH_VARARGS, (char *)"_gpgme_trust_item__keyid_set(self, _keyid)"},
45906 : { (char *)"_gpgme_trust_item__keyid_get", _wrap__gpgme_trust_item__keyid_get, METH_VARARGS, (char *)"_gpgme_trust_item__keyid_get(self) -> char [16+1]"},
45907 : { (char *)"_gpgme_trust_item_type_set", _wrap__gpgme_trust_item_type_set, METH_VARARGS, (char *)"_gpgme_trust_item_type_set(self, type)"},
45908 : { (char *)"_gpgme_trust_item_type_get", _wrap__gpgme_trust_item_type_get, METH_VARARGS, (char *)"_gpgme_trust_item_type_get(self) -> int"},
45909 : { (char *)"_gpgme_trust_item_level_set", _wrap__gpgme_trust_item_level_set, METH_VARARGS, (char *)"_gpgme_trust_item_level_set(self, level)"},
45910 : { (char *)"_gpgme_trust_item_level_get", _wrap__gpgme_trust_item_level_get, METH_VARARGS, (char *)"_gpgme_trust_item_level_get(self) -> int"},
45911 : { (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)"},
45912 : { (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 *"},
45913 : { (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)"},
45914 : { (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]"},
45915 : { (char *)"_gpgme_trust_item_validity_set", _wrap__gpgme_trust_item_validity_set, METH_VARARGS, (char *)"_gpgme_trust_item_validity_set(self, validity)"},
45916 : { (char *)"_gpgme_trust_item_validity_get", _wrap__gpgme_trust_item_validity_get, METH_VARARGS, (char *)"_gpgme_trust_item_validity_get(self) -> char *"},
45917 : { (char *)"_gpgme_trust_item__validity_set", _wrap__gpgme_trust_item__validity_set, METH_VARARGS, (char *)"_gpgme_trust_item__validity_set(self, _validity)"},
45918 : { (char *)"_gpgme_trust_item__validity_get", _wrap__gpgme_trust_item__validity_get, METH_VARARGS, (char *)"_gpgme_trust_item__validity_get(self) -> char [2]"},
45919 : { (char *)"_gpgme_trust_item_name_set", _wrap__gpgme_trust_item_name_set, METH_VARARGS, (char *)"_gpgme_trust_item_name_set(self, name)"},
45920 : { (char *)"_gpgme_trust_item_name_get", _wrap__gpgme_trust_item_name_get, METH_VARARGS, (char *)"_gpgme_trust_item_name_get(self) -> char *"},
45921 : { (char *)"new__gpgme_trust_item", _wrap_new__gpgme_trust_item, METH_VARARGS, (char *)"new__gpgme_trust_item() -> _gpgme_trust_item"},
45922 : { (char *)"delete__gpgme_trust_item", _wrap_delete__gpgme_trust_item, METH_VARARGS, (char *)"delete__gpgme_trust_item(self)"},
45923 : { (char *)"_gpgme_trust_item_swigregister", _gpgme_trust_item_swigregister, METH_VARARGS, NULL},
45924 : { (char *)"gpgme_op_trustlist_start", _wrap_gpgme_op_trustlist_start, METH_VARARGS, (char *)"gpgme_op_trustlist_start(ctx, pattern, max_level) -> gpgme_error_t"},
45925 : { (char *)"gpgme_op_trustlist_next", _wrap_gpgme_op_trustlist_next, METH_VARARGS, (char *)"gpgme_op_trustlist_next(ctx, r_item) -> gpgme_error_t"},
45926 : { (char *)"gpgme_op_trustlist_end", _wrap_gpgme_op_trustlist_end, METH_VARARGS, (char *)"gpgme_op_trustlist_end(ctx) -> gpgme_error_t"},
45927 : { (char *)"gpgme_trust_item_ref", _wrap_gpgme_trust_item_ref, METH_VARARGS, (char *)"gpgme_trust_item_ref(item)"},
45928 : { (char *)"gpgme_trust_item_unref", _wrap_gpgme_trust_item_unref, METH_VARARGS, (char *)"gpgme_trust_item_unref(item)"},
45929 : { (char *)"gpgme_op_getauditlog_start", _wrap_gpgme_op_getauditlog_start, METH_VARARGS, (char *)"gpgme_op_getauditlog_start(ctx, output, flags) -> gpgme_error_t"},
45930 : { (char *)"gpgme_op_getauditlog", _wrap_gpgme_op_getauditlog, METH_VARARGS, (char *)"gpgme_op_getauditlog(ctx, output, flags) -> gpgme_error_t"},
45931 : { (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"},
45932 : { (char *)"gpgme_op_spawn", _wrap_gpgme_op_spawn, METH_VARARGS, (char *)"gpgme_op_spawn(ctx, file, argv, datain, dataout, dataerr, flags) -> gpgme_error_t"},
45933 : { (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"},
45934 : { (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"},
45935 : { (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)"},
45936 : { (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 *"},
45937 : { (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"},
45938 : { (char *)"delete__gpgme_op_vfs_mount_result", _wrap_delete__gpgme_op_vfs_mount_result, METH_VARARGS, (char *)"delete__gpgme_op_vfs_mount_result(self)"},
45939 : { (char *)"_gpgme_op_vfs_mount_result_swigregister", _gpgme_op_vfs_mount_result_swigregister, METH_VARARGS, NULL},
45940 : { (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"},
45941 : { (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"},
45942 : { (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"},
45943 : { (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)"},
45944 : { (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"},
45945 : { (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"},
45946 : { (char *)"new_gpgme_conf_arg", _wrap_new_gpgme_conf_arg, METH_VARARGS, (char *)"new_gpgme_conf_arg() -> gpgme_conf_arg"},
45947 : { (char *)"delete_gpgme_conf_arg", _wrap_delete_gpgme_conf_arg, METH_VARARGS, (char *)"delete_gpgme_conf_arg(self)"},
45948 : { (char *)"gpgme_conf_arg_swigregister", gpgme_conf_arg_swigregister, METH_VARARGS, NULL},
45949 : { (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)"},
45950 : { (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"},
45951 : { (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)"},
45952 : { (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"},
45953 : { (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)"},
45954 : { (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"},
45955 : { (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)"},
45956 : { (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 *"},
45957 : { (char *)"new_gpgme_conf_arg_value", _wrap_new_gpgme_conf_arg_value, METH_VARARGS, (char *)"new_gpgme_conf_arg_value() -> gpgme_conf_arg_value"},
45958 : { (char *)"delete_gpgme_conf_arg_value", _wrap_delete_gpgme_conf_arg_value, METH_VARARGS, (char *)"delete_gpgme_conf_arg_value(self)"},
45959 : { (char *)"gpgme_conf_arg_value_swigregister", gpgme_conf_arg_value_swigregister, METH_VARARGS, NULL},
45960 : { (char *)"gpgme_conf_opt_name_set", _wrap_gpgme_conf_opt_name_set, METH_VARARGS, (char *)"gpgme_conf_opt_name_set(self, name)"},
45961 : { (char *)"gpgme_conf_opt_name_get", _wrap_gpgme_conf_opt_name_get, METH_VARARGS, (char *)"gpgme_conf_opt_name_get(self) -> char *"},
45962 : { (char *)"gpgme_conf_opt_flags_set", _wrap_gpgme_conf_opt_flags_set, METH_VARARGS, (char *)"gpgme_conf_opt_flags_set(self, flags)"},
45963 : { (char *)"gpgme_conf_opt_flags_get", _wrap_gpgme_conf_opt_flags_get, METH_VARARGS, (char *)"gpgme_conf_opt_flags_get(self) -> unsigned int"},
45964 : { (char *)"gpgme_conf_opt_level_set", _wrap_gpgme_conf_opt_level_set, METH_VARARGS, (char *)"gpgme_conf_opt_level_set(self, level)"},
45965 : { (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"},
45966 : { (char *)"gpgme_conf_opt_description_set", _wrap_gpgme_conf_opt_description_set, METH_VARARGS, (char *)"gpgme_conf_opt_description_set(self, description)"},
45967 : { (char *)"gpgme_conf_opt_description_get", _wrap_gpgme_conf_opt_description_get, METH_VARARGS, (char *)"gpgme_conf_opt_description_get(self) -> char *"},
45968 : { (char *)"gpgme_conf_opt_type_set", _wrap_gpgme_conf_opt_type_set, METH_VARARGS, (char *)"gpgme_conf_opt_type_set(self, type)"},
45969 : { (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"},
45970 : { (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)"},
45971 : { (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"},
45972 : { (char *)"gpgme_conf_opt_argname_set", _wrap_gpgme_conf_opt_argname_set, METH_VARARGS, (char *)"gpgme_conf_opt_argname_set(self, argname)"},
45973 : { (char *)"gpgme_conf_opt_argname_get", _wrap_gpgme_conf_opt_argname_get, METH_VARARGS, (char *)"gpgme_conf_opt_argname_get(self) -> char *"},
45974 : { (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)"},
45975 : { (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"},
45976 : { (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)"},
45977 : { (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 *"},
45978 : { (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)"},
45979 : { (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"},
45980 : { (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)"},
45981 : { (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 *"},
45982 : { (char *)"gpgme_conf_opt_value_set", _wrap_gpgme_conf_opt_value_set, METH_VARARGS, (char *)"gpgme_conf_opt_value_set(self, value)"},
45983 : { (char *)"gpgme_conf_opt_value_get", _wrap_gpgme_conf_opt_value_get, METH_VARARGS, (char *)"gpgme_conf_opt_value_get(self) -> gpgme_conf_arg"},
45984 : { (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)"},
45985 : { (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"},
45986 : { (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)"},
45987 : { (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"},
45988 : { (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)"},
45989 : { (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 *"},
45990 : { (char *)"new_gpgme_conf_opt", _wrap_new_gpgme_conf_opt, METH_VARARGS, (char *)"new_gpgme_conf_opt() -> gpgme_conf_opt"},
45991 : { (char *)"delete_gpgme_conf_opt", _wrap_delete_gpgme_conf_opt, METH_VARARGS, (char *)"delete_gpgme_conf_opt(self)"},
45992 : { (char *)"gpgme_conf_opt_swigregister", gpgme_conf_opt_swigregister, METH_VARARGS, NULL},
45993 : { (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)"},
45994 : { (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 *"},
45995 : { (char *)"gpgme_conf_comp_name_set", _wrap_gpgme_conf_comp_name_set, METH_VARARGS, (char *)"gpgme_conf_comp_name_set(self, name)"},
45996 : { (char *)"gpgme_conf_comp_name_get", _wrap_gpgme_conf_comp_name_get, METH_VARARGS, (char *)"gpgme_conf_comp_name_get(self) -> char *"},
45997 : { (char *)"gpgme_conf_comp_description_set", _wrap_gpgme_conf_comp_description_set, METH_VARARGS, (char *)"gpgme_conf_comp_description_set(self, description)"},
45998 : { (char *)"gpgme_conf_comp_description_get", _wrap_gpgme_conf_comp_description_get, METH_VARARGS, (char *)"gpgme_conf_comp_description_get(self) -> char *"},
45999 : { (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)"},
46000 : { (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 *"},
46001 : { (char *)"gpgme_conf_comp_options_set", _wrap_gpgme_conf_comp_options_set, METH_VARARGS, (char *)"gpgme_conf_comp_options_set(self, options)"},
46002 : { (char *)"gpgme_conf_comp_options_get", _wrap_gpgme_conf_comp_options_get, METH_VARARGS, (char *)"gpgme_conf_comp_options_get(self) -> gpgme_conf_opt"},
46003 : { (char *)"new_gpgme_conf_comp", _wrap_new_gpgme_conf_comp, METH_VARARGS, (char *)"new_gpgme_conf_comp() -> gpgme_conf_comp"},
46004 : { (char *)"delete_gpgme_conf_comp", _wrap_delete_gpgme_conf_comp, METH_VARARGS, (char *)"delete_gpgme_conf_comp(self)"},
46005 : { (char *)"gpgme_conf_comp_swigregister", gpgme_conf_comp_swigregister, METH_VARARGS, NULL},
46006 : { (char *)"gpgme_conf_arg_new", _wrap_gpgme_conf_arg_new, METH_VARARGS, (char *)"gpgme_conf_arg_new(arg_p, type, value) -> gpgme_error_t"},
46007 : { (char *)"gpgme_conf_arg_release", _wrap_gpgme_conf_arg_release, METH_VARARGS, (char *)"gpgme_conf_arg_release(arg, type)"},
46008 : { (char *)"gpgme_conf_opt_change", _wrap_gpgme_conf_opt_change, METH_VARARGS, (char *)"gpgme_conf_opt_change(opt, reset, arg) -> gpgme_error_t"},
46009 : { (char *)"gpgme_conf_release", _wrap_gpgme_conf_release, METH_VARARGS, (char *)"gpgme_conf_release(conf)"},
46010 : { (char *)"gpgme_op_conf_load", _wrap_gpgme_op_conf_load, METH_VARARGS, (char *)"gpgme_op_conf_load(ctx, conf_p) -> gpgme_error_t"},
46011 : { (char *)"gpgme_op_conf_save", _wrap_gpgme_op_conf_save, METH_VARARGS, (char *)"gpgme_op_conf_save(ctx, comp) -> gpgme_error_t"},
46012 : { (char *)"gpgme_op_conf_dir", _wrap_gpgme_op_conf_dir, METH_VARARGS, (char *)"gpgme_op_conf_dir(ctx, what, result) -> gpgme_error_t"},
46013 : { (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)"},
46014 : { (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 *"},
46015 : { (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)"},
46016 : { (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 *"},
46017 : { (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)"},
46018 : { (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"},
46019 : { (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)"},
46020 : { (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"},
46021 : { (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)"},
46022 : { (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"},
46023 : { (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)"},
46024 : { (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"},
46025 : { (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)"},
46026 : { (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"},
46027 : { (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)"},
46028 : { (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"},
46029 : { (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)"},
46030 : { (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"},
46031 : { (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)"},
46032 : { (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"},
46033 : { (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)"},
46034 : { (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"},
46035 : { (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)"},
46036 : { (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"},
46037 : { (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)"},
46038 : { (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 *"},
46039 : { (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)"},
46040 : { (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"},
46041 : { (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"},
46042 : { (char *)"delete__gpgme_op_query_swdb_result", _wrap_delete__gpgme_op_query_swdb_result, METH_VARARGS, (char *)"delete__gpgme_op_query_swdb_result(self)"},
46043 : { (char *)"_gpgme_op_query_swdb_result_swigregister", _gpgme_op_query_swdb_result_swigregister, METH_VARARGS, NULL},
46044 : { (char *)"gpgme_op_query_swdb", _wrap_gpgme_op_query_swdb, METH_VARARGS, (char *)"gpgme_op_query_swdb(ctx, name, iversion, reserved) -> gpgme_error_t"},
46045 : { (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"},
46046 : { (char *)"gpgme_set_global_flag", _wrap_gpgme_set_global_flag, METH_VARARGS, (char *)"gpgme_set_global_flag(name, value) -> int"},
46047 : { (char *)"gpgme_check_version", _wrap_gpgme_check_version, METH_VARARGS, (char *)"gpgme_check_version(req_version) -> char const *"},
46048 : { (char *)"gpgme_check_version_internal", _wrap_gpgme_check_version_internal, METH_VARARGS, (char *)"gpgme_check_version_internal(req_version, offset_sig_validity) -> char const *"},
46049 : { (char *)"gpgme_get_dirinfo", _wrap_gpgme_get_dirinfo, METH_VARARGS, (char *)"gpgme_get_dirinfo(what) -> char const *"},
46050 : { (char *)"gpgme_get_engine_info", _wrap_gpgme_get_engine_info, METH_VARARGS, (char *)"gpgme_get_engine_info(engine_info) -> gpgme_error_t"},
46051 : { (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"},
46052 : { (char *)"gpgme_engine_check_version", _wrap_gpgme_engine_check_version, METH_VARARGS, (char *)"gpgme_engine_check_version(proto) -> gpgme_error_t"},
46053 : { (char *)"gpgme_result_ref", _wrap_gpgme_result_ref, METH_VARARGS, (char *)"gpgme_result_ref(result)"},
46054 : { (char *)"gpgme_result_unref", _wrap_gpgme_result_unref, METH_VARARGS, (char *)"gpgme_result_unref(result)"},
46055 : { (char *)"gpgme_pubkey_algo_string", _wrap_gpgme_pubkey_algo_string, METH_VARARGS, (char *)"gpgme_pubkey_algo_string(subkey) -> char *"},
46056 : { (char *)"gpgme_pubkey_algo_name", _wrap_gpgme_pubkey_algo_name, METH_VARARGS, (char *)"gpgme_pubkey_algo_name(algo) -> char const *"},
46057 : { (char *)"gpgme_hash_algo_name", _wrap_gpgme_hash_algo_name, METH_VARARGS, (char *)"gpgme_hash_algo_name(algo) -> char const *"},
46058 : { (char *)"gpgme_addrspec_from_uid", _wrap_gpgme_addrspec_from_uid, METH_VARARGS, (char *)"gpgme_addrspec_from_uid(uid) -> char *"},
46059 : { (char *)"gpgme_op_edit_start", _wrap_gpgme_op_edit_start, METH_VARARGS, (char *)"gpgme_op_edit_start(ctx, key, fnc, fnc_value, out) -> gpgme_error_t"},
46060 : { (char *)"gpgme_op_edit", _wrap_gpgme_op_edit, METH_VARARGS, (char *)"gpgme_op_edit(ctx, key, fnc, fnc_value, out) -> gpgme_error_t"},
46061 : { (char *)"gpgme_op_card_edit_start", _wrap_gpgme_op_card_edit_start, METH_VARARGS, (char *)"gpgme_op_card_edit_start(ctx, key, fnc, fnc_value, out) -> gpgme_error_t"},
46062 : { (char *)"gpgme_op_card_edit", _wrap_gpgme_op_card_edit, METH_VARARGS, (char *)"gpgme_op_card_edit(ctx, key, fnc, fnc_value, out) -> gpgme_error_t"},
46063 : { (char *)"gpgme_get_sig_status", _wrap_gpgme_get_sig_status, METH_VARARGS, (char *)"gpgme_get_sig_status(ctx, idx, r_stat, r_created) -> char const *"},
46064 : { (char *)"gpgme_get_sig_ulong_attr", _wrap_gpgme_get_sig_ulong_attr, METH_VARARGS, (char *)"gpgme_get_sig_ulong_attr(c, idx, what, whatidx) -> unsigned long"},
46065 : { (char *)"gpgme_get_sig_string_attr", _wrap_gpgme_get_sig_string_attr, METH_VARARGS, (char *)"gpgme_get_sig_string_attr(c, idx, what, whatidx) -> char const *"},
46066 : { (char *)"gpgme_get_sig_key", _wrap_gpgme_get_sig_key, METH_VARARGS, (char *)"gpgme_get_sig_key(ctx, idx, r_key) -> gpgme_error_t"},
46067 : { (char *)"gpgme_data_new_with_read_cb", _wrap_gpgme_data_new_with_read_cb, METH_VARARGS, (char *)"gpgme_data_new_with_read_cb(r_dh, read_cb, read_cb_value) -> gpgme_error_t"},
46068 : { (char *)"gpgme_key_get_string_attr", _wrap_gpgme_key_get_string_attr, METH_VARARGS, (char *)"gpgme_key_get_string_attr(key, what, reserved, idx) -> char const *"},
46069 : { (char *)"gpgme_key_get_ulong_attr", _wrap_gpgme_key_get_ulong_attr, METH_VARARGS, (char *)"gpgme_key_get_ulong_attr(key, what, reserved, idx) -> unsigned long"},
46070 : { (char *)"gpgme_key_sig_get_string_attr", _wrap_gpgme_key_sig_get_string_attr, METH_VARARGS, (char *)"gpgme_key_sig_get_string_attr(key, uid_idx, what, reserved, idx) -> char const *"},
46071 : { (char *)"gpgme_key_sig_get_ulong_attr", _wrap_gpgme_key_sig_get_ulong_attr, METH_VARARGS, (char *)"gpgme_key_sig_get_ulong_attr(key, uid_idx, what, reserved, idx) -> unsigned long"},
46072 : { (char *)"gpgme_op_import_ext", _wrap_gpgme_op_import_ext, METH_VARARGS, (char *)"gpgme_op_import_ext(ctx, keydata, nr) -> gpgme_error_t"},
46073 : { (char *)"gpgme_trust_item_release", _wrap_gpgme_trust_item_release, METH_VARARGS, (char *)"gpgme_trust_item_release(item)"},
46074 : { (char *)"gpgme_trust_item_get_string_attr", _wrap_gpgme_trust_item_get_string_attr, METH_VARARGS, (char *)"gpgme_trust_item_get_string_attr(item, what, reserved, idx) -> char const *"},
46075 : { (char *)"gpgme_trust_item_get_int_attr", _wrap_gpgme_trust_item_get_int_attr, METH_VARARGS, (char *)"gpgme_trust_item_get_int_attr(item, what, reserved, idx) -> int"},
46076 : { (char *)"_gpgme_op_assuan_result_err_set", _wrap__gpgme_op_assuan_result_err_set, METH_VARARGS, (char *)"_gpgme_op_assuan_result_err_set(self, err)"},
46077 : { (char *)"_gpgme_op_assuan_result_err_get", _wrap__gpgme_op_assuan_result_err_get, METH_VARARGS, (char *)"_gpgme_op_assuan_result_err_get(self) -> gpgme_error_t"},
46078 : { (char *)"new__gpgme_op_assuan_result", _wrap_new__gpgme_op_assuan_result, METH_VARARGS, (char *)"new__gpgme_op_assuan_result() -> _gpgme_op_assuan_result"},
46079 : { (char *)"delete__gpgme_op_assuan_result", _wrap_delete__gpgme_op_assuan_result, METH_VARARGS, (char *)"delete__gpgme_op_assuan_result(self)"},
46080 : { (char *)"_gpgme_op_assuan_result_swigregister", _gpgme_op_assuan_result_swigregister, METH_VARARGS, NULL},
46081 : { (char *)"gpgme_op_assuan_result", _wrap_gpgme_op_assuan_result, METH_VARARGS, (char *)"gpgme_op_assuan_result(ctx) -> _gpgme_op_assuan_result"},
46082 : { (char *)"gpgme_op_assuan_transact", _wrap_gpgme_op_assuan_transact, METH_VARARGS, (char *)"gpgme_op_assuan_transact(ctx, command, data_cb, inq_cb, status_cb, status_cb_value) -> gpgme_error_t"},
46083 : { (char *)"new_gpgme_ctx_t_p", _wrap_new_gpgme_ctx_t_p, METH_VARARGS, (char *)"new_gpgme_ctx_t_p() -> gpgme_ctx_t *"},
46084 : { (char *)"copy_gpgme_ctx_t_p", _wrap_copy_gpgme_ctx_t_p, METH_VARARGS, (char *)"copy_gpgme_ctx_t_p(value) -> gpgme_ctx_t *"},
46085 : { (char *)"delete_gpgme_ctx_t_p", _wrap_delete_gpgme_ctx_t_p, METH_VARARGS, (char *)"delete_gpgme_ctx_t_p(obj)"},
46086 : { (char *)"gpgme_ctx_t_p_assign", _wrap_gpgme_ctx_t_p_assign, METH_VARARGS, (char *)"gpgme_ctx_t_p_assign(obj, value)"},
46087 : { (char *)"gpgme_ctx_t_p_value", _wrap_gpgme_ctx_t_p_value, METH_VARARGS, (char *)"gpgme_ctx_t_p_value(obj) -> gpgme_ctx_t"},
46088 : { (char *)"new_gpgme_data_t_p", _wrap_new_gpgme_data_t_p, METH_VARARGS, (char *)"new_gpgme_data_t_p() -> gpgme_data_t *"},
46089 : { (char *)"copy_gpgme_data_t_p", _wrap_copy_gpgme_data_t_p, METH_VARARGS, (char *)"copy_gpgme_data_t_p(value) -> gpgme_data_t *"},
46090 : { (char *)"delete_gpgme_data_t_p", _wrap_delete_gpgme_data_t_p, METH_VARARGS, (char *)"delete_gpgme_data_t_p(obj)"},
46091 : { (char *)"gpgme_data_t_p_assign", _wrap_gpgme_data_t_p_assign, METH_VARARGS, (char *)"gpgme_data_t_p_assign(obj, value)"},
46092 : { (char *)"gpgme_data_t_p_value", _wrap_gpgme_data_t_p_value, METH_VARARGS, (char *)"gpgme_data_t_p_value(obj) -> gpgme_data_t"},
46093 : { (char *)"new_gpgme_key_t_p", _wrap_new_gpgme_key_t_p, METH_VARARGS, (char *)"new_gpgme_key_t_p() -> gpgme_key_t *"},
46094 : { (char *)"copy_gpgme_key_t_p", _wrap_copy_gpgme_key_t_p, METH_VARARGS, (char *)"copy_gpgme_key_t_p(value) -> gpgme_key_t *"},
46095 : { (char *)"delete_gpgme_key_t_p", _wrap_delete_gpgme_key_t_p, METH_VARARGS, (char *)"delete_gpgme_key_t_p(obj)"},
46096 : { (char *)"gpgme_key_t_p_assign", _wrap_gpgme_key_t_p_assign, METH_VARARGS, (char *)"gpgme_key_t_p_assign(obj, value)"},
46097 : { (char *)"gpgme_key_t_p_value", _wrap_gpgme_key_t_p_value, METH_VARARGS, (char *)"gpgme_key_t_p_value(obj) -> _gpgme_key"},
46098 : { (char *)"new_gpgme_error_t_p", _wrap_new_gpgme_error_t_p, METH_VARARGS, (char *)"new_gpgme_error_t_p() -> gpgme_error_t *"},
46099 : { (char *)"copy_gpgme_error_t_p", _wrap_copy_gpgme_error_t_p, METH_VARARGS, (char *)"copy_gpgme_error_t_p(value) -> gpgme_error_t *"},
46100 : { (char *)"delete_gpgme_error_t_p", _wrap_delete_gpgme_error_t_p, METH_VARARGS, (char *)"delete_gpgme_error_t_p(obj)"},
46101 : { (char *)"gpgme_error_t_p_assign", _wrap_gpgme_error_t_p_assign, METH_VARARGS, (char *)"gpgme_error_t_p_assign(obj, value)"},
46102 : { (char *)"gpgme_error_t_p_value", _wrap_gpgme_error_t_p_value, METH_VARARGS, (char *)"gpgme_error_t_p_value(obj) -> gpgme_error_t"},
46103 : { (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 *"},
46104 : { (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 *"},
46105 : { (char *)"delete_gpgme_trust_item_t_p", _wrap_delete_gpgme_trust_item_t_p, METH_VARARGS, (char *)"delete_gpgme_trust_item_t_p(obj)"},
46106 : { (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)"},
46107 : { (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"},
46108 : { (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 *"},
46109 : { (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 *"},
46110 : { (char *)"delete_gpgme_engine_info_t_p", _wrap_delete_gpgme_engine_info_t_p, METH_VARARGS, (char *)"delete_gpgme_engine_info_t_p(obj)"},
46111 : { (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)"},
46112 : { (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"},
46113 : { (char *)"fdopen", _wrap_fdopen, METH_VARARGS, (char *)"fdopen(fildes, mode) -> FILE *"},
46114 : { (char *)"gpg_raise_callback_exception", _wrap_gpg_raise_callback_exception, METH_VARARGS, (char *)"gpg_raise_callback_exception(arg1) -> PyObject *"},
46115 : { (char *)"gpg_set_passphrase_cb", _wrap_gpg_set_passphrase_cb, METH_VARARGS, (char *)"gpg_set_passphrase_cb(arg1, cb) -> PyObject *"},
46116 : { (char *)"gpg_set_progress_cb", _wrap_gpg_set_progress_cb, METH_VARARGS, (char *)"gpg_set_progress_cb(arg1, cb) -> PyObject *"},
46117 : { (char *)"gpg_set_status_cb", _wrap_gpg_set_status_cb, METH_VARARGS, (char *)"gpg_set_status_cb(arg1, cb) -> PyObject *"},
46118 : { (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 *"},
46119 : { NULL, NULL, 0, NULL }
46120 : };
46121 :
46122 :
46123 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46124 :
46125 : static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
46126 : static swig_type_info _swigt__p__gpgme_attr_t = {"_p__gpgme_attr_t", "enum _gpgme_attr_t *|_gpgme_attr_t *|gpgme_attr_t *|GpgmeAttr *", 0, 0, (void*)0, 0};
46127 : 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};
46128 : 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};
46129 : 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};
46130 : static swig_type_info _swigt__p__gpgme_key = {"_p__gpgme_key", "struct _gpgme_key *|_gpgme_key *|gpgme_key_t", 0, 0, (void*)0, 0};
46131 : 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};
46132 : 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};
46133 : static swig_type_info _swigt__p__gpgme_op_assuan_result = {"_p__gpgme_op_assuan_result", "struct _gpgme_op_assuan_result *|_gpgme_op_assuan_result *|gpgme_assuan_result_t", 0, 0, (void*)0, 0};
46134 : 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};
46135 : 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};
46136 : 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};
46137 : 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};
46138 : 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};
46139 : 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};
46140 : 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};
46141 : 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};
46142 : 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};
46143 : static swig_type_info _swigt__p__gpgme_recipient = {"_p__gpgme_recipient", "gpgme_recipient_t|struct _gpgme_recipient *|_gpgme_recipient *", 0, 0, (void*)0, 0};
46144 : 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};
46145 : static swig_type_info _swigt__p__gpgme_sig_stat_t = {"_p__gpgme_sig_stat_t", "GpgmeSigStat *|enum _gpgme_sig_stat_t *|_gpgme_sig_stat_t *|gpgme_sig_stat_t *", 0, 0, (void*)0, 0};
46146 : static swig_type_info _swigt__p__gpgme_signature = {"_p__gpgme_signature", "struct _gpgme_signature *|_gpgme_signature *|gpgme_signature_t", 0, 0, (void*)0, 0};
46147 : static swig_type_info _swigt__p__gpgme_subkey = {"_p__gpgme_subkey", "struct _gpgme_subkey *|_gpgme_subkey *|gpgme_subkey_t", 0, 0, (void*)0, 0};
46148 : 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};
46149 : 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};
46150 : 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};
46151 : 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};
46152 : static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
46153 : 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};
46154 : 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};
46155 : static swig_type_info _swigt__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t = {"_p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t", "gpgme_edit_cb_t|gpg_error_t (*)(void *,enum gpgme_status_code_t,char const *,int)", 0, 0, (void*)0, 0};
46156 : 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};
46157 : 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};
46158 : static swig_type_info _swigt__p_f_p_void_p_char_size_t_p_size_t__int = {"_p_f_p_void_p_char_size_t_p_size_t__int", "int (*)(void *,char *,size_t,size_t *)", 0, 0, (void*)0, 0};
46159 : 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};
46160 : 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};
46161 : 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};
46162 : 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};
46163 : 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};
46164 : 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};
46165 : 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};
46166 : 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};
46167 : 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};
46168 : 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};
46169 : static swig_type_info _swigt__p_gpg_error_t = {"_p_gpg_error_t", "GpgmeError *|gpg_error_t *|gpgme_error_t *", 0, 0, (void*)0, 0};
46170 : 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};
46171 : static swig_type_info _swigt__p_gpgme_conf_arg_value = {"_p_gpgme_conf_arg_value", "gpgme_conf_arg_value *", 0, 0, (void*)0, 0};
46172 : 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};
46173 : 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};
46174 : 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};
46175 : 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};
46176 : static swig_type_info _swigt__p_gpgme_context = {"_p_gpgme_context", "gpgme_ctx_t|struct gpgme_context *", 0, 0, (void*)0, 0};
46177 : static swig_type_info _swigt__p_gpgme_data = {"_p_gpgme_data", "struct gpgme_data *|gpgme_data_t", 0, 0, (void*)0, 0};
46178 : 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};
46179 : static swig_type_info _swigt__p_gpgme_data_encoding_t = {"_p_gpgme_data_encoding_t", "GpgmeDataEncoding *|enum gpgme_data_encoding_t *|gpgme_data_encoding_t *", 0, 0, (void*)0, 0};
46180 : 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};
46181 : static swig_type_info _swigt__p_gpgme_decrypt_flags_t = {"_p_gpgme_decrypt_flags_t", "enum gpgme_decrypt_flags_t *|gpgme_decrypt_flags_t *", 0, 0, (void*)0, 0};
46182 : 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};
46183 : static swig_type_info _swigt__p_gpgme_event_io_t = {"_p_gpgme_event_io_t", "enum gpgme_event_io_t *|gpgme_event_io_t *|GpgmeEventIO *", 0, 0, (void*)0, 0};
46184 : static swig_type_info _swigt__p_gpgme_hash_algo_t = {"_p_gpgme_hash_algo_t", "enum gpgme_hash_algo_t *|gpgme_hash_algo_t *|GpgmeHashAlgo *", 0, 0, (void*)0, 0};
46185 : 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};
46186 : 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};
46187 : static swig_type_info _swigt__p_gpgme_keyorg_t = {"_p_gpgme_keyorg_t", "enum gpgme_keyorg_t *|gpgme_keyorg_t *", 0, 0, (void*)0, 0};
46188 : 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};
46189 : static swig_type_info _swigt__p_gpgme_protocol_t = {"_p_gpgme_protocol_t", "enum gpgme_protocol_t *|gpgme_protocol_t *|GpgmeProtocol *", 0, 0, (void*)0, 0};
46190 : static swig_type_info _swigt__p_gpgme_pubkey_algo_t = {"_p_gpgme_pubkey_algo_t", "enum gpgme_pubkey_algo_t *|gpgme_pubkey_algo_t *|GpgmePubKeyAlgo *", 0, 0, (void*)0, 0};
46191 : static swig_type_info _swigt__p_gpgme_sig_mode_t = {"_p_gpgme_sig_mode_t", "GpgmeSigMode *|enum gpgme_sig_mode_t *|gpgme_sig_mode_t *", 0, 0, (void*)0, 0};
46192 : 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};
46193 : static swig_type_info _swigt__p_gpgme_status_code_t = {"_p_gpgme_status_code_t", "enum gpgme_status_code_t *|gpgme_status_code_t *|GpgmeStatusCode *", 0, 0, (void*)0, 0};
46194 : 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};
46195 : static swig_type_info _swigt__p_gpgme_validity_t = {"_p_gpgme_validity_t", "GpgmeValidity *|enum gpgme_validity_t *|gpgme_validity_t *", 0, 0, (void*)0, 0};
46196 : static swig_type_info _swigt__p_gpgrt_stream_t = {"_p_gpgrt_stream_t", "gpgrt_stream_t *", 0, 0, (void*)0, 0};
46197 : static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
46198 : static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *|gpgme_off_t *", 0, 0, (void*)0, 0};
46199 : static swig_type_info _swigt__p_p__gpgme_engine_info = {"_p_p__gpgme_engine_info", "GpgmeEngineInfo *|struct _gpgme_engine_info **|gpgme_engine_info_t *", 0, 0, (void*)0, 0};
46200 : static swig_type_info _swigt__p_p__gpgme_import_status = {"_p_p__gpgme_import_status", "struct _gpgme_import_status **|GpgmeImportStatus *", 0, 0, (void*)0, 0};
46201 : static swig_type_info _swigt__p_p__gpgme_key = {"_p_p__gpgme_key", "struct _gpgme_key **|GpgmeKey *|gpgme_key_t *", 0, 0, (void*)0, 0};
46202 : static swig_type_info _swigt__p_p__gpgme_key_sig = {"_p_p__gpgme_key_sig", "struct _gpgme_key_sig **|GpgmeKeySig *", 0, 0, (void*)0, 0};
46203 : static swig_type_info _swigt__p_p__gpgme_op_encrypt_result = {"_p_p__gpgme_op_encrypt_result", "GpgmeEncryptResult *|struct _gpgme_op_encrypt_result **", 0, 0, (void*)0, 0};
46204 : static swig_type_info _swigt__p_p__gpgme_op_genkey_result = {"_p_p__gpgme_op_genkey_result", "GpgmeGenKeyResult *|struct _gpgme_op_genkey_result **", 0, 0, (void*)0, 0};
46205 : static swig_type_info _swigt__p_p__gpgme_op_import_result = {"_p_p__gpgme_op_import_result", "GpgmeImportResult *|struct _gpgme_op_import_result **", 0, 0, (void*)0, 0};
46206 : static swig_type_info _swigt__p_p__gpgme_op_verify_result = {"_p_p__gpgme_op_verify_result", "GpgmeVerifyResult *|struct _gpgme_op_verify_result **", 0, 0, (void*)0, 0};
46207 : static swig_type_info _swigt__p_p__gpgme_sig_notation = {"_p_p__gpgme_sig_notation", "struct _gpgme_sig_notation **|GpgmeSigNotation *", 0, 0, (void*)0, 0};
46208 : static swig_type_info _swigt__p_p__gpgme_signature = {"_p_p__gpgme_signature", "GpgmeSignature *|struct _gpgme_signature **", 0, 0, (void*)0, 0};
46209 : static swig_type_info _swigt__p_p__gpgme_subkey = {"_p_p__gpgme_subkey", "GpgmeSubkey *|struct _gpgme_subkey **", 0, 0, (void*)0, 0};
46210 : static swig_type_info _swigt__p_p__gpgme_trust_item = {"_p_p__gpgme_trust_item", "struct _gpgme_trust_item **|GpgmeTrustItem *|gpgme_trust_item_t *", 0, 0, (void*)0, 0};
46211 : static swig_type_info _swigt__p_p__gpgme_user_id = {"_p_p__gpgme_user_id", "struct _gpgme_user_id **|GpgmeUserID *", 0, 0, (void*)0, 0};
46212 : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
46213 : static swig_type_info _swigt__p_p_f_p_void__void = {"_p_p_f_p_void__void", "GpgmeDataReleaseCb *|void (**)(void *)|GpgmeRemoveIOCb *", 0, 0, (void*)0, 0};
46214 : static swig_type_info _swigt__p_p_f_p_void_enum_gpgme_event_io_t_p_void__void = {"_p_p_f_p_void_enum_gpgme_event_io_t_p_void__void", "GpgmeEventIOCb *|void (**)(void *,enum gpgme_event_io_t,void *)", 0, 0, (void*)0, 0};
46215 : static swig_type_info _swigt__p_p_f_p_void_int__gpg_error_t = {"_p_p_f_p_void_int__gpg_error_t", "gpg_error_t (**)(void *,int)|GpgmeIOCb *", 0, 0, (void*)0, 0};
46216 : static swig_type_info _swigt__p_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t = {"_p_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 **)|GpgmeRegisterIOCb *", 0, 0, (void*)0, 0};
46217 : static swig_type_info _swigt__p_p_f_p_void_off_t_int__off_t = {"_p_p_f_p_void_off_t_int__off_t", "off_t (**)(void *,off_t,int)|GpgmeDataSeekCb *", 0, 0, (void*)0, 0};
46218 : 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", "GpgmeProgressCb *|void (**)(void *,char const *,int,int,int)|gpgme_progress_cb_t *", 0, 0, (void*)0, 0};
46219 : 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};
46220 : 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", "GpgmePassphraseCb *|gpg_error_t (**)(void *,char const *,char const *,int,int)|gpgme_passphrase_cb_t *", 0, 0, (void*)0, 0};
46221 : static swig_type_info _swigt__p_p_f_p_void_p_q_const__void_size_t__ssize_t = {"_p_p_f_p_void_p_q_const__void_size_t__ssize_t", "ssize_t (**)(void *,void const *,size_t)|GpgmeDataWriteCb *", 0, 0, (void*)0, 0};
46222 : static swig_type_info _swigt__p_p_f_p_void_p_void_size_t__ssize_t = {"_p_p_f_p_void_p_void_size_t__ssize_t", "ssize_t (**)(void *,void *,size_t)|GpgmeDataReadCb *", 0, 0, (void*)0, 0};
46223 : 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};
46224 : 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};
46225 : 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};
46226 : static swig_type_info _swigt__p_p_gpgme_context = {"_p_p_gpgme_context", "gpgme_ctx_t *|struct gpgme_context **|GpgmeCtx *", 0, 0, (void*)0, 0};
46227 : static swig_type_info _swigt__p_p_gpgme_data = {"_p_p_gpgme_data", "gpgme_data_t *|GpgmeData *|struct gpgme_data **", 0, 0, (void*)0, 0};
46228 : static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
46229 : static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
46230 : static swig_type_info _swigt__p_ssize_t = {"_p_ssize_t", "ssize_t *|gpgme_ssize_t *", 0, 0, (void*)0, 0};
46231 : static swig_type_info _swigt__p_time_t = {"_p_time_t", "time_t *", 0, 0, (void*)0, 0};
46232 : 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};
46233 : static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
46234 :
46235 : static swig_type_info *swig_type_initial[] = {
46236 : &_swigt__p_FILE,
46237 : &_swigt__p__gpgme_attr_t,
46238 : &_swigt__p__gpgme_engine_info,
46239 : &_swigt__p__gpgme_import_status,
46240 : &_swigt__p__gpgme_invalid_key,
46241 : &_swigt__p__gpgme_key,
46242 : &_swigt__p__gpgme_key_sig,
46243 : &_swigt__p__gpgme_new_signature,
46244 : &_swigt__p__gpgme_op_assuan_result,
46245 : &_swigt__p__gpgme_op_decrypt_result,
46246 : &_swigt__p__gpgme_op_encrypt_result,
46247 : &_swigt__p__gpgme_op_genkey_result,
46248 : &_swigt__p__gpgme_op_import_result,
46249 : &_swigt__p__gpgme_op_keylist_result,
46250 : &_swigt__p__gpgme_op_query_swdb_result,
46251 : &_swigt__p__gpgme_op_sign_result,
46252 : &_swigt__p__gpgme_op_verify_result,
46253 : &_swigt__p__gpgme_op_vfs_mount_result,
46254 : &_swigt__p__gpgme_recipient,
46255 : &_swigt__p__gpgme_sig_notation,
46256 : &_swigt__p__gpgme_sig_stat_t,
46257 : &_swigt__p__gpgme_signature,
46258 : &_swigt__p__gpgme_subkey,
46259 : &_swigt__p__gpgme_tofu_info,
46260 : &_swigt__p__gpgme_trust_item,
46261 : &_swigt__p__gpgme_user_id,
46262 : &_swigt__p_a___p__gpgme_key,
46263 : &_swigt__p_char,
46264 : &_swigt__p_f_p_void__void,
46265 : &_swigt__p_f_p_void_enum_gpgme_event_io_t_p_void__void,
46266 : &_swigt__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t,
46267 : &_swigt__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t,
46268 : &_swigt__p_f_p_void_off_t_int__off_t,
46269 : &_swigt__p_f_p_void_p_char_size_t_p_size_t__int,
46270 : &_swigt__p_f_p_void_p_q_const__char_int_int_int__void,
46271 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
46272 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t,
46273 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
46274 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t,
46275 : &_swigt__p_f_p_void_p_q_const__void_size_t__gpg_error_t,
46276 : &_swigt__p_f_p_void_p_q_const__void_size_t__ssize_t,
46277 : &_swigt__p_f_p_void_p_void_size_t__ssize_t,
46278 : &_swigt__p_gpg_err_code_t,
46279 : &_swigt__p_gpg_err_source_t,
46280 : &_swigt__p_gpg_error_t,
46281 : &_swigt__p_gpgme_conf_arg,
46282 : &_swigt__p_gpgme_conf_arg_value,
46283 : &_swigt__p_gpgme_conf_comp,
46284 : &_swigt__p_gpgme_conf_level_t,
46285 : &_swigt__p_gpgme_conf_opt,
46286 : &_swigt__p_gpgme_conf_type_t,
46287 : &_swigt__p_gpgme_context,
46288 : &_swigt__p_gpgme_data,
46289 : &_swigt__p_gpgme_data_cbs,
46290 : &_swigt__p_gpgme_data_encoding_t,
46291 : &_swigt__p_gpgme_data_type_t,
46292 : &_swigt__p_gpgme_decrypt_flags_t,
46293 : &_swigt__p_gpgme_encrypt_flags_t,
46294 : &_swigt__p_gpgme_event_io_t,
46295 : &_swigt__p_gpgme_hash_algo_t,
46296 : &_swigt__p_gpgme_io_cbs,
46297 : &_swigt__p_gpgme_io_event_done_data,
46298 : &_swigt__p_gpgme_keyorg_t,
46299 : &_swigt__p_gpgme_pinentry_mode_t,
46300 : &_swigt__p_gpgme_protocol_t,
46301 : &_swigt__p_gpgme_pubkey_algo_t,
46302 : &_swigt__p_gpgme_sig_mode_t,
46303 : &_swigt__p_gpgme_sigsum_t,
46304 : &_swigt__p_gpgme_status_code_t,
46305 : &_swigt__p_gpgme_tofu_policy_t,
46306 : &_swigt__p_gpgme_validity_t,
46307 : &_swigt__p_gpgrt_stream_t,
46308 : &_swigt__p_int,
46309 : &_swigt__p_off_t,
46310 : &_swigt__p_p__gpgme_engine_info,
46311 : &_swigt__p_p__gpgme_import_status,
46312 : &_swigt__p_p__gpgme_key,
46313 : &_swigt__p_p__gpgme_key_sig,
46314 : &_swigt__p_p__gpgme_op_encrypt_result,
46315 : &_swigt__p_p__gpgme_op_genkey_result,
46316 : &_swigt__p_p__gpgme_op_import_result,
46317 : &_swigt__p_p__gpgme_op_verify_result,
46318 : &_swigt__p_p__gpgme_sig_notation,
46319 : &_swigt__p_p__gpgme_signature,
46320 : &_swigt__p_p__gpgme_subkey,
46321 : &_swigt__p_p__gpgme_trust_item,
46322 : &_swigt__p_p__gpgme_user_id,
46323 : &_swigt__p_p_char,
46324 : &_swigt__p_p_f_p_void__void,
46325 : &_swigt__p_p_f_p_void_enum_gpgme_event_io_t_p_void__void,
46326 : &_swigt__p_p_f_p_void_int__gpg_error_t,
46327 : &_swigt__p_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t,
46328 : &_swigt__p_p_f_p_void_off_t_int__off_t,
46329 : &_swigt__p_p_f_p_void_p_q_const__char_int_int_int__void,
46330 : &_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
46331 : &_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
46332 : &_swigt__p_p_f_p_void_p_q_const__void_size_t__ssize_t,
46333 : &_swigt__p_p_f_p_void_p_void_size_t__ssize_t,
46334 : &_swigt__p_p_gpgme_conf_arg,
46335 : &_swigt__p_p_gpgme_conf_comp,
46336 : &_swigt__p_p_gpgme_conf_opt,
46337 : &_swigt__p_p_gpgme_context,
46338 : &_swigt__p_p_gpgme_data,
46339 : &_swigt__p_p_void,
46340 : &_swigt__p_size_t,
46341 : &_swigt__p_ssize_t,
46342 : &_swigt__p_time_t,
46343 : &_swigt__p_unsigned_int,
46344 : &_swigt__p_void,
46345 : };
46346 :
46347 : static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
46348 : static swig_cast_info _swigc__p__gpgme_attr_t[] = { {&_swigt__p__gpgme_attr_t, 0, 0, 0},{0, 0, 0, 0}};
46349 : static swig_cast_info _swigc__p__gpgme_engine_info[] = { {&_swigt__p__gpgme_engine_info, 0, 0, 0},{0, 0, 0, 0}};
46350 : static swig_cast_info _swigc__p__gpgme_import_status[] = { {&_swigt__p__gpgme_import_status, 0, 0, 0},{0, 0, 0, 0}};
46351 : static swig_cast_info _swigc__p__gpgme_invalid_key[] = { {&_swigt__p__gpgme_invalid_key, 0, 0, 0},{0, 0, 0, 0}};
46352 : static swig_cast_info _swigc__p__gpgme_key[] = { {&_swigt__p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
46353 : static swig_cast_info _swigc__p__gpgme_key_sig[] = { {&_swigt__p__gpgme_key_sig, 0, 0, 0},{0, 0, 0, 0}};
46354 : static swig_cast_info _swigc__p__gpgme_new_signature[] = { {&_swigt__p__gpgme_new_signature, 0, 0, 0},{0, 0, 0, 0}};
46355 : static swig_cast_info _swigc__p__gpgme_op_assuan_result[] = { {&_swigt__p__gpgme_op_assuan_result, 0, 0, 0},{0, 0, 0, 0}};
46356 : static swig_cast_info _swigc__p__gpgme_op_decrypt_result[] = { {&_swigt__p__gpgme_op_decrypt_result, 0, 0, 0},{0, 0, 0, 0}};
46357 : static swig_cast_info _swigc__p__gpgme_op_encrypt_result[] = { {&_swigt__p__gpgme_op_encrypt_result, 0, 0, 0},{0, 0, 0, 0}};
46358 : static swig_cast_info _swigc__p__gpgme_op_genkey_result[] = { {&_swigt__p__gpgme_op_genkey_result, 0, 0, 0},{0, 0, 0, 0}};
46359 : static swig_cast_info _swigc__p__gpgme_op_import_result[] = { {&_swigt__p__gpgme_op_import_result, 0, 0, 0},{0, 0, 0, 0}};
46360 : static swig_cast_info _swigc__p__gpgme_op_keylist_result[] = { {&_swigt__p__gpgme_op_keylist_result, 0, 0, 0},{0, 0, 0, 0}};
46361 : 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}};
46362 : static swig_cast_info _swigc__p__gpgme_op_sign_result[] = { {&_swigt__p__gpgme_op_sign_result, 0, 0, 0},{0, 0, 0, 0}};
46363 : static swig_cast_info _swigc__p__gpgme_op_verify_result[] = { {&_swigt__p__gpgme_op_verify_result, 0, 0, 0},{0, 0, 0, 0}};
46364 : 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}};
46365 : static swig_cast_info _swigc__p__gpgme_recipient[] = { {&_swigt__p__gpgme_recipient, 0, 0, 0},{0, 0, 0, 0}};
46366 : static swig_cast_info _swigc__p__gpgme_sig_notation[] = { {&_swigt__p__gpgme_sig_notation, 0, 0, 0},{0, 0, 0, 0}};
46367 : static swig_cast_info _swigc__p__gpgme_sig_stat_t[] = { {&_swigt__p__gpgme_sig_stat_t, 0, 0, 0},{0, 0, 0, 0}};
46368 : static swig_cast_info _swigc__p__gpgme_signature[] = { {&_swigt__p__gpgme_signature, 0, 0, 0},{0, 0, 0, 0}};
46369 : static swig_cast_info _swigc__p__gpgme_subkey[] = { {&_swigt__p__gpgme_subkey, 0, 0, 0},{0, 0, 0, 0}};
46370 : static swig_cast_info _swigc__p__gpgme_tofu_info[] = { {&_swigt__p__gpgme_tofu_info, 0, 0, 0},{0, 0, 0, 0}};
46371 : static swig_cast_info _swigc__p__gpgme_trust_item[] = { {&_swigt__p__gpgme_trust_item, 0, 0, 0},{0, 0, 0, 0}};
46372 : static swig_cast_info _swigc__p__gpgme_user_id[] = { {&_swigt__p__gpgme_user_id, 0, 0, 0},{0, 0, 0, 0}};
46373 : static swig_cast_info _swigc__p_a___p__gpgme_key[] = { {&_swigt__p_a___p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
46374 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
46375 : static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
46376 : 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}};
46377 : static swig_cast_info _swigc__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t[] = { {&_swigt__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
46378 : 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}};
46379 : 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}};
46380 : static swig_cast_info _swigc__p_f_p_void_p_char_size_t_p_size_t__int[] = { {&_swigt__p_f_p_void_p_char_size_t_p_size_t__int, 0, 0, 0},{0, 0, 0, 0}};
46381 : 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}};
46382 : 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}};
46383 : 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}};
46384 : 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}};
46385 : 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}};
46386 : 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}};
46387 : 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}};
46388 : 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}};
46389 : static swig_cast_info _swigc__p_gpg_err_code_t[] = { {&_swigt__p_gpg_err_code_t, 0, 0, 0},{0, 0, 0, 0}};
46390 : static swig_cast_info _swigc__p_gpg_err_source_t[] = { {&_swigt__p_gpg_err_source_t, 0, 0, 0},{0, 0, 0, 0}};
46391 : static swig_cast_info _swigc__p_gpg_error_t[] = { {&_swigt__p_gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
46392 : static swig_cast_info _swigc__p_gpgme_conf_arg[] = { {&_swigt__p_gpgme_conf_arg, 0, 0, 0},{0, 0, 0, 0}};
46393 : static swig_cast_info _swigc__p_gpgme_conf_arg_value[] = { {&_swigt__p_gpgme_conf_arg_value, 0, 0, 0},{0, 0, 0, 0}};
46394 : static swig_cast_info _swigc__p_gpgme_conf_comp[] = { {&_swigt__p_gpgme_conf_comp, 0, 0, 0},{0, 0, 0, 0}};
46395 : static swig_cast_info _swigc__p_gpgme_conf_level_t[] = { {&_swigt__p_gpgme_conf_level_t, 0, 0, 0},{0, 0, 0, 0}};
46396 : static swig_cast_info _swigc__p_gpgme_conf_opt[] = { {&_swigt__p_gpgme_conf_opt, 0, 0, 0},{0, 0, 0, 0}};
46397 : static swig_cast_info _swigc__p_gpgme_conf_type_t[] = { {&_swigt__p_gpgme_conf_type_t, 0, 0, 0},{0, 0, 0, 0}};
46398 : static swig_cast_info _swigc__p_gpgme_context[] = { {&_swigt__p_gpgme_context, 0, 0, 0},{0, 0, 0, 0}};
46399 : static swig_cast_info _swigc__p_gpgme_data[] = { {&_swigt__p_gpgme_data, 0, 0, 0},{0, 0, 0, 0}};
46400 : static swig_cast_info _swigc__p_gpgme_data_cbs[] = { {&_swigt__p_gpgme_data_cbs, 0, 0, 0},{0, 0, 0, 0}};
46401 : static swig_cast_info _swigc__p_gpgme_data_encoding_t[] = { {&_swigt__p_gpgme_data_encoding_t, 0, 0, 0},{0, 0, 0, 0}};
46402 : static swig_cast_info _swigc__p_gpgme_data_type_t[] = { {&_swigt__p_gpgme_data_type_t, 0, 0, 0},{0, 0, 0, 0}};
46403 : static swig_cast_info _swigc__p_gpgme_decrypt_flags_t[] = { {&_swigt__p_gpgme_decrypt_flags_t, 0, 0, 0},{0, 0, 0, 0}};
46404 : static swig_cast_info _swigc__p_gpgme_encrypt_flags_t[] = { {&_swigt__p_gpgme_encrypt_flags_t, 0, 0, 0},{0, 0, 0, 0}};
46405 : static swig_cast_info _swigc__p_gpgme_event_io_t[] = { {&_swigt__p_gpgme_event_io_t, 0, 0, 0},{0, 0, 0, 0}};
46406 : static swig_cast_info _swigc__p_gpgme_hash_algo_t[] = { {&_swigt__p_gpgme_hash_algo_t, 0, 0, 0},{0, 0, 0, 0}};
46407 : static swig_cast_info _swigc__p_gpgme_io_cbs[] = { {&_swigt__p_gpgme_io_cbs, 0, 0, 0},{0, 0, 0, 0}};
46408 : 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}};
46409 : static swig_cast_info _swigc__p_gpgme_keyorg_t[] = { {&_swigt__p_gpgme_keyorg_t, 0, 0, 0},{0, 0, 0, 0}};
46410 : static swig_cast_info _swigc__p_gpgme_pinentry_mode_t[] = { {&_swigt__p_gpgme_pinentry_mode_t, 0, 0, 0},{0, 0, 0, 0}};
46411 : static swig_cast_info _swigc__p_gpgme_protocol_t[] = { {&_swigt__p_gpgme_protocol_t, 0, 0, 0},{0, 0, 0, 0}};
46412 : static swig_cast_info _swigc__p_gpgme_pubkey_algo_t[] = { {&_swigt__p_gpgme_pubkey_algo_t, 0, 0, 0},{0, 0, 0, 0}};
46413 : static swig_cast_info _swigc__p_gpgme_sig_mode_t[] = { {&_swigt__p_gpgme_sig_mode_t, 0, 0, 0},{0, 0, 0, 0}};
46414 : static swig_cast_info _swigc__p_gpgme_sigsum_t[] = { {&_swigt__p_gpgme_sigsum_t, 0, 0, 0},{0, 0, 0, 0}};
46415 : static swig_cast_info _swigc__p_gpgme_status_code_t[] = { {&_swigt__p_gpgme_status_code_t, 0, 0, 0},{0, 0, 0, 0}};
46416 : static swig_cast_info _swigc__p_gpgme_tofu_policy_t[] = { {&_swigt__p_gpgme_tofu_policy_t, 0, 0, 0},{0, 0, 0, 0}};
46417 : static swig_cast_info _swigc__p_gpgme_validity_t[] = { {&_swigt__p_gpgme_validity_t, 0, 0, 0},{0, 0, 0, 0}};
46418 : static swig_cast_info _swigc__p_gpgrt_stream_t[] = { {&_swigt__p_gpgrt_stream_t, 0, 0, 0},{0, 0, 0, 0}};
46419 : static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
46420 : static swig_cast_info _swigc__p_off_t[] = { {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
46421 : static swig_cast_info _swigc__p_p__gpgme_engine_info[] = { {&_swigt__p_p__gpgme_engine_info, 0, 0, 0},{0, 0, 0, 0}};
46422 : static swig_cast_info _swigc__p_p__gpgme_import_status[] = { {&_swigt__p_p__gpgme_import_status, 0, 0, 0},{0, 0, 0, 0}};
46423 : static swig_cast_info _swigc__p_p__gpgme_key[] = { {&_swigt__p_p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
46424 : static swig_cast_info _swigc__p_p__gpgme_key_sig[] = { {&_swigt__p_p__gpgme_key_sig, 0, 0, 0},{0, 0, 0, 0}};
46425 : static swig_cast_info _swigc__p_p__gpgme_op_encrypt_result[] = { {&_swigt__p_p__gpgme_op_encrypt_result, 0, 0, 0},{0, 0, 0, 0}};
46426 : static swig_cast_info _swigc__p_p__gpgme_op_genkey_result[] = { {&_swigt__p_p__gpgme_op_genkey_result, 0, 0, 0},{0, 0, 0, 0}};
46427 : static swig_cast_info _swigc__p_p__gpgme_op_import_result[] = { {&_swigt__p_p__gpgme_op_import_result, 0, 0, 0},{0, 0, 0, 0}};
46428 : static swig_cast_info _swigc__p_p__gpgme_op_verify_result[] = { {&_swigt__p_p__gpgme_op_verify_result, 0, 0, 0},{0, 0, 0, 0}};
46429 : static swig_cast_info _swigc__p_p__gpgme_sig_notation[] = { {&_swigt__p_p__gpgme_sig_notation, 0, 0, 0},{0, 0, 0, 0}};
46430 : static swig_cast_info _swigc__p_p__gpgme_signature[] = { {&_swigt__p_p__gpgme_signature, 0, 0, 0},{0, 0, 0, 0}};
46431 : static swig_cast_info _swigc__p_p__gpgme_subkey[] = { {&_swigt__p_p__gpgme_subkey, 0, 0, 0},{0, 0, 0, 0}};
46432 : static swig_cast_info _swigc__p_p__gpgme_trust_item[] = { {&_swigt__p_p__gpgme_trust_item, 0, 0, 0},{0, 0, 0, 0}};
46433 : static swig_cast_info _swigc__p_p__gpgme_user_id[] = { {&_swigt__p_p__gpgme_user_id, 0, 0, 0},{0, 0, 0, 0}};
46434 : static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
46435 : static swig_cast_info _swigc__p_p_f_p_void__void[] = { {&_swigt__p_p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
46436 : static swig_cast_info _swigc__p_p_f_p_void_enum_gpgme_event_io_t_p_void__void[] = { {&_swigt__p_p_f_p_void_enum_gpgme_event_io_t_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
46437 : static swig_cast_info _swigc__p_p_f_p_void_int__gpg_error_t[] = { {&_swigt__p_p_f_p_void_int__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
46438 : static swig_cast_info _swigc__p_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t[] = { {&_swigt__p_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}};
46439 : static swig_cast_info _swigc__p_p_f_p_void_off_t_int__off_t[] = { {&_swigt__p_p_f_p_void_off_t_int__off_t, 0, 0, 0},{0, 0, 0, 0}};
46440 : 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}};
46441 : 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}};
46442 : 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}};
46443 : static swig_cast_info _swigc__p_p_f_p_void_p_q_const__void_size_t__ssize_t[] = { {&_swigt__p_p_f_p_void_p_q_const__void_size_t__ssize_t, 0, 0, 0},{0, 0, 0, 0}};
46444 : static swig_cast_info _swigc__p_p_f_p_void_p_void_size_t__ssize_t[] = { {&_swigt__p_p_f_p_void_p_void_size_t__ssize_t, 0, 0, 0},{0, 0, 0, 0}};
46445 : static swig_cast_info _swigc__p_p_gpgme_conf_arg[] = { {&_swigt__p_p_gpgme_conf_arg, 0, 0, 0},{0, 0, 0, 0}};
46446 : static swig_cast_info _swigc__p_p_gpgme_conf_comp[] = { {&_swigt__p_p_gpgme_conf_comp, 0, 0, 0},{0, 0, 0, 0}};
46447 : static swig_cast_info _swigc__p_p_gpgme_conf_opt[] = { {&_swigt__p_p_gpgme_conf_opt, 0, 0, 0},{0, 0, 0, 0}};
46448 : static swig_cast_info _swigc__p_p_gpgme_context[] = { {&_swigt__p_p_gpgme_context, 0, 0, 0},{0, 0, 0, 0}};
46449 : static swig_cast_info _swigc__p_p_gpgme_data[] = { {&_swigt__p_p_gpgme_data, 0, 0, 0},{0, 0, 0, 0}};
46450 : static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
46451 : static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
46452 : static swig_cast_info _swigc__p_ssize_t[] = { {&_swigt__p_ssize_t, 0, 0, 0},{0, 0, 0, 0}};
46453 : static swig_cast_info _swigc__p_time_t[] = { {&_swigt__p_time_t, 0, 0, 0},{0, 0, 0, 0}};
46454 : static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
46455 : static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
46456 :
46457 : static swig_cast_info *swig_cast_initial[] = {
46458 : _swigc__p_FILE,
46459 : _swigc__p__gpgme_attr_t,
46460 : _swigc__p__gpgme_engine_info,
46461 : _swigc__p__gpgme_import_status,
46462 : _swigc__p__gpgme_invalid_key,
46463 : _swigc__p__gpgme_key,
46464 : _swigc__p__gpgme_key_sig,
46465 : _swigc__p__gpgme_new_signature,
46466 : _swigc__p__gpgme_op_assuan_result,
46467 : _swigc__p__gpgme_op_decrypt_result,
46468 : _swigc__p__gpgme_op_encrypt_result,
46469 : _swigc__p__gpgme_op_genkey_result,
46470 : _swigc__p__gpgme_op_import_result,
46471 : _swigc__p__gpgme_op_keylist_result,
46472 : _swigc__p__gpgme_op_query_swdb_result,
46473 : _swigc__p__gpgme_op_sign_result,
46474 : _swigc__p__gpgme_op_verify_result,
46475 : _swigc__p__gpgme_op_vfs_mount_result,
46476 : _swigc__p__gpgme_recipient,
46477 : _swigc__p__gpgme_sig_notation,
46478 : _swigc__p__gpgme_sig_stat_t,
46479 : _swigc__p__gpgme_signature,
46480 : _swigc__p__gpgme_subkey,
46481 : _swigc__p__gpgme_tofu_info,
46482 : _swigc__p__gpgme_trust_item,
46483 : _swigc__p__gpgme_user_id,
46484 : _swigc__p_a___p__gpgme_key,
46485 : _swigc__p_char,
46486 : _swigc__p_f_p_void__void,
46487 : _swigc__p_f_p_void_enum_gpgme_event_io_t_p_void__void,
46488 : _swigc__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t,
46489 : _swigc__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t,
46490 : _swigc__p_f_p_void_off_t_int__off_t,
46491 : _swigc__p_f_p_void_p_char_size_t_p_size_t__int,
46492 : _swigc__p_f_p_void_p_q_const__char_int_int_int__void,
46493 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
46494 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t,
46495 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
46496 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t,
46497 : _swigc__p_f_p_void_p_q_const__void_size_t__gpg_error_t,
46498 : _swigc__p_f_p_void_p_q_const__void_size_t__ssize_t,
46499 : _swigc__p_f_p_void_p_void_size_t__ssize_t,
46500 : _swigc__p_gpg_err_code_t,
46501 : _swigc__p_gpg_err_source_t,
46502 : _swigc__p_gpg_error_t,
46503 : _swigc__p_gpgme_conf_arg,
46504 : _swigc__p_gpgme_conf_arg_value,
46505 : _swigc__p_gpgme_conf_comp,
46506 : _swigc__p_gpgme_conf_level_t,
46507 : _swigc__p_gpgme_conf_opt,
46508 : _swigc__p_gpgme_conf_type_t,
46509 : _swigc__p_gpgme_context,
46510 : _swigc__p_gpgme_data,
46511 : _swigc__p_gpgme_data_cbs,
46512 : _swigc__p_gpgme_data_encoding_t,
46513 : _swigc__p_gpgme_data_type_t,
46514 : _swigc__p_gpgme_decrypt_flags_t,
46515 : _swigc__p_gpgme_encrypt_flags_t,
46516 : _swigc__p_gpgme_event_io_t,
46517 : _swigc__p_gpgme_hash_algo_t,
46518 : _swigc__p_gpgme_io_cbs,
46519 : _swigc__p_gpgme_io_event_done_data,
46520 : _swigc__p_gpgme_keyorg_t,
46521 : _swigc__p_gpgme_pinentry_mode_t,
46522 : _swigc__p_gpgme_protocol_t,
46523 : _swigc__p_gpgme_pubkey_algo_t,
46524 : _swigc__p_gpgme_sig_mode_t,
46525 : _swigc__p_gpgme_sigsum_t,
46526 : _swigc__p_gpgme_status_code_t,
46527 : _swigc__p_gpgme_tofu_policy_t,
46528 : _swigc__p_gpgme_validity_t,
46529 : _swigc__p_gpgrt_stream_t,
46530 : _swigc__p_int,
46531 : _swigc__p_off_t,
46532 : _swigc__p_p__gpgme_engine_info,
46533 : _swigc__p_p__gpgme_import_status,
46534 : _swigc__p_p__gpgme_key,
46535 : _swigc__p_p__gpgme_key_sig,
46536 : _swigc__p_p__gpgme_op_encrypt_result,
46537 : _swigc__p_p__gpgme_op_genkey_result,
46538 : _swigc__p_p__gpgme_op_import_result,
46539 : _swigc__p_p__gpgme_op_verify_result,
46540 : _swigc__p_p__gpgme_sig_notation,
46541 : _swigc__p_p__gpgme_signature,
46542 : _swigc__p_p__gpgme_subkey,
46543 : _swigc__p_p__gpgme_trust_item,
46544 : _swigc__p_p__gpgme_user_id,
46545 : _swigc__p_p_char,
46546 : _swigc__p_p_f_p_void__void,
46547 : _swigc__p_p_f_p_void_enum_gpgme_event_io_t_p_void__void,
46548 : _swigc__p_p_f_p_void_int__gpg_error_t,
46549 : _swigc__p_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t,
46550 : _swigc__p_p_f_p_void_off_t_int__off_t,
46551 : _swigc__p_p_f_p_void_p_q_const__char_int_int_int__void,
46552 : _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
46553 : _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
46554 : _swigc__p_p_f_p_void_p_q_const__void_size_t__ssize_t,
46555 : _swigc__p_p_f_p_void_p_void_size_t__ssize_t,
46556 : _swigc__p_p_gpgme_conf_arg,
46557 : _swigc__p_p_gpgme_conf_comp,
46558 : _swigc__p_p_gpgme_conf_opt,
46559 : _swigc__p_p_gpgme_context,
46560 : _swigc__p_p_gpgme_data,
46561 : _swigc__p_p_void,
46562 : _swigc__p_size_t,
46563 : _swigc__p_ssize_t,
46564 : _swigc__p_time_t,
46565 : _swigc__p_unsigned_int,
46566 : _swigc__p_void,
46567 : };
46568 :
46569 :
46570 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46571 :
46572 : static swig_const_info swig_const_table[] = {
46573 : {0, 0, 0, 0.0, 0, 0}};
46574 :
46575 : #ifdef __cplusplus
46576 : }
46577 : #endif
46578 : /* -----------------------------------------------------------------------------
46579 : * Type initialization:
46580 : * This problem is tough by the requirement that no dynamic
46581 : * memory is used. Also, since swig_type_info structures store pointers to
46582 : * swig_cast_info structures and swig_cast_info structures store pointers back
46583 : * to swig_type_info structures, we need some lookup code at initialization.
46584 : * The idea is that swig generates all the structures that are needed.
46585 : * The runtime then collects these partially filled structures.
46586 : * The SWIG_InitializeModule function takes these initial arrays out of
46587 : * swig_module, and does all the lookup, filling in the swig_module.types
46588 : * array with the correct data and linking the correct swig_cast_info
46589 : * structures together.
46590 : *
46591 : * The generated swig_type_info structures are assigned statically to an initial
46592 : * array. We just loop through that array, and handle each type individually.
46593 : * First we lookup if this type has been already loaded, and if so, use the
46594 : * loaded structure instead of the generated one. Then we have to fill in the
46595 : * cast linked list. The cast data is initially stored in something like a
46596 : * two-dimensional array. Each row corresponds to a type (there are the same
46597 : * number of rows as there are in the swig_type_initial array). Each entry in
46598 : * a column is one of the swig_cast_info structures for that type.
46599 : * The cast_initial array is actually an array of arrays, because each row has
46600 : * a variable number of columns. So to actually build the cast linked list,
46601 : * we find the array of casts associated with the type, and loop through it
46602 : * adding the casts to the list. The one last trick we need to do is making
46603 : * sure the type pointer in the swig_cast_info struct is correct.
46604 : *
46605 : * First off, we lookup the cast->type name to see if it is already loaded.
46606 : * There are three cases to handle:
46607 : * 1) If the cast->type has already been loaded AND the type we are adding
46608 : * casting info to has not been loaded (it is in this module), THEN we
46609 : * replace the cast->type pointer with the type pointer that has already
46610 : * been loaded.
46611 : * 2) If BOTH types (the one we are adding casting info to, and the
46612 : * cast->type) are loaded, THEN the cast info has already been loaded by
46613 : * the previous module so we just ignore it.
46614 : * 3) Finally, if cast->type has not already been loaded, then we add that
46615 : * swig_cast_info to the linked list (because the cast->type) pointer will
46616 : * be correct.
46617 : * ----------------------------------------------------------------------------- */
46618 :
46619 : #ifdef __cplusplus
46620 : extern "C" {
46621 : #if 0
46622 : } /* c-mode */
46623 : #endif
46624 : #endif
46625 :
46626 : #if 0
46627 : #define SWIGRUNTIME_DEBUG
46628 : #endif
46629 :
46630 :
46631 : SWIGRUNTIME void
46632 29 : SWIG_InitializeModule(void *clientdata) {
46633 : size_t i;
46634 : swig_module_info *module_head, *iter;
46635 : int init;
46636 :
46637 : /* check to see if the circular list has been setup, if not, set it up */
46638 29 : if (swig_module.next==0) {
46639 : /* Initialize the swig_module */
46640 29 : swig_module.type_initial = swig_type_initial;
46641 29 : swig_module.cast_initial = swig_cast_initial;
46642 29 : swig_module.next = &swig_module;
46643 29 : init = 1;
46644 : } else {
46645 : init = 0;
46646 : }
46647 :
46648 : /* Try and load any already created modules */
46649 29 : module_head = SWIG_GetModule(clientdata);
46650 29 : if (!module_head) {
46651 : /* This is the first module loaded for this interpreter */
46652 : /* so set the swig module into the interpreter */
46653 29 : SWIG_SetModule(clientdata, &swig_module);
46654 : } else {
46655 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
46656 : iter=module_head;
46657 : do {
46658 0 : if (iter==&swig_module) {
46659 : /* Our module is already in the list, so there's nothing more to do. */
46660 : return;
46661 : }
46662 0 : iter=iter->next;
46663 0 : } while (iter!= module_head);
46664 :
46665 : /* otherwise we must add our module into the list */
46666 0 : swig_module.next = module_head->next;
46667 0 : module_head->next = &swig_module;
46668 : }
46669 :
46670 : /* When multiple interpreters are used, a module could have already been initialized in
46671 : a different interpreter, but not yet have a pointer in this interpreter.
46672 : In this case, we do not want to continue adding types... everything should be
46673 : set up already */
46674 29 : if (init == 0) return;
46675 :
46676 : /* Now work on filling in swig_module.types */
46677 : #ifdef SWIGRUNTIME_DEBUG
46678 : printf("SWIG_InitializeModule: size %d\n", swig_module.size);
46679 : #endif
46680 3161 : for (i = 0; i < swig_module.size; ++i) {
46681 3161 : swig_type_info *type = 0;
46682 : swig_type_info *ret;
46683 : swig_cast_info *cast;
46684 :
46685 : #ifdef SWIGRUNTIME_DEBUG
46686 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
46687 : #endif
46688 :
46689 : /* if there is another module already loaded */
46690 3161 : if (swig_module.next != &swig_module) {
46691 0 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
46692 : }
46693 3161 : if (type) {
46694 : /* Overwrite clientdata field */
46695 : #ifdef SWIGRUNTIME_DEBUG
46696 : printf("SWIG_InitializeModule: found type %s\n", type->name);
46697 : #endif
46698 0 : if (swig_module.type_initial[i]->clientdata) {
46699 0 : type->clientdata = swig_module.type_initial[i]->clientdata;
46700 : #ifdef SWIGRUNTIME_DEBUG
46701 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
46702 : #endif
46703 : }
46704 : } else {
46705 3161 : type = swig_module.type_initial[i];
46706 : }
46707 :
46708 : /* Insert casting types */
46709 3161 : cast = swig_module.cast_initial[i];
46710 6322 : while (cast->type) {
46711 : /* Don't need to add information already in the list */
46712 3161 : ret = 0;
46713 : #ifdef SWIGRUNTIME_DEBUG
46714 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
46715 : #endif
46716 3161 : if (swig_module.next != &swig_module) {
46717 0 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
46718 : #ifdef SWIGRUNTIME_DEBUG
46719 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
46720 : #endif
46721 : }
46722 3161 : if (ret) {
46723 0 : if (type == swig_module.type_initial[i]) {
46724 : #ifdef SWIGRUNTIME_DEBUG
46725 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
46726 : #endif
46727 0 : cast->type = ret;
46728 0 : ret = 0;
46729 : } else {
46730 : /* Check for casting already in the list */
46731 0 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
46732 : #ifdef SWIGRUNTIME_DEBUG
46733 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
46734 : #endif
46735 0 : if (!ocast) ret = 0;
46736 : }
46737 : }
46738 :
46739 3161 : if (!ret) {
46740 : #ifdef SWIGRUNTIME_DEBUG
46741 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
46742 : #endif
46743 3161 : if (type->cast) {
46744 0 : type->cast->prev = cast;
46745 0 : cast->next = type->cast;
46746 : }
46747 3161 : type->cast = cast;
46748 : }
46749 3161 : cast++;
46750 : }
46751 : /* Set entry in modules->types array equal to the type */
46752 3161 : swig_module.types[i] = type;
46753 : }
46754 29 : swig_module.types[i] = 0;
46755 :
46756 : #ifdef SWIGRUNTIME_DEBUG
46757 : printf("**** SWIG_InitializeModule: Cast List ******\n");
46758 : for (i = 0; i < swig_module.size; ++i) {
46759 : int j = 0;
46760 : swig_cast_info *cast = swig_module.cast_initial[i];
46761 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
46762 : while (cast->type) {
46763 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
46764 : cast++;
46765 : ++j;
46766 : }
46767 : printf("---- Total casts: %d\n",j);
46768 : }
46769 : printf("**** SWIG_InitializeModule: Cast List ******\n");
46770 : #endif
46771 : }
46772 :
46773 : /* This function will propagate the clientdata field of type to
46774 : * any new swig_type_info structures that have been added into the list
46775 : * of equivalent types. It is like calling
46776 : * SWIG_TypeClientData(type, clientdata) a second time.
46777 : */
46778 : SWIGRUNTIME void
46779 : SWIG_PropagateClientData(void) {
46780 : size_t i;
46781 : swig_cast_info *equiv;
46782 : static int init_run = 0;
46783 :
46784 : if (init_run) return;
46785 : init_run = 1;
46786 :
46787 : for (i = 0; i < swig_module.size; i++) {
46788 : if (swig_module.types[i]->clientdata) {
46789 : equiv = swig_module.types[i]->cast;
46790 : while (equiv) {
46791 : if (!equiv->converter) {
46792 : if (equiv->type && !equiv->type->clientdata)
46793 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
46794 : }
46795 : equiv = equiv->next;
46796 : }
46797 : }
46798 : }
46799 : }
46800 :
46801 : #ifdef __cplusplus
46802 : #if 0
46803 : {
46804 : /* c-mode */
46805 : #endif
46806 : }
46807 : #endif
46808 :
46809 :
46810 :
46811 : #ifdef __cplusplus
46812 : extern "C" {
46813 : #endif
46814 :
46815 : /* Python-specific SWIG API */
46816 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
46817 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46818 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46819 :
46820 : /* -----------------------------------------------------------------------------
46821 : * global variable support code.
46822 : * ----------------------------------------------------------------------------- */
46823 :
46824 : typedef struct swig_globalvar {
46825 : char *name; /* Name of global variable */
46826 : PyObject *(*get_attr)(void); /* Return the current value */
46827 : int (*set_attr)(PyObject *); /* Set the value */
46828 : struct swig_globalvar *next;
46829 : } swig_globalvar;
46830 :
46831 : typedef struct swig_varlinkobject {
46832 : PyObject_HEAD
46833 : swig_globalvar *vars;
46834 : } swig_varlinkobject;
46835 :
46836 : SWIGINTERN PyObject *
46837 0 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
46838 : #if PY_VERSION_HEX >= 0x03000000
46839 0 : return PyUnicode_InternFromString("<Swig global variables>");
46840 : #else
46841 : return PyString_FromString("<Swig global variables>");
46842 : #endif
46843 : }
46844 :
46845 : SWIGINTERN PyObject *
46846 0 : swig_varlink_str(swig_varlinkobject *v) {
46847 : #if PY_VERSION_HEX >= 0x03000000
46848 0 : PyObject *str = PyUnicode_InternFromString("(");
46849 : PyObject *tail;
46850 : PyObject *joined;
46851 : swig_globalvar *var;
46852 0 : for (var = v->vars; var; var=var->next) {
46853 0 : tail = PyUnicode_FromString(var->name);
46854 0 : joined = PyUnicode_Concat(str, tail);
46855 0 : Py_DecRef(str);
46856 0 : Py_DecRef(tail);
46857 0 : str = joined;
46858 0 : if (var->next) {
46859 0 : tail = PyUnicode_InternFromString(", ");
46860 0 : joined = PyUnicode_Concat(str, tail);
46861 0 : Py_DecRef(str);
46862 0 : Py_DecRef(tail);
46863 0 : str = joined;
46864 : }
46865 : }
46866 0 : tail = PyUnicode_InternFromString(")");
46867 0 : joined = PyUnicode_Concat(str, tail);
46868 0 : Py_DecRef(str);
46869 0 : Py_DecRef(tail);
46870 0 : str = joined;
46871 : #else
46872 : PyObject *str = PyString_FromString("(");
46873 : swig_globalvar *var;
46874 : for (var = v->vars; var; var=var->next) {
46875 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
46876 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
46877 : }
46878 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
46879 : #endif
46880 0 : return str;
46881 : }
46882 :
46883 : SWIGINTERN int
46884 0 : swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
46885 : char *tmp;
46886 0 : PyObject *str = swig_varlink_str(v);
46887 0 : fprintf(fp,"Swig global variables ");
46888 0 : fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
46889 0 : SWIG_Python_str_DelForPy3(tmp);
46890 0 : Py_DECREF(str);
46891 0 : return 0;
46892 : }
46893 :
46894 : SWIGINTERN void
46895 0 : swig_varlink_dealloc(swig_varlinkobject *v) {
46896 0 : swig_globalvar *var = v->vars;
46897 0 : while (var) {
46898 0 : swig_globalvar *n = var->next;
46899 0 : free(var->name);
46900 0 : free(var);
46901 0 : var = n;
46902 : }
46903 0 : }
46904 :
46905 : SWIGINTERN PyObject *
46906 29 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46907 29 : PyObject *res = NULL;
46908 29 : swig_globalvar *var = v->vars;
46909 58 : while (var) {
46910 29 : if (strcmp(var->name,n) == 0) {
46911 29 : res = (*var->get_attr)();
46912 29 : break;
46913 : }
46914 0 : var = var->next;
46915 : }
46916 29 : if (res == NULL && !PyErr_Occurred()) {
46917 0 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
46918 : }
46919 29 : return res;
46920 : }
46921 :
46922 : SWIGINTERN int
46923 0 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46924 0 : int res = 1;
46925 0 : swig_globalvar *var = v->vars;
46926 0 : while (var) {
46927 0 : if (strcmp(var->name,n) == 0) {
46928 0 : res = (*var->set_attr)(p);
46929 0 : break;
46930 : }
46931 0 : var = var->next;
46932 : }
46933 0 : if (res == 1 && !PyErr_Occurred()) {
46934 0 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
46935 : }
46936 0 : return res;
46937 : }
46938 :
46939 : SWIGINTERN PyTypeObject*
46940 58 : swig_varlink_type(void) {
46941 : static char varlink__doc__[] = "Swig var link object";
46942 : static PyTypeObject varlink_type;
46943 : static int type_init = 0;
46944 58 : if (!type_init) {
46945 : const PyTypeObject tmp = {
46946 : /* PyObject header changed in Python 3 */
46947 : #if PY_VERSION_HEX >= 0x03000000
46948 : PyVarObject_HEAD_INIT(NULL, 0)
46949 : #else
46950 : PyObject_HEAD_INIT(NULL)
46951 : 0, /* ob_size */
46952 : #endif
46953 : (char *)"swigvarlink", /* tp_name */
46954 : sizeof(swig_varlinkobject), /* tp_basicsize */
46955 : 0, /* tp_itemsize */
46956 : (destructor) swig_varlink_dealloc, /* tp_dealloc */
46957 : (printfunc) swig_varlink_print, /* tp_print */
46958 : (getattrfunc) swig_varlink_getattr, /* tp_getattr */
46959 : (setattrfunc) swig_varlink_setattr, /* tp_setattr */
46960 : 0, /* tp_compare */
46961 : (reprfunc) swig_varlink_repr, /* tp_repr */
46962 : 0, /* tp_as_number */
46963 : 0, /* tp_as_sequence */
46964 : 0, /* tp_as_mapping */
46965 : 0, /* tp_hash */
46966 : 0, /* tp_call */
46967 : (reprfunc) swig_varlink_str, /* tp_str */
46968 : 0, /* tp_getattro */
46969 : 0, /* tp_setattro */
46970 : 0, /* tp_as_buffer */
46971 : 0, /* tp_flags */
46972 : varlink__doc__, /* tp_doc */
46973 : 0, /* tp_traverse */
46974 : 0, /* tp_clear */
46975 : 0, /* tp_richcompare */
46976 : 0, /* tp_weaklistoffset */
46977 : #if PY_VERSION_HEX >= 0x02020000
46978 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46979 : #endif
46980 : #if PY_VERSION_HEX >= 0x02030000
46981 : 0, /* tp_del */
46982 : #endif
46983 : #if PY_VERSION_HEX >= 0x02060000
46984 : 0, /* tp_version_tag */
46985 : #endif
46986 : #if PY_VERSION_HEX >= 0x03040000
46987 : 0, /* tp_finalize */
46988 : #endif
46989 : #ifdef COUNT_ALLOCS
46990 : 0, /* tp_allocs */
46991 : 0, /* tp_frees */
46992 : 0, /* tp_maxalloc */
46993 : #if PY_VERSION_HEX >= 0x02050000
46994 : 0, /* tp_prev */
46995 : #endif
46996 : 0 /* tp_next */
46997 : #endif
46998 : };
46999 29 : varlink_type = tmp;
47000 29 : type_init = 1;
47001 : #if PY_VERSION_HEX < 0x02020000
47002 : varlink_type.ob_type = &PyType_Type;
47003 : #else
47004 29 : if (PyType_Ready(&varlink_type) < 0)
47005 : return NULL;
47006 : #endif
47007 : }
47008 : return &varlink_type;
47009 : }
47010 :
47011 : /* Create a variable linking object for use later */
47012 : SWIGINTERN PyObject *
47013 29 : SWIG_Python_newvarlink(void) {
47014 29 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
47015 29 : if (result) {
47016 29 : result->vars = 0;
47017 : }
47018 29 : return ((PyObject*) result);
47019 : }
47020 :
47021 : SWIGINTERN void
47022 29 : SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47023 29 : swig_varlinkobject *v = (swig_varlinkobject *) p;
47024 29 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47025 29 : if (gv) {
47026 29 : size_t size = strlen(name)+1;
47027 29 : gv->name = (char *)malloc(size);
47028 29 : if (gv->name) {
47029 58 : strncpy(gv->name,name,size);
47030 29 : gv->get_attr = get_attr;
47031 29 : gv->set_attr = set_attr;
47032 29 : gv->next = v->vars;
47033 : }
47034 : }
47035 29 : v->vars = gv;
47036 29 : }
47037 :
47038 : SWIGINTERN PyObject *
47039 : SWIG_globals(void) {
47040 : static PyObject *_SWIG_globals = 0;
47041 58 : if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
47042 58 : return _SWIG_globals;
47043 : }
47044 :
47045 : /* -----------------------------------------------------------------------------
47046 : * constants/methods manipulation
47047 : * ----------------------------------------------------------------------------- */
47048 :
47049 : /* Install Constants */
47050 : SWIGINTERN void
47051 29 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47052 29 : PyObject *obj = 0;
47053 : size_t i;
47054 29 : for (i = 0; constants[i].type; ++i) {
47055 0 : switch(constants[i].type) {
47056 : case SWIG_PY_POINTER:
47057 0 : obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47058 0 : break;
47059 : case SWIG_PY_BINARY:
47060 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47061 : break;
47062 : default:
47063 : obj = 0;
47064 : break;
47065 : }
47066 0 : if (obj) {
47067 0 : PyDict_SetItemString(d, constants[i].name, obj);
47068 0 : Py_DECREF(obj);
47069 : }
47070 : }
47071 29 : }
47072 :
47073 : /* -----------------------------------------------------------------------------*/
47074 : /* Fix SwigMethods to carry the callback ptrs when needed */
47075 : /* -----------------------------------------------------------------------------*/
47076 :
47077 : SWIGINTERN void
47078 29 : SWIG_Python_FixMethods(PyMethodDef *methods,
47079 : swig_const_info *const_table,
47080 : swig_type_info **types,
47081 : swig_type_info **types_initial) {
47082 : size_t i;
47083 23606 : for (i = 0; methods[i].ml_name; ++i) {
47084 23577 : const char *c = methods[i].ml_doc;
47085 23577 : if (!c) continue;
47086 22678 : c = strstr(c, "swig_ptr: ");
47087 22678 : if (c) {
47088 : int j;
47089 0 : swig_const_info *ci = 0;
47090 0 : const char *name = c + 10;
47091 0 : for (j = 0; const_table[j].type; ++j) {
47092 0 : if (strncmp(const_table[j].name, name,
47093 : strlen(const_table[j].name)) == 0) {
47094 : ci = &(const_table[j]);
47095 : break;
47096 : }
47097 : }
47098 0 : if (ci) {
47099 0 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
47100 0 : if (ptr) {
47101 0 : size_t shift = (ci->ptype) - types;
47102 0 : swig_type_info *ty = types_initial[shift];
47103 0 : size_t ldoc = (c - methods[i].ml_doc);
47104 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47105 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
47106 0 : if (ndoc) {
47107 0 : char *buff = ndoc;
47108 0 : strncpy(buff, methods[i].ml_doc, ldoc);
47109 0 : buff += ldoc;
47110 0 : strncpy(buff, "swig_ptr: ", 10);
47111 0 : buff += 10;
47112 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47113 0 : methods[i].ml_doc = ndoc;
47114 : }
47115 : }
47116 : }
47117 : }
47118 : }
47119 29 : }
47120 :
47121 : #ifdef __cplusplus
47122 : }
47123 : #endif
47124 :
47125 : /* -----------------------------------------------------------------------------*
47126 : * Partial Init method
47127 : * -----------------------------------------------------------------------------*/
47128 :
47129 : #ifdef __cplusplus
47130 : extern "C"
47131 : #endif
47132 :
47133 : SWIGEXPORT
47134 : #if PY_VERSION_HEX >= 0x03000000
47135 : PyObject*
47136 : #else
47137 : void
47138 : #endif
47139 29 : SWIG_init(void) {
47140 : PyObject *m, *d, *md;
47141 : #if PY_VERSION_HEX >= 0x03000000
47142 : static struct PyModuleDef SWIG_module = {
47143 : # if PY_VERSION_HEX >= 0x03020000
47144 : PyModuleDef_HEAD_INIT,
47145 : # else
47146 : {
47147 : PyObject_HEAD_INIT(NULL)
47148 : NULL, /* m_init */
47149 : 0, /* m_index */
47150 : NULL, /* m_copy */
47151 : },
47152 : # endif
47153 : (char *) SWIG_name,
47154 : NULL,
47155 : -1,
47156 : SwigMethods,
47157 : NULL,
47158 : NULL,
47159 : NULL,
47160 : NULL
47161 : };
47162 : #endif
47163 :
47164 : #if defined(SWIGPYTHON_BUILTIN)
47165 : static SwigPyClientData SwigPyObject_clientdata = {
47166 : 0, 0, 0, 0, 0, 0, 0
47167 : };
47168 : static PyGetSetDef this_getset_def = {
47169 : (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
47170 : };
47171 : static SwigPyGetSet thisown_getset_closure = {
47172 : (PyCFunction) SwigPyObject_own,
47173 : (PyCFunction) SwigPyObject_own
47174 : };
47175 : static PyGetSetDef thisown_getset_def = {
47176 : (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
47177 : };
47178 : PyObject *metatype_args;
47179 : PyTypeObject *builtin_pytype;
47180 : int builtin_base_count;
47181 : swig_type_info *builtin_basetype;
47182 : PyObject *tuple;
47183 : PyGetSetDescrObject *static_getset;
47184 : PyTypeObject *metatype;
47185 : SwigPyClientData *cd;
47186 : PyObject *public_interface, *public_symbol;
47187 : PyObject *this_descr;
47188 : PyObject *thisown_descr;
47189 : PyObject *self = 0;
47190 : int i;
47191 :
47192 : (void)builtin_pytype;
47193 : (void)builtin_base_count;
47194 : (void)builtin_basetype;
47195 : (void)tuple;
47196 : (void)static_getset;
47197 : (void)self;
47198 :
47199 : /* metatype is used to implement static member variables. */
47200 : metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
47201 : assert(metatype_args);
47202 : metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
47203 : assert(metatype);
47204 : Py_DECREF(metatype_args);
47205 : metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
47206 : assert(PyType_Ready(metatype) >= 0);
47207 : #endif
47208 :
47209 : /* Fix SwigMethods to carry the callback ptrs when needed */
47210 29 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
47211 :
47212 : #if PY_VERSION_HEX >= 0x03000000
47213 29 : m = PyModule_Create(&SWIG_module);
47214 : #else
47215 : m = Py_InitModule((char *) SWIG_name, SwigMethods);
47216 : #endif
47217 :
47218 29 : md = d = PyModule_GetDict(m);
47219 : (void)md;
47220 :
47221 29 : SWIG_InitializeModule(0);
47222 :
47223 : #ifdef SWIGPYTHON_BUILTIN
47224 : SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
47225 : assert(SwigPyObject_stype);
47226 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
47227 : if (!cd) {
47228 : SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
47229 : SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
47230 : } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
47231 : PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
47232 : # if PY_VERSION_HEX >= 0x03000000
47233 : return NULL;
47234 : # else
47235 : return;
47236 : # endif
47237 : }
47238 :
47239 : /* All objects have a 'this' attribute */
47240 : this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
47241 : (void)this_descr;
47242 :
47243 : /* All objects have a 'thisown' attribute */
47244 : thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
47245 : (void)thisown_descr;
47246 :
47247 : public_interface = PyList_New(0);
47248 : public_symbol = 0;
47249 : (void)public_symbol;
47250 :
47251 : PyDict_SetItemString(md, "__all__", public_interface);
47252 : Py_DECREF(public_interface);
47253 : for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
47254 : SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
47255 : for (i = 0; swig_const_table[i].name != 0; ++i)
47256 : SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
47257 : #endif
47258 :
47259 29 : SWIG_InstallConstants(d,swig_const_table);
47260 :
47261 29 : SWIG_Python_SetConstant(d, "BUILD_REVISION",SWIG_FromCharPtr("c4aa4af"));
47262 29 : SWIG_Python_SetConstant(d, "BUILD_TIMESTAMP",SWIG_FromCharPtr("<none>"));
47263 29 : SWIG_Python_SetConstant(d, "ENABLE_UISERVER",SWIG_From_int((int)(1)));
47264 29 : SWIG_Python_SetConstant(d, "GPGME_LIBASSUAN_VERSION",SWIG_FromCharPtr(""));
47265 29 : SWIG_Python_SetConstant(d, "HAVE_ARGP_H",SWIG_From_int((int)(1)));
47266 29 : SWIG_Python_SetConstant(d, "HAVE_DECL_TTYNAME_R",SWIG_From_int((int)(1)));
47267 29 : SWIG_Python_SetConstant(d, "HAVE_DLFCN_H",SWIG_From_int((int)(1)));
47268 29 : SWIG_Python_SetConstant(d, "HAVE_ERROR_T",SWIG_From_int((int)(1)));
47269 29 : SWIG_Python_SetConstant(d, "HAVE_FSEEKO",SWIG_From_int((int)(1)));
47270 29 : SWIG_Python_SetConstant(d, "HAVE_GETEGID",SWIG_From_int((int)(1)));
47271 29 : SWIG_Python_SetConstant(d, "HAVE_GETGID",SWIG_From_int((int)(1)));
47272 29 : SWIG_Python_SetConstant(d, "HAVE_INTTYPES_H",SWIG_From_int((int)(1)));
47273 29 : SWIG_Python_SetConstant(d, "HAVE_LOCALE_H",SWIG_From_int((int)(1)));
47274 29 : SWIG_Python_SetConstant(d, "HAVE_MEMORY_H",SWIG_From_int((int)(1)));
47275 29 : SWIG_Python_SetConstant(d, "HAVE_POSIXDECL_TTYNAME_R",SWIG_From_int((int)(1)));
47276 29 : SWIG_Python_SetConstant(d, "HAVE_SETENV",SWIG_From_int((int)(1)));
47277 29 : SWIG_Python_SetConstant(d, "HAVE_SETLOCALE",SWIG_From_int((int)(1)));
47278 29 : SWIG_Python_SetConstant(d, "HAVE_STDINT_H",SWIG_From_int((int)(1)));
47279 29 : SWIG_Python_SetConstant(d, "HAVE_STDLIB_H",SWIG_From_int((int)(1)));
47280 29 : SWIG_Python_SetConstant(d, "HAVE_STPCPY",SWIG_From_int((int)(1)));
47281 29 : SWIG_Python_SetConstant(d, "HAVE_STRINGS_H",SWIG_From_int((int)(1)));
47282 29 : SWIG_Python_SetConstant(d, "HAVE_STRING_H",SWIG_From_int((int)(1)));
47283 29 : SWIG_Python_SetConstant(d, "HAVE_SYS_SELECT_H",SWIG_From_int((int)(1)));
47284 29 : SWIG_Python_SetConstant(d, "HAVE_SYS_STAT_H",SWIG_From_int((int)(1)));
47285 29 : SWIG_Python_SetConstant(d, "HAVE_SYS_TIME_H",SWIG_From_int((int)(1)));
47286 29 : SWIG_Python_SetConstant(d, "HAVE_SYS_TYPES_H",SWIG_From_int((int)(1)));
47287 29 : SWIG_Python_SetConstant(d, "HAVE_SYS_UIO_H",SWIG_From_int((int)(1)));
47288 29 : SWIG_Python_SetConstant(d, "HAVE_THREAD_SAFE_GETENV",SWIG_From_int((int)(1)));
47289 29 : SWIG_Python_SetConstant(d, "HAVE_TIMEGM",SWIG_From_int((int)(1)));
47290 29 : SWIG_Python_SetConstant(d, "HAVE_TLS",SWIG_From_int((int)(1)));
47291 29 : SWIG_Python_SetConstant(d, "HAVE_TTYNAME_R",SWIG_From_int((int)(1)));
47292 29 : SWIG_Python_SetConstant(d, "HAVE_UINTPTR_T",SWIG_From_int((int)(1)));
47293 29 : SWIG_Python_SetConstant(d, "HAVE_UNISTD_H",SWIG_From_int((int)(1)));
47294 29 : SWIG_Python_SetConstant(d, "LT_OBJDIR",SWIG_FromCharPtr(".libs/"));
47295 29 : SWIG_Python_SetConstant(d, "PACKAGE",SWIG_FromCharPtr("gpgme"));
47296 29 : SWIG_Python_SetConstant(d, "PACKAGE_BUGREPORT",SWIG_FromCharPtr("https://bugs.gnupg.org"));
47297 29 : SWIG_Python_SetConstant(d, "PACKAGE_NAME",SWIG_FromCharPtr("gpgme"));
47298 29 : SWIG_Python_SetConstant(d, "PACKAGE_STRING",SWIG_FromCharPtr("gpgme 1.12.1"));
47299 29 : SWIG_Python_SetConstant(d, "PACKAGE_TARNAME",SWIG_FromCharPtr("gpgme"));
47300 29 : SWIG_Python_SetConstant(d, "PACKAGE_URL",SWIG_FromCharPtr(""));
47301 29 : SWIG_Python_SetConstant(d, "PACKAGE_VERSION",SWIG_FromCharPtr("1.12.1"));
47302 29 : SWIG_Python_SetConstant(d, "PATHSEP_C",SWIG_From_char((char)(':')));
47303 29 : SWIG_Python_SetConstant(d, "DIRSEP_C",SWIG_From_char((char)('/')));
47304 29 : SWIG_Python_SetConstant(d, "DIRSEP_S",SWIG_FromCharPtr("/"));
47305 29 : SWIG_Python_SetConstant(d, "SIZEOF_UNSIGNED_INT",SWIG_From_int((int)(4)));
47306 29 : SWIG_Python_SetConstant(d, "STDC_HEADERS",SWIG_From_int((int)(1)));
47307 29 : SWIG_Python_SetConstant(d, "USE_DESCRIPTOR_PASSING",SWIG_From_int((int)(1)));
47308 29 : SWIG_Python_SetConstant(d, "USE_LINUX_GETDENTS",SWIG_From_int((int)(1)));
47309 29 : SWIG_Python_SetConstant(d, "_ALL_SOURCE",SWIG_From_int((int)(1)));
47310 29 : SWIG_Python_SetConstant(d, "_GNU_SOURCE",SWIG_From_int((int)(1)));
47311 29 : SWIG_Python_SetConstant(d, "_POSIX_PTHREAD_SEMANTICS",SWIG_From_int((int)(1)));
47312 29 : SWIG_Python_SetConstant(d, "_TANDEM_SOURCE",SWIG_From_int((int)(1)));
47313 29 : SWIG_Python_SetConstant(d, "__EXTENSIONS__",SWIG_From_int((int)(1)));
47314 29 : SWIG_Python_SetConstant(d, "VERSION",SWIG_FromCharPtr("1.12.1"));
47315 29 : SWIG_Python_SetConstant(d, "_DARWIN_USE_64_BIT_INODE",SWIG_From_int((int)(1)));
47316 29 : SWIG_Python_SetConstant(d, "_REENTRANT",SWIG_From_int((int)(1)));
47317 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENABLE_ERRNO_MACROS",SWIG_From_int((int)(1)));
47318 29 : SWIG_Python_SetConstant(d, "CRIGHTBLURB",SWIG_FromCharPtr("Copyright (C) 2000 Werner Koch\nCopyright (C) 2001--2018 g10 Code GmbH\n"));
47319 29 : SWIG_Python_SetConstant(d, "GPGME_VERSION",SWIG_FromCharPtr("1.12.1"));
47320 29 : SWIG_Python_SetConstant(d, "GPGME_VERSION_NUMBER",SWIG_From_int((int)(0x010c01)));
47321 29 : SWIG_Python_SetConstant(d, "_GPGME_OBSOLETE_SOME_SYMBOLS",SWIG_From_int((int)(1)));
47322 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_NONE",SWIG_From_int((int)(GPGME_DATA_ENCODING_NONE)));
47323 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_BINARY",SWIG_From_int((int)(GPGME_DATA_ENCODING_BINARY)));
47324 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_BASE64",SWIG_From_int((int)(GPGME_DATA_ENCODING_BASE64)));
47325 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_ARMOR",SWIG_From_int((int)(GPGME_DATA_ENCODING_ARMOR)));
47326 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_URL",SWIG_From_int((int)(GPGME_DATA_ENCODING_URL)));
47327 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_URLESC",SWIG_From_int((int)(GPGME_DATA_ENCODING_URLESC)));
47328 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_URL0",SWIG_From_int((int)(GPGME_DATA_ENCODING_URL0)));
47329 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_MIME",SWIG_From_int((int)(GPGME_DATA_ENCODING_MIME)));
47330 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_INVALID",SWIG_From_int((int)(GPGME_DATA_TYPE_INVALID)));
47331 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_UNKNOWN",SWIG_From_int((int)(GPGME_DATA_TYPE_UNKNOWN)));
47332 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_SIGNED",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_SIGNED)));
47333 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_ENCRYPTED",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_ENCRYPTED)));
47334 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_OTHER",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_OTHER)));
47335 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_KEY",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_KEY)));
47336 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_SIGNATURE",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_SIGNATURE)));
47337 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_CMS_SIGNED",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_SIGNED)));
47338 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_CMS_ENCRYPTED",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_ENCRYPTED)));
47339 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_CMS_OTHER",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_OTHER)));
47340 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_X509_CERT",SWIG_From_int((int)(GPGME_DATA_TYPE_X509_CERT)));
47341 29 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PKCS12",SWIG_From_int((int)(GPGME_DATA_TYPE_PKCS12)));
47342 29 : SWIG_Python_SetConstant(d, "GPGME_PK_RSA",SWIG_From_int((int)(GPGME_PK_RSA)));
47343 29 : SWIG_Python_SetConstant(d, "GPGME_PK_RSA_E",SWIG_From_int((int)(GPGME_PK_RSA_E)));
47344 29 : SWIG_Python_SetConstant(d, "GPGME_PK_RSA_S",SWIG_From_int((int)(GPGME_PK_RSA_S)));
47345 29 : SWIG_Python_SetConstant(d, "GPGME_PK_ELG_E",SWIG_From_int((int)(GPGME_PK_ELG_E)));
47346 29 : SWIG_Python_SetConstant(d, "GPGME_PK_DSA",SWIG_From_int((int)(GPGME_PK_DSA)));
47347 29 : SWIG_Python_SetConstant(d, "GPGME_PK_ECC",SWIG_From_int((int)(GPGME_PK_ECC)));
47348 29 : SWIG_Python_SetConstant(d, "GPGME_PK_ELG",SWIG_From_int((int)(GPGME_PK_ELG)));
47349 29 : SWIG_Python_SetConstant(d, "GPGME_PK_ECDSA",SWIG_From_int((int)(GPGME_PK_ECDSA)));
47350 29 : SWIG_Python_SetConstant(d, "GPGME_PK_ECDH",SWIG_From_int((int)(GPGME_PK_ECDH)));
47351 29 : SWIG_Python_SetConstant(d, "GPGME_PK_EDDSA",SWIG_From_int((int)(GPGME_PK_EDDSA)));
47352 29 : SWIG_Python_SetConstant(d, "GPGME_MD_NONE",SWIG_From_int((int)(GPGME_MD_NONE)));
47353 29 : SWIG_Python_SetConstant(d, "GPGME_MD_MD5",SWIG_From_int((int)(GPGME_MD_MD5)));
47354 29 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA1",SWIG_From_int((int)(GPGME_MD_SHA1)));
47355 29 : SWIG_Python_SetConstant(d, "GPGME_MD_RMD160",SWIG_From_int((int)(GPGME_MD_RMD160)));
47356 29 : SWIG_Python_SetConstant(d, "GPGME_MD_MD2",SWIG_From_int((int)(GPGME_MD_MD2)));
47357 29 : SWIG_Python_SetConstant(d, "GPGME_MD_TIGER",SWIG_From_int((int)(GPGME_MD_TIGER)));
47358 29 : SWIG_Python_SetConstant(d, "GPGME_MD_HAVAL",SWIG_From_int((int)(GPGME_MD_HAVAL)));
47359 29 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA256",SWIG_From_int((int)(GPGME_MD_SHA256)));
47360 29 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA384",SWIG_From_int((int)(GPGME_MD_SHA384)));
47361 29 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA512",SWIG_From_int((int)(GPGME_MD_SHA512)));
47362 29 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA224",SWIG_From_int((int)(GPGME_MD_SHA224)));
47363 29 : SWIG_Python_SetConstant(d, "GPGME_MD_MD4",SWIG_From_int((int)(GPGME_MD_MD4)));
47364 29 : SWIG_Python_SetConstant(d, "GPGME_MD_CRC32",SWIG_From_int((int)(GPGME_MD_CRC32)));
47365 29 : SWIG_Python_SetConstant(d, "GPGME_MD_CRC32_RFC1510",SWIG_From_int((int)(GPGME_MD_CRC32_RFC1510)));
47366 29 : SWIG_Python_SetConstant(d, "GPGME_MD_CRC24_RFC2440",SWIG_From_int((int)(GPGME_MD_CRC24_RFC2440)));
47367 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_MODE_NORMAL",SWIG_From_int((int)(GPGME_SIG_MODE_NORMAL)));
47368 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_MODE_DETACH",SWIG_From_int((int)(GPGME_SIG_MODE_DETACH)));
47369 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_MODE_CLEAR",SWIG_From_int((int)(GPGME_SIG_MODE_CLEAR)));
47370 29 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_UNKNOWN",SWIG_From_int((int)(GPGME_VALIDITY_UNKNOWN)));
47371 29 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_UNDEFINED",SWIG_From_int((int)(GPGME_VALIDITY_UNDEFINED)));
47372 29 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_NEVER",SWIG_From_int((int)(GPGME_VALIDITY_NEVER)));
47373 29 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_MARGINAL",SWIG_From_int((int)(GPGME_VALIDITY_MARGINAL)));
47374 29 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_FULL",SWIG_From_int((int)(GPGME_VALIDITY_FULL)));
47375 29 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_ULTIMATE",SWIG_From_int((int)(GPGME_VALIDITY_ULTIMATE)));
47376 29 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_NONE",SWIG_From_int((int)(GPGME_TOFU_POLICY_NONE)));
47377 29 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_AUTO",SWIG_From_int((int)(GPGME_TOFU_POLICY_AUTO)));
47378 29 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_GOOD",SWIG_From_int((int)(GPGME_TOFU_POLICY_GOOD)));
47379 29 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_UNKNOWN",SWIG_From_int((int)(GPGME_TOFU_POLICY_UNKNOWN)));
47380 29 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_BAD",SWIG_From_int((int)(GPGME_TOFU_POLICY_BAD)));
47381 29 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_ASK",SWIG_From_int((int)(GPGME_TOFU_POLICY_ASK)));
47382 29 : SWIG_Python_SetConstant(d, "GPGME_KEYORG_UNKNOWN",SWIG_From_int((int)(GPGME_KEYORG_UNKNOWN)));
47383 29 : SWIG_Python_SetConstant(d, "GPGME_KEYORG_KS",SWIG_From_int((int)(GPGME_KEYORG_KS)));
47384 29 : SWIG_Python_SetConstant(d, "GPGME_KEYORG_DANE",SWIG_From_int((int)(GPGME_KEYORG_DANE)));
47385 29 : SWIG_Python_SetConstant(d, "GPGME_KEYORG_WKD",SWIG_From_int((int)(GPGME_KEYORG_WKD)));
47386 29 : SWIG_Python_SetConstant(d, "GPGME_KEYORG_URL",SWIG_From_int((int)(GPGME_KEYORG_URL)));
47387 29 : SWIG_Python_SetConstant(d, "GPGME_KEYORG_FILE",SWIG_From_int((int)(GPGME_KEYORG_FILE)));
47388 29 : SWIG_Python_SetConstant(d, "GPGME_KEYORG_SELF",SWIG_From_int((int)(GPGME_KEYORG_SELF)));
47389 29 : SWIG_Python_SetConstant(d, "GPGME_KEYORG_OTHER",SWIG_From_int((int)(GPGME_KEYORG_OTHER)));
47390 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_OpenPGP",SWIG_From_int((int)(GPGME_PROTOCOL_OpenPGP)));
47391 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_CMS",SWIG_From_int((int)(GPGME_PROTOCOL_CMS)));
47392 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_GPGCONF",SWIG_From_int((int)(GPGME_PROTOCOL_GPGCONF)));
47393 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_ASSUAN",SWIG_From_int((int)(GPGME_PROTOCOL_ASSUAN)));
47394 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_G13",SWIG_From_int((int)(GPGME_PROTOCOL_G13)));
47395 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_UISERVER",SWIG_From_int((int)(GPGME_PROTOCOL_UISERVER)));
47396 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_SPAWN",SWIG_From_int((int)(GPGME_PROTOCOL_SPAWN)));
47397 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_DEFAULT",SWIG_From_int((int)(GPGME_PROTOCOL_DEFAULT)));
47398 29 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_UNKNOWN",SWIG_From_int((int)(GPGME_PROTOCOL_UNKNOWN)));
47399 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_LOCAL",SWIG_From_int((int)(1)));
47400 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_EXTERN",SWIG_From_int((int)(2)));
47401 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_SIGS",SWIG_From_int((int)(4)));
47402 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_SIG_NOTATIONS",SWIG_From_int((int)(8)));
47403 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_WITH_SECRET",SWIG_From_int((int)(16)));
47404 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_WITH_TOFU",SWIG_From_int((int)(32)));
47405 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_EPHEMERAL",SWIG_From_int((int)(128)));
47406 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_VALIDATE",SWIG_From_int((int)(256)));
47407 29 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_LOCATE",SWIG_From_int((int)((1|2))));
47408 29 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_DEFAULT",SWIG_From_int((int)(GPGME_PINENTRY_MODE_DEFAULT)));
47409 29 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_ASK",SWIG_From_int((int)(GPGME_PINENTRY_MODE_ASK)));
47410 29 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_CANCEL",SWIG_From_int((int)(GPGME_PINENTRY_MODE_CANCEL)));
47411 29 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_ERROR",SWIG_From_int((int)(GPGME_PINENTRY_MODE_ERROR)));
47412 29 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_LOOPBACK",SWIG_From_int((int)(GPGME_PINENTRY_MODE_LOOPBACK)));
47413 29 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_EXTERN",SWIG_From_int((int)(2)));
47414 29 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_MINIMAL",SWIG_From_int((int)(4)));
47415 29 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_SECRET",SWIG_From_int((int)(16)));
47416 29 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_RAW",SWIG_From_int((int)(32)));
47417 29 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_PKCS12",SWIG_From_int((int)(64)));
47418 29 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_NOUID",SWIG_From_int((int)(128)));
47419 29 : SWIG_Python_SetConstant(d, "GPGME_AUDITLOG_DEFAULT",SWIG_From_int((int)(0)));
47420 29 : SWIG_Python_SetConstant(d, "GPGME_AUDITLOG_HTML",SWIG_From_int((int)(1)));
47421 29 : SWIG_Python_SetConstant(d, "GPGME_AUDITLOG_DIAG",SWIG_From_int((int)(2)));
47422 29 : SWIG_Python_SetConstant(d, "GPGME_AUDITLOG_WITH_HELP",SWIG_From_int((int)(128)));
47423 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_NOTATION_HUMAN_READABLE",SWIG_From_int((int)(1)));
47424 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_NOTATION_CRITICAL",SWIG_From_int((int)(2)));
47425 29 : SWIG_Python_SetConstant(d, "GPGME_INCLUDE_CERTS_DEFAULT",SWIG_From_int((int)(-256)));
47426 29 : SWIG_Python_SetConstant(d, "GPGME_EVENT_START",SWIG_From_int((int)(GPGME_EVENT_START)));
47427 29 : SWIG_Python_SetConstant(d, "GPGME_EVENT_DONE",SWIG_From_int((int)(GPGME_EVENT_DONE)));
47428 29 : SWIG_Python_SetConstant(d, "GPGME_EVENT_NEXT_KEY",SWIG_From_int((int)(GPGME_EVENT_NEXT_KEY)));
47429 29 : SWIG_Python_SetConstant(d, "GPGME_EVENT_NEXT_TRUSTITEM",SWIG_From_int((int)(GPGME_EVENT_NEXT_TRUSTITEM)));
47430 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_ALWAYS_TRUST",SWIG_From_int((int)(GPGME_ENCRYPT_ALWAYS_TRUST)));
47431 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_NO_ENCRYPT_TO",SWIG_From_int((int)(GPGME_ENCRYPT_NO_ENCRYPT_TO)));
47432 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_PREPARE",SWIG_From_int((int)(GPGME_ENCRYPT_PREPARE)));
47433 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_EXPECT_SIGN",SWIG_From_int((int)(GPGME_ENCRYPT_EXPECT_SIGN)));
47434 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_NO_COMPRESS",SWIG_From_int((int)(GPGME_ENCRYPT_NO_COMPRESS)));
47435 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_SYMMETRIC",SWIG_From_int((int)(GPGME_ENCRYPT_SYMMETRIC)));
47436 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_THROW_KEYIDS",SWIG_From_int((int)(GPGME_ENCRYPT_THROW_KEYIDS)));
47437 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_WRAP",SWIG_From_int((int)(GPGME_ENCRYPT_WRAP)));
47438 29 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_WANT_ADDRESS",SWIG_From_int((int)(GPGME_ENCRYPT_WANT_ADDRESS)));
47439 29 : SWIG_Python_SetConstant(d, "GPGME_DECRYPT_VERIFY",SWIG_From_int((int)(GPGME_DECRYPT_VERIFY)));
47440 29 : SWIG_Python_SetConstant(d, "GPGME_DECRYPT_UNWRAP",SWIG_From_int((int)(GPGME_DECRYPT_UNWRAP)));
47441 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_VALID",SWIG_From_int((int)(GPGME_SIGSUM_VALID)));
47442 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_GREEN",SWIG_From_int((int)(GPGME_SIGSUM_GREEN)));
47443 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_RED",SWIG_From_int((int)(GPGME_SIGSUM_RED)));
47444 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_KEY_REVOKED",SWIG_From_int((int)(GPGME_SIGSUM_KEY_REVOKED)));
47445 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_KEY_EXPIRED",SWIG_From_int((int)(GPGME_SIGSUM_KEY_EXPIRED)));
47446 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_SIG_EXPIRED",SWIG_From_int((int)(GPGME_SIGSUM_SIG_EXPIRED)));
47447 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_KEY_MISSING",SWIG_From_int((int)(GPGME_SIGSUM_KEY_MISSING)));
47448 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_CRL_MISSING",SWIG_From_int((int)(GPGME_SIGSUM_CRL_MISSING)));
47449 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_CRL_TOO_OLD",SWIG_From_int((int)(GPGME_SIGSUM_CRL_TOO_OLD)));
47450 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_BAD_POLICY",SWIG_From_int((int)(GPGME_SIGSUM_BAD_POLICY)));
47451 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_SYS_ERROR",SWIG_From_int((int)(GPGME_SIGSUM_SYS_ERROR)));
47452 29 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_TOFU_CONFLICT",SWIG_From_int((int)(GPGME_SIGSUM_TOFU_CONFLICT)));
47453 29 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_NEW",SWIG_From_int((int)(1)));
47454 29 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_UID",SWIG_From_int((int)(2)));
47455 29 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_SIG",SWIG_From_int((int)(4)));
47456 29 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_SUBKEY",SWIG_From_int((int)(8)));
47457 29 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_SECRET",SWIG_From_int((int)(16)));
47458 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_SIGN",SWIG_From_int((int)((1 << 0))));
47459 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_ENCR",SWIG_From_int((int)((1 << 1))));
47460 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_CERT",SWIG_From_int((int)((1 << 2))));
47461 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_AUTH",SWIG_From_int((int)((1 << 3))));
47462 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_NOPASSWD",SWIG_From_int((int)((1 << 7))));
47463 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_SELFSIGNED",SWIG_From_int((int)((1 << 8))));
47464 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_NOSTORE",SWIG_From_int((int)((1 << 9))));
47465 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_WANTPUB",SWIG_From_int((int)((1 << 10))));
47466 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_WANTSEC",SWIG_From_int((int)((1 << 11))));
47467 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_FORCE",SWIG_From_int((int)((1 << 12))));
47468 29 : SWIG_Python_SetConstant(d, "GPGME_CREATE_NOEXPIRE",SWIG_From_int((int)((1 << 13))));
47469 29 : SWIG_Python_SetConstant(d, "GPGME_DELETE_ALLOW_SECRET",SWIG_From_int((int)((1 << 0))));
47470 29 : SWIG_Python_SetConstant(d, "GPGME_DELETE_FORCE",SWIG_From_int((int)((1 << 1))));
47471 29 : SWIG_Python_SetConstant(d, "GPGME_KEYSIGN_LOCAL",SWIG_From_int((int)((1 << 7))));
47472 29 : SWIG_Python_SetConstant(d, "GPGME_KEYSIGN_LFSEP",SWIG_From_int((int)((1 << 8))));
47473 29 : SWIG_Python_SetConstant(d, "GPGME_KEYSIGN_NOEXPIRE",SWIG_From_int((int)((1 << 9))));
47474 29 : SWIG_Python_SetConstant(d, "GPGME_INTERACT_CARD",SWIG_From_int((int)((1 << 0))));
47475 29 : SWIG_Python_SetConstant(d, "GPGME_SPAWN_DETACHED",SWIG_From_int((int)(1)));
47476 29 : SWIG_Python_SetConstant(d, "GPGME_SPAWN_ALLOW_SET_FG",SWIG_From_int((int)(2)));
47477 29 : SWIG_Python_SetConstant(d, "GPGME_SPAWN_SHOW_WINDOW",SWIG_From_int((int)(4)));
47478 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_BASIC",SWIG_From_int((int)(GPGME_CONF_BASIC)));
47479 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_ADVANCED",SWIG_From_int((int)(GPGME_CONF_ADVANCED)));
47480 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_EXPERT",SWIG_From_int((int)(GPGME_CONF_EXPERT)));
47481 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_INVISIBLE",SWIG_From_int((int)(GPGME_CONF_INVISIBLE)));
47482 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_INTERNAL",SWIG_From_int((int)(GPGME_CONF_INTERNAL)));
47483 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_NONE",SWIG_From_int((int)(GPGME_CONF_NONE)));
47484 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_STRING",SWIG_From_int((int)(GPGME_CONF_STRING)));
47485 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_INT32",SWIG_From_int((int)(GPGME_CONF_INT32)));
47486 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_UINT32",SWIG_From_int((int)(GPGME_CONF_UINT32)));
47487 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_FILENAME",SWIG_From_int((int)(GPGME_CONF_FILENAME)));
47488 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_LDAP_SERVER",SWIG_From_int((int)(GPGME_CONF_LDAP_SERVER)));
47489 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_KEY_FPR",SWIG_From_int((int)(GPGME_CONF_KEY_FPR)));
47490 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_PUB_KEY",SWIG_From_int((int)(GPGME_CONF_PUB_KEY)));
47491 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_SEC_KEY",SWIG_From_int((int)(GPGME_CONF_SEC_KEY)));
47492 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_ALIAS_LIST",SWIG_From_int((int)(GPGME_CONF_ALIAS_LIST)));
47493 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_GROUP",SWIG_From_int((int)((1 << 0))));
47494 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_OPTIONAL",SWIG_From_int((int)((1 << 1))));
47495 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_LIST",SWIG_From_int((int)((1 << 2))));
47496 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_RUNTIME",SWIG_From_int((int)((1 << 3))));
47497 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_DEFAULT",SWIG_From_int((int)((1 << 4))));
47498 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_DEFAULT_DESC",SWIG_From_int((int)((1 << 5))));
47499 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_NO_ARG_DESC",SWIG_From_int((int)((1 << 6))));
47500 29 : SWIG_Python_SetConstant(d, "GPGME_CONF_NO_CHANGE",SWIG_From_int((int)((1 << 7))));
47501 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_EOF",SWIG_From_int((int)(GPGME_STATUS_EOF)));
47502 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ENTER",SWIG_From_int((int)(GPGME_STATUS_ENTER)));
47503 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_LEAVE",SWIG_From_int((int)(GPGME_STATUS_LEAVE)));
47504 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ABORT",SWIG_From_int((int)(GPGME_STATUS_ABORT)));
47505 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GOODSIG",SWIG_From_int((int)(GPGME_STATUS_GOODSIG)));
47506 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BADSIG",SWIG_From_int((int)(GPGME_STATUS_BADSIG)));
47507 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ERRSIG",SWIG_From_int((int)(GPGME_STATUS_ERRSIG)));
47508 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BADARMOR",SWIG_From_int((int)(GPGME_STATUS_BADARMOR)));
47509 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_RSA_OR_IDEA",SWIG_From_int((int)(GPGME_STATUS_RSA_OR_IDEA)));
47510 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEYEXPIRED",SWIG_From_int((int)(GPGME_STATUS_KEYEXPIRED)));
47511 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEYREVOKED",SWIG_From_int((int)(GPGME_STATUS_KEYREVOKED)));
47512 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_UNDEFINED",SWIG_From_int((int)(GPGME_STATUS_TRUST_UNDEFINED)));
47513 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_NEVER",SWIG_From_int((int)(GPGME_STATUS_TRUST_NEVER)));
47514 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_MARGINAL",SWIG_From_int((int)(GPGME_STATUS_TRUST_MARGINAL)));
47515 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_FULLY",SWIG_From_int((int)(GPGME_STATUS_TRUST_FULLY)));
47516 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_ULTIMATE",SWIG_From_int((int)(GPGME_STATUS_TRUST_ULTIMATE)));
47517 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SHM_INFO",SWIG_From_int((int)(GPGME_STATUS_SHM_INFO)));
47518 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SHM_GET",SWIG_From_int((int)(GPGME_STATUS_SHM_GET)));
47519 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SHM_GET_BOOL",SWIG_From_int((int)(GPGME_STATUS_SHM_GET_BOOL)));
47520 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SHM_GET_HIDDEN",SWIG_From_int((int)(GPGME_STATUS_SHM_GET_HIDDEN)));
47521 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NEED_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE)));
47522 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_VALIDSIG",SWIG_From_int((int)(GPGME_STATUS_VALIDSIG)));
47523 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SIG_ID",SWIG_From_int((int)(GPGME_STATUS_SIG_ID)));
47524 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ENC_TO",SWIG_From_int((int)(GPGME_STATUS_ENC_TO)));
47525 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NODATA",SWIG_From_int((int)(GPGME_STATUS_NODATA)));
47526 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BAD_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_BAD_PASSPHRASE)));
47527 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NO_PUBKEY",SWIG_From_int((int)(GPGME_STATUS_NO_PUBKEY)));
47528 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NO_SECKEY",SWIG_From_int((int)(GPGME_STATUS_NO_SECKEY)));
47529 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NEED_PASSPHRASE_SYM",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE_SYM)));
47530 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DECRYPTION_FAILED",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_FAILED)));
47531 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DECRYPTION_OKAY",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_OKAY)));
47532 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_MISSING_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_MISSING_PASSPHRASE)));
47533 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GOOD_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_GOOD_PASSPHRASE)));
47534 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GOODMDC",SWIG_From_int((int)(GPGME_STATUS_GOODMDC)));
47535 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BADMDC",SWIG_From_int((int)(GPGME_STATUS_BADMDC)));
47536 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ERRMDC",SWIG_From_int((int)(GPGME_STATUS_ERRMDC)));
47537 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_IMPORTED",SWIG_From_int((int)(GPGME_STATUS_IMPORTED)));
47538 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_IMPORT_OK",SWIG_From_int((int)(GPGME_STATUS_IMPORT_OK)));
47539 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_IMPORT_PROBLEM",SWIG_From_int((int)(GPGME_STATUS_IMPORT_PROBLEM)));
47540 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_IMPORT_RES",SWIG_From_int((int)(GPGME_STATUS_IMPORT_RES)));
47541 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_FILE_START",SWIG_From_int((int)(GPGME_STATUS_FILE_START)));
47542 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_FILE_DONE",SWIG_From_int((int)(GPGME_STATUS_FILE_DONE)));
47543 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_FILE_ERROR",SWIG_From_int((int)(GPGME_STATUS_FILE_ERROR)));
47544 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BEGIN_DECRYPTION",SWIG_From_int((int)(GPGME_STATUS_BEGIN_DECRYPTION)));
47545 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_END_DECRYPTION",SWIG_From_int((int)(GPGME_STATUS_END_DECRYPTION)));
47546 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BEGIN_ENCRYPTION",SWIG_From_int((int)(GPGME_STATUS_BEGIN_ENCRYPTION)));
47547 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_END_ENCRYPTION",SWIG_From_int((int)(GPGME_STATUS_END_ENCRYPTION)));
47548 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DELETE_PROBLEM",SWIG_From_int((int)(GPGME_STATUS_DELETE_PROBLEM)));
47549 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GET_BOOL",SWIG_From_int((int)(GPGME_STATUS_GET_BOOL)));
47550 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GET_LINE",SWIG_From_int((int)(GPGME_STATUS_GET_LINE)));
47551 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GET_HIDDEN",SWIG_From_int((int)(GPGME_STATUS_GET_HIDDEN)));
47552 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GOT_IT",SWIG_From_int((int)(GPGME_STATUS_GOT_IT)));
47553 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PROGRESS",SWIG_From_int((int)(GPGME_STATUS_PROGRESS)));
47554 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SIG_CREATED",SWIG_From_int((int)(GPGME_STATUS_SIG_CREATED)));
47555 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SESSION_KEY",SWIG_From_int((int)(GPGME_STATUS_SESSION_KEY)));
47556 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NOTATION_NAME",SWIG_From_int((int)(GPGME_STATUS_NOTATION_NAME)));
47557 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NOTATION_DATA",SWIG_From_int((int)(GPGME_STATUS_NOTATION_DATA)));
47558 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_POLICY_URL",SWIG_From_int((int)(GPGME_STATUS_POLICY_URL)));
47559 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BEGIN_STREAM",SWIG_From_int((int)(GPGME_STATUS_BEGIN_STREAM)));
47560 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_END_STREAM",SWIG_From_int((int)(GPGME_STATUS_END_STREAM)));
47561 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEY_CREATED",SWIG_From_int((int)(GPGME_STATUS_KEY_CREATED)));
47562 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_USERID_HINT",SWIG_From_int((int)(GPGME_STATUS_USERID_HINT)));
47563 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_UNEXPECTED",SWIG_From_int((int)(GPGME_STATUS_UNEXPECTED)));
47564 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_INV_RECP",SWIG_From_int((int)(GPGME_STATUS_INV_RECP)));
47565 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NO_RECP",SWIG_From_int((int)(GPGME_STATUS_NO_RECP)));
47566 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ALREADY_SIGNED",SWIG_From_int((int)(GPGME_STATUS_ALREADY_SIGNED)));
47567 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SIGEXPIRED",SWIG_From_int((int)(GPGME_STATUS_SIGEXPIRED)));
47568 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_EXPSIG",SWIG_From_int((int)(GPGME_STATUS_EXPSIG)));
47569 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_EXPKEYSIG",SWIG_From_int((int)(GPGME_STATUS_EXPKEYSIG)));
47570 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUNCATED",SWIG_From_int((int)(GPGME_STATUS_TRUNCATED)));
47571 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ERROR",SWIG_From_int((int)(GPGME_STATUS_ERROR)));
47572 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NEWSIG",SWIG_From_int((int)(GPGME_STATUS_NEWSIG)));
47573 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_REVKEYSIG",SWIG_From_int((int)(GPGME_STATUS_REVKEYSIG)));
47574 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SIG_SUBPACKET",SWIG_From_int((int)(GPGME_STATUS_SIG_SUBPACKET)));
47575 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NEED_PASSPHRASE_PIN",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE_PIN)));
47576 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SC_OP_FAILURE",SWIG_From_int((int)(GPGME_STATUS_SC_OP_FAILURE)));
47577 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SC_OP_SUCCESS",SWIG_From_int((int)(GPGME_STATUS_SC_OP_SUCCESS)));
47578 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_CARDCTRL",SWIG_From_int((int)(GPGME_STATUS_CARDCTRL)));
47579 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BACKUP_KEY_CREATED",SWIG_From_int((int)(GPGME_STATUS_BACKUP_KEY_CREATED)));
47580 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PKA_TRUST_BAD",SWIG_From_int((int)(GPGME_STATUS_PKA_TRUST_BAD)));
47581 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PKA_TRUST_GOOD",SWIG_From_int((int)(GPGME_STATUS_PKA_TRUST_GOOD)));
47582 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PLAINTEXT",SWIG_From_int((int)(GPGME_STATUS_PLAINTEXT)));
47583 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_INV_SGNR",SWIG_From_int((int)(GPGME_STATUS_INV_SGNR)));
47584 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NO_SGNR",SWIG_From_int((int)(GPGME_STATUS_NO_SGNR)));
47585 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SUCCESS",SWIG_From_int((int)(GPGME_STATUS_SUCCESS)));
47586 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DECRYPTION_INFO",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_INFO)));
47587 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PLAINTEXT_LENGTH",SWIG_From_int((int)(GPGME_STATUS_PLAINTEXT_LENGTH)));
47588 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_MOUNTPOINT",SWIG_From_int((int)(GPGME_STATUS_MOUNTPOINT)));
47589 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PINENTRY_LAUNCHED",SWIG_From_int((int)(GPGME_STATUS_PINENTRY_LAUNCHED)));
47590 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ATTRIBUTE",SWIG_From_int((int)(GPGME_STATUS_ATTRIBUTE)));
47591 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BEGIN_SIGNING",SWIG_From_int((int)(GPGME_STATUS_BEGIN_SIGNING)));
47592 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEY_NOT_CREATED",SWIG_From_int((int)(GPGME_STATUS_KEY_NOT_CREATED)));
47593 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_INQUIRE_MAXLEN",SWIG_From_int((int)(GPGME_STATUS_INQUIRE_MAXLEN)));
47594 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_FAILURE",SWIG_From_int((int)(GPGME_STATUS_FAILURE)));
47595 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEY_CONSIDERED",SWIG_From_int((int)(GPGME_STATUS_KEY_CONSIDERED)));
47596 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TOFU_USER",SWIG_From_int((int)(GPGME_STATUS_TOFU_USER)));
47597 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TOFU_STATS",SWIG_From_int((int)(GPGME_STATUS_TOFU_STATS)));
47598 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TOFU_STATS_LONG",SWIG_From_int((int)(GPGME_STATUS_TOFU_STATS_LONG)));
47599 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NOTATION_FLAGS",SWIG_From_int((int)(GPGME_STATUS_NOTATION_FLAGS)));
47600 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DECRYPTION_COMPLIANCE_MODE",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_COMPLIANCE_MODE)));
47601 29 : SWIG_Python_SetConstant(d, "GPGME_STATUS_VERIFICATION_COMPLIANCE_MODE",SWIG_From_int((int)(GPGME_STATUS_VERIFICATION_COMPLIANCE_MODE)));
47602 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_NONE",SWIG_From_int((int)(GPGME_SIG_STAT_NONE)));
47603 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_GOOD",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD)));
47604 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_BAD",SWIG_From_int((int)(GPGME_SIG_STAT_BAD)));
47605 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_NOKEY",SWIG_From_int((int)(GPGME_SIG_STAT_NOKEY)));
47606 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_NOSIG",SWIG_From_int((int)(GPGME_SIG_STAT_NOSIG)));
47607 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_ERROR",SWIG_From_int((int)(GPGME_SIG_STAT_ERROR)));
47608 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_DIFF",SWIG_From_int((int)(GPGME_SIG_STAT_DIFF)));
47609 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_GOOD_EXP",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD_EXP)));
47610 29 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_GOOD_EXPKEY",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD_EXPKEY)));
47611 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEYID",SWIG_From_int((int)(GPGME_ATTR_KEYID)));
47612 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_FPR",SWIG_From_int((int)(GPGME_ATTR_FPR)));
47613 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_ALGO",SWIG_From_int((int)(GPGME_ATTR_ALGO)));
47614 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_LEN",SWIG_From_int((int)(GPGME_ATTR_LEN)));
47615 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CREATED",SWIG_From_int((int)(GPGME_ATTR_CREATED)));
47616 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_EXPIRE",SWIG_From_int((int)(GPGME_ATTR_EXPIRE)));
47617 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_OTRUST",SWIG_From_int((int)(GPGME_ATTR_OTRUST)));
47618 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_USERID",SWIG_From_int((int)(GPGME_ATTR_USERID)));
47619 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_NAME",SWIG_From_int((int)(GPGME_ATTR_NAME)));
47620 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_EMAIL",SWIG_From_int((int)(GPGME_ATTR_EMAIL)));
47621 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_COMMENT",SWIG_From_int((int)(GPGME_ATTR_COMMENT)));
47622 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_VALIDITY",SWIG_From_int((int)(GPGME_ATTR_VALIDITY)));
47623 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_LEVEL",SWIG_From_int((int)(GPGME_ATTR_LEVEL)));
47624 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_TYPE",SWIG_From_int((int)(GPGME_ATTR_TYPE)));
47625 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_IS_SECRET",SWIG_From_int((int)(GPGME_ATTR_IS_SECRET)));
47626 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_REVOKED",SWIG_From_int((int)(GPGME_ATTR_KEY_REVOKED)));
47627 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_INVALID",SWIG_From_int((int)(GPGME_ATTR_KEY_INVALID)));
47628 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_UID_REVOKED",SWIG_From_int((int)(GPGME_ATTR_UID_REVOKED)));
47629 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_UID_INVALID",SWIG_From_int((int)(GPGME_ATTR_UID_INVALID)));
47630 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_CAPS",SWIG_From_int((int)(GPGME_ATTR_KEY_CAPS)));
47631 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CAN_ENCRYPT",SWIG_From_int((int)(GPGME_ATTR_CAN_ENCRYPT)));
47632 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CAN_SIGN",SWIG_From_int((int)(GPGME_ATTR_CAN_SIGN)));
47633 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CAN_CERTIFY",SWIG_From_int((int)(GPGME_ATTR_CAN_CERTIFY)));
47634 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_EXPIRED",SWIG_From_int((int)(GPGME_ATTR_KEY_EXPIRED)));
47635 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_DISABLED",SWIG_From_int((int)(GPGME_ATTR_KEY_DISABLED)));
47636 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_SERIAL",SWIG_From_int((int)(GPGME_ATTR_SERIAL)));
47637 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_ISSUER",SWIG_From_int((int)(GPGME_ATTR_ISSUER)));
47638 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CHAINID",SWIG_From_int((int)(GPGME_ATTR_CHAINID)));
47639 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_SIG_STATUS",SWIG_From_int((int)(GPGME_ATTR_SIG_STATUS)));
47640 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_ERRTOK",SWIG_From_int((int)(GPGME_ATTR_ERRTOK)));
47641 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_SIG_SUMMARY",SWIG_From_int((int)(GPGME_ATTR_SIG_SUMMARY)));
47642 29 : SWIG_Python_SetConstant(d, "GPGME_ATTR_SIG_CLASS",SWIG_From_int((int)(GPGME_ATTR_SIG_CLASS)));
47643 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_UNKNOWN",SWIG_From_long((long)(GPG_ERR_SOURCE_UNKNOWN)));
47644 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GCRYPT",SWIG_From_long((long)(GPG_ERR_SOURCE_GCRYPT)));
47645 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPG",SWIG_From_long((long)(GPG_ERR_SOURCE_GPG)));
47646 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPGSM",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGSM)));
47647 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPGAGENT",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGAGENT)));
47648 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_PINENTRY",SWIG_From_long((long)(GPG_ERR_SOURCE_PINENTRY)));
47649 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_SCD",SWIG_From_long((long)(GPG_ERR_SOURCE_SCD)));
47650 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPGME",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGME)));
47651 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_KEYBOX",SWIG_From_long((long)(GPG_ERR_SOURCE_KEYBOX)));
47652 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_KSBA",SWIG_From_long((long)(GPG_ERR_SOURCE_KSBA)));
47653 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_DIRMNGR",SWIG_From_long((long)(GPG_ERR_SOURCE_DIRMNGR)));
47654 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GSTI",SWIG_From_long((long)(GPG_ERR_SOURCE_GSTI)));
47655 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPA",SWIG_From_long((long)(GPG_ERR_SOURCE_GPA)));
47656 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_KLEO",SWIG_From_long((long)(GPG_ERR_SOURCE_KLEO)));
47657 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_G13",SWIG_From_long((long)(GPG_ERR_SOURCE_G13)));
47658 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_ASSUAN",SWIG_From_long((long)(GPG_ERR_SOURCE_ASSUAN)));
47659 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_TLS",SWIG_From_long((long)(GPG_ERR_SOURCE_TLS)));
47660 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_ANY",SWIG_From_long((long)(GPG_ERR_SOURCE_ANY)));
47661 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_USER_1",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_1)));
47662 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_USER_2",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_2)));
47663 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_USER_3",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_3)));
47664 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_USER_4",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_4)));
47665 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_DIM",SWIG_From_long((long)(GPG_ERR_SOURCE_DIM)));
47666 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_ERROR",SWIG_From_long((long)(GPG_ERR_NO_ERROR)));
47667 29 : SWIG_Python_SetConstant(d, "GPG_ERR_GENERAL",SWIG_From_long((long)(GPG_ERR_GENERAL)));
47668 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_PACKET",SWIG_From_long((long)(GPG_ERR_UNKNOWN_PACKET)));
47669 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_VERSION",SWIG_From_long((long)(GPG_ERR_UNKNOWN_VERSION)));
47670 29 : SWIG_Python_SetConstant(d, "GPG_ERR_PUBKEY_ALGO",SWIG_From_long((long)(GPG_ERR_PUBKEY_ALGO)));
47671 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DIGEST_ALGO",SWIG_From_long((long)(GPG_ERR_DIGEST_ALGO)));
47672 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_PUBKEY",SWIG_From_long((long)(GPG_ERR_BAD_PUBKEY)));
47673 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_SECKEY",SWIG_From_long((long)(GPG_ERR_BAD_SECKEY)));
47674 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_SIGNATURE",SWIG_From_long((long)(GPG_ERR_BAD_SIGNATURE)));
47675 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PUBKEY",SWIG_From_long((long)(GPG_ERR_NO_PUBKEY)));
47676 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CHECKSUM",SWIG_From_long((long)(GPG_ERR_CHECKSUM)));
47677 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_BAD_PASSPHRASE)));
47678 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CIPHER_ALGO",SWIG_From_long((long)(GPG_ERR_CIPHER_ALGO)));
47679 29 : SWIG_Python_SetConstant(d, "GPG_ERR_KEYRING_OPEN",SWIG_From_long((long)(GPG_ERR_KEYRING_OPEN)));
47680 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_PACKET",SWIG_From_long((long)(GPG_ERR_INV_PACKET)));
47681 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ARMOR",SWIG_From_long((long)(GPG_ERR_INV_ARMOR)));
47682 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_USER_ID",SWIG_From_long((long)(GPG_ERR_NO_USER_ID)));
47683 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_SECKEY",SWIG_From_long((long)(GPG_ERR_NO_SECKEY)));
47684 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_SECKEY",SWIG_From_long((long)(GPG_ERR_WRONG_SECKEY)));
47685 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_KEY",SWIG_From_long((long)(GPG_ERR_BAD_KEY)));
47686 29 : SWIG_Python_SetConstant(d, "GPG_ERR_COMPR_ALGO",SWIG_From_long((long)(GPG_ERR_COMPR_ALGO)));
47687 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PRIME",SWIG_From_long((long)(GPG_ERR_NO_PRIME)));
47688 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_ENCODING_METHOD",SWIG_From_long((long)(GPG_ERR_NO_ENCODING_METHOD)));
47689 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_ENCRYPTION_SCHEME",SWIG_From_long((long)(GPG_ERR_NO_ENCRYPTION_SCHEME)));
47690 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_SIGNATURE_SCHEME",SWIG_From_long((long)(GPG_ERR_NO_SIGNATURE_SCHEME)));
47691 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ATTR",SWIG_From_long((long)(GPG_ERR_INV_ATTR)));
47692 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_VALUE",SWIG_From_long((long)(GPG_ERR_NO_VALUE)));
47693 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_NOT_FOUND)));
47694 29 : SWIG_Python_SetConstant(d, "GPG_ERR_VALUE_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_VALUE_NOT_FOUND)));
47695 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SYNTAX",SWIG_From_long((long)(GPG_ERR_SYNTAX)));
47696 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_MPI",SWIG_From_long((long)(GPG_ERR_BAD_MPI)));
47697 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_INV_PASSPHRASE)));
47698 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SIG_CLASS",SWIG_From_long((long)(GPG_ERR_SIG_CLASS)));
47699 29 : SWIG_Python_SetConstant(d, "GPG_ERR_RESOURCE_LIMIT",SWIG_From_long((long)(GPG_ERR_RESOURCE_LIMIT)));
47700 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_KEYRING",SWIG_From_long((long)(GPG_ERR_INV_KEYRING)));
47701 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TRUSTDB",SWIG_From_long((long)(GPG_ERR_TRUSTDB)));
47702 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_CERT",SWIG_From_long((long)(GPG_ERR_BAD_CERT)));
47703 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_USER_ID",SWIG_From_long((long)(GPG_ERR_INV_USER_ID)));
47704 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNEXPECTED",SWIG_From_long((long)(GPG_ERR_UNEXPECTED)));
47705 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TIME_CONFLICT",SWIG_From_long((long)(GPG_ERR_TIME_CONFLICT)));
47706 29 : SWIG_Python_SetConstant(d, "GPG_ERR_KEYSERVER",SWIG_From_long((long)(GPG_ERR_KEYSERVER)));
47707 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_PUBKEY_ALGO",SWIG_From_long((long)(GPG_ERR_WRONG_PUBKEY_ALGO)));
47708 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TRIBUTE_TO_D_A",SWIG_From_long((long)(GPG_ERR_TRIBUTE_TO_D_A)));
47709 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WEAK_KEY",SWIG_From_long((long)(GPG_ERR_WEAK_KEY)));
47710 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_KEYLEN",SWIG_From_long((long)(GPG_ERR_INV_KEYLEN)));
47711 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ARG",SWIG_From_long((long)(GPG_ERR_INV_ARG)));
47712 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_URI",SWIG_From_long((long)(GPG_ERR_BAD_URI)));
47713 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_URI",SWIG_From_long((long)(GPG_ERR_INV_URI)));
47714 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NETWORK",SWIG_From_long((long)(GPG_ERR_NETWORK)));
47715 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_HOST",SWIG_From_long((long)(GPG_ERR_UNKNOWN_HOST)));
47716 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SELFTEST_FAILED",SWIG_From_long((long)(GPG_ERR_SELFTEST_FAILED)));
47717 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_ENCRYPTED",SWIG_From_long((long)(GPG_ERR_NOT_ENCRYPTED)));
47718 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_PROCESSED",SWIG_From_long((long)(GPG_ERR_NOT_PROCESSED)));
47719 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNUSABLE_PUBKEY",SWIG_From_long((long)(GPG_ERR_UNUSABLE_PUBKEY)));
47720 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNUSABLE_SECKEY",SWIG_From_long((long)(GPG_ERR_UNUSABLE_SECKEY)));
47721 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_VALUE",SWIG_From_long((long)(GPG_ERR_INV_VALUE)));
47722 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_CERT_CHAIN",SWIG_From_long((long)(GPG_ERR_BAD_CERT_CHAIN)));
47723 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_CERT)));
47724 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_DATA",SWIG_From_long((long)(GPG_ERR_NO_DATA)));
47725 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BUG",SWIG_From_long((long)(GPG_ERR_BUG)));
47726 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_SUPPORTED",SWIG_From_long((long)(GPG_ERR_NOT_SUPPORTED)));
47727 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_OP",SWIG_From_long((long)(GPG_ERR_INV_OP)));
47728 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TIMEOUT",SWIG_From_long((long)(GPG_ERR_TIMEOUT)));
47729 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INTERNAL",SWIG_From_long((long)(GPG_ERR_INTERNAL)));
47730 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EOF_GCRYPT",SWIG_From_long((long)(GPG_ERR_EOF_GCRYPT)));
47731 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_OBJ",SWIG_From_long((long)(GPG_ERR_INV_OBJ)));
47732 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_TOO_SHORT)));
47733 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_TOO_LARGE)));
47734 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_OBJ",SWIG_From_long((long)(GPG_ERR_NO_OBJ)));
47735 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_IMPLEMENTED",SWIG_From_long((long)(GPG_ERR_NOT_IMPLEMENTED)));
47736 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CONFLICT",SWIG_From_long((long)(GPG_ERR_CONFLICT)));
47737 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CIPHER_MODE",SWIG_From_long((long)(GPG_ERR_INV_CIPHER_MODE)));
47738 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_FLAG",SWIG_From_long((long)(GPG_ERR_INV_FLAG)));
47739 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_HANDLE",SWIG_From_long((long)(GPG_ERR_INV_HANDLE)));
47740 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TRUNCATED",SWIG_From_long((long)(GPG_ERR_TRUNCATED)));
47741 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INCOMPLETE_LINE",SWIG_From_long((long)(GPG_ERR_INCOMPLETE_LINE)));
47742 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_RESPONSE",SWIG_From_long((long)(GPG_ERR_INV_RESPONSE)));
47743 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_AGENT",SWIG_From_long((long)(GPG_ERR_NO_AGENT)));
47744 29 : SWIG_Python_SetConstant(d, "GPG_ERR_AGENT",SWIG_From_long((long)(GPG_ERR_AGENT)));
47745 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_DATA",SWIG_From_long((long)(GPG_ERR_INV_DATA)));
47746 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASSUAN_SERVER_FAULT",SWIG_From_long((long)(GPG_ERR_ASSUAN_SERVER_FAULT)));
47747 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASSUAN",SWIG_From_long((long)(GPG_ERR_ASSUAN)));
47748 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_SESSION_KEY",SWIG_From_long((long)(GPG_ERR_INV_SESSION_KEY)));
47749 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_SEXP",SWIG_From_long((long)(GPG_ERR_INV_SEXP)));
47750 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_ALGORITHM",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_ALGORITHM)));
47751 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PIN_ENTRY",SWIG_From_long((long)(GPG_ERR_NO_PIN_ENTRY)));
47752 29 : SWIG_Python_SetConstant(d, "GPG_ERR_PIN_ENTRY",SWIG_From_long((long)(GPG_ERR_PIN_ENTRY)));
47753 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_PIN",SWIG_From_long((long)(GPG_ERR_BAD_PIN)));
47754 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_NAME",SWIG_From_long((long)(GPG_ERR_INV_NAME)));
47755 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_DATA",SWIG_From_long((long)(GPG_ERR_BAD_DATA)));
47756 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_PARAMETER",SWIG_From_long((long)(GPG_ERR_INV_PARAMETER)));
47757 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_CARD",SWIG_From_long((long)(GPG_ERR_WRONG_CARD)));
47758 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_DIRMNGR",SWIG_From_long((long)(GPG_ERR_NO_DIRMNGR)));
47759 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DIRMNGR",SWIG_From_long((long)(GPG_ERR_DIRMNGR)));
47760 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CERT_REVOKED",SWIG_From_long((long)(GPG_ERR_CERT_REVOKED)));
47761 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CRL_KNOWN",SWIG_From_long((long)(GPG_ERR_NO_CRL_KNOWN)));
47762 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CRL_TOO_OLD",SWIG_From_long((long)(GPG_ERR_CRL_TOO_OLD)));
47763 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LINE_TOO_LONG",SWIG_From_long((long)(GPG_ERR_LINE_TOO_LONG)));
47764 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_TRUSTED",SWIG_From_long((long)(GPG_ERR_NOT_TRUSTED)));
47765 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CANCELED",SWIG_From_long((long)(GPG_ERR_CANCELED)));
47766 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_CA_CERT",SWIG_From_long((long)(GPG_ERR_BAD_CA_CERT)));
47767 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CERT_EXPIRED",SWIG_From_long((long)(GPG_ERR_CERT_EXPIRED)));
47768 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CERT_TOO_YOUNG",SWIG_From_long((long)(GPG_ERR_CERT_TOO_YOUNG)));
47769 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_CERT",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CERT)));
47770 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_SEXP",SWIG_From_long((long)(GPG_ERR_UNKNOWN_SEXP)));
47771 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_PROTECTION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_PROTECTION)));
47772 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CORRUPTED_PROTECTION",SWIG_From_long((long)(GPG_ERR_CORRUPTED_PROTECTION)));
47773 29 : SWIG_Python_SetConstant(d, "GPG_ERR_AMBIGUOUS_NAME",SWIG_From_long((long)(GPG_ERR_AMBIGUOUS_NAME)));
47774 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD",SWIG_From_long((long)(GPG_ERR_CARD)));
47775 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD_RESET",SWIG_From_long((long)(GPG_ERR_CARD_RESET)));
47776 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD_REMOVED",SWIG_From_long((long)(GPG_ERR_CARD_REMOVED)));
47777 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CARD",SWIG_From_long((long)(GPG_ERR_INV_CARD)));
47778 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD_NOT_PRESENT",SWIG_From_long((long)(GPG_ERR_CARD_NOT_PRESENT)));
47779 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PKCS15_APP",SWIG_From_long((long)(GPG_ERR_NO_PKCS15_APP)));
47780 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_CONFIRMED",SWIG_From_long((long)(GPG_ERR_NOT_CONFIRMED)));
47781 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CONFIGURATION",SWIG_From_long((long)(GPG_ERR_CONFIGURATION)));
47782 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_POLICY_MATCH",SWIG_From_long((long)(GPG_ERR_NO_POLICY_MATCH)));
47783 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_INDEX",SWIG_From_long((long)(GPG_ERR_INV_INDEX)));
47784 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ID",SWIG_From_long((long)(GPG_ERR_INV_ID)));
47785 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_SCDAEMON",SWIG_From_long((long)(GPG_ERR_NO_SCDAEMON)));
47786 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SCDAEMON",SWIG_From_long((long)(GPG_ERR_SCDAEMON)));
47787 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_PROTOCOL",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_PROTOCOL)));
47788 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_PIN_METHOD",SWIG_From_long((long)(GPG_ERR_BAD_PIN_METHOD)));
47789 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD_NOT_INITIALIZED",SWIG_From_long((long)(GPG_ERR_CARD_NOT_INITIALIZED)));
47790 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_OPERATION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_OPERATION)));
47791 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_KEY_USAGE",SWIG_From_long((long)(GPG_ERR_WRONG_KEY_USAGE)));
47792 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOTHING_FOUND",SWIG_From_long((long)(GPG_ERR_NOTHING_FOUND)));
47793 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_BLOB_TYPE",SWIG_From_long((long)(GPG_ERR_WRONG_BLOB_TYPE)));
47794 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_VALUE",SWIG_From_long((long)(GPG_ERR_MISSING_VALUE)));
47795 29 : SWIG_Python_SetConstant(d, "GPG_ERR_HARDWARE",SWIG_From_long((long)(GPG_ERR_HARDWARE)));
47796 29 : SWIG_Python_SetConstant(d, "GPG_ERR_PIN_BLOCKED",SWIG_From_long((long)(GPG_ERR_PIN_BLOCKED)));
47797 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USE_CONDITIONS",SWIG_From_long((long)(GPG_ERR_USE_CONDITIONS)));
47798 29 : SWIG_Python_SetConstant(d, "GPG_ERR_PIN_NOT_SYNCED",SWIG_From_long((long)(GPG_ERR_PIN_NOT_SYNCED)));
47799 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CRL",SWIG_From_long((long)(GPG_ERR_INV_CRL)));
47800 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_BER",SWIG_From_long((long)(GPG_ERR_BAD_BER)));
47801 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_BER",SWIG_From_long((long)(GPG_ERR_INV_BER)));
47802 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ELEMENT_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_ELEMENT_NOT_FOUND)));
47803 29 : SWIG_Python_SetConstant(d, "GPG_ERR_IDENTIFIER_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_IDENTIFIER_NOT_FOUND)));
47804 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_TAG",SWIG_From_long((long)(GPG_ERR_INV_TAG)));
47805 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_LENGTH",SWIG_From_long((long)(GPG_ERR_INV_LENGTH)));
47806 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_KEYINFO",SWIG_From_long((long)(GPG_ERR_INV_KEYINFO)));
47807 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNEXPECTED_TAG",SWIG_From_long((long)(GPG_ERR_UNEXPECTED_TAG)));
47808 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_DER_ENCODED",SWIG_From_long((long)(GPG_ERR_NOT_DER_ENCODED)));
47809 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_NO_CMS_OBJ)));
47810 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CMS_OBJ)));
47811 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CMS_OBJ)));
47812 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CMS_OBJ)));
47813 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_ENCODING",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_ENCODING)));
47814 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_CMS_VERSION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CMS_VERSION)));
47815 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_ALGORITHM",SWIG_From_long((long)(GPG_ERR_UNKNOWN_ALGORITHM)));
47816 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ENGINE",SWIG_From_long((long)(GPG_ERR_INV_ENGINE)));
47817 29 : SWIG_Python_SetConstant(d, "GPG_ERR_PUBKEY_NOT_TRUSTED",SWIG_From_long((long)(GPG_ERR_PUBKEY_NOT_TRUSTED)));
47818 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DECRYPT_FAILED",SWIG_From_long((long)(GPG_ERR_DECRYPT_FAILED)));
47819 29 : SWIG_Python_SetConstant(d, "GPG_ERR_KEY_EXPIRED",SWIG_From_long((long)(GPG_ERR_KEY_EXPIRED)));
47820 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SIG_EXPIRED",SWIG_From_long((long)(GPG_ERR_SIG_EXPIRED)));
47821 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENCODING_PROBLEM",SWIG_From_long((long)(GPG_ERR_ENCODING_PROBLEM)));
47822 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_STATE",SWIG_From_long((long)(GPG_ERR_INV_STATE)));
47823 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DUP_VALUE",SWIG_From_long((long)(GPG_ERR_DUP_VALUE)));
47824 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_ACTION",SWIG_From_long((long)(GPG_ERR_MISSING_ACTION)));
47825 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MODULE_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_MODULE_NOT_FOUND)));
47826 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_OID_STRING",SWIG_From_long((long)(GPG_ERR_INV_OID_STRING)));
47827 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_TIME",SWIG_From_long((long)(GPG_ERR_INV_TIME)));
47828 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CRL_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CRL_OBJ)));
47829 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_CRL_VERSION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CRL_VERSION)));
47830 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CERT_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CERT_OBJ)));
47831 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_NAME",SWIG_From_long((long)(GPG_ERR_UNKNOWN_NAME)));
47832 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LOCALE_PROBLEM",SWIG_From_long((long)(GPG_ERR_LOCALE_PROBLEM)));
47833 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_LOCKED",SWIG_From_long((long)(GPG_ERR_NOT_LOCKED)));
47834 29 : SWIG_Python_SetConstant(d, "GPG_ERR_PROTOCOL_VIOLATION",SWIG_From_long((long)(GPG_ERR_PROTOCOL_VIOLATION)));
47835 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_MAC",SWIG_From_long((long)(GPG_ERR_INV_MAC)));
47836 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_REQUEST",SWIG_From_long((long)(GPG_ERR_INV_REQUEST)));
47837 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_EXTN",SWIG_From_long((long)(GPG_ERR_UNKNOWN_EXTN)));
47838 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_CRIT_EXTN",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CRIT_EXTN)));
47839 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LOCKED",SWIG_From_long((long)(GPG_ERR_LOCKED)));
47840 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_OPTION",SWIG_From_long((long)(GPG_ERR_UNKNOWN_OPTION)));
47841 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_COMMAND",SWIG_From_long((long)(GPG_ERR_UNKNOWN_COMMAND)));
47842 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_OPERATIONAL",SWIG_From_long((long)(GPG_ERR_NOT_OPERATIONAL)));
47843 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_NO_PASSPHRASE)));
47844 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PIN",SWIG_From_long((long)(GPG_ERR_NO_PIN)));
47845 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_ENABLED",SWIG_From_long((long)(GPG_ERR_NOT_ENABLED)));
47846 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_ENGINE",SWIG_From_long((long)(GPG_ERR_NO_ENGINE)));
47847 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_KEY",SWIG_From_long((long)(GPG_ERR_MISSING_KEY)));
47848 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_MANY",SWIG_From_long((long)(GPG_ERR_TOO_MANY)));
47849 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LIMIT_REACHED",SWIG_From_long((long)(GPG_ERR_LIMIT_REACHED)));
47850 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_INITIALIZED",SWIG_From_long((long)(GPG_ERR_NOT_INITIALIZED)));
47851 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_ISSUER_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_ISSUER_CERT)));
47852 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_KEYSERVER",SWIG_From_long((long)(GPG_ERR_NO_KEYSERVER)));
47853 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CURVE",SWIG_From_long((long)(GPG_ERR_INV_CURVE)));
47854 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_CURVE",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CURVE)));
47855 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DUP_KEY",SWIG_From_long((long)(GPG_ERR_DUP_KEY)));
47856 29 : SWIG_Python_SetConstant(d, "GPG_ERR_AMBIGUOUS",SWIG_From_long((long)(GPG_ERR_AMBIGUOUS)));
47857 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_NO_CRYPT_CTX)));
47858 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_WRONG_CRYPT_CTX)));
47859 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_BAD_CRYPT_CTX)));
47860 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CRYPT_CTX_CONFLICT",SWIG_From_long((long)(GPG_ERR_CRYPT_CTX_CONFLICT)));
47861 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BROKEN_PUBKEY",SWIG_From_long((long)(GPG_ERR_BROKEN_PUBKEY)));
47862 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BROKEN_SECKEY",SWIG_From_long((long)(GPG_ERR_BROKEN_SECKEY)));
47863 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MAC_ALGO",SWIG_From_long((long)(GPG_ERR_MAC_ALGO)));
47864 29 : SWIG_Python_SetConstant(d, "GPG_ERR_FULLY_CANCELED",SWIG_From_long((long)(GPG_ERR_FULLY_CANCELED)));
47865 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNFINISHED",SWIG_From_long((long)(GPG_ERR_UNFINISHED)));
47866 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BUFFER_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_BUFFER_TOO_SHORT)));
47867 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_INV_LEN_SPEC",SWIG_From_long((long)(GPG_ERR_SEXP_INV_LEN_SPEC)));
47868 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_STRING_TOO_LONG",SWIG_From_long((long)(GPG_ERR_SEXP_STRING_TOO_LONG)));
47869 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_UNMATCHED_PAREN",SWIG_From_long((long)(GPG_ERR_SEXP_UNMATCHED_PAREN)));
47870 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_NOT_CANONICAL",SWIG_From_long((long)(GPG_ERR_SEXP_NOT_CANONICAL)));
47871 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_BAD_CHARACTER",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_CHARACTER)));
47872 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_BAD_QUOTATION",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_QUOTATION)));
47873 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_ZERO_PREFIX",SWIG_From_long((long)(GPG_ERR_SEXP_ZERO_PREFIX)));
47874 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_NESTED_DH",SWIG_From_long((long)(GPG_ERR_SEXP_NESTED_DH)));
47875 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_UNMATCHED_DH",SWIG_From_long((long)(GPG_ERR_SEXP_UNMATCHED_DH)));
47876 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_UNEXPECTED_PUNC",SWIG_From_long((long)(GPG_ERR_SEXP_UNEXPECTED_PUNC)));
47877 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_BAD_HEX_CHAR",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_HEX_CHAR)));
47878 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_ODD_HEX_NUMBERS",SWIG_From_long((long)(GPG_ERR_SEXP_ODD_HEX_NUMBERS)));
47879 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_BAD_OCT_CHAR",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_OCT_CHAR)));
47880 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SUBKEYS_EXP_OR_REV",SWIG_From_long((long)(GPG_ERR_SUBKEYS_EXP_OR_REV)));
47881 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DB_CORRUPTED",SWIG_From_long((long)(GPG_ERR_DB_CORRUPTED)));
47882 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SERVER_FAILED",SWIG_From_long((long)(GPG_ERR_SERVER_FAILED)));
47883 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_NAME",SWIG_From_long((long)(GPG_ERR_NO_NAME)));
47884 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_KEY",SWIG_From_long((long)(GPG_ERR_NO_KEY)));
47885 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LEGACY_KEY",SWIG_From_long((long)(GPG_ERR_LEGACY_KEY)));
47886 29 : SWIG_Python_SetConstant(d, "GPG_ERR_REQUEST_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_REQUEST_TOO_SHORT)));
47887 29 : SWIG_Python_SetConstant(d, "GPG_ERR_REQUEST_TOO_LONG",SWIG_From_long((long)(GPG_ERR_REQUEST_TOO_LONG)));
47888 29 : SWIG_Python_SetConstant(d, "GPG_ERR_OBJ_TERM_STATE",SWIG_From_long((long)(GPG_ERR_OBJ_TERM_STATE)));
47889 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CERT_CHAIN",SWIG_From_long((long)(GPG_ERR_NO_CERT_CHAIN)));
47890 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CERT_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_CERT_TOO_LARGE)));
47891 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_RECORD",SWIG_From_long((long)(GPG_ERR_INV_RECORD)));
47892 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_MAC",SWIG_From_long((long)(GPG_ERR_BAD_MAC)));
47893 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNEXPECTED_MSG",SWIG_From_long((long)(GPG_ERR_UNEXPECTED_MSG)));
47894 29 : SWIG_Python_SetConstant(d, "GPG_ERR_COMPR_FAILED",SWIG_From_long((long)(GPG_ERR_COMPR_FAILED)));
47895 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WOULD_WRAP",SWIG_From_long((long)(GPG_ERR_WOULD_WRAP)));
47896 29 : SWIG_Python_SetConstant(d, "GPG_ERR_FATAL_ALERT",SWIG_From_long((long)(GPG_ERR_FATAL_ALERT)));
47897 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CIPHER",SWIG_From_long((long)(GPG_ERR_NO_CIPHER)));
47898 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_CLIENT_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_CLIENT_CERT)));
47899 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CLOSE_NOTIFY",SWIG_From_long((long)(GPG_ERR_CLOSE_NOTIFY)));
47900 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TICKET_EXPIRED",SWIG_From_long((long)(GPG_ERR_TICKET_EXPIRED)));
47901 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_TICKET",SWIG_From_long((long)(GPG_ERR_BAD_TICKET)));
47902 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_IDENTITY",SWIG_From_long((long)(GPG_ERR_UNKNOWN_IDENTITY)));
47903 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CERT",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT)));
47904 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CERT_REQ",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT_REQ)));
47905 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CERT_VER",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT_VER)));
47906 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CHANGE_CIPHER",SWIG_From_long((long)(GPG_ERR_BAD_HS_CHANGE_CIPHER)));
47907 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CLIENT_HELLO",SWIG_From_long((long)(GPG_ERR_BAD_HS_CLIENT_HELLO)));
47908 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_SERVER_HELLO",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_HELLO)));
47909 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_SERVER_HELLO_DONE",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_HELLO_DONE)));
47910 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_FINISHED",SWIG_From_long((long)(GPG_ERR_BAD_HS_FINISHED)));
47911 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_SERVER_KEX",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_KEX)));
47912 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CLIENT_KEX",SWIG_From_long((long)(GPG_ERR_BAD_HS_CLIENT_KEX)));
47913 29 : SWIG_Python_SetConstant(d, "GPG_ERR_BOGUS_STRING",SWIG_From_long((long)(GPG_ERR_BOGUS_STRING)));
47914 29 : SWIG_Python_SetConstant(d, "GPG_ERR_FORBIDDEN",SWIG_From_long((long)(GPG_ERR_FORBIDDEN)));
47915 29 : SWIG_Python_SetConstant(d, "GPG_ERR_KEY_DISABLED",SWIG_From_long((long)(GPG_ERR_KEY_DISABLED)));
47916 29 : SWIG_Python_SetConstant(d, "GPG_ERR_KEY_ON_CARD",SWIG_From_long((long)(GPG_ERR_KEY_ON_CARD)));
47917 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_LOCK_OBJ",SWIG_From_long((long)(GPG_ERR_INV_LOCK_OBJ)));
47918 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TRUE",SWIG_From_long((long)(GPG_ERR_TRUE)));
47919 29 : SWIG_Python_SetConstant(d, "GPG_ERR_FALSE",SWIG_From_long((long)(GPG_ERR_FALSE)));
47920 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_GENERAL",SWIG_From_long((long)(GPG_ERR_ASS_GENERAL)));
47921 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_ACCEPT_FAILED",SWIG_From_long((long)(GPG_ERR_ASS_ACCEPT_FAILED)));
47922 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_CONNECT_FAILED",SWIG_From_long((long)(GPG_ERR_ASS_CONNECT_FAILED)));
47923 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_INV_RESPONSE",SWIG_From_long((long)(GPG_ERR_ASS_INV_RESPONSE)));
47924 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_INV_VALUE",SWIG_From_long((long)(GPG_ERR_ASS_INV_VALUE)));
47925 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_INCOMPLETE_LINE",SWIG_From_long((long)(GPG_ERR_ASS_INCOMPLETE_LINE)));
47926 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_LINE_TOO_LONG",SWIG_From_long((long)(GPG_ERR_ASS_LINE_TOO_LONG)));
47927 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NESTED_COMMANDS",SWIG_From_long((long)(GPG_ERR_ASS_NESTED_COMMANDS)));
47928 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NO_DATA_CB",SWIG_From_long((long)(GPG_ERR_ASS_NO_DATA_CB)));
47929 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NO_INQUIRE_CB",SWIG_From_long((long)(GPG_ERR_ASS_NO_INQUIRE_CB)));
47930 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NOT_A_SERVER",SWIG_From_long((long)(GPG_ERR_ASS_NOT_A_SERVER)));
47931 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NOT_A_CLIENT",SWIG_From_long((long)(GPG_ERR_ASS_NOT_A_CLIENT)));
47932 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_SERVER_START",SWIG_From_long((long)(GPG_ERR_ASS_SERVER_START)));
47933 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_READ_ERROR",SWIG_From_long((long)(GPG_ERR_ASS_READ_ERROR)));
47934 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_WRITE_ERROR",SWIG_From_long((long)(GPG_ERR_ASS_WRITE_ERROR)));
47935 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_TOO_MUCH_DATA",SWIG_From_long((long)(GPG_ERR_ASS_TOO_MUCH_DATA)));
47936 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_UNEXPECTED_CMD",SWIG_From_long((long)(GPG_ERR_ASS_UNEXPECTED_CMD)));
47937 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_UNKNOWN_CMD",SWIG_From_long((long)(GPG_ERR_ASS_UNKNOWN_CMD)));
47938 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_SYNTAX",SWIG_From_long((long)(GPG_ERR_ASS_SYNTAX)));
47939 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_CANCELED",SWIG_From_long((long)(GPG_ERR_ASS_CANCELED)));
47940 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NO_INPUT",SWIG_From_long((long)(GPG_ERR_ASS_NO_INPUT)));
47941 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NO_OUTPUT",SWIG_From_long((long)(GPG_ERR_ASS_NO_OUTPUT)));
47942 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_PARAMETER",SWIG_From_long((long)(GPG_ERR_ASS_PARAMETER)));
47943 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_UNKNOWN_INQUIRE",SWIG_From_long((long)(GPG_ERR_ASS_UNKNOWN_INQUIRE)));
47944 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENGINE_TOO_OLD",SWIG_From_long((long)(GPG_ERR_ENGINE_TOO_OLD)));
47945 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WINDOW_TOO_SMALL",SWIG_From_long((long)(GPG_ERR_WINDOW_TOO_SMALL)));
47946 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WINDOW_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_WINDOW_TOO_LARGE)));
47947 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_ENVVAR",SWIG_From_long((long)(GPG_ERR_MISSING_ENVVAR)));
47948 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_ID_EXISTS",SWIG_From_long((long)(GPG_ERR_USER_ID_EXISTS)));
47949 29 : SWIG_Python_SetConstant(d, "GPG_ERR_NAME_EXISTS",SWIG_From_long((long)(GPG_ERR_NAME_EXISTS)));
47950 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DUP_NAME",SWIG_From_long((long)(GPG_ERR_DUP_NAME)));
47951 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_YOUNG",SWIG_From_long((long)(GPG_ERR_TOO_YOUNG)));
47952 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_OLD",SWIG_From_long((long)(GPG_ERR_TOO_OLD)));
47953 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_FLAG",SWIG_From_long((long)(GPG_ERR_UNKNOWN_FLAG)));
47954 29 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ORDER",SWIG_From_long((long)(GPG_ERR_INV_ORDER)));
47955 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ALREADY_FETCHED",SWIG_From_long((long)(GPG_ERR_ALREADY_FETCHED)));
47956 29 : SWIG_Python_SetConstant(d, "GPG_ERR_TRY_LATER",SWIG_From_long((long)(GPG_ERR_TRY_LATER)));
47957 29 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_NAME",SWIG_From_long((long)(GPG_ERR_WRONG_NAME)));
47958 29 : SWIG_Python_SetConstant(d, "GPG_ERR_SYSTEM_BUG",SWIG_From_long((long)(GPG_ERR_SYSTEM_BUG)));
47959 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_UNKNOWN",SWIG_From_long((long)(GPG_ERR_DNS_UNKNOWN)));
47960 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_SECTION",SWIG_From_long((long)(GPG_ERR_DNS_SECTION)));
47961 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_ADDRESS",SWIG_From_long((long)(GPG_ERR_DNS_ADDRESS)));
47962 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_NO_QUERY",SWIG_From_long((long)(GPG_ERR_DNS_NO_QUERY)));
47963 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_NO_ANSWER",SWIG_From_long((long)(GPG_ERR_DNS_NO_ANSWER)));
47964 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_CLOSED",SWIG_From_long((long)(GPG_ERR_DNS_CLOSED)));
47965 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_VERIFY",SWIG_From_long((long)(GPG_ERR_DNS_VERIFY)));
47966 29 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_TIMEOUT",SWIG_From_long((long)(GPG_ERR_DNS_TIMEOUT)));
47967 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_GENERAL)));
47968 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ATTR_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_ATTR_GENERAL)));
47969 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NAME_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_NAME_GENERAL)));
47970 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SECURITY_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_SECURITY_GENERAL)));
47971 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SERVICE_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_SERVICE_GENERAL)));
47972 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UPDATE_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_UPDATE_GENERAL)));
47973 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_E_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_E_GENERAL)));
47974 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_X_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_X_GENERAL)));
47975 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_OTHER_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_OTHER_GENERAL)));
47976 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_X_CONNECTING",SWIG_From_long((long)(GPG_ERR_LDAP_X_CONNECTING)));
47977 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_REFERRAL_LIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_REFERRAL_LIMIT)));
47978 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CLIENT_LOOP",SWIG_From_long((long)(GPG_ERR_LDAP_CLIENT_LOOP)));
47979 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_RESULTS",SWIG_From_long((long)(GPG_ERR_LDAP_NO_RESULTS)));
47980 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CONTROL_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_LDAP_CONTROL_NOT_FOUND)));
47981 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NOT_SUPPORTED",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_SUPPORTED)));
47982 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CONNECT",SWIG_From_long((long)(GPG_ERR_LDAP_CONNECT)));
47983 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_MEMORY",SWIG_From_long((long)(GPG_ERR_LDAP_NO_MEMORY)));
47984 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_PARAM",SWIG_From_long((long)(GPG_ERR_LDAP_PARAM)));
47985 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_USER_CANCELLED",SWIG_From_long((long)(GPG_ERR_LDAP_USER_CANCELLED)));
47986 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_FILTER",SWIG_From_long((long)(GPG_ERR_LDAP_FILTER)));
47987 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_AUTH_UNKNOWN",SWIG_From_long((long)(GPG_ERR_LDAP_AUTH_UNKNOWN)));
47988 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_TIMEOUT",SWIG_From_long((long)(GPG_ERR_LDAP_TIMEOUT)));
47989 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_DECODING",SWIG_From_long((long)(GPG_ERR_LDAP_DECODING)));
47990 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ENCODING",SWIG_From_long((long)(GPG_ERR_LDAP_ENCODING)));
47991 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_LOCAL",SWIG_From_long((long)(GPG_ERR_LDAP_LOCAL)));
47992 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SERVER_DOWN",SWIG_From_long((long)(GPG_ERR_LDAP_SERVER_DOWN)));
47993 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SUCCESS",SWIG_From_long((long)(GPG_ERR_LDAP_SUCCESS)));
47994 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_OPERATIONS",SWIG_From_long((long)(GPG_ERR_LDAP_OPERATIONS)));
47995 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_PROTOCOL",SWIG_From_long((long)(GPG_ERR_LDAP_PROTOCOL)));
47996 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_TIMELIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_TIMELIMIT)));
47997 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SIZELIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_SIZELIMIT)));
47998 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_COMPARE_FALSE",SWIG_From_long((long)(GPG_ERR_LDAP_COMPARE_FALSE)));
47999 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_COMPARE_TRUE",SWIG_From_long((long)(GPG_ERR_LDAP_COMPARE_TRUE)));
48000 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNSUPPORTED_AUTH",SWIG_From_long((long)(GPG_ERR_LDAP_UNSUPPORTED_AUTH)));
48001 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_STRONG_AUTH_RQRD",SWIG_From_long((long)(GPG_ERR_LDAP_STRONG_AUTH_RQRD)));
48002 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_PARTIAL_RESULTS",SWIG_From_long((long)(GPG_ERR_LDAP_PARTIAL_RESULTS)));
48003 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_REFERRAL",SWIG_From_long((long)(GPG_ERR_LDAP_REFERRAL)));
48004 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ADMINLIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_ADMINLIMIT)));
48005 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN",SWIG_From_long((long)(GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN)));
48006 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CONFIDENT_RQRD",SWIG_From_long((long)(GPG_ERR_LDAP_CONFIDENT_RQRD)));
48007 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SASL_BIND_INPROG",SWIG_From_long((long)(GPG_ERR_LDAP_SASL_BIND_INPROG)));
48008 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE)));
48009 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNDEFINED_TYPE",SWIG_From_long((long)(GPG_ERR_LDAP_UNDEFINED_TYPE)));
48010 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_BAD_MATCHING",SWIG_From_long((long)(GPG_ERR_LDAP_BAD_MATCHING)));
48011 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CONST_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_CONST_VIOLATION)));
48012 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_TYPE_VALUE_EXISTS",SWIG_From_long((long)(GPG_ERR_LDAP_TYPE_VALUE_EXISTS)));
48013 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_INV_SYNTAX",SWIG_From_long((long)(GPG_ERR_LDAP_INV_SYNTAX)));
48014 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_SUCH_OBJ",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_OBJ)));
48015 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ALIAS_PROBLEM",SWIG_From_long((long)(GPG_ERR_LDAP_ALIAS_PROBLEM)));
48016 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_INV_DN_SYNTAX",SWIG_From_long((long)(GPG_ERR_LDAP_INV_DN_SYNTAX)));
48017 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_IS_LEAF",SWIG_From_long((long)(GPG_ERR_LDAP_IS_LEAF)));
48018 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ALIAS_DEREF",SWIG_From_long((long)(GPG_ERR_LDAP_ALIAS_DEREF)));
48019 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_X_PROXY_AUTH_FAIL",SWIG_From_long((long)(GPG_ERR_LDAP_X_PROXY_AUTH_FAIL)));
48020 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_BAD_AUTH",SWIG_From_long((long)(GPG_ERR_LDAP_BAD_AUTH)));
48021 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_INV_CREDENTIALS",SWIG_From_long((long)(GPG_ERR_LDAP_INV_CREDENTIALS)));
48022 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_INSUFFICIENT_ACC",SWIG_From_long((long)(GPG_ERR_LDAP_INSUFFICIENT_ACC)));
48023 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_BUSY",SWIG_From_long((long)(GPG_ERR_LDAP_BUSY)));
48024 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNAVAILABLE",SWIG_From_long((long)(GPG_ERR_LDAP_UNAVAILABLE)));
48025 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNWILL_TO_PERFORM",SWIG_From_long((long)(GPG_ERR_LDAP_UNWILL_TO_PERFORM)));
48026 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_LOOP_DETECT",SWIG_From_long((long)(GPG_ERR_LDAP_LOOP_DETECT)));
48027 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NAMING_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_NAMING_VIOLATION)));
48028 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_OBJ_CLS_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_OBJ_CLS_VIOLATION)));
48029 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NOT_ALLOW_NONLEAF",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_ALLOW_NONLEAF)));
48030 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NOT_ALLOW_ON_RDN",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_ALLOW_ON_RDN)));
48031 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ALREADY_EXISTS",SWIG_From_long((long)(GPG_ERR_LDAP_ALREADY_EXISTS)));
48032 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_OBJ_CLASS_MODS",SWIG_From_long((long)(GPG_ERR_LDAP_NO_OBJ_CLASS_MODS)));
48033 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_RESULTS_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_LDAP_RESULTS_TOO_LARGE)));
48034 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_AFFECTS_MULT_DSAS",SWIG_From_long((long)(GPG_ERR_LDAP_AFFECTS_MULT_DSAS)));
48035 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_VLV",SWIG_From_long((long)(GPG_ERR_LDAP_VLV)));
48036 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_OTHER",SWIG_From_long((long)(GPG_ERR_LDAP_OTHER)));
48037 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_RESOURCE_LIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_RESOURCE_LIMIT)));
48038 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_SEC_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_SEC_VIOLATION)));
48039 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_INV_DATA",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_INV_DATA)));
48040 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_UNSUP_SCHEME",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_UNSUP_SCHEME)));
48041 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_RELOAD",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_RELOAD)));
48042 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CANCELLED",SWIG_From_long((long)(GPG_ERR_LDAP_CANCELLED)));
48043 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_SUCH_OPERATION",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_OPERATION)));
48044 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_TOO_LATE",SWIG_From_long((long)(GPG_ERR_LDAP_TOO_LATE)));
48045 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CANNOT_CANCEL",SWIG_From_long((long)(GPG_ERR_LDAP_CANNOT_CANCEL)));
48046 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ASSERTION_FAILED",SWIG_From_long((long)(GPG_ERR_LDAP_ASSERTION_FAILED)));
48047 29 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_PROX_AUTH_DENIED",SWIG_From_long((long)(GPG_ERR_LDAP_PROX_AUTH_DENIED)));
48048 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_1",SWIG_From_long((long)(GPG_ERR_USER_1)));
48049 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_2",SWIG_From_long((long)(GPG_ERR_USER_2)));
48050 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_3",SWIG_From_long((long)(GPG_ERR_USER_3)));
48051 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_4",SWIG_From_long((long)(GPG_ERR_USER_4)));
48052 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_5",SWIG_From_long((long)(GPG_ERR_USER_5)));
48053 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_6",SWIG_From_long((long)(GPG_ERR_USER_6)));
48054 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_7",SWIG_From_long((long)(GPG_ERR_USER_7)));
48055 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_8",SWIG_From_long((long)(GPG_ERR_USER_8)));
48056 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_9",SWIG_From_long((long)(GPG_ERR_USER_9)));
48057 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_10",SWIG_From_long((long)(GPG_ERR_USER_10)));
48058 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_11",SWIG_From_long((long)(GPG_ERR_USER_11)));
48059 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_12",SWIG_From_long((long)(GPG_ERR_USER_12)));
48060 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_13",SWIG_From_long((long)(GPG_ERR_USER_13)));
48061 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_14",SWIG_From_long((long)(GPG_ERR_USER_14)));
48062 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_15",SWIG_From_long((long)(GPG_ERR_USER_15)));
48063 29 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_16",SWIG_From_long((long)(GPG_ERR_USER_16)));
48064 29 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_ERRNO",SWIG_From_long((long)(GPG_ERR_MISSING_ERRNO)));
48065 29 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_ERRNO",SWIG_From_long((long)(GPG_ERR_UNKNOWN_ERRNO)));
48066 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EOF",SWIG_From_long((long)(GPG_ERR_EOF)));
48067 29 : SWIG_Python_SetConstant(d, "GPG_ERR_E2BIG",SWIG_From_long((long)(GPG_ERR_E2BIG)));
48068 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EACCES",SWIG_From_long((long)(GPG_ERR_EACCES)));
48069 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EADDRINUSE",SWIG_From_long((long)(GPG_ERR_EADDRINUSE)));
48070 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EADDRNOTAVAIL",SWIG_From_long((long)(GPG_ERR_EADDRNOTAVAIL)));
48071 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EADV",SWIG_From_long((long)(GPG_ERR_EADV)));
48072 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EAFNOSUPPORT",SWIG_From_long((long)(GPG_ERR_EAFNOSUPPORT)));
48073 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EAGAIN",SWIG_From_long((long)(GPG_ERR_EAGAIN)));
48074 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EALREADY",SWIG_From_long((long)(GPG_ERR_EALREADY)));
48075 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EAUTH",SWIG_From_long((long)(GPG_ERR_EAUTH)));
48076 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBACKGROUND",SWIG_From_long((long)(GPG_ERR_EBACKGROUND)));
48077 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADE",SWIG_From_long((long)(GPG_ERR_EBADE)));
48078 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADF",SWIG_From_long((long)(GPG_ERR_EBADF)));
48079 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADFD",SWIG_From_long((long)(GPG_ERR_EBADFD)));
48080 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADMSG",SWIG_From_long((long)(GPG_ERR_EBADMSG)));
48081 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADR",SWIG_From_long((long)(GPG_ERR_EBADR)));
48082 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADRPC",SWIG_From_long((long)(GPG_ERR_EBADRPC)));
48083 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADRQC",SWIG_From_long((long)(GPG_ERR_EBADRQC)));
48084 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADSLT",SWIG_From_long((long)(GPG_ERR_EBADSLT)));
48085 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBFONT",SWIG_From_long((long)(GPG_ERR_EBFONT)));
48086 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EBUSY",SWIG_From_long((long)(GPG_ERR_EBUSY)));
48087 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ECANCELED",SWIG_From_long((long)(GPG_ERR_ECANCELED)));
48088 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ECHILD",SWIG_From_long((long)(GPG_ERR_ECHILD)));
48089 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ECHRNG",SWIG_From_long((long)(GPG_ERR_ECHRNG)));
48090 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ECOMM",SWIG_From_long((long)(GPG_ERR_ECOMM)));
48091 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ECONNABORTED",SWIG_From_long((long)(GPG_ERR_ECONNABORTED)));
48092 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ECONNREFUSED",SWIG_From_long((long)(GPG_ERR_ECONNREFUSED)));
48093 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ECONNRESET",SWIG_From_long((long)(GPG_ERR_ECONNRESET)));
48094 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ED",SWIG_From_long((long)(GPG_ERR_ED)));
48095 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EDEADLK",SWIG_From_long((long)(GPG_ERR_EDEADLK)));
48096 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EDEADLOCK",SWIG_From_long((long)(GPG_ERR_EDEADLOCK)));
48097 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EDESTADDRREQ",SWIG_From_long((long)(GPG_ERR_EDESTADDRREQ)));
48098 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EDIED",SWIG_From_long((long)(GPG_ERR_EDIED)));
48099 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EDOM",SWIG_From_long((long)(GPG_ERR_EDOM)));
48100 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EDOTDOT",SWIG_From_long((long)(GPG_ERR_EDOTDOT)));
48101 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EDQUOT",SWIG_From_long((long)(GPG_ERR_EDQUOT)));
48102 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EEXIST",SWIG_From_long((long)(GPG_ERR_EEXIST)));
48103 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EFAULT",SWIG_From_long((long)(GPG_ERR_EFAULT)));
48104 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EFBIG",SWIG_From_long((long)(GPG_ERR_EFBIG)));
48105 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EFTYPE",SWIG_From_long((long)(GPG_ERR_EFTYPE)));
48106 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EGRATUITOUS",SWIG_From_long((long)(GPG_ERR_EGRATUITOUS)));
48107 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EGREGIOUS",SWIG_From_long((long)(GPG_ERR_EGREGIOUS)));
48108 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EHOSTDOWN",SWIG_From_long((long)(GPG_ERR_EHOSTDOWN)));
48109 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EHOSTUNREACH",SWIG_From_long((long)(GPG_ERR_EHOSTUNREACH)));
48110 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EIDRM",SWIG_From_long((long)(GPG_ERR_EIDRM)));
48111 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EIEIO",SWIG_From_long((long)(GPG_ERR_EIEIO)));
48112 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EILSEQ",SWIG_From_long((long)(GPG_ERR_EILSEQ)));
48113 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EINPROGRESS",SWIG_From_long((long)(GPG_ERR_EINPROGRESS)));
48114 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EINTR",SWIG_From_long((long)(GPG_ERR_EINTR)));
48115 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EINVAL",SWIG_From_long((long)(GPG_ERR_EINVAL)));
48116 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EIO",SWIG_From_long((long)(GPG_ERR_EIO)));
48117 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EISCONN",SWIG_From_long((long)(GPG_ERR_EISCONN)));
48118 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EISDIR",SWIG_From_long((long)(GPG_ERR_EISDIR)));
48119 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EISNAM",SWIG_From_long((long)(GPG_ERR_EISNAM)));
48120 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EL2HLT",SWIG_From_long((long)(GPG_ERR_EL2HLT)));
48121 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EL2NSYNC",SWIG_From_long((long)(GPG_ERR_EL2NSYNC)));
48122 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EL3HLT",SWIG_From_long((long)(GPG_ERR_EL3HLT)));
48123 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EL3RST",SWIG_From_long((long)(GPG_ERR_EL3RST)));
48124 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBACC",SWIG_From_long((long)(GPG_ERR_ELIBACC)));
48125 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBBAD",SWIG_From_long((long)(GPG_ERR_ELIBBAD)));
48126 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBEXEC",SWIG_From_long((long)(GPG_ERR_ELIBEXEC)));
48127 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBMAX",SWIG_From_long((long)(GPG_ERR_ELIBMAX)));
48128 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBSCN",SWIG_From_long((long)(GPG_ERR_ELIBSCN)));
48129 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ELNRNG",SWIG_From_long((long)(GPG_ERR_ELNRNG)));
48130 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ELOOP",SWIG_From_long((long)(GPG_ERR_ELOOP)));
48131 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EMEDIUMTYPE",SWIG_From_long((long)(GPG_ERR_EMEDIUMTYPE)));
48132 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EMFILE",SWIG_From_long((long)(GPG_ERR_EMFILE)));
48133 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EMLINK",SWIG_From_long((long)(GPG_ERR_EMLINK)));
48134 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EMSGSIZE",SWIG_From_long((long)(GPG_ERR_EMSGSIZE)));
48135 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EMULTIHOP",SWIG_From_long((long)(GPG_ERR_EMULTIHOP)));
48136 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENAMETOOLONG",SWIG_From_long((long)(GPG_ERR_ENAMETOOLONG)));
48137 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENAVAIL",SWIG_From_long((long)(GPG_ERR_ENAVAIL)));
48138 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENEEDAUTH",SWIG_From_long((long)(GPG_ERR_ENEEDAUTH)));
48139 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENETDOWN",SWIG_From_long((long)(GPG_ERR_ENETDOWN)));
48140 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENETRESET",SWIG_From_long((long)(GPG_ERR_ENETRESET)));
48141 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENETUNREACH",SWIG_From_long((long)(GPG_ERR_ENETUNREACH)));
48142 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENFILE",SWIG_From_long((long)(GPG_ERR_ENFILE)));
48143 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOANO",SWIG_From_long((long)(GPG_ERR_ENOANO)));
48144 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOBUFS",SWIG_From_long((long)(GPG_ERR_ENOBUFS)));
48145 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOCSI",SWIG_From_long((long)(GPG_ERR_ENOCSI)));
48146 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENODATA",SWIG_From_long((long)(GPG_ERR_ENODATA)));
48147 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENODEV",SWIG_From_long((long)(GPG_ERR_ENODEV)));
48148 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOENT",SWIG_From_long((long)(GPG_ERR_ENOENT)));
48149 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOEXEC",SWIG_From_long((long)(GPG_ERR_ENOEXEC)));
48150 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOLCK",SWIG_From_long((long)(GPG_ERR_ENOLCK)));
48151 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOLINK",SWIG_From_long((long)(GPG_ERR_ENOLINK)));
48152 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOMEDIUM",SWIG_From_long((long)(GPG_ERR_ENOMEDIUM)));
48153 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOMEM",SWIG_From_long((long)(GPG_ERR_ENOMEM)));
48154 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOMSG",SWIG_From_long((long)(GPG_ERR_ENOMSG)));
48155 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENONET",SWIG_From_long((long)(GPG_ERR_ENONET)));
48156 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOPKG",SWIG_From_long((long)(GPG_ERR_ENOPKG)));
48157 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOPROTOOPT",SWIG_From_long((long)(GPG_ERR_ENOPROTOOPT)));
48158 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOSPC",SWIG_From_long((long)(GPG_ERR_ENOSPC)));
48159 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOSR",SWIG_From_long((long)(GPG_ERR_ENOSR)));
48160 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOSTR",SWIG_From_long((long)(GPG_ERR_ENOSTR)));
48161 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOSYS",SWIG_From_long((long)(GPG_ERR_ENOSYS)));
48162 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTBLK",SWIG_From_long((long)(GPG_ERR_ENOTBLK)));
48163 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTCONN",SWIG_From_long((long)(GPG_ERR_ENOTCONN)));
48164 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTDIR",SWIG_From_long((long)(GPG_ERR_ENOTDIR)));
48165 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTEMPTY",SWIG_From_long((long)(GPG_ERR_ENOTEMPTY)));
48166 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTNAM",SWIG_From_long((long)(GPG_ERR_ENOTNAM)));
48167 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTSOCK",SWIG_From_long((long)(GPG_ERR_ENOTSOCK)));
48168 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTSUP",SWIG_From_long((long)(GPG_ERR_ENOTSUP)));
48169 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTTY",SWIG_From_long((long)(GPG_ERR_ENOTTY)));
48170 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTUNIQ",SWIG_From_long((long)(GPG_ERR_ENOTUNIQ)));
48171 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ENXIO",SWIG_From_long((long)(GPG_ERR_ENXIO)));
48172 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EOPNOTSUPP",SWIG_From_long((long)(GPG_ERR_EOPNOTSUPP)));
48173 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EOVERFLOW",SWIG_From_long((long)(GPG_ERR_EOVERFLOW)));
48174 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPERM",SWIG_From_long((long)(GPG_ERR_EPERM)));
48175 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPFNOSUPPORT",SWIG_From_long((long)(GPG_ERR_EPFNOSUPPORT)));
48176 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPIPE",SWIG_From_long((long)(GPG_ERR_EPIPE)));
48177 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROCLIM",SWIG_From_long((long)(GPG_ERR_EPROCLIM)));
48178 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROCUNAVAIL",SWIG_From_long((long)(GPG_ERR_EPROCUNAVAIL)));
48179 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROGMISMATCH",SWIG_From_long((long)(GPG_ERR_EPROGMISMATCH)));
48180 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROGUNAVAIL",SWIG_From_long((long)(GPG_ERR_EPROGUNAVAIL)));
48181 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROTO",SWIG_From_long((long)(GPG_ERR_EPROTO)));
48182 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROTONOSUPPORT",SWIG_From_long((long)(GPG_ERR_EPROTONOSUPPORT)));
48183 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROTOTYPE",SWIG_From_long((long)(GPG_ERR_EPROTOTYPE)));
48184 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ERANGE",SWIG_From_long((long)(GPG_ERR_ERANGE)));
48185 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EREMCHG",SWIG_From_long((long)(GPG_ERR_EREMCHG)));
48186 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EREMOTE",SWIG_From_long((long)(GPG_ERR_EREMOTE)));
48187 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EREMOTEIO",SWIG_From_long((long)(GPG_ERR_EREMOTEIO)));
48188 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ERESTART",SWIG_From_long((long)(GPG_ERR_ERESTART)));
48189 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EROFS",SWIG_From_long((long)(GPG_ERR_EROFS)));
48190 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ERPCMISMATCH",SWIG_From_long((long)(GPG_ERR_ERPCMISMATCH)));
48191 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ESHUTDOWN",SWIG_From_long((long)(GPG_ERR_ESHUTDOWN)));
48192 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ESOCKTNOSUPPORT",SWIG_From_long((long)(GPG_ERR_ESOCKTNOSUPPORT)));
48193 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ESPIPE",SWIG_From_long((long)(GPG_ERR_ESPIPE)));
48194 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ESRCH",SWIG_From_long((long)(GPG_ERR_ESRCH)));
48195 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ESRMNT",SWIG_From_long((long)(GPG_ERR_ESRMNT)));
48196 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ESTALE",SWIG_From_long((long)(GPG_ERR_ESTALE)));
48197 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ESTRPIPE",SWIG_From_long((long)(GPG_ERR_ESTRPIPE)));
48198 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ETIME",SWIG_From_long((long)(GPG_ERR_ETIME)));
48199 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ETIMEDOUT",SWIG_From_long((long)(GPG_ERR_ETIMEDOUT)));
48200 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ETOOMANYREFS",SWIG_From_long((long)(GPG_ERR_ETOOMANYREFS)));
48201 29 : SWIG_Python_SetConstant(d, "GPG_ERR_ETXTBSY",SWIG_From_long((long)(GPG_ERR_ETXTBSY)));
48202 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EUCLEAN",SWIG_From_long((long)(GPG_ERR_EUCLEAN)));
48203 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EUNATCH",SWIG_From_long((long)(GPG_ERR_EUNATCH)));
48204 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EUSERS",SWIG_From_long((long)(GPG_ERR_EUSERS)));
48205 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EWOULDBLOCK",SWIG_From_long((long)(GPG_ERR_EWOULDBLOCK)));
48206 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EXDEV",SWIG_From_long((long)(GPG_ERR_EXDEV)));
48207 29 : SWIG_Python_SetConstant(d, "GPG_ERR_EXFULL",SWIG_From_long((long)(GPG_ERR_EXFULL)));
48208 29 : SWIG_Python_SetConstant(d, "GPG_ERR_CODE_DIM",SWIG_From_long((long)(GPG_ERR_CODE_DIM)));
48209 29 : PyDict_SetItemString(md,(char*)"cvar", SWIG_globals());
48210 29 : SWIG_addvarlink(SWIG_globals(),(char*)"gpg_in_tree_build",Swig_var_gpg_in_tree_build_get, Swig_var_gpg_in_tree_build_set);
48211 :
48212 : /* Initialize threading */
48213 29 : SWIG_PYTHON_INITIALIZE_THREADS;
48214 : #if PY_VERSION_HEX >= 0x03000000
48215 29 : return m;
48216 : #else
48217 : return;
48218 : #endif
48219 : }
48220 :
|
