1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 3.0.12
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIG_PYTHON_STRICT_BYTE_CHAR
12 #if defined(_MSC_VER)
13 /* Prevent "non-constant aggregate initializer" errors from Python.h in
14 * Python 3.9 */
15 # pragma warning(default : 4204)
16 #endif
17
18
19
20 #ifndef SWIGPYTHON
21 #define SWIGPYTHON
22 #endif
23
24 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
25
26 /* -----------------------------------------------------------------------------
27 * This section contains generic SWIG labels for method/variable
28 * declarations/attributes, and other compiler dependent labels.
29 * ----------------------------------------------------------------------------- */
30
31 /* template workaround for compilers that cannot correctly implement the C++ standard */
32 #ifndef SWIGTEMPLATEDISAMBIGUATOR
33 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
34 # define SWIGTEMPLATEDISAMBIGUATOR template
35 # elif defined(__HP_aCC)
36 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
37 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
38 # define SWIGTEMPLATEDISAMBIGUATOR template
39 # else
40 # define SWIGTEMPLATEDISAMBIGUATOR
41 # endif
42 #endif
43
44 /* inline attribute */
45 #ifndef SWIGINLINE
46 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
47 # define SWIGINLINE inline
48 # else
49 # define SWIGINLINE
50 # endif
51 #endif
52
53 /* attribute recognised by some compilers to avoid 'unused' warnings */
54 #ifndef SWIGUNUSED
55 # if defined(__GNUC__)
56 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
57 # define SWIGUNUSED __attribute__ ((__unused__))
58 # else
59 # define SWIGUNUSED
60 # endif
61 # elif defined(__ICC)
62 # define SWIGUNUSED __attribute__ ((__unused__))
63 # else
64 # define SWIGUNUSED
65 # endif
66 #endif
67
68 #ifndef SWIG_MSC_UNSUPPRESS_4505
69 # if defined(_MSC_VER)
70 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
71 # endif
72 #endif
73
74 #ifndef SWIGUNUSEDPARM
75 # ifdef __cplusplus
76 # define SWIGUNUSEDPARM(p)
77 # else
78 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
79 # endif
80 #endif
81
82 /* internal SWIG method */
83 #ifndef SWIGINTERN
84 # define SWIGINTERN static SWIGUNUSED
85 #endif
86
87 /* internal inline SWIG method */
88 #ifndef SWIGINTERNINLINE
89 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
90 #endif
91
92 /* exporting methods */
93 #if defined(__GNUC__)
94 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
95 # ifndef GCC_HASCLASSVISIBILITY
96 # define GCC_HASCLASSVISIBILITY
97 # endif
98 # endif
99 #endif
100
101 #ifndef SWIGEXPORT
102 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
103 # if defined(STATIC_LINKED)
104 # define SWIGEXPORT
105 # else
106 # define SWIGEXPORT __declspec(dllexport)
107 # endif
108 # else
109 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
110 # define SWIGEXPORT __attribute__ ((visibility("default")))
111 # else
112 # define SWIGEXPORT
113 # endif
114 # endif
115 #endif
116
117 /* calling conventions for Windows */
118 #ifndef SWIGSTDCALL
119 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
120 # define SWIGSTDCALL __stdcall
121 # else
122 # define SWIGSTDCALL
123 # endif
124 #endif
125
126 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
127 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
128 # define _CRT_SECURE_NO_DEPRECATE
129 #endif
130
131 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
132 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
133 # define _SCL_SECURE_NO_DEPRECATE
134 #endif
135
136 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
137 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
138 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
139 #endif
140
141 /* Intel's compiler complains if a variable which was never initialised is
142 * cast to void, which is a common idiom which we use to indicate that we
143 * are aware a variable isn't used. So we just silence that warning.
144 * See: https://github.com/swig/swig/issues/192 for more discussion.
145 */
146 #ifdef __INTEL_COMPILER
147 # pragma warning disable 592
148 #endif
149
150
151 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
152 /* Use debug wrappers with the Python release dll */
153 # undef _DEBUG
154 # include <Python.h>
155 # define _DEBUG
156 #else
157 # include <Python.h>
158 #endif
159
160 /* -----------------------------------------------------------------------------
161 * swigrun.swg
162 *
163 * This file contains generic C API SWIG runtime support for pointer
164 * type checking.
165 * ----------------------------------------------------------------------------- */
166
167 /* This should only be incremented when either the layout of swig_type_info changes,
168 or for whatever reason, the runtime changes incompatibly */
169 #define SWIG_RUNTIME_VERSION "4"
170
171 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
172 #ifdef SWIG_TYPE_TABLE
173 # define SWIG_QUOTE_STRING(x) #x
174 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
175 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
176 #else
177 # define SWIG_TYPE_TABLE_NAME
178 #endif
179
180 /*
181 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
182 creating a static or dynamic library from the SWIG runtime code.
183 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
184
185 But only do this if strictly necessary, ie, if you have problems
186 with your compiler or suchlike.
187 */
188
189 #ifndef SWIGRUNTIME
190 # define SWIGRUNTIME SWIGINTERN
191 #endif
192
193 #ifndef SWIGRUNTIMEINLINE
194 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
195 #endif
196
197 /* Generic buffer size */
198 #ifndef SWIG_BUFFER_SIZE
199 # define SWIG_BUFFER_SIZE 1024
200 #endif
201
202 /* Flags for pointer conversions */
203 #define SWIG_POINTER_DISOWN 0x1
204 #define SWIG_CAST_NEW_MEMORY 0x2
205
206 /* Flags for new pointer objects */
207 #define SWIG_POINTER_OWN 0x1
208
209
210 /*
211 Flags/methods for returning states.
212
213 The SWIG conversion methods, as ConvertPtr, return an integer
214 that tells if the conversion was successful or not. And if not,
215 an error code can be returned (see swigerrors.swg for the codes).
216
217 Use the following macros/flags to set or process the returning
218 states.
219
220 In old versions of SWIG, code such as the following was usually written:
221
222 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
223 // success code
224 } else {
225 //fail code
226 }
227
228 Now you can be more explicit:
229
230 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
231 if (SWIG_IsOK(res)) {
232 // success code
233 } else {
234 // fail code
235 }
236
237 which is the same really, but now you can also do
238
239 Type *ptr;
240 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
241 if (SWIG_IsOK(res)) {
242 // success code
243 if (SWIG_IsNewObj(res) {
244 ...
245 delete *ptr;
246 } else {
247 ...
248 }
249 } else {
250 // fail code
251 }
252
253 I.e., now SWIG_ConvertPtr can return new objects and you can
254 identify the case and take care of the deallocation. Of course that
255 also requires SWIG_ConvertPtr to return new result values, such as
256
257 int SWIG_ConvertPtr(obj, ptr,...) {
258 if (<obj is ok>) {
259 if (<need new object>) {
260 *ptr = <ptr to new allocated object>;
261 return SWIG_NEWOBJ;
262 } else {
263 *ptr = <ptr to old object>;
264 return SWIG_OLDOBJ;
265 }
266 } else {
267 return SWIG_BADOBJ;
268 }
269 }
270
271 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
272 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
273 SWIG errors code.
274
275 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
276 allows to return the 'cast rank', for example, if you have this
277
278 int food(double)
279 int fooi(int);
280
281 and you call
282
283 food(1) // cast rank '1' (1 -> 1.0)
284 fooi(1) // cast rank '0'
285
286 just use the SWIG_AddCast()/SWIG_CheckState()
287 */
288
289 #define SWIG_OK (0)
290 #define SWIG_ERROR (-1)
291 #define SWIG_IsOK(r) (r >= 0)
292 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
293
294 /* The CastRankLimit says how many bits are used for the cast rank */
295 #define SWIG_CASTRANKLIMIT (1 << 8)
296 /* The NewMask denotes the object was created (using new/malloc) */
297 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
298 /* The TmpMask is for in/out typemaps that use temporal objects */
299 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
300 /* Simple returning values */
301 #define SWIG_BADOBJ (SWIG_ERROR)
302 #define SWIG_OLDOBJ (SWIG_OK)
303 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
304 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
305 /* Check, add and del mask methods */
306 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
307 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
308 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
309 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
310 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
311 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
312
313 /* Cast-Rank Mode */
314 #if defined(SWIG_CASTRANK_MODE)
315 # ifndef SWIG_TypeRank
316 # define SWIG_TypeRank unsigned long
317 # endif
318 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
319 # define SWIG_MAXCASTRANK (2)
320 # endif
321 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
322 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIG_AddCast(int r)323 SWIGINTERNINLINE int SWIG_AddCast(int r) {
324 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
325 }
SWIG_CheckState(int r)326 SWIGINTERNINLINE int SWIG_CheckState(int r) {
327 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
328 }
329 #else /* no cast-rank mode */
330 # define SWIG_AddCast(r) (r)
331 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
332 #endif
333
334
335 #include <string.h>
336
337 #ifdef __cplusplus
338 extern "C" {
339 #endif
340
341 typedef void *(*swig_converter_func)(void *, int *);
342 typedef struct swig_type_info *(*swig_dycast_func)(void **);
343
344 /* Structure to store information on one type */
345 typedef struct swig_type_info {
346 const char *name; /* mangled name of this type */
347 const char *str; /* human readable name of this type */
348 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
349 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
350 void *clientdata; /* language specific type data */
351 int owndata; /* flag if the structure owns the clientdata */
352 } swig_type_info;
353
354 /* Structure to store a type and conversion function used for casting */
355 typedef struct swig_cast_info {
356 swig_type_info *type; /* pointer to type that is equivalent to this type */
357 swig_converter_func converter; /* function to cast the void pointers */
358 struct swig_cast_info *next; /* pointer to next cast in linked list */
359 struct swig_cast_info *prev; /* pointer to the previous cast */
360 } swig_cast_info;
361
362 /* Structure used to store module information
363 * Each module generates one structure like this, and the runtime collects
364 * all of these structures and stores them in a circularly linked list.*/
365 typedef struct swig_module_info {
366 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
367 size_t size; /* Number of types in this module */
368 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
369 swig_type_info **type_initial; /* Array of initially generated type structures */
370 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
371 void *clientdata; /* Language specific module data */
372 } swig_module_info;
373
374 /*
375 Compare two type names skipping the space characters, therefore
376 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
377
378 Return 0 when the two name types are equivalent, as in
379 strncmp, but skipping ' '.
380 */
381 SWIGRUNTIME int
SWIG_TypeNameComp(const char * f1,const char * l1,const char * f2,const char * l2)382 SWIG_TypeNameComp(const char *f1, const char *l1,
383 const char *f2, const char *l2) {
384 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
385 while ((*f1 == ' ') && (f1 != l1)) ++f1;
386 while ((*f2 == ' ') && (f2 != l2)) ++f2;
387 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
388 }
389 return (int)((l1 - f1) - (l2 - f2));
390 }
391
392 /*
393 Check type equivalence in a name list like <name1>|<name2>|...
394 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
395 */
396 SWIGRUNTIME int
SWIG_TypeCmp(const char * nb,const char * tb)397 SWIG_TypeCmp(const char *nb, const char *tb) {
398 int equiv = 1;
399 const char* te = tb + strlen(tb);
400 const char* ne = nb;
401 while (equiv != 0 && *ne) {
402 for (nb = ne; *ne; ++ne) {
403 if (*ne == '|') break;
404 }
405 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
406 if (*ne) ++ne;
407 }
408 return equiv;
409 }
410
411 /*
412 Check type equivalence in a name list like <name1>|<name2>|...
413 Return 0 if not equal, 1 if equal
414 */
415 SWIGRUNTIME int
SWIG_TypeEquiv(const char * nb,const char * tb)416 SWIG_TypeEquiv(const char *nb, const char *tb) {
417 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
418 }
419
420 /*
421 Check the typename
422 */
423 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char * c,swig_type_info * ty)424 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
425 if (ty) {
426 swig_cast_info *iter = ty->cast;
427 while (iter) {
428 if (strcmp(iter->type->name, c) == 0) {
429 if (iter == ty->cast)
430 return iter;
431 /* Move iter to the top of the linked list */
432 iter->prev->next = iter->next;
433 if (iter->next)
434 iter->next->prev = iter->prev;
435 iter->next = ty->cast;
436 iter->prev = 0;
437 if (ty->cast) ty->cast->prev = iter;
438 ty->cast = iter;
439 return iter;
440 }
441 iter = iter->next;
442 }
443 }
444 return 0;
445 }
446
447 /*
448 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
449 */
450 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info * from,swig_type_info * ty)451 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
452 if (ty) {
453 swig_cast_info *iter = ty->cast;
454 while (iter) {
455 if (iter->type == from) {
456 if (iter == ty->cast)
457 return iter;
458 /* Move iter to the top of the linked list */
459 iter->prev->next = iter->next;
460 if (iter->next)
461 iter->next->prev = iter->prev;
462 iter->next = ty->cast;
463 iter->prev = 0;
464 if (ty->cast) ty->cast->prev = iter;
465 ty->cast = iter;
466 return iter;
467 }
468 iter = iter->next;
469 }
470 }
471 return 0;
472 }
473
474 /*
475 Cast a pointer up an inheritance hierarchy
476 */
477 SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info * ty,void * ptr,int * newmemory)478 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
479 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
480 }
481
482 /*
483 Dynamic pointer casting. Down an inheritance hierarchy
484 */
485 SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info * ty,void ** ptr)486 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
487 swig_type_info *lastty = ty;
488 if (!ty || !ty->dcast) return ty;
489 while (ty && (ty->dcast)) {
490 ty = (*ty->dcast)(ptr);
491 if (ty) lastty = ty;
492 }
493 return lastty;
494 }
495
496 /*
497 Return the name associated with this type
498 */
499 SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info * ty)500 SWIG_TypeName(const swig_type_info *ty) {
501 return ty->name;
502 }
503
504 /*
505 Return the pretty name associated with this type,
506 that is an unmangled type name in a form presentable to the user.
507 */
508 SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info * type)509 SWIG_TypePrettyName(const swig_type_info *type) {
510 /* The "str" field contains the equivalent pretty names of the
511 type, separated by vertical-bar characters. We choose
512 to print the last name, as it is often (?) the most
513 specific. */
514 if (!type) return NULL;
515 if (type->str != NULL) {
516 const char *last_name = type->str;
517 const char *s;
518 for (s = type->str; *s; s++)
519 if (*s == '|') last_name = s+1;
520 return last_name;
521 }
522 else
523 return type->name;
524 }
525
526 /*
527 Set the clientdata field for a type
528 */
529 SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info * ti,void * clientdata)530 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
531 swig_cast_info *cast = ti->cast;
532 /* if (ti->clientdata == clientdata) return; */
533 ti->clientdata = clientdata;
534
535 while (cast) {
536 if (!cast->converter) {
537 swig_type_info *tc = cast->type;
538 if (!tc->clientdata) {
539 SWIG_TypeClientData(tc, clientdata);
540 }
541 }
542 cast = cast->next;
543 }
544 }
545 SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info * ti,void * clientdata)546 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
547 SWIG_TypeClientData(ti, clientdata);
548 ti->owndata = 1;
549 }
550
551 /*
552 Search for a swig_type_info structure only by mangled name
553 Search is a O(log #types)
554
555 We start searching at module start, and finish searching when start == end.
556 Note: if start == end at the beginning of the function, we go all the way around
557 the circular list.
558 */
559 SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)560 SWIG_MangledTypeQueryModule(swig_module_info *start,
561 swig_module_info *end,
562 const char *name) {
563 swig_module_info *iter = start;
564 do {
565 if (iter->size) {
566 size_t l = 0;
567 size_t r = iter->size - 1;
568 do {
569 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
570 size_t i = (l + r) >> 1;
571 const char *iname = iter->types[i]->name;
572 if (iname) {
573 int compare = strcmp(name, iname);
574 if (compare == 0) {
575 return iter->types[i];
576 } else if (compare < 0) {
577 if (i) {
578 r = i - 1;
579 } else {
580 break;
581 }
582 } else if (compare > 0) {
583 l = i + 1;
584 }
585 } else {
586 break; /* should never happen */
587 }
588 } while (l <= r);
589 }
590 iter = iter->next;
591 } while (iter != end);
592 return 0;
593 }
594
595 /*
596 Search for a swig_type_info structure for either a mangled name or a human readable name.
597 It first searches the mangled names of the types, which is a O(log #types)
598 If a type is not found it then searches the human readable names, which is O(#types).
599
600 We start searching at module start, and finish searching when start == end.
601 Note: if start == end at the beginning of the function, we go all the way around
602 the circular list.
603 */
604 SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)605 SWIG_TypeQueryModule(swig_module_info *start,
606 swig_module_info *end,
607 const char *name) {
608 /* STEP 1: Search the name field using binary search */
609 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
610 if (ret) {
611 return ret;
612 } else {
613 /* STEP 2: If the type hasn't been found, do a complete search
614 of the str field (the human readable name) */
615 swig_module_info *iter = start;
616 do {
617 size_t i = 0;
618 for (; i < iter->size; ++i) {
619 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
620 return iter->types[i];
621 }
622 iter = iter->next;
623 } while (iter != end);
624 }
625
626 /* neither found a match */
627 return 0;
628 }
629
630 /*
631 Pack binary data into a string
632 */
633 SWIGRUNTIME char *
SWIG_PackData(char * c,void * ptr,size_t sz)634 SWIG_PackData(char *c, void *ptr, size_t sz) {
635 static const char hex[17] = "0123456789abcdef";
636 const unsigned char *u = (unsigned char *) ptr;
637 const unsigned char *eu = u + sz;
638 for (; u != eu; ++u) {
639 unsigned char uu = *u;
640 *(c++) = hex[(uu & 0xf0) >> 4];
641 *(c++) = hex[uu & 0xf];
642 }
643 return c;
644 }
645
646 /*
647 Unpack binary data from a string
648 */
649 SWIGRUNTIME const char *
SWIG_UnpackData(const char * c,void * ptr,size_t sz)650 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
651 unsigned char *u = (unsigned char *) ptr;
652 const unsigned char *eu = u + sz;
653 for (; u != eu; ++u) {
654 char d = *(c++);
655 unsigned char uu;
656 if ((d >= '0') && (d <= '9'))
657 uu = (unsigned char)((d - '0') << 4);
658 else if ((d >= 'a') && (d <= 'f'))
659 uu = (unsigned char)((d - ('a'-10)) << 4);
660 else
661 return (char *) 0;
662 d = *(c++);
663 if ((d >= '0') && (d <= '9'))
664 uu |= (unsigned char)(d - '0');
665 else if ((d >= 'a') && (d <= 'f'))
666 uu |= (unsigned char)(d - ('a'-10));
667 else
668 return (char *) 0;
669 *u = uu;
670 }
671 return c;
672 }
673
674 /*
675 Pack 'void *' into a string buffer.
676 */
677 SWIGRUNTIME char *
SWIG_PackVoidPtr(char * buff,void * ptr,const char * name,size_t bsz)678 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
679 char *r = buff;
680 if ((2*sizeof(void *) + 2) > bsz) return 0;
681 *(r++) = '_';
682 r = SWIG_PackData(r,&ptr,sizeof(void *));
683 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
684 strcpy(r,name);
685 return buff;
686 }
687
688 SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char * c,void ** ptr,const char * name)689 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
690 if (*c != '_') {
691 if (strcmp(c,"NULL") == 0) {
692 *ptr = (void *) 0;
693 return name;
694 } else {
695 return 0;
696 }
697 }
698 return SWIG_UnpackData(++c,ptr,sizeof(void *));
699 }
700
701 SWIGRUNTIME char *
SWIG_PackDataName(char * buff,void * ptr,size_t sz,const char * name,size_t bsz)702 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
703 char *r = buff;
704 size_t lname = (name ? strlen(name) : 0);
705 if ((2*sz + 2 + lname) > bsz) return 0;
706 *(r++) = '_';
707 r = SWIG_PackData(r,ptr,sz);
708 if (lname) {
709 strncpy(r,name,lname+1);
710 } else {
711 *r = 0;
712 }
713 return buff;
714 }
715
716 SWIGRUNTIME const char *
SWIG_UnpackDataName(const char * c,void * ptr,size_t sz,const char * name)717 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
718 if (*c != '_') {
719 if (strcmp(c,"NULL") == 0) {
720 memset(ptr,0,sz);
721 return name;
722 } else {
723 return 0;
724 }
725 }
726 return SWIG_UnpackData(++c,ptr,sz);
727 }
728
729 #ifdef __cplusplus
730 }
731 #endif
732
733 /* Errors in SWIG */
734 #define SWIG_UnknownError -1
735 #define SWIG_IOError -2
736 #define SWIG_RuntimeError -3
737 #define SWIG_IndexError -4
738 #define SWIG_TypeError -5
739 #define SWIG_DivisionByZero -6
740 #define SWIG_OverflowError -7
741 #define SWIG_SyntaxError -8
742 #define SWIG_ValueError -9
743 #define SWIG_SystemError -10
744 #define SWIG_AttributeError -11
745 #define SWIG_MemoryError -12
746 #define SWIG_NullReferenceError -13
747
748
749
750 /* Compatibility macros for Python 3 */
751 #if PY_VERSION_HEX >= 0x03000000
752
753 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
754 #define PyInt_Check(x) PyLong_Check(x)
755 #define PyInt_AsLong(x) PyLong_AsLong(x)
756 #define PyInt_FromLong(x) PyLong_FromLong(x)
757 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
758 #define PyString_Check(name) PyBytes_Check(name)
759 #define PyString_FromString(x) PyUnicode_FromString(x)
760 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
761 #define PyString_AsString(str) PyBytes_AsString(str)
762 #define PyString_Size(str) PyBytes_Size(str)
763 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
764 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
765 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
766 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
767
768 #endif
769
770 #ifndef Py_TYPE
771 # define Py_TYPE(op) ((op)->ob_type)
772 #endif
773
774 /* SWIG APIs for compatibility of both Python 2 & 3 */
775
776 #if PY_VERSION_HEX >= 0x03000000
777 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
778 #else
779 # define SWIG_Python_str_FromFormat PyString_FromFormat
780 #endif
781
782
783 /* Warning: This function will allocate a new string in Python 3,
784 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
785 */
786 SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject * str)787 SWIG_Python_str_AsChar(PyObject *str)
788 {
789 #if PY_VERSION_HEX >= 0x03000000
790 char *cstr;
791 char *newstr;
792 Py_ssize_t len;
793 str = PyUnicode_AsUTF8String(str);
794 PyBytes_AsStringAndSize(str, &cstr, &len);
795 newstr = (char *) malloc(len+1);
796 memcpy(newstr, cstr, len+1);
797 Py_XDECREF(str);
798 return newstr;
799 #else
800 return PyString_AsString(str);
801 #endif
802 }
803
804 #if PY_VERSION_HEX >= 0x03000000
805 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
806 #else
807 # define SWIG_Python_str_DelForPy3(x)
808 #endif
809
810
811 SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char * c)812 SWIG_Python_str_FromChar(const char *c)
813 {
814 #if PY_VERSION_HEX >= 0x03000000
815 return PyUnicode_FromString(c);
816 #else
817 return PyString_FromString(c);
818 #endif
819 }
820
821 /* Add PyOS_snprintf for old Pythons */
822 #if PY_VERSION_HEX < 0x02020000
823 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
824 # define PyOS_snprintf _snprintf
825 # else
826 # define PyOS_snprintf snprintf
827 # endif
828 #endif
829
830 /* A crude PyString_FromFormat implementation for old Pythons */
831 #if PY_VERSION_HEX < 0x02020000
832
833 #ifndef SWIG_PYBUFFER_SIZE
834 # define SWIG_PYBUFFER_SIZE 1024
835 #endif
836
837 static PyObject *
PyString_FromFormat(const char * fmt,...)838 PyString_FromFormat(const char *fmt, ...) {
839 va_list ap;
840 char buf[SWIG_PYBUFFER_SIZE * 2];
841 int res;
842 va_start(ap, fmt);
843 res = vsnprintf(buf, sizeof(buf), fmt, ap);
844 va_end(ap);
845 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
846 }
847 #endif
848
849 #ifndef PyObject_DEL
850 # define PyObject_DEL PyObject_Del
851 #endif
852
853 /* A crude PyExc_StopIteration exception for old Pythons */
854 #if PY_VERSION_HEX < 0x02020000
855 # ifndef PyExc_StopIteration
856 # define PyExc_StopIteration PyExc_RuntimeError
857 # endif
858 # ifndef PyObject_GenericGetAttr
859 # define PyObject_GenericGetAttr 0
860 # endif
861 #endif
862
863 /* Py_NotImplemented is defined in 2.1 and up. */
864 #if PY_VERSION_HEX < 0x02010000
865 # ifndef Py_NotImplemented
866 # define Py_NotImplemented PyExc_RuntimeError
867 # endif
868 #endif
869
870 /* A crude PyString_AsStringAndSize implementation for old Pythons */
871 #if PY_VERSION_HEX < 0x02010000
872 # ifndef PyString_AsStringAndSize
873 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
874 # endif
875 #endif
876
877 /* PySequence_Size for old Pythons */
878 #if PY_VERSION_HEX < 0x02000000
879 # ifndef PySequence_Size
880 # define PySequence_Size PySequence_Length
881 # endif
882 #endif
883
884 /* PyBool_FromLong for old Pythons */
885 #if PY_VERSION_HEX < 0x02030000
886 static
PyBool_FromLong(long ok)887 PyObject *PyBool_FromLong(long ok)
888 {
889 PyObject *result = ok ? Py_True : Py_False;
890 Py_INCREF(result);
891 return result;
892 }
893 #endif
894
895 /* Py_ssize_t for old Pythons */
896 /* This code is as recommended by: */
897 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
898 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
899 typedef int Py_ssize_t;
900 # define PY_SSIZE_T_MAX INT_MAX
901 # define PY_SSIZE_T_MIN INT_MIN
902 typedef inquiry lenfunc;
903 typedef intargfunc ssizeargfunc;
904 typedef intintargfunc ssizessizeargfunc;
905 typedef intobjargproc ssizeobjargproc;
906 typedef intintobjargproc ssizessizeobjargproc;
907 typedef getreadbufferproc readbufferproc;
908 typedef getwritebufferproc writebufferproc;
909 typedef getsegcountproc segcountproc;
910 typedef getcharbufferproc charbufferproc;
PyNumber_AsSsize_t(PyObject * x,void * SWIGUNUSEDPARM (exc))911 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
912 {
913 long result = 0;
914 PyObject *i = PyNumber_Int(x);
915 if (i) {
916 result = PyInt_AsLong(i);
917 Py_DECREF(i);
918 }
919 return result;
920 }
921 #endif
922
923 #if PY_VERSION_HEX < 0x02050000
924 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
925 #endif
926
927 #if PY_VERSION_HEX < 0x02040000
928 #define Py_VISIT(op) \
929 do { \
930 if (op) { \
931 int vret = visit((op), arg); \
932 if (vret) \
933 return vret; \
934 } \
935 } while (0)
936 #endif
937
938 #if PY_VERSION_HEX < 0x02030000
939 typedef struct {
940 PyTypeObject type;
941 PyNumberMethods as_number;
942 PyMappingMethods as_mapping;
943 PySequenceMethods as_sequence;
944 PyBufferProcs as_buffer;
945 PyObject *name, *slots;
946 } PyHeapTypeObject;
947 #endif
948
949 #if PY_VERSION_HEX < 0x02030000
950 typedef destructor freefunc;
951 #endif
952
953 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
954 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
955 (PY_MAJOR_VERSION > 3))
956 # define SWIGPY_USE_CAPSULE
957 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
958 #endif
959
960 #if PY_VERSION_HEX < 0x03020000
961 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
962 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
963 #define Py_hash_t long
964 #endif
965
966 /* -----------------------------------------------------------------------------
967 * error manipulation
968 * ----------------------------------------------------------------------------- */
969
970 SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code)971 SWIG_Python_ErrorType(int code) {
972 PyObject* type = 0;
973 switch(code) {
974 case SWIG_MemoryError:
975 type = PyExc_MemoryError;
976 break;
977 case SWIG_IOError:
978 type = PyExc_IOError;
979 break;
980 case SWIG_RuntimeError:
981 type = PyExc_RuntimeError;
982 break;
983 case SWIG_IndexError:
984 type = PyExc_IndexError;
985 break;
986 case SWIG_TypeError:
987 type = PyExc_TypeError;
988 break;
989 case SWIG_DivisionByZero:
990 type = PyExc_ZeroDivisionError;
991 break;
992 case SWIG_OverflowError:
993 type = PyExc_OverflowError;
994 break;
995 case SWIG_SyntaxError:
996 type = PyExc_SyntaxError;
997 break;
998 case SWIG_ValueError:
999 type = PyExc_ValueError;
1000 break;
1001 case SWIG_SystemError:
1002 type = PyExc_SystemError;
1003 break;
1004 case SWIG_AttributeError:
1005 type = PyExc_AttributeError;
1006 break;
1007 default:
1008 type = PyExc_RuntimeError;
1009 }
1010 return type;
1011 }
1012
1013
1014 SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char * mesg)1015 SWIG_Python_AddErrorMsg(const char* mesg)
1016 {
1017 PyObject *type = 0;
1018 PyObject *value = 0;
1019 PyObject *traceback = 0;
1020
1021 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1022 if (value) {
1023 char *tmp;
1024 PyObject *old_str = PyObject_Str(value);
1025 PyErr_Clear();
1026 Py_XINCREF(type);
1027
1028 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1029 SWIG_Python_str_DelForPy3(tmp);
1030 Py_DECREF(old_str);
1031 Py_DECREF(value);
1032 } else {
1033 PyErr_SetString(PyExc_RuntimeError, mesg);
1034 }
1035 }
1036
1037 #if defined(SWIG_PYTHON_NO_THREADS)
1038 # if defined(SWIG_PYTHON_THREADS)
1039 # undef SWIG_PYTHON_THREADS
1040 # endif
1041 #endif
1042 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1043 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1044 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1045 # define SWIG_PYTHON_USE_GIL
1046 # endif
1047 # endif
1048 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1049 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1050 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1051 # endif
1052 # ifdef __cplusplus /* C++ code */
1053 class SWIG_Python_Thread_Block {
1054 bool status;
1055 PyGILState_STATE state;
1056 public:
end()1057 void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block()1058 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block()1059 ~SWIG_Python_Thread_Block() { end(); }
1060 };
1061 class SWIG_Python_Thread_Allow {
1062 bool status;
1063 PyThreadState *save;
1064 public:
end()1065 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow()1066 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow()1067 ~SWIG_Python_Thread_Allow() { end(); }
1068 };
1069 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1070 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1071 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1072 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1073 # else /* C code */
1074 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1075 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1076 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1077 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1078 # endif
1079 # else /* Old thread way, not implemented, user must provide it */
1080 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1081 # define SWIG_PYTHON_INITIALIZE_THREADS
1082 # endif
1083 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1084 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1085 # endif
1086 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1087 # define SWIG_PYTHON_THREAD_END_BLOCK
1088 # endif
1089 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1090 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1091 # endif
1092 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1093 # define SWIG_PYTHON_THREAD_END_ALLOW
1094 # endif
1095 # endif
1096 #else /* No thread support */
1097 # define SWIG_PYTHON_INITIALIZE_THREADS
1098 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1099 # define SWIG_PYTHON_THREAD_END_BLOCK
1100 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1101 # define SWIG_PYTHON_THREAD_END_ALLOW
1102 #endif
1103
1104 /* -----------------------------------------------------------------------------
1105 * Python API portion that goes into the runtime
1106 * ----------------------------------------------------------------------------- */
1107
1108 #ifdef __cplusplus
1109 extern "C" {
1110 #endif
1111
1112 /* -----------------------------------------------------------------------------
1113 * Constant declarations
1114 * ----------------------------------------------------------------------------- */
1115
1116 /* Constant Types */
1117 #define SWIG_PY_POINTER 4
1118 #define SWIG_PY_BINARY 5
1119
1120 /* Constant information structure */
1121 typedef struct swig_const_info {
1122 int type;
1123 char *name;
1124 long lvalue;
1125 double dvalue;
1126 void *pvalue;
1127 swig_type_info **ptype;
1128 } swig_const_info;
1129
1130
1131 /* -----------------------------------------------------------------------------
1132 * Wrapper of PyInstanceMethod_New() used in Python 3
1133 * It is exported to the generated module, used for -fastproxy
1134 * ----------------------------------------------------------------------------- */
1135 #if PY_VERSION_HEX >= 0x03000000
SWIG_PyInstanceMethod_New(PyObject * SWIGUNUSEDPARM (self),PyObject * func)1136 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1137 {
1138 return PyInstanceMethod_New(func);
1139 }
1140 #else
SWIG_PyInstanceMethod_New(PyObject * SWIGUNUSEDPARM (self),PyObject * SWIGUNUSEDPARM (func))1141 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1142 {
1143 return NULL;
1144 }
1145 #endif
1146
1147 #ifdef __cplusplus
1148 }
1149 #endif
1150
1151
1152 /* -----------------------------------------------------------------------------
1153 * pyrun.swg
1154 *
1155 * This file contains the runtime support for Python modules
1156 * and includes code for managing global variables and pointer
1157 * type checking.
1158 *
1159 * ----------------------------------------------------------------------------- */
1160
1161 /* Common SWIG API */
1162
1163 /* for raw pointers */
1164 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1165 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1166 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1167
1168 #ifdef SWIGPYTHON_BUILTIN
1169 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1170 #else
1171 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1172 #endif
1173
1174 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1175
1176 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1177 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1178 #define swig_owntype int
1179
1180 /* for raw packed data */
1181 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1182 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1183
1184 /* for class or struct pointers */
1185 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1186 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1187
1188 /* for C or C++ function pointers */
1189 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1190 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1191
1192 /* for C++ member pointers, ie, member methods */
1193 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1194 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1195
1196
1197 /* Runtime API */
1198
1199 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1200 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1201 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1202
1203 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1204 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1205 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1206 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1207 #define SWIG_fail goto fail
1208
1209
1210 /* Runtime API implementation */
1211
1212 /* Error manipulation */
1213
1214 SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject * errtype,PyObject * obj)1215 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1216 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1217 PyErr_SetObject(errtype, obj);
1218 Py_DECREF(obj);
1219 SWIG_PYTHON_THREAD_END_BLOCK;
1220 }
1221
1222 SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject * errtype,const char * msg)1223 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1224 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1225 PyErr_SetString(errtype, msg);
1226 SWIG_PYTHON_THREAD_END_BLOCK;
1227 }
1228
1229 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1230
1231 /* Set a constant value */
1232
1233 #if defined(SWIGPYTHON_BUILTIN)
1234
1235 SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject * seq,const char * key)1236 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1237 PyObject *s = PyString_InternFromString(key);
1238 PyList_Append(seq, s);
1239 Py_DECREF(s);
1240 }
1241
1242 SWIGINTERN void
SWIG_Python_SetConstant(PyObject * d,PyObject * public_interface,const char * name,PyObject * obj)1243 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1244 #if PY_VERSION_HEX < 0x02030000
1245 PyDict_SetItemString(d, (char *)name, obj);
1246 #else
1247 PyDict_SetItemString(d, name, obj);
1248 #endif
1249 Py_DECREF(obj);
1250 if (public_interface)
1251 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1252 }
1253
1254 #else
1255
1256 SWIGINTERN void
SWIG_Python_SetConstant(PyObject * d,const char * name,PyObject * obj)1257 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1258 #if PY_VERSION_HEX < 0x02030000
1259 PyDict_SetItemString(d, (char *)name, obj);
1260 #else
1261 PyDict_SetItemString(d, name, obj);
1262 #endif
1263 Py_DECREF(obj);
1264 }
1265
1266 #endif
1267
1268 /* Append a value to the result obj */
1269
1270 SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject * result,PyObject * obj)1271 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1272 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1273 if (!result) {
1274 result = obj;
1275 } else if (result == Py_None) {
1276 Py_DECREF(result);
1277 result = obj;
1278 } else {
1279 if (!PyList_Check(result)) {
1280 PyObject *o2 = result;
1281 result = PyList_New(1);
1282 PyList_SetItem(result, 0, o2);
1283 }
1284 PyList_Append(result,obj);
1285 Py_DECREF(obj);
1286 }
1287 return result;
1288 #else
1289 PyObject* o2;
1290 PyObject* o3;
1291 if (!result) {
1292 result = obj;
1293 } else if (result == Py_None) {
1294 Py_DECREF(result);
1295 result = obj;
1296 } else {
1297 if (!PyTuple_Check(result)) {
1298 o2 = result;
1299 result = PyTuple_New(1);
1300 PyTuple_SET_ITEM(result, 0, o2);
1301 }
1302 o3 = PyTuple_New(1);
1303 PyTuple_SET_ITEM(o3, 0, obj);
1304 o2 = result;
1305 result = PySequence_Concat(o2, o3);
1306 Py_DECREF(o2);
1307 Py_DECREF(o3);
1308 }
1309 return result;
1310 #endif
1311 }
1312
1313 /* Unpack the argument tuple */
1314
1315 SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject * args,const char * name,Py_ssize_t min,Py_ssize_t max,PyObject ** objs)1316 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1317 {
1318 if (!args) {
1319 if (!min && !max) {
1320 return 1;
1321 } else {
1322 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1323 name, (min == max ? "" : "at least "), (int)min);
1324 return 0;
1325 }
1326 }
1327 if (!PyTuple_Check(args)) {
1328 if (min <= 1 && max >= 1) {
1329 Py_ssize_t i;
1330 objs[0] = args;
1331 for (i = 1; i < max; ++i) {
1332 objs[i] = 0;
1333 }
1334 return 2;
1335 }
1336 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1337 return 0;
1338 } else {
1339 Py_ssize_t l = PyTuple_GET_SIZE(args);
1340 if (l < min) {
1341 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1342 name, (min == max ? "" : "at least "), (int)min, (int)l);
1343 return 0;
1344 } else if (l > max) {
1345 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1346 name, (min == max ? "" : "at most "), (int)max, (int)l);
1347 return 0;
1348 } else {
1349 Py_ssize_t i;
1350 for (i = 0; i < l; ++i) {
1351 objs[i] = PyTuple_GET_ITEM(args, i);
1352 }
1353 for (; l < max; ++l) {
1354 objs[l] = 0;
1355 }
1356 return i + 1;
1357 }
1358 }
1359 }
1360
1361 /* A functor is a function object with one single object argument */
1362 #if PY_VERSION_HEX >= 0x02020000
1363 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1364 #else
1365 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1366 #endif
1367
1368 /*
1369 Helper for static pointer initialization for both C and C++ code, for example
1370 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1371 */
1372 #ifdef __cplusplus
1373 #define SWIG_STATIC_POINTER(var) var
1374 #else
1375 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1376 #endif
1377
1378 /* -----------------------------------------------------------------------------
1379 * Pointer declarations
1380 * ----------------------------------------------------------------------------- */
1381
1382 /* Flags for new pointer objects */
1383 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1384 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1385
1386 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1387
1388 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1389 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1390
1391 #ifdef __cplusplus
1392 extern "C" {
1393 #endif
1394
1395 /* How to access Py_None */
1396 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1397 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1398 # ifndef SWIG_PYTHON_BUILD_NONE
1399 # define SWIG_PYTHON_BUILD_NONE
1400 # endif
1401 # endif
1402 #endif
1403
1404 #ifdef SWIG_PYTHON_BUILD_NONE
1405 # ifdef Py_None
1406 # undef Py_None
1407 # define Py_None SWIG_Py_None()
1408 # endif
1409 SWIGRUNTIMEINLINE PyObject *
_SWIG_Py_None(void)1410 _SWIG_Py_None(void)
1411 {
1412 PyObject *none = Py_BuildValue((char*)"");
1413 Py_DECREF(none);
1414 return none;
1415 }
1416 SWIGRUNTIME PyObject *
SWIG_Py_None(void)1417 SWIG_Py_None(void)
1418 {
1419 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1420 return none;
1421 }
1422 #endif
1423
1424 /* The python void return value */
1425
1426 SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)1427 SWIG_Py_Void(void)
1428 {
1429 PyObject *none = Py_None;
1430 Py_INCREF(none);
1431 return none;
1432 }
1433
1434 /* SwigPyClientData */
1435
1436 typedef struct {
1437 PyObject *klass;
1438 PyObject *newraw;
1439 PyObject *newargs;
1440 PyObject *destroy;
1441 int delargs;
1442 int implicitconv;
1443 PyTypeObject *pytype;
1444 } SwigPyClientData;
1445
1446 SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info * ty)1447 SWIG_Python_CheckImplicit(swig_type_info *ty)
1448 {
1449 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1450 return data ? data->implicitconv : 0;
1451 }
1452
1453 SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info * desc)1454 SWIG_Python_ExceptionType(swig_type_info *desc) {
1455 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1456 PyObject *klass = data ? data->klass : 0;
1457 return (klass ? klass : PyExc_RuntimeError);
1458 }
1459
1460
1461 SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject * obj)1462 SwigPyClientData_New(PyObject* obj)
1463 {
1464 if (!obj) {
1465 return 0;
1466 } else {
1467 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1468 /* the klass element */
1469 data->klass = obj;
1470 Py_INCREF(data->klass);
1471 /* the newraw method and newargs arguments used to create a new raw instance */
1472 if (PyClass_Check(obj)) {
1473 data->newraw = 0;
1474 data->newargs = obj;
1475 Py_INCREF(obj);
1476 } else {
1477 #if (PY_VERSION_HEX < 0x02020000)
1478 data->newraw = 0;
1479 #else
1480 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1481 #endif
1482 if (data->newraw) {
1483 Py_INCREF(data->newraw);
1484 data->newargs = PyTuple_New(1);
1485 PyTuple_SetItem(data->newargs, 0, obj);
1486 } else {
1487 data->newargs = obj;
1488 }
1489 Py_INCREF(data->newargs);
1490 }
1491 /* the destroy method, aka as the C++ delete method */
1492 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1493 if (PyErr_Occurred()) {
1494 PyErr_Clear();
1495 data->destroy = 0;
1496 }
1497 if (data->destroy) {
1498 int flags;
1499 Py_INCREF(data->destroy);
1500 flags = PyCFunction_GET_FLAGS(data->destroy);
1501 #ifdef METH_O
1502 data->delargs = !(flags & (METH_O));
1503 #else
1504 data->delargs = 0;
1505 #endif
1506 } else {
1507 data->delargs = 0;
1508 }
1509 data->implicitconv = 0;
1510 data->pytype = 0;
1511 return data;
1512 }
1513 }
1514
1515 SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData * data)1516 SwigPyClientData_Del(SwigPyClientData *data) {
1517 Py_XDECREF(data->newraw);
1518 Py_XDECREF(data->newargs);
1519 Py_XDECREF(data->destroy);
1520 }
1521
1522 /* =============== SwigPyObject =====================*/
1523
1524 typedef struct {
1525 PyObject_HEAD
1526 void *ptr;
1527 swig_type_info *ty;
1528 int own;
1529 PyObject *next;
1530 #ifdef SWIGPYTHON_BUILTIN
1531 PyObject *dict;
1532 #endif
1533 } SwigPyObject;
1534
1535
1536 #ifdef SWIGPYTHON_BUILTIN
1537
1538 SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject * v,PyObject * SWIGUNUSEDPARM (args))1539 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1540 {
1541 SwigPyObject *sobj = (SwigPyObject *)v;
1542
1543 if (!sobj->dict)
1544 sobj->dict = PyDict_New();
1545
1546 Py_INCREF(sobj->dict);
1547 return sobj->dict;
1548 }
1549
1550 #endif
1551
1552 SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject * v)1553 SwigPyObject_long(SwigPyObject *v)
1554 {
1555 return PyLong_FromVoidPtr(v->ptr);
1556 }
1557
1558 SWIGRUNTIME PyObject *
SwigPyObject_format(const char * fmt,SwigPyObject * v)1559 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1560 {
1561 PyObject *res = NULL;
1562 PyObject *args = PyTuple_New(1);
1563 if (args) {
1564 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1565 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1566 if (ofmt) {
1567 #if PY_VERSION_HEX >= 0x03000000
1568 res = PyUnicode_Format(ofmt,args);
1569 #else
1570 res = PyString_Format(ofmt,args);
1571 #endif
1572 Py_DECREF(ofmt);
1573 }
1574 Py_DECREF(args);
1575 }
1576 }
1577 return res;
1578 }
1579
1580 SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject * v)1581 SwigPyObject_oct(SwigPyObject *v)
1582 {
1583 return SwigPyObject_format("%o",v);
1584 }
1585
1586 SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject * v)1587 SwigPyObject_hex(SwigPyObject *v)
1588 {
1589 return SwigPyObject_format("%x",v);
1590 }
1591
1592 SWIGRUNTIME PyObject *
1593 #ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject * v)1594 SwigPyObject_repr(SwigPyObject *v)
1595 #else
1596 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1597 #endif
1598 {
1599 const char *name = SWIG_TypePrettyName(v->ty);
1600 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1601 if (v->next) {
1602 # ifdef METH_NOARGS
1603 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1604 # else
1605 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1606 # endif
1607 # if PY_VERSION_HEX >= 0x03000000
1608 PyObject *joined = PyUnicode_Concat(repr, nrep);
1609 Py_DecRef(repr);
1610 Py_DecRef(nrep);
1611 repr = joined;
1612 # else
1613 PyString_ConcatAndDel(&repr,nrep);
1614 # endif
1615 }
1616 return repr;
1617 }
1618
1619 SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject * v,SwigPyObject * w)1620 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1621 {
1622 void *i = v->ptr;
1623 void *j = w->ptr;
1624 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1625 }
1626
1627 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1628 SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject * v,SwigPyObject * w,int op)1629 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1630 {
1631 PyObject* res;
1632 if( op != Py_EQ && op != Py_NE ) {
1633 Py_INCREF(Py_NotImplemented);
1634 return Py_NotImplemented;
1635 }
1636 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1637 return res;
1638 }
1639
1640
1641 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1642
1643 #ifdef SWIGPYTHON_BUILTIN
1644 static swig_type_info *SwigPyObject_stype = 0;
1645 SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void)1646 SwigPyObject_type(void) {
1647 SwigPyClientData *cd;
1648 assert(SwigPyObject_stype);
1649 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1650 assert(cd);
1651 assert(cd->pytype);
1652 return cd->pytype;
1653 }
1654 #else
1655 SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void)1656 SwigPyObject_type(void) {
1657 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1658 return type;
1659 }
1660 #endif
1661
1662 SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject * op)1663 SwigPyObject_Check(PyObject *op) {
1664 #ifdef SWIGPYTHON_BUILTIN
1665 PyTypeObject *target_tp = SwigPyObject_type();
1666 if (PyType_IsSubtype(op->ob_type, target_tp))
1667 return 1;
1668 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1669 #else
1670 return (Py_TYPE(op) == SwigPyObject_type())
1671 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1672 #endif
1673 }
1674
1675 SWIGRUNTIME PyObject *
1676 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1677
1678 SWIGRUNTIME void
SwigPyObject_dealloc(PyObject * v)1679 SwigPyObject_dealloc(PyObject *v)
1680 {
1681 SwigPyObject *sobj = (SwigPyObject *) v;
1682 PyObject *next = sobj->next;
1683 if (sobj->own == SWIG_POINTER_OWN) {
1684 swig_type_info *ty = sobj->ty;
1685 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1686 PyObject *destroy = data ? data->destroy : 0;
1687 if (destroy) {
1688 /* destroy is always a VARARGS method */
1689 PyObject *res;
1690
1691 /* PyObject_CallFunction() has the potential to silently drop
1692 the active active exception. In cases of unnamed temporary
1693 variable or where we just finished iterating over a generator
1694 StopIteration will be active right now, and this needs to
1695 remain true upon return from SwigPyObject_dealloc. So save
1696 and restore. */
1697
1698 PyObject *val = NULL, *type = NULL, *tb = NULL;
1699 PyErr_Fetch(&val, &type, &tb);
1700
1701 if (data->delargs) {
1702 /* we need to create a temporary object to carry the destroy operation */
1703 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1704 res = SWIG_Python_CallFunctor(destroy, tmp);
1705 Py_DECREF(tmp);
1706 } else {
1707 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1708 PyObject *mself = PyCFunction_GET_SELF(destroy);
1709 res = ((*meth)(mself, v));
1710 }
1711 if (!res)
1712 PyErr_WriteUnraisable(destroy);
1713
1714 PyErr_Restore(val, type, tb);
1715
1716 Py_XDECREF(res);
1717 }
1718 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1719 else {
1720 const char *name = SWIG_TypePrettyName(ty);
1721 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1722 }
1723 #endif
1724 }
1725 Py_XDECREF(next);
1726 PyObject_DEL(v);
1727 }
1728
1729 SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject * v,PyObject * next)1730 SwigPyObject_append(PyObject* v, PyObject* next)
1731 {
1732 SwigPyObject *sobj = (SwigPyObject *) v;
1733 #ifndef METH_O
1734 PyObject *tmp = 0;
1735 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1736 next = tmp;
1737 #endif
1738 if (!SwigPyObject_Check(next)) {
1739 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1740 return NULL;
1741 }
1742 sobj->next = next;
1743 Py_INCREF(next);
1744 return SWIG_Py_Void();
1745 }
1746
1747 SWIGRUNTIME PyObject*
1748 #ifdef METH_NOARGS
SwigPyObject_next(PyObject * v)1749 SwigPyObject_next(PyObject* v)
1750 #else
1751 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1752 #endif
1753 {
1754 SwigPyObject *sobj = (SwigPyObject *) v;
1755 if (sobj->next) {
1756 Py_INCREF(sobj->next);
1757 return sobj->next;
1758 } else {
1759 return SWIG_Py_Void();
1760 }
1761 }
1762
1763 SWIGINTERN PyObject*
1764 #ifdef METH_NOARGS
SwigPyObject_disown(PyObject * v)1765 SwigPyObject_disown(PyObject *v)
1766 #else
1767 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1768 #endif
1769 {
1770 SwigPyObject *sobj = (SwigPyObject *)v;
1771 sobj->own = 0;
1772 return SWIG_Py_Void();
1773 }
1774
1775 SWIGINTERN PyObject*
1776 #ifdef METH_NOARGS
SwigPyObject_acquire(PyObject * v)1777 SwigPyObject_acquire(PyObject *v)
1778 #else
1779 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1780 #endif
1781 {
1782 SwigPyObject *sobj = (SwigPyObject *)v;
1783 sobj->own = SWIG_POINTER_OWN;
1784 return SWIG_Py_Void();
1785 }
1786
1787 SWIGINTERN PyObject*
SwigPyObject_own(PyObject * v,PyObject * args)1788 SwigPyObject_own(PyObject *v, PyObject *args)
1789 {
1790 PyObject *val = 0;
1791 #if (PY_VERSION_HEX < 0x02020000)
1792 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1793 #elif (PY_VERSION_HEX < 0x02050000)
1794 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1795 #else
1796 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1797 #endif
1798 {
1799 return NULL;
1800 }
1801 else
1802 {
1803 SwigPyObject *sobj = (SwigPyObject *)v;
1804 PyObject *obj = PyBool_FromLong(sobj->own);
1805 if (val) {
1806 #ifdef METH_NOARGS
1807 if (PyObject_IsTrue(val)) {
1808 SwigPyObject_acquire(v);
1809 } else {
1810 SwigPyObject_disown(v);
1811 }
1812 #else
1813 if (PyObject_IsTrue(val)) {
1814 SwigPyObject_acquire(v,args);
1815 } else {
1816 SwigPyObject_disown(v,args);
1817 }
1818 #endif
1819 }
1820 return obj;
1821 }
1822 }
1823
1824 #ifdef METH_O
1825 static PyMethodDef
1826 swigobject_methods[] = {
1827 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1828 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1829 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1830 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1831 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1832 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1833 {0, 0, 0, 0}
1834 };
1835 #else
1836 static PyMethodDef
1837 swigobject_methods[] = {
1838 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1839 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1840 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1841 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1842 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1843 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1844 {0, 0, 0, 0}
1845 };
1846 #endif
1847
1848 #if PY_VERSION_HEX < 0x02020000
1849 SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject * sobj,char * name)1850 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1851 {
1852 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1853 }
1854 #endif
1855
1856 SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void)1857 SwigPyObject_TypeOnce(void) {
1858 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1859
1860 static PyNumberMethods SwigPyObject_as_number = {
1861 (binaryfunc)0, /*nb_add*/
1862 (binaryfunc)0, /*nb_subtract*/
1863 (binaryfunc)0, /*nb_multiply*/
1864 /* nb_divide removed in Python 3 */
1865 #if PY_VERSION_HEX < 0x03000000
1866 (binaryfunc)0, /*nb_divide*/
1867 #endif
1868 (binaryfunc)0, /*nb_remainder*/
1869 (binaryfunc)0, /*nb_divmod*/
1870 (ternaryfunc)0,/*nb_power*/
1871 (unaryfunc)0, /*nb_negative*/
1872 (unaryfunc)0, /*nb_positive*/
1873 (unaryfunc)0, /*nb_absolute*/
1874 (inquiry)0, /*nb_nonzero*/
1875 0, /*nb_invert*/
1876 0, /*nb_lshift*/
1877 0, /*nb_rshift*/
1878 0, /*nb_and*/
1879 0, /*nb_xor*/
1880 0, /*nb_or*/
1881 #if PY_VERSION_HEX < 0x03000000
1882 0, /*nb_coerce*/
1883 #endif
1884 (unaryfunc)SwigPyObject_long, /*nb_int*/
1885 #if PY_VERSION_HEX < 0x03000000
1886 (unaryfunc)SwigPyObject_long, /*nb_long*/
1887 #else
1888 0, /*nb_reserved*/
1889 #endif
1890 (unaryfunc)0, /*nb_float*/
1891 #if PY_VERSION_HEX < 0x03000000
1892 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1893 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1894 #endif
1895 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1896 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1897 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1898 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1899 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1900 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1901 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1902 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1903 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1904 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1905 #endif
1906 };
1907
1908 static PyTypeObject swigpyobject_type;
1909 static int type_init = 0;
1910 if (!type_init) {
1911 const PyTypeObject tmp = {
1912 #if PY_VERSION_HEX >= 0x03000000
1913 PyVarObject_HEAD_INIT(NULL, 0)
1914 #else
1915 PyObject_HEAD_INIT(NULL)
1916 0, /* ob_size */
1917 #endif
1918 (char *)"SwigPyObject", /* tp_name */
1919 sizeof(SwigPyObject), /* tp_basicsize */
1920 0, /* tp_itemsize */
1921 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1922 0, /* tp_print */
1923 #if PY_VERSION_HEX < 0x02020000
1924 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1925 #else
1926 (getattrfunc)0, /* tp_getattr */
1927 #endif
1928 (setattrfunc)0, /* tp_setattr */
1929 #if PY_VERSION_HEX >= 0x03000000
1930 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1931 #else
1932 (cmpfunc)SwigPyObject_compare, /* tp_compare */
1933 #endif
1934 (reprfunc)SwigPyObject_repr, /* tp_repr */
1935 &SwigPyObject_as_number, /* tp_as_number */
1936 0, /* tp_as_sequence */
1937 0, /* tp_as_mapping */
1938 (hashfunc)0, /* tp_hash */
1939 (ternaryfunc)0, /* tp_call */
1940 0, /* tp_str */
1941 PyObject_GenericGetAttr, /* tp_getattro */
1942 0, /* tp_setattro */
1943 0, /* tp_as_buffer */
1944 Py_TPFLAGS_DEFAULT, /* tp_flags */
1945 swigobject_doc, /* tp_doc */
1946 0, /* tp_traverse */
1947 0, /* tp_clear */
1948 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1949 0, /* tp_weaklistoffset */
1950 #if PY_VERSION_HEX >= 0x02020000
1951 0, /* tp_iter */
1952 0, /* tp_iternext */
1953 swigobject_methods, /* tp_methods */
1954 0, /* tp_members */
1955 0, /* tp_getset */
1956 0, /* tp_base */
1957 0, /* tp_dict */
1958 0, /* tp_descr_get */
1959 0, /* tp_descr_set */
1960 0, /* tp_dictoffset */
1961 0, /* tp_init */
1962 0, /* tp_alloc */
1963 0, /* tp_new */
1964 0, /* tp_free */
1965 0, /* tp_is_gc */
1966 0, /* tp_bases */
1967 0, /* tp_mro */
1968 0, /* tp_cache */
1969 0, /* tp_subclasses */
1970 0, /* tp_weaklist */
1971 #endif
1972 #if PY_VERSION_HEX >= 0x02030000
1973 0, /* tp_del */
1974 #endif
1975 #if PY_VERSION_HEX >= 0x02060000
1976 0, /* tp_version_tag */
1977 #endif
1978 #if PY_VERSION_HEX >= 0x03040000
1979 0, /* tp_finalize */
1980 #endif
1981 #ifdef COUNT_ALLOCS
1982 0, /* tp_allocs */
1983 0, /* tp_frees */
1984 0, /* tp_maxalloc */
1985 #if PY_VERSION_HEX >= 0x02050000
1986 0, /* tp_prev */
1987 #endif
1988 0 /* tp_next */
1989 #endif
1990 };
1991 swigpyobject_type = tmp;
1992 type_init = 1;
1993 #if PY_VERSION_HEX < 0x02020000
1994 swigpyobject_type.ob_type = &PyType_Type;
1995 #else
1996 if (PyType_Ready(&swigpyobject_type) < 0)
1997 return NULL;
1998 #endif
1999 }
2000 return &swigpyobject_type;
2001 }
2002
2003 SWIGRUNTIME PyObject *
SwigPyObject_New(void * ptr,swig_type_info * ty,int own)2004 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2005 {
2006 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2007 if (sobj) {
2008 sobj->ptr = ptr;
2009 sobj->ty = ty;
2010 sobj->own = own;
2011 sobj->next = 0;
2012 }
2013 return (PyObject *)sobj;
2014 }
2015
2016 /* -----------------------------------------------------------------------------
2017 * Implements a simple Swig Packed type, and use it instead of string
2018 * ----------------------------------------------------------------------------- */
2019
2020 typedef struct {
2021 PyObject_HEAD
2022 void *pack;
2023 swig_type_info *ty;
2024 size_t size;
2025 } SwigPyPacked;
2026
2027 SWIGRUNTIME int
SwigPyPacked_print(SwigPyPacked * v,FILE * fp,int SWIGUNUSEDPARM (flags))2028 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2029 {
2030 char result[SWIG_BUFFER_SIZE];
2031 fputs("<Swig Packed ", fp);
2032 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2033 fputs("at ", fp);
2034 fputs(result, fp);
2035 }
2036 fputs(v->ty->name,fp);
2037 fputs(">", fp);
2038 return 0;
2039 }
2040
2041 SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked * v)2042 SwigPyPacked_repr(SwigPyPacked *v)
2043 {
2044 char result[SWIG_BUFFER_SIZE];
2045 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2046 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2047 } else {
2048 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2049 }
2050 }
2051
2052 SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked * v)2053 SwigPyPacked_str(SwigPyPacked *v)
2054 {
2055 char result[SWIG_BUFFER_SIZE];
2056 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2057 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2058 } else {
2059 return SWIG_Python_str_FromChar(v->ty->name);
2060 }
2061 }
2062
2063 SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked * v,SwigPyPacked * w)2064 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2065 {
2066 size_t i = v->size;
2067 size_t j = w->size;
2068 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2069 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2070 }
2071
2072 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2073
2074 SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void)2075 SwigPyPacked_type(void) {
2076 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2077 return type;
2078 }
2079
2080 SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject * op)2081 SwigPyPacked_Check(PyObject *op) {
2082 return ((op)->ob_type == SwigPyPacked_TypeOnce())
2083 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2084 }
2085
2086 SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject * v)2087 SwigPyPacked_dealloc(PyObject *v)
2088 {
2089 if (SwigPyPacked_Check(v)) {
2090 SwigPyPacked *sobj = (SwigPyPacked *) v;
2091 free(sobj->pack);
2092 }
2093 PyObject_DEL(v);
2094 }
2095
2096 SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void)2097 SwigPyPacked_TypeOnce(void) {
2098 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2099 static PyTypeObject swigpypacked_type;
2100 static int type_init = 0;
2101 if (!type_init) {
2102 const PyTypeObject tmp = {
2103 #if PY_VERSION_HEX>=0x03000000
2104 PyVarObject_HEAD_INIT(NULL, 0)
2105 #else
2106 PyObject_HEAD_INIT(NULL)
2107 0, /* ob_size */
2108 #endif
2109 (char *)"SwigPyPacked", /* tp_name */
2110 sizeof(SwigPyPacked), /* tp_basicsize */
2111 0, /* tp_itemsize */
2112 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2113 (printfunc)SwigPyPacked_print, /* tp_print */
2114 (getattrfunc)0, /* tp_getattr */
2115 (setattrfunc)0, /* tp_setattr */
2116 #if PY_VERSION_HEX>=0x03000000
2117 0, /* tp_reserved in 3.0.1 */
2118 #else
2119 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2120 #endif
2121 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2122 0, /* tp_as_number */
2123 0, /* tp_as_sequence */
2124 0, /* tp_as_mapping */
2125 (hashfunc)0, /* tp_hash */
2126 (ternaryfunc)0, /* tp_call */
2127 (reprfunc)SwigPyPacked_str, /* tp_str */
2128 PyObject_GenericGetAttr, /* tp_getattro */
2129 0, /* tp_setattro */
2130 0, /* tp_as_buffer */
2131 Py_TPFLAGS_DEFAULT, /* tp_flags */
2132 swigpacked_doc, /* tp_doc */
2133 0, /* tp_traverse */
2134 0, /* tp_clear */
2135 0, /* tp_richcompare */
2136 0, /* tp_weaklistoffset */
2137 #if PY_VERSION_HEX >= 0x02020000
2138 0, /* tp_iter */
2139 0, /* tp_iternext */
2140 0, /* tp_methods */
2141 0, /* tp_members */
2142 0, /* tp_getset */
2143 0, /* tp_base */
2144 0, /* tp_dict */
2145 0, /* tp_descr_get */
2146 0, /* tp_descr_set */
2147 0, /* tp_dictoffset */
2148 0, /* tp_init */
2149 0, /* tp_alloc */
2150 0, /* tp_new */
2151 0, /* tp_free */
2152 0, /* tp_is_gc */
2153 0, /* tp_bases */
2154 0, /* tp_mro */
2155 0, /* tp_cache */
2156 0, /* tp_subclasses */
2157 0, /* tp_weaklist */
2158 #endif
2159 #if PY_VERSION_HEX >= 0x02030000
2160 0, /* tp_del */
2161 #endif
2162 #if PY_VERSION_HEX >= 0x02060000
2163 0, /* tp_version_tag */
2164 #endif
2165 #if PY_VERSION_HEX >= 0x03040000
2166 0, /* tp_finalize */
2167 #endif
2168 #ifdef COUNT_ALLOCS
2169 0, /* tp_allocs */
2170 0, /* tp_frees */
2171 0, /* tp_maxalloc */
2172 #if PY_VERSION_HEX >= 0x02050000
2173 0, /* tp_prev */
2174 #endif
2175 0 /* tp_next */
2176 #endif
2177 };
2178 swigpypacked_type = tmp;
2179 type_init = 1;
2180 #if PY_VERSION_HEX < 0x02020000
2181 swigpypacked_type.ob_type = &PyType_Type;
2182 #else
2183 if (PyType_Ready(&swigpypacked_type) < 0)
2184 return NULL;
2185 #endif
2186 }
2187 return &swigpypacked_type;
2188 }
2189
2190 SWIGRUNTIME PyObject *
SwigPyPacked_New(void * ptr,size_t size,swig_type_info * ty)2191 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2192 {
2193 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2194 if (sobj) {
2195 void *pack = malloc(size);
2196 if (pack) {
2197 memcpy(pack, ptr, size);
2198 sobj->pack = pack;
2199 sobj->ty = ty;
2200 sobj->size = size;
2201 } else {
2202 PyObject_DEL((PyObject *) sobj);
2203 sobj = 0;
2204 }
2205 }
2206 return (PyObject *) sobj;
2207 }
2208
2209 SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject * obj,void * ptr,size_t size)2210 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2211 {
2212 if (SwigPyPacked_Check(obj)) {
2213 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2214 if (sobj->size != size) return 0;
2215 memcpy(ptr, sobj->pack, size);
2216 return sobj->ty;
2217 } else {
2218 return 0;
2219 }
2220 }
2221
2222 /* -----------------------------------------------------------------------------
2223 * pointers/data manipulation
2224 * ----------------------------------------------------------------------------- */
2225
2226 SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)2227 _SWIG_This(void)
2228 {
2229 return SWIG_Python_str_FromChar("this");
2230 }
2231
2232 static PyObject *swig_this = NULL;
2233
2234 SWIGRUNTIME PyObject *
SWIG_This(void)2235 SWIG_This(void)
2236 {
2237 if (swig_this == NULL)
2238 swig_this = _SWIG_This();
2239 return swig_this;
2240 }
2241
2242 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2243
2244 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2245 #if PY_VERSION_HEX>=0x03000000
2246 #define SWIG_PYTHON_SLOW_GETSET_THIS
2247 #endif
2248
2249 SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject * pyobj)2250 SWIG_Python_GetSwigThis(PyObject *pyobj)
2251 {
2252 PyObject *obj;
2253
2254 if (SwigPyObject_Check(pyobj))
2255 return (SwigPyObject *) pyobj;
2256
2257 #ifdef SWIGPYTHON_BUILTIN
2258 (void)obj;
2259 # ifdef PyWeakref_CheckProxy
2260 if (PyWeakref_CheckProxy(pyobj)) {
2261 pyobj = PyWeakref_GET_OBJECT(pyobj);
2262 if (pyobj && SwigPyObject_Check(pyobj))
2263 return (SwigPyObject*) pyobj;
2264 }
2265 # endif
2266 return NULL;
2267 #else
2268
2269 obj = 0;
2270
2271 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2272 if (PyInstance_Check(pyobj)) {
2273 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2274 } else {
2275 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2276 if (dictptr != NULL) {
2277 PyObject *dict = *dictptr;
2278 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2279 } else {
2280 #ifdef PyWeakref_CheckProxy
2281 if (PyWeakref_CheckProxy(pyobj)) {
2282 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2283 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2284 }
2285 #endif
2286 obj = PyObject_GetAttr(pyobj,SWIG_This());
2287 if (obj) {
2288 Py_DECREF(obj);
2289 } else {
2290 if (PyErr_Occurred()) PyErr_Clear();
2291 return 0;
2292 }
2293 }
2294 }
2295 #else
2296 obj = PyObject_GetAttr(pyobj,SWIG_This());
2297 if (obj) {
2298 Py_DECREF(obj);
2299 } else {
2300 if (PyErr_Occurred()) PyErr_Clear();
2301 return 0;
2302 }
2303 #endif
2304 if (obj && !SwigPyObject_Check(obj)) {
2305 /* a PyObject is called 'this', try to get the 'real this'
2306 SwigPyObject from it */
2307 return SWIG_Python_GetSwigThis(obj);
2308 }
2309 return (SwigPyObject *)obj;
2310 #endif
2311 }
2312
2313 /* Acquire a pointer value */
2314
2315 SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject * obj,int own)2316 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2317 if (own == SWIG_POINTER_OWN) {
2318 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2319 if (sobj) {
2320 int oldown = sobj->own;
2321 sobj->own = own;
2322 return oldown;
2323 }
2324 }
2325 return 0;
2326 }
2327
2328 /* Convert a pointer value */
2329
2330 SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject * obj,void ** ptr,swig_type_info * ty,int flags,int * own)2331 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2332 int res;
2333 SwigPyObject *sobj;
2334 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2335
2336 if (!obj)
2337 return SWIG_ERROR;
2338 if (obj == Py_None && !implicit_conv) {
2339 if (ptr)
2340 *ptr = 0;
2341 return SWIG_OK;
2342 }
2343
2344 res = SWIG_ERROR;
2345
2346 sobj = SWIG_Python_GetSwigThis(obj);
2347 if (own)
2348 *own = 0;
2349 while (sobj) {
2350 void *vptr = sobj->ptr;
2351 if (ty) {
2352 swig_type_info *to = sobj->ty;
2353 if (to == ty) {
2354 /* no type cast needed */
2355 if (ptr) *ptr = vptr;
2356 break;
2357 } else {
2358 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2359 if (!tc) {
2360 sobj = (SwigPyObject *)sobj->next;
2361 } else {
2362 if (ptr) {
2363 int newmemory = 0;
2364 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2365 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2366 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2367 if (own)
2368 *own = *own | SWIG_CAST_NEW_MEMORY;
2369 }
2370 }
2371 break;
2372 }
2373 }
2374 } else {
2375 if (ptr) *ptr = vptr;
2376 break;
2377 }
2378 }
2379 if (sobj) {
2380 if (own)
2381 *own = *own | sobj->own;
2382 if (flags & SWIG_POINTER_DISOWN) {
2383 sobj->own = 0;
2384 }
2385 res = SWIG_OK;
2386 } else {
2387 if (implicit_conv) {
2388 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2389 if (data && !data->implicitconv) {
2390 PyObject *klass = data->klass;
2391 if (klass) {
2392 PyObject *impconv;
2393 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2394 impconv = SWIG_Python_CallFunctor(klass, obj);
2395 data->implicitconv = 0;
2396 if (PyErr_Occurred()) {
2397 PyErr_Clear();
2398 impconv = 0;
2399 }
2400 if (impconv) {
2401 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2402 if (iobj) {
2403 void *vptr;
2404 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2405 if (SWIG_IsOK(res)) {
2406 if (ptr) {
2407 *ptr = vptr;
2408 /* transfer the ownership to 'ptr' */
2409 iobj->own = 0;
2410 res = SWIG_AddCast(res);
2411 res = SWIG_AddNewMask(res);
2412 } else {
2413 res = SWIG_AddCast(res);
2414 }
2415 }
2416 }
2417 Py_DECREF(impconv);
2418 }
2419 }
2420 }
2421 }
2422 if (!SWIG_IsOK(res) && obj == Py_None) {
2423 if (ptr)
2424 *ptr = 0;
2425 if (PyErr_Occurred())
2426 PyErr_Clear();
2427 res = SWIG_OK;
2428 }
2429 }
2430 return res;
2431 }
2432
2433 /* Convert a function ptr value */
2434
2435 SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject * obj,void ** ptr,swig_type_info * ty)2436 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2437 if (!PyCFunction_Check(obj)) {
2438 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2439 } else {
2440 void *vptr = 0;
2441
2442 /* here we get the method pointer for callbacks */
2443 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2444 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2445 if (desc)
2446 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2447 if (!desc)
2448 return SWIG_ERROR;
2449 if (ty) {
2450 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2451 if (tc) {
2452 int newmemory = 0;
2453 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2454 assert(!newmemory); /* newmemory handling not yet implemented */
2455 } else {
2456 return SWIG_ERROR;
2457 }
2458 } else {
2459 *ptr = vptr;
2460 }
2461 return SWIG_OK;
2462 }
2463 }
2464
2465 /* Convert a packed value value */
2466
2467 SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject * obj,void * ptr,size_t sz,swig_type_info * ty)2468 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2469 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2470 if (!to) return SWIG_ERROR;
2471 if (ty) {
2472 if (to != ty) {
2473 /* check type cast? */
2474 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2475 if (!tc) return SWIG_ERROR;
2476 }
2477 }
2478 return SWIG_OK;
2479 }
2480
2481 /* -----------------------------------------------------------------------------
2482 * Create a new pointer object
2483 * ----------------------------------------------------------------------------- */
2484
2485 /*
2486 Create a new instance object, without calling __init__, and set the
2487 'this' attribute.
2488 */
2489
2490 SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData * data,PyObject * swig_this)2491 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2492 {
2493 #if (PY_VERSION_HEX >= 0x02020000)
2494 PyObject *inst = 0;
2495 PyObject *newraw = data->newraw;
2496 if (newraw) {
2497 inst = PyObject_Call(newraw, data->newargs, NULL);
2498 if (inst) {
2499 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2500 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2501 if (dictptr != NULL) {
2502 PyObject *dict = *dictptr;
2503 if (dict == NULL) {
2504 dict = PyDict_New();
2505 *dictptr = dict;
2506 PyDict_SetItem(dict, SWIG_This(), swig_this);
2507 }
2508 }
2509 #else
2510 PyObject *key = SWIG_This();
2511 PyObject_SetAttr(inst, key, swig_this);
2512 #endif
2513 }
2514 } else {
2515 #if PY_VERSION_HEX >= 0x03000000
2516 inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2517 if (inst) {
2518 PyObject_SetAttr(inst, SWIG_This(), swig_this);
2519 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2520 }
2521 #else
2522 PyObject *dict = PyDict_New();
2523 if (dict) {
2524 PyDict_SetItem(dict, SWIG_This(), swig_this);
2525 inst = PyInstance_NewRaw(data->newargs, dict);
2526 Py_DECREF(dict);
2527 }
2528 #endif
2529 }
2530 return inst;
2531 #else
2532 #if (PY_VERSION_HEX >= 0x02010000)
2533 PyObject *inst = 0;
2534 PyObject *dict = PyDict_New();
2535 if (dict) {
2536 PyDict_SetItem(dict, SWIG_This(), swig_this);
2537 inst = PyInstance_NewRaw(data->newargs, dict);
2538 Py_DECREF(dict);
2539 }
2540 return (PyObject *) inst;
2541 #else
2542 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2543 if (inst == NULL) {
2544 return NULL;
2545 }
2546 inst->in_class = (PyClassObject *)data->newargs;
2547 Py_INCREF(inst->in_class);
2548 inst->in_dict = PyDict_New();
2549 if (inst->in_dict == NULL) {
2550 Py_DECREF(inst);
2551 return NULL;
2552 }
2553 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2554 inst->in_weakreflist = NULL;
2555 #endif
2556 #ifdef Py_TPFLAGS_GC
2557 PyObject_GC_Init(inst);
2558 #endif
2559 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2560 return (PyObject *) inst;
2561 #endif
2562 #endif
2563 }
2564
2565 SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject * inst,PyObject * swig_this)2566 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2567 {
2568 PyObject *dict;
2569 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2570 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2571 if (dictptr != NULL) {
2572 dict = *dictptr;
2573 if (dict == NULL) {
2574 dict = PyDict_New();
2575 *dictptr = dict;
2576 }
2577 PyDict_SetItem(dict, SWIG_This(), swig_this);
2578 return;
2579 }
2580 #endif
2581 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2582 PyDict_SetItem(dict, SWIG_This(), swig_this);
2583 Py_DECREF(dict);
2584 }
2585
2586
2587 SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject * args)2588 SWIG_Python_InitShadowInstance(PyObject *args) {
2589 PyObject *obj[2];
2590 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2591 return NULL;
2592 } else {
2593 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2594 if (sthis) {
2595 SwigPyObject_append((PyObject*) sthis, obj[1]);
2596 } else {
2597 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2598 }
2599 return SWIG_Py_Void();
2600 }
2601 }
2602
2603 /* Create a new pointer object */
2604
2605 SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject * self,void * ptr,swig_type_info * type,int flags)2606 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2607 SwigPyClientData *clientdata;
2608 PyObject * robj;
2609 int own;
2610
2611 if (!ptr)
2612 return SWIG_Py_Void();
2613
2614 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2615 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2616 if (clientdata && clientdata->pytype) {
2617 SwigPyObject *newobj;
2618 if (flags & SWIG_BUILTIN_TP_INIT) {
2619 newobj = (SwigPyObject*) self;
2620 if (newobj->ptr) {
2621 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2622 while (newobj->next)
2623 newobj = (SwigPyObject *) newobj->next;
2624 newobj->next = next_self;
2625 newobj = (SwigPyObject *)next_self;
2626 #ifdef SWIGPYTHON_BUILTIN
2627 newobj->dict = 0;
2628 #endif
2629 }
2630 } else {
2631 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2632 #ifdef SWIGPYTHON_BUILTIN
2633 newobj->dict = 0;
2634 #endif
2635 }
2636 if (newobj) {
2637 newobj->ptr = ptr;
2638 newobj->ty = type;
2639 newobj->own = own;
2640 newobj->next = 0;
2641 return (PyObject*) newobj;
2642 }
2643 return SWIG_Py_Void();
2644 }
2645
2646 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2647
2648 robj = SwigPyObject_New(ptr, type, own);
2649 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2650 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2651 Py_DECREF(robj);
2652 robj = inst;
2653 }
2654 return robj;
2655 }
2656
2657 /* Create a new packed object */
2658
2659 SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void * ptr,size_t sz,swig_type_info * type)2660 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2661 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2662 }
2663
2664 /* -----------------------------------------------------------------------------*
2665 * Get type list
2666 * -----------------------------------------------------------------------------*/
2667
2668 #ifdef SWIG_LINK_RUNTIME
2669 void *SWIG_ReturnGlobalTypeList(void *);
2670 #endif
2671
2672 SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void * SWIGUNUSEDPARM (clientdata))2673 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2674 static void *type_pointer = (void *)0;
2675 /* first check if module already created */
2676 if (!type_pointer) {
2677 #ifdef SWIG_LINK_RUNTIME
2678 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2679 #else
2680 # ifdef SWIGPY_USE_CAPSULE
2681 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2682 # else
2683 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2684 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2685 # endif
2686 if (PyErr_Occurred()) {
2687 PyErr_Clear();
2688 type_pointer = (void *)0;
2689 }
2690 #endif
2691 }
2692 return (swig_module_info *) type_pointer;
2693 }
2694
2695 #if PY_MAJOR_VERSION < 2
2696 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2697 is copied out of Python/modsupport.c in python version 2.3.4 */
2698 SWIGINTERN int
PyModule_AddObject(PyObject * m,char * name,PyObject * o)2699 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2700 {
2701 PyObject *dict;
2702 if (!PyModule_Check(m)) {
2703 PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2704 return SWIG_ERROR;
2705 }
2706 if (!o) {
2707 PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2708 return SWIG_ERROR;
2709 }
2710
2711 dict = PyModule_GetDict(m);
2712 if (dict == NULL) {
2713 /* Internal error -- modules must have a dict! */
2714 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2715 PyModule_GetName(m));
2716 return SWIG_ERROR;
2717 }
2718 if (PyDict_SetItemString(dict, name, o))
2719 return SWIG_ERROR;
2720 Py_DECREF(o);
2721 return SWIG_OK;
2722 }
2723 #endif
2724
2725 SWIGRUNTIME void
2726 #ifdef SWIGPY_USE_CAPSULE
SWIG_Python_DestroyModule(PyObject * obj)2727 SWIG_Python_DestroyModule(PyObject *obj)
2728 #else
2729 SWIG_Python_DestroyModule(void *vptr)
2730 #endif
2731 {
2732 #ifdef SWIGPY_USE_CAPSULE
2733 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2734 #else
2735 swig_module_info *swig_module = (swig_module_info *) vptr;
2736 #endif
2737 swig_type_info **types = swig_module->types;
2738 size_t i;
2739 for (i =0; i < swig_module->size; ++i) {
2740 swig_type_info *ty = types[i];
2741 if (ty->owndata) {
2742 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2743 if (data) SwigPyClientData_Del(data);
2744 }
2745 }
2746 Py_DECREF(SWIG_This());
2747 swig_this = NULL;
2748 }
2749
2750 SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info * swig_module)2751 SWIG_Python_SetModule(swig_module_info *swig_module) {
2752 #if PY_VERSION_HEX >= 0x03000000
2753 /* Add a dummy module object into sys.modules */
2754 PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2755 #else
2756 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2757 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2758 #endif
2759 #ifdef SWIGPY_USE_CAPSULE
2760 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2761 if (pointer && module) {
2762 PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2763 } else {
2764 Py_XDECREF(pointer);
2765 }
2766 #else
2767 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2768 if (pointer && module) {
2769 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2770 } else {
2771 Py_XDECREF(pointer);
2772 }
2773 #endif
2774 }
2775
2776 /* The python cached type query */
2777 SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void)2778 SWIG_Python_TypeCache(void) {
2779 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2780 return cache;
2781 }
2782
2783 SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char * type)2784 SWIG_Python_TypeQuery(const char *type)
2785 {
2786 PyObject *cache = SWIG_Python_TypeCache();
2787 PyObject *key = SWIG_Python_str_FromChar(type);
2788 PyObject *obj = PyDict_GetItem(cache, key);
2789 swig_type_info *descriptor;
2790 if (obj) {
2791 #ifdef SWIGPY_USE_CAPSULE
2792 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2793 #else
2794 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2795 #endif
2796 } else {
2797 swig_module_info *swig_module = SWIG_GetModule(0);
2798 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2799 if (descriptor) {
2800 #ifdef SWIGPY_USE_CAPSULE
2801 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2802 #else
2803 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2804 #endif
2805 PyDict_SetItem(cache, key, obj);
2806 Py_DECREF(obj);
2807 }
2808 }
2809 Py_DECREF(key);
2810 return descriptor;
2811 }
2812
2813 /*
2814 For backward compatibility only
2815 */
2816 #define SWIG_POINTER_EXCEPTION 0
2817 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2818 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2819
2820 SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char * mesg,int infront)2821 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2822 {
2823 if (PyErr_Occurred()) {
2824 PyObject *type = 0;
2825 PyObject *value = 0;
2826 PyObject *traceback = 0;
2827 PyErr_Fetch(&type, &value, &traceback);
2828 if (value) {
2829 char *tmp;
2830 PyObject *old_str = PyObject_Str(value);
2831 Py_XINCREF(type);
2832 PyErr_Clear();
2833 if (infront) {
2834 PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2835 } else {
2836 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2837 }
2838 SWIG_Python_str_DelForPy3(tmp);
2839 Py_DECREF(old_str);
2840 }
2841 return 1;
2842 } else {
2843 return 0;
2844 }
2845 }
2846
2847 SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)2848 SWIG_Python_ArgFail(int argnum)
2849 {
2850 if (PyErr_Occurred()) {
2851 /* add information about failing argument */
2852 char mesg[256];
2853 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2854 return SWIG_Python_AddErrMesg(mesg, 1);
2855 } else {
2856 return 0;
2857 }
2858 }
2859
2860 SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject * self)2861 SwigPyObject_GetDesc(PyObject *self)
2862 {
2863 SwigPyObject *v = (SwigPyObject *)self;
2864 swig_type_info *ty = v ? v->ty : 0;
2865 return ty ? ty->str : "";
2866 }
2867
2868 SWIGRUNTIME void
SWIG_Python_TypeError(const char * type,PyObject * obj)2869 SWIG_Python_TypeError(const char *type, PyObject *obj)
2870 {
2871 if (type) {
2872 #if defined(SWIG_COBJECT_TYPES)
2873 if (obj && SwigPyObject_Check(obj)) {
2874 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2875 if (otype) {
2876 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2877 type, otype);
2878 return;
2879 }
2880 } else
2881 #endif
2882 {
2883 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2884 if (otype) {
2885 PyObject *str = PyObject_Str(obj);
2886 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2887 if (cstr) {
2888 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2889 type, otype, cstr);
2890 SWIG_Python_str_DelForPy3(cstr);
2891 } else {
2892 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2893 type, otype);
2894 }
2895 Py_XDECREF(str);
2896 return;
2897 }
2898 }
2899 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2900 } else {
2901 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2902 }
2903 }
2904
2905
2906 /* Convert a pointer value, signal an exception on a type mismatch */
2907 SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject * obj,swig_type_info * ty,int SWIGUNUSEDPARM (argnum),int flags)2908 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2909 void *result;
2910 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2911 PyErr_Clear();
2912 #if SWIG_POINTER_EXCEPTION
2913 if (flags) {
2914 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2915 SWIG_Python_ArgFail(argnum);
2916 }
2917 #endif
2918 }
2919 return result;
2920 }
2921
2922 #ifdef SWIGPYTHON_BUILTIN
2923 SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject * obj,PyObject * name,PyObject * value)2924 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2925 PyTypeObject *tp = obj->ob_type;
2926 PyObject *descr;
2927 PyObject *encoded_name;
2928 descrsetfunc f;
2929 int res = -1;
2930
2931 # ifdef Py_USING_UNICODE
2932 if (PyString_Check(name)) {
2933 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2934 if (!name)
2935 return -1;
2936 } else if (!PyUnicode_Check(name))
2937 # else
2938 if (!PyString_Check(name))
2939 # endif
2940 {
2941 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2942 return -1;
2943 } else {
2944 Py_INCREF(name);
2945 }
2946
2947 if (!tp->tp_dict) {
2948 if (PyType_Ready(tp) < 0)
2949 goto done;
2950 }
2951
2952 descr = _PyType_Lookup(tp, name);
2953 f = NULL;
2954 if (descr != NULL)
2955 f = descr->ob_type->tp_descr_set;
2956 if (!f) {
2957 if (PyString_Check(name)) {
2958 encoded_name = name;
2959 Py_INCREF(name);
2960 } else {
2961 encoded_name = PyUnicode_AsUTF8String(name);
2962 }
2963 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2964 Py_DECREF(encoded_name);
2965 } else {
2966 res = f(descr, obj, value);
2967 }
2968
2969 done:
2970 Py_DECREF(name);
2971 return res;
2972 }
2973 #endif
2974
2975
2976 #ifdef __cplusplus
2977 }
2978 #endif
2979
2980
2981
2982 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2983
2984 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2985
2986
2987
2988 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2989
2990
2991 /* -------- TYPES TABLE (BEGIN) -------- */
2992
2993 #define SWIGTYPE_p_apr_array_header_t swig_types[0]
2994 #define SWIGTYPE_p_apr_hash_t swig_types[1]
2995 #define SWIGTYPE_p_apr_int32_t swig_types[2]
2996 #define SWIGTYPE_p_apr_int64_t swig_types[3]
2997 #define SWIGTYPE_p_apr_off_t swig_types[4]
2998 #define SWIGTYPE_p_apr_pool_t swig_types[5]
2999 #define SWIGTYPE_p_apr_uint32_t swig_types[6]
3000 #define SWIGTYPE_p_char swig_types[7]
3001 #define SWIGTYPE_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[8]
3002 #define SWIGTYPE_p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t swig_types[9]
3003 #define SWIGTYPE_p_f_p_void__p_svn_error_t swig_types[10]
3004 #define SWIGTYPE_p_f_p_void__void swig_types[11]
3005 #define SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t swig_types[12]
3006 #define SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t swig_types[13]
3007 #define SWIGTYPE_p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t swig_types[14]
3008 #define SWIGTYPE_p_f_p_void_p_void__void swig_types[15]
3009 #define SWIGTYPE_p_f_p_void_p_void_p_void_p_int__p_svn_error_t swig_types[16]
3010 #define SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t swig_types[17]
3011 #define SWIGTYPE_p_int swig_types[18]
3012 #define SWIGTYPE_p_long swig_types[19]
3013 #define SWIGTYPE_p_p_char swig_types[20]
3014 #define SWIGTYPE_p_p_svn_diff_t swig_types[21]
3015 #define SWIGTYPE_p_p_svn_patch_file_t swig_types[22]
3016 #define SWIGTYPE_p_p_svn_patch_t swig_types[23]
3017 #define SWIGTYPE_p_p_svn_stringbuf_t swig_types[24]
3018 #define SWIGTYPE_p_p_void swig_types[25]
3019 #define SWIGTYPE_p_svn_auth_baton_t swig_types[26]
3020 #define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[27]
3021 #define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[28]
3022 #define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[29]
3023 #define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[30]
3024 #define SWIGTYPE_p_svn_auth_cred_username_t swig_types[31]
3025 #define SWIGTYPE_p_svn_auth_iterstate_t swig_types[32]
3026 #define SWIGTYPE_p_svn_auth_provider_object_t swig_types[33]
3027 #define SWIGTYPE_p_svn_auth_provider_t swig_types[34]
3028 #define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[35]
3029 #define SWIGTYPE_p_svn_cache_config_t swig_types[36]
3030 #define SWIGTYPE_p_svn_checksum_ctx_t swig_types[37]
3031 #define SWIGTYPE_p_svn_checksum_kind_t swig_types[38]
3032 #define SWIGTYPE_p_svn_checksum_t swig_types[39]
3033 #define SWIGTYPE_p_svn_client__shelf_version_t swig_types[40]
3034 #define SWIGTYPE_p_svn_client_conflict_option_t swig_types[41]
3035 #define SWIGTYPE_p_svn_commit_info_t swig_types[42]
3036 #define SWIGTYPE_p_svn_config_t swig_types[43]
3037 #define SWIGTYPE_p_svn_depth_t swig_types[44]
3038 #define SWIGTYPE_p_svn_diff_binary_patch_t swig_types[45]
3039 #define SWIGTYPE_p_svn_diff_conflict_display_style_t swig_types[46]
3040 #define SWIGTYPE_p_svn_diff_datasource_e swig_types[47]
3041 #define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[48]
3042 #define SWIGTYPE_p_svn_diff_file_options_t swig_types[49]
3043 #define SWIGTYPE_p_svn_diff_fns2_t swig_types[50]
3044 #define SWIGTYPE_p_svn_diff_fns_t swig_types[51]
3045 #define SWIGTYPE_p_svn_diff_hunk_t swig_types[52]
3046 #define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[53]
3047 #define SWIGTYPE_p_svn_diff_output_fns_t swig_types[54]
3048 #define SWIGTYPE_p_svn_diff_t swig_types[55]
3049 #define SWIGTYPE_p_svn_dirent_t swig_types[56]
3050 #define SWIGTYPE_p_svn_errno_t swig_types[57]
3051 #define SWIGTYPE_p_svn_error_t swig_types[58]
3052 #define SWIGTYPE_p_svn_fs_lock_target_t swig_types[59]
3053 #define SWIGTYPE_p_svn_io_dirent2_t swig_types[60]
3054 #define SWIGTYPE_p_svn_io_dirent_t swig_types[61]
3055 #define SWIGTYPE_p_svn_io_file_del_t swig_types[62]
3056 #define SWIGTYPE_p_svn_location_segment_t swig_types[63]
3057 #define SWIGTYPE_p_svn_lock_t swig_types[64]
3058 #define SWIGTYPE_p_svn_log_changed_path2_t swig_types[65]
3059 #define SWIGTYPE_p_svn_log_changed_path_t swig_types[66]
3060 #define SWIGTYPE_p_svn_log_entry_t swig_types[67]
3061 #define SWIGTYPE_p_svn_merge_range_t swig_types[68]
3062 #define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[69]
3063 #define SWIGTYPE_p_svn_node_kind_t swig_types[70]
3064 #define SWIGTYPE_p_svn_opt_revision_range_t swig_types[71]
3065 #define SWIGTYPE_p_svn_opt_revision_t swig_types[72]
3066 #define SWIGTYPE_p_svn_opt_revision_value_t swig_types[73]
3067 #define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[74]
3068 #define SWIGTYPE_p_svn_opt_subcommand_desc3_t swig_types[75]
3069 #define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[76]
3070 #define SWIGTYPE_p_svn_patch_file_t swig_types[77]
3071 #define SWIGTYPE_p_svn_patch_t swig_types[78]
3072 #define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[79]
3073 #define SWIGTYPE_p_svn_prop_kind swig_types[80]
3074 #define SWIGTYPE_p_svn_prop_patch_t swig_types[81]
3075 #define SWIGTYPE_p_svn_stream_mark_t swig_types[82]
3076 #define SWIGTYPE_p_svn_stream_t swig_types[83]
3077 #define SWIGTYPE_p_svn_string_t swig_types[84]
3078 #define SWIGTYPE_p_svn_stringbuf_t swig_types[85]
3079 #define SWIGTYPE_p_svn_tristate_t swig_types[86]
3080 #define SWIGTYPE_p_svn_version_checklist_t swig_types[87]
3081 #define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[88]
3082 #define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[89]
3083 #define SWIGTYPE_p_svn_version_extended_t swig_types[90]
3084 #define SWIGTYPE_p_svn_version_t swig_types[91]
3085 #define SWIGTYPE_p_svn_wc_external_item2_t swig_types[92]
3086 #define SWIGTYPE_p_unsigned_long swig_types[93]
3087 #define SWIGTYPE_p_void swig_types[94]
3088 static swig_type_info *swig_types[96];
3089 static swig_module_info swig_module = {swig_types, 95, 0, 0, 0, 0};
3090 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3091 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3092
3093 /* -------- TYPES TABLE (END) -------- */
3094
3095 #if (PY_VERSION_HEX <= 0x02000000)
3096 # if !defined(SWIG_PYTHON_CLASSIC)
3097 # error "This python version requires swig to be run with the '-classic' option"
3098 # endif
3099 #endif
3100 #if (PY_VERSION_HEX <= 0x02020000)
3101 # error "This python version requires swig to be run with the '-nomodern' option"
3102 #endif
3103 #if (PY_VERSION_HEX <= 0x02020000)
3104 # error "This python version requires swig to be run with the '-nomodernargs' option"
3105 #endif
3106
3107 /*-----------------------------------------------
3108 @(target):= _diff.so
3109 ------------------------------------------------*/
3110 #if PY_VERSION_HEX >= 0x03000000
3111 # define SWIG_init PyInit__diff
3112
3113 #else
3114 # define SWIG_init init_diff
3115
3116 #endif
3117 #define SWIG_name "_diff"
3118
3119 #define SWIGVERSION 0x030012
3120 #define SWIG_VERSION SWIGVERSION
3121
3122
3123 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
3124 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3125
3126
3127 #include "svn_time.h"
3128 #include "svn_pools.h"
3129
3130
3131 #include "swigutil_py.h"
3132 #include "swigutil_py3c.h"
3133
3134
3135 static PyObject * _global_py_pool = NULL;
3136
3137
3138 #define svn_argnum_obj0 1
3139 #define svn_argnum_obj1 2
3140 #define svn_argnum_obj2 3
3141 #define svn_argnum_obj3 4
3142 #define svn_argnum_obj4 5
3143 #define svn_argnum_obj5 6
3144 #define svn_argnum_obj6 7
3145 #define svn_argnum_obj7 8
3146 #define svn_argnum_obj8 9
3147 #define svn_argnum_obj9 10
3148 #define svn_argnum_obj10 11
3149 #define svn_argnum_obj11 12
3150 #define svn_argnum_obj12 13
3151 #define svn_argnum_obj13 14
3152 #define svn_argnum_obj14 15
3153 #define svn_argnum_obj15 16
3154 #define svn_argnum_obj16 17
3155 #define svn_argnum_obj17 18
3156 #define svn_argnum_obj18 19
3157 #define svn_argnum_obj19 20
3158 #define svn_argnum_obj20 21
3159 #define svn_argnum_obj21 22
3160 #define svn_argnum_obj22 23
3161 #define svn_argnum_obj23 24
3162 #define svn_argnum_obj24 25
3163 #define svn_argnum_obj25 26
3164 #define svn_argnum_obj26 27
3165 #define svn_argnum_obj27 28
3166 #define svn_argnum_obj28 29
3167 #define svn_argnum_obj29 30
3168 #define svn_argnum_obj30 31
3169 #define svn_argnum_obj31 32
3170 #define svn_argnum_obj32 33
3171 #define svn_argnum_obj33 34
3172 #define svn_argnum_obj34 35
3173 #define svn_argnum_obj35 36
3174 #define svn_argnum_obj36 37
3175 #define svn_argnum_obj37 38
3176 #define svn_argnum_obj38 39
3177 #define svn_argnum_obj39 40
3178
3179
3180 #include "svn_diff.h"
3181
3182
3183 #define SWIG_From_long PyInt_FromLong
3184
3185
3186 SWIGINTERN int
SWIG_AsVal_double(PyObject * obj,double * val)3187 SWIG_AsVal_double (PyObject *obj, double *val)
3188 {
3189 int res = SWIG_TypeError;
3190 if (PyFloat_Check(obj)) {
3191 if (val) *val = PyFloat_AsDouble(obj);
3192 return SWIG_OK;
3193 #if PY_VERSION_HEX < 0x03000000
3194 } else if (PyInt_Check(obj)) {
3195 if (val) *val = (double) PyInt_AsLong(obj);
3196 return SWIG_OK;
3197 #endif
3198 } else if (PyLong_Check(obj)) {
3199 double v = PyLong_AsDouble(obj);
3200 if (!PyErr_Occurred()) {
3201 if (val) *val = v;
3202 return SWIG_OK;
3203 } else {
3204 PyErr_Clear();
3205 }
3206 }
3207 #ifdef SWIG_PYTHON_CAST_MODE
3208 {
3209 int dispatch = 0;
3210 double d = PyFloat_AsDouble(obj);
3211 if (!PyErr_Occurred()) {
3212 if (val) *val = d;
3213 return SWIG_AddCast(SWIG_OK);
3214 } else {
3215 PyErr_Clear();
3216 }
3217 if (!dispatch) {
3218 long v = PyLong_AsLong(obj);
3219 if (!PyErr_Occurred()) {
3220 if (val) *val = v;
3221 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3222 } else {
3223 PyErr_Clear();
3224 }
3225 }
3226 }
3227 #endif
3228 return res;
3229 }
3230
3231
3232 #include <float.h>
3233
3234
3235 #include <math.h>
3236
3237
3238 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)3239 SWIG_CanCastAsInteger(double *d, double min, double max) {
3240 double x = *d;
3241 if ((min <= x && x <= max)) {
3242 double fx = floor(x);
3243 double cx = ceil(x);
3244 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3245 if ((errno == EDOM) || (errno == ERANGE)) {
3246 errno = 0;
3247 } else {
3248 double summ, reps, diff;
3249 if (rd < x) {
3250 diff = x - rd;
3251 } else if (rd > x) {
3252 diff = rd - x;
3253 } else {
3254 return 1;
3255 }
3256 summ = rd + x;
3257 reps = diff/summ;
3258 if (reps < 8*DBL_EPSILON) {
3259 *d = rd;
3260 return 1;
3261 }
3262 }
3263 }
3264 return 0;
3265 }
3266
3267
3268 SWIGINTERN int
SWIG_AsVal_long(PyObject * obj,long * val)3269 SWIG_AsVal_long (PyObject *obj, long* val)
3270 {
3271 #if PY_VERSION_HEX < 0x03000000
3272 if (PyInt_Check(obj)) {
3273 if (val) *val = PyInt_AsLong(obj);
3274 return SWIG_OK;
3275 } else
3276 #endif
3277 if (PyLong_Check(obj)) {
3278 long v = PyLong_AsLong(obj);
3279 if (!PyErr_Occurred()) {
3280 if (val) *val = v;
3281 return SWIG_OK;
3282 } else {
3283 PyErr_Clear();
3284 return SWIG_OverflowError;
3285 }
3286 }
3287 #ifdef SWIG_PYTHON_CAST_MODE
3288 {
3289 int dispatch = 0;
3290 long v = PyInt_AsLong(obj);
3291 if (!PyErr_Occurred()) {
3292 if (val) *val = v;
3293 return SWIG_AddCast(SWIG_OK);
3294 } else {
3295 PyErr_Clear();
3296 }
3297 if (!dispatch) {
3298 double d;
3299 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3300 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3301 if (val) *val = (long)(d);
3302 return res;
3303 }
3304 }
3305 }
3306 #endif
3307 return SWIG_TypeError;
3308 }
3309
3310
3311 SWIGINTERNINLINE long
SWIG_As_long(PyObject * obj)3312 SWIG_As_long (PyObject* obj)
3313 {
3314 long v;
3315 int res = SWIG_AsVal_long (obj, &v);
3316 if (!SWIG_IsOK(res)) {
3317 /*
3318 this is needed to make valgrind/purify happier.
3319 */
3320 memset((void*)&v, 0, sizeof(long));
3321 SWIG_Error(res, "");
3322 }
3323 return v;
3324 }
3325
3326
3327 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)3328 SWIG_pchar_descriptor(void)
3329 {
3330 static int init = 0;
3331 static swig_type_info* info = 0;
3332 if (!init) {
3333 info = SWIG_TypeQuery("_p_char");
3334 init = 1;
3335 }
3336 return info;
3337 }
3338
3339
3340 SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject * obj,char ** cptr,size_t * psize,int * alloc)3341 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3342 {
3343 #if PY_VERSION_HEX>=0x03000000
3344 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3345 if (PyBytes_Check(obj))
3346 #else
3347 if (PyUnicode_Check(obj))
3348 #endif
3349 #else
3350 if (PyString_Check(obj))
3351 #endif
3352 {
3353 char *cstr; Py_ssize_t len;
3354 #if PY_VERSION_HEX>=0x03000000
3355 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3356 if (!alloc && cptr) {
3357 /* We can't allow converting without allocation, since the internal
3358 representation of string in Python 3 is UCS-2/UCS-4 but we require
3359 a UTF-8 representation.
3360 TODO(bhy) More detailed explanation */
3361 return SWIG_RuntimeError;
3362 }
3363 obj = PyUnicode_AsUTF8String(obj);
3364 if(alloc) *alloc = SWIG_NEWOBJ;
3365 #endif
3366 PyBytes_AsStringAndSize(obj, &cstr, &len);
3367 #else
3368 PyString_AsStringAndSize(obj, &cstr, &len);
3369 #endif
3370 if (cptr) {
3371 if (alloc) {
3372 /*
3373 In python the user should not be able to modify the inner
3374 string representation. To warranty that, if you define
3375 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3376 buffer is always returned.
3377
3378 The default behavior is just to return the pointer value,
3379 so, be careful.
3380 */
3381 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3382 if (*alloc != SWIG_OLDOBJ)
3383 #else
3384 if (*alloc == SWIG_NEWOBJ)
3385 #endif
3386 {
3387 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3388 *alloc = SWIG_NEWOBJ;
3389 } else {
3390 *cptr = cstr;
3391 *alloc = SWIG_OLDOBJ;
3392 }
3393 } else {
3394 #if PY_VERSION_HEX>=0x03000000
3395 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3396 *cptr = PyBytes_AsString(obj);
3397 #else
3398 assert(0); /* Should never reach here with Unicode strings in Python 3 */
3399 #endif
3400 #else
3401 *cptr = SWIG_Python_str_AsChar(obj);
3402 #endif
3403 }
3404 }
3405 if (psize) *psize = len + 1;
3406 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3407 Py_XDECREF(obj);
3408 #endif
3409 return SWIG_OK;
3410 } else {
3411 #if defined(SWIG_PYTHON_2_UNICODE)
3412 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3413 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3414 #endif
3415 #if PY_VERSION_HEX<0x03000000
3416 if (PyUnicode_Check(obj)) {
3417 char *cstr; Py_ssize_t len;
3418 if (!alloc && cptr) {
3419 return SWIG_RuntimeError;
3420 }
3421 obj = PyUnicode_AsUTF8String(obj);
3422 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3423 if (cptr) {
3424 if (alloc) *alloc = SWIG_NEWOBJ;
3425 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3426 }
3427 if (psize) *psize = len + 1;
3428
3429 Py_XDECREF(obj);
3430 return SWIG_OK;
3431 } else {
3432 Py_XDECREF(obj);
3433 }
3434 }
3435 #endif
3436 #endif
3437
3438 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3439 if (pchar_descriptor) {
3440 void* vptr = 0;
3441 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3442 if (cptr) *cptr = (char *) vptr;
3443 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3444 if (alloc) *alloc = SWIG_OLDOBJ;
3445 return SWIG_OK;
3446 }
3447 }
3448 }
3449 return SWIG_TypeError;
3450 }
3451
3452
3453
3454
3455
3456 SWIGINTERNINLINE PyObject*
SWIG_From_int(int value)3457 SWIG_From_int (int value)
3458 {
3459 return PyInt_FromLong((long) value);
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject*
SWIG_From_unsigned_SS_long(unsigned long value)3464 SWIG_From_unsigned_SS_long (unsigned long value)
3465 {
3466 return (value > LONG_MAX) ?
3467 PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
3468 }
3469
3470
3471 SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)3472 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3473 {
3474 if (carray) {
3475 if (size > INT_MAX) {
3476 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3477 return pchar_descriptor ?
3478 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3479 } else {
3480 #if PY_VERSION_HEX >= 0x03000000
3481 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3482 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3483 #else
3484 #if PY_VERSION_HEX >= 0x03010000
3485 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3486 #else
3487 return PyUnicode_FromStringAndSize(carray, (Py_ssize_t)(size));
3488 #endif
3489 #endif
3490 #else
3491 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3492 #endif
3493 }
3494 } else {
3495 return SWIG_Py_Void();
3496 }
3497 }
3498
3499
3500 SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char * cptr)3501 SWIG_FromCharPtr(const char *cptr)
3502 {
3503 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3504 }
3505
3506
svn_diff_fns2_invoke_datasources_open(svn_diff_fns2_t * _obj,void * diff_baton,apr_off_t * prefix_lines,apr_off_t * suffix_lines,const svn_diff_datasource_e * datasources,apr_size_t datasources_len)3507 static svn_error_t * svn_diff_fns2_invoke_datasources_open(
3508 svn_diff_fns2_t * _obj, void *diff_baton, apr_off_t *prefix_lines, apr_off_t *suffix_lines, const svn_diff_datasource_e *datasources, apr_size_t datasources_len) {
3509 return (_obj->datasources_open)(diff_baton, prefix_lines, suffix_lines, datasources, datasources_len);
3510 }
3511
svn_diff_fns2_invoke_datasource_close(svn_diff_fns2_t * _obj,void * diff_baton,svn_diff_datasource_e datasource)3512 static svn_error_t * svn_diff_fns2_invoke_datasource_close(
3513 svn_diff_fns2_t * _obj, void *diff_baton, svn_diff_datasource_e datasource) {
3514 return (_obj->datasource_close)(diff_baton, datasource);
3515 }
3516
svn_diff_fns2_invoke_datasource_get_next_token(svn_diff_fns2_t * _obj,apr_uint32_t * hash,void ** token,void * diff_baton,svn_diff_datasource_e datasource)3517 static svn_error_t * svn_diff_fns2_invoke_datasource_get_next_token(
3518 svn_diff_fns2_t * _obj, apr_uint32_t *hash, void **token, void *diff_baton, svn_diff_datasource_e datasource) {
3519 return (_obj->datasource_get_next_token)(hash, token, diff_baton, datasource);
3520 }
3521
svn_diff_fns2_invoke_token_compare(svn_diff_fns2_t * _obj,void * diff_baton,void * ltoken,void * rtoken,int * compare)3522 static svn_error_t * svn_diff_fns2_invoke_token_compare(
3523 svn_diff_fns2_t * _obj, void *diff_baton, void *ltoken, void *rtoken, int *compare) {
3524 return (_obj->token_compare)(diff_baton, ltoken, rtoken, compare);
3525 }
3526
svn_diff_fns2_invoke_token_discard(svn_diff_fns2_t * _obj,void * diff_baton,void * token)3527 static void svn_diff_fns2_invoke_token_discard(
3528 svn_diff_fns2_t * _obj, void *diff_baton, void *token) {
3529 (_obj->token_discard)(diff_baton, token);
3530 }
3531
svn_diff_fns2_invoke_token_discard_all(svn_diff_fns2_t * _obj,void * diff_baton)3532 static void svn_diff_fns2_invoke_token_discard_all(
3533 svn_diff_fns2_t * _obj, void *diff_baton) {
3534 (_obj->token_discard_all)(diff_baton);
3535 }
3536
svn_diff_fns_invoke_datasource_open(svn_diff_fns_t * _obj,void * diff_baton,svn_diff_datasource_e datasource)3537 static svn_error_t * svn_diff_fns_invoke_datasource_open(
3538 svn_diff_fns_t * _obj, void *diff_baton, svn_diff_datasource_e datasource) {
3539 return (_obj->datasource_open)(diff_baton, datasource);
3540 }
3541
svn_diff_fns_invoke_datasource_close(svn_diff_fns_t * _obj,void * diff_baton,svn_diff_datasource_e datasource)3542 static svn_error_t * svn_diff_fns_invoke_datasource_close(
3543 svn_diff_fns_t * _obj, void *diff_baton, svn_diff_datasource_e datasource) {
3544 return (_obj->datasource_close)(diff_baton, datasource);
3545 }
3546
svn_diff_fns_invoke_datasource_get_next_token(svn_diff_fns_t * _obj,apr_uint32_t * hash,void ** token,void * diff_baton,svn_diff_datasource_e datasource)3547 static svn_error_t * svn_diff_fns_invoke_datasource_get_next_token(
3548 svn_diff_fns_t * _obj, apr_uint32_t *hash, void **token, void *diff_baton, svn_diff_datasource_e datasource) {
3549 return (_obj->datasource_get_next_token)(hash, token, diff_baton, datasource);
3550 }
3551
svn_diff_fns_invoke_token_compare(svn_diff_fns_t * _obj,void * diff_baton,void * ltoken,void * rtoken,int * compare)3552 static svn_error_t * svn_diff_fns_invoke_token_compare(
3553 svn_diff_fns_t * _obj, void *diff_baton, void *ltoken, void *rtoken, int *compare) {
3554 return (_obj->token_compare)(diff_baton, ltoken, rtoken, compare);
3555 }
3556
svn_diff_fns_invoke_token_discard(svn_diff_fns_t * _obj,void * diff_baton,void * token)3557 static void svn_diff_fns_invoke_token_discard(
3558 svn_diff_fns_t * _obj, void *diff_baton, void *token) {
3559 (_obj->token_discard)(diff_baton, token);
3560 }
3561
svn_diff_fns_invoke_token_discard_all(svn_diff_fns_t * _obj,void * diff_baton)3562 static void svn_diff_fns_invoke_token_discard_all(
3563 svn_diff_fns_t * _obj, void *diff_baton) {
3564 (_obj->token_discard_all)(diff_baton);
3565 }
3566
svn_diff_output_fns_invoke_output_common(svn_diff_output_fns_t * _obj,void * output_baton,apr_off_t original_start,apr_off_t original_length,apr_off_t modified_start,apr_off_t modified_length,apr_off_t latest_start,apr_off_t latest_length)3567 static svn_error_t * svn_diff_output_fns_invoke_output_common(
3568 svn_diff_output_fns_t * _obj, void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length) {
3569 return (_obj->output_common)(output_baton, original_start, original_length, modified_start, modified_length, latest_start, latest_length);
3570 }
3571
svn_diff_output_fns_invoke_output_diff_modified(svn_diff_output_fns_t * _obj,void * output_baton,apr_off_t original_start,apr_off_t original_length,apr_off_t modified_start,apr_off_t modified_length,apr_off_t latest_start,apr_off_t latest_length)3572 static svn_error_t * svn_diff_output_fns_invoke_output_diff_modified(
3573 svn_diff_output_fns_t * _obj, void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length) {
3574 return (_obj->output_diff_modified)(output_baton, original_start, original_length, modified_start, modified_length, latest_start, latest_length);
3575 }
3576
svn_diff_output_fns_invoke_output_diff_latest(svn_diff_output_fns_t * _obj,void * output_baton,apr_off_t original_start,apr_off_t original_length,apr_off_t modified_start,apr_off_t modified_length,apr_off_t latest_start,apr_off_t latest_length)3577 static svn_error_t * svn_diff_output_fns_invoke_output_diff_latest(
3578 svn_diff_output_fns_t * _obj, void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length) {
3579 return (_obj->output_diff_latest)(output_baton, original_start, original_length, modified_start, modified_length, latest_start, latest_length);
3580 }
3581
svn_diff_output_fns_invoke_output_diff_common(svn_diff_output_fns_t * _obj,void * output_baton,apr_off_t original_start,apr_off_t original_length,apr_off_t modified_start,apr_off_t modified_length,apr_off_t latest_start,apr_off_t latest_length)3582 static svn_error_t * svn_diff_output_fns_invoke_output_diff_common(
3583 svn_diff_output_fns_t * _obj, void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length) {
3584 return (_obj->output_diff_common)(output_baton, original_start, original_length, modified_start, modified_length, latest_start, latest_length);
3585 }
3586
svn_diff_output_fns_invoke_output_conflict(svn_diff_output_fns_t * _obj,void * output_baton,apr_off_t original_start,apr_off_t original_length,apr_off_t modified_start,apr_off_t modified_length,apr_off_t latest_start,apr_off_t latest_length,svn_diff_t * resolved_diff)3587 static svn_error_t * svn_diff_output_fns_invoke_output_conflict(
3588 svn_diff_output_fns_t * _obj, void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length, svn_diff_t *resolved_diff) {
3589 return (_obj->output_conflict)(output_baton, original_start, original_length, modified_start, modified_length, latest_start, latest_length, resolved_diff);
3590 }
3591
3592
3593
3594 SWIGINTERN int
SWIG_AsVal_unsigned_SS_long(PyObject * obj,unsigned long * val)3595 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3596 {
3597 #if PY_VERSION_HEX < 0x03000000
3598 if (PyInt_Check(obj)) {
3599 long v = PyInt_AsLong(obj);
3600 if (v >= 0) {
3601 if (val) *val = v;
3602 return SWIG_OK;
3603 } else {
3604 return SWIG_OverflowError;
3605 }
3606 } else
3607 #endif
3608 if (PyLong_Check(obj)) {
3609 unsigned long v = PyLong_AsUnsignedLong(obj);
3610 if (!PyErr_Occurred()) {
3611 if (val) *val = v;
3612 return SWIG_OK;
3613 } else {
3614 PyErr_Clear();
3615 return SWIG_OverflowError;
3616 }
3617 }
3618 #ifdef SWIG_PYTHON_CAST_MODE
3619 {
3620 int dispatch = 0;
3621 unsigned long v = PyLong_AsUnsignedLong(obj);
3622 if (!PyErr_Occurred()) {
3623 if (val) *val = v;
3624 return SWIG_AddCast(SWIG_OK);
3625 } else {
3626 PyErr_Clear();
3627 }
3628 if (!dispatch) {
3629 double d;
3630 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3631 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3632 if (val) *val = (unsigned long)(d);
3633 return res;
3634 }
3635 }
3636 }
3637 #endif
3638 return SWIG_TypeError;
3639 }
3640
3641
3642 SWIGINTERNINLINE unsigned long
SWIG_As_unsigned_SS_long(PyObject * obj)3643 SWIG_As_unsigned_SS_long (PyObject* obj)
3644 {
3645 unsigned long v;
3646 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3647 if (!SWIG_IsOK(res)) {
3648 /*
3649 this is needed to make valgrind/purify happier.
3650 */
3651 memset((void*)&v, 0, sizeof(unsigned long));
3652 SWIG_Error(res, "");
3653 }
3654 return v;
3655 }
3656
3657 #ifdef __cplusplus
3658 extern "C" {
3659 #endif
_wrap_svn_diff_version(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3660 SWIGINTERN PyObject *_wrap_svn_diff_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3661 PyObject *resultobj = 0;
3662 svn_version_t *result = 0 ;
3663
3664 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_version",0,0)) SWIG_fail;
3665 {
3666 svn_swig_py_release_py_lock();
3667
3668 result = (svn_version_t *)svn_diff_version();
3669
3670 svn_swig_py_acquire_py_lock();
3671
3672 }
3673 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_version_t,
3674 _global_py_pool, args);
3675 return resultobj;
3676 fail:
3677 return NULL;
3678 }
3679
3680
_wrap_svn_diff_fns2_t_datasources_open_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3681 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_datasources_open_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3682 PyObject *resultobj = 0;
3683 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3684 svn_error_t *(*arg2)(void *,apr_off_t *,apr_off_t *,svn_diff_datasource_e const *,apr_size_t) = (svn_error_t *(*)(void *,apr_off_t *,apr_off_t *,svn_diff_datasource_e const *,apr_size_t)) 0 ;
3685 PyObject * obj0 = 0 ;
3686 PyObject * obj1 = 0 ;
3687
3688 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_datasources_open_set",2,2,&obj0,&obj1)) SWIG_fail;
3689 {
3690 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3691 if (PyErr_Occurred()) {
3692 SWIG_fail;
3693 }
3694 }
3695 {
3696 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t);
3697 if (!SWIG_IsOK(res)) {
3698 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns2_t_datasources_open_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,apr_off_t *,apr_off_t *,svn_diff_datasource_e const *,apr_size_t)""'");
3699 }
3700 }
3701 if (arg1) (arg1)->datasources_open = arg2;
3702 resultobj = SWIG_Py_Void();
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
_wrap_svn_diff_fns2_t_datasources_open_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3709 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_datasources_open_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3710 PyObject *resultobj = 0;
3711 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3712 PyObject * obj0 = 0 ;
3713 svn_error_t *(*result)(void *,apr_off_t *,apr_off_t *,svn_diff_datasource_e const *,apr_size_t) = 0 ;
3714
3715 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_datasources_open_get",1,1,&obj0)) SWIG_fail;
3716 {
3717 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3718 if (PyErr_Occurred()) {
3719 SWIG_fail;
3720 }
3721 }
3722 result = (svn_error_t *(*)(void *,apr_off_t *,apr_off_t *,svn_diff_datasource_e const *,apr_size_t)) ((arg1)->datasources_open);
3723 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t);
3724 return resultobj;
3725 fail:
3726 return NULL;
3727 }
3728
3729
_wrap_svn_diff_fns2_t_datasource_close_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3730 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_datasource_close_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3731 PyObject *resultobj = 0;
3732 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3733 svn_error_t *(*arg2)(void *,svn_diff_datasource_e) = (svn_error_t *(*)(void *,svn_diff_datasource_e)) 0 ;
3734 PyObject * obj0 = 0 ;
3735 PyObject * obj1 = 0 ;
3736
3737 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_datasource_close_set",2,2,&obj0,&obj1)) SWIG_fail;
3738 {
3739 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3740 if (PyErr_Occurred()) {
3741 SWIG_fail;
3742 }
3743 }
3744 {
3745 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t);
3746 if (!SWIG_IsOK(res)) {
3747 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns2_t_datasource_close_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,svn_diff_datasource_e)""'");
3748 }
3749 }
3750 if (arg1) (arg1)->datasource_close = arg2;
3751 resultobj = SWIG_Py_Void();
3752 return resultobj;
3753 fail:
3754 return NULL;
3755 }
3756
3757
_wrap_svn_diff_fns2_t_datasource_close_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3758 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_datasource_close_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3759 PyObject *resultobj = 0;
3760 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3761 PyObject * obj0 = 0 ;
3762 svn_error_t *(*result)(void *,svn_diff_datasource_e) = 0 ;
3763
3764 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_datasource_close_get",1,1,&obj0)) SWIG_fail;
3765 {
3766 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3767 if (PyErr_Occurred()) {
3768 SWIG_fail;
3769 }
3770 }
3771 result = (svn_error_t *(*)(void *,svn_diff_datasource_e)) ((arg1)->datasource_close);
3772 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t);
3773 return resultobj;
3774 fail:
3775 return NULL;
3776 }
3777
3778
_wrap_svn_diff_fns2_t_datasource_get_next_token_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3779 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_datasource_get_next_token_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3780 PyObject *resultobj = 0;
3781 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3782 svn_error_t *(*arg2)(apr_uint32_t *,void **,void *,svn_diff_datasource_e) = (svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)) 0 ;
3783 PyObject * obj0 = 0 ;
3784 PyObject * obj1 = 0 ;
3785
3786 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_datasource_get_next_token_set",2,2,&obj0,&obj1)) SWIG_fail;
3787 {
3788 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3789 if (PyErr_Occurred()) {
3790 SWIG_fail;
3791 }
3792 }
3793 {
3794 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t);
3795 if (!SWIG_IsOK(res)) {
3796 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns2_t_datasource_get_next_token_set" "', argument " "2"" of type '" "svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)""'");
3797 }
3798 }
3799 if (arg1) (arg1)->datasource_get_next_token = arg2;
3800 resultobj = SWIG_Py_Void();
3801 return resultobj;
3802 fail:
3803 return NULL;
3804 }
3805
3806
_wrap_svn_diff_fns2_t_datasource_get_next_token_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3807 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_datasource_get_next_token_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3808 PyObject *resultobj = 0;
3809 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3810 PyObject * obj0 = 0 ;
3811 svn_error_t *(*result)(apr_uint32_t *,void **,void *,svn_diff_datasource_e) = 0 ;
3812
3813 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_datasource_get_next_token_get",1,1,&obj0)) SWIG_fail;
3814 {
3815 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3816 if (PyErr_Occurred()) {
3817 SWIG_fail;
3818 }
3819 }
3820 result = (svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)) ((arg1)->datasource_get_next_token);
3821 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t);
3822 return resultobj;
3823 fail:
3824 return NULL;
3825 }
3826
3827
_wrap_svn_diff_fns2_t_token_compare_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3828 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_token_compare_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3829 PyObject *resultobj = 0;
3830 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3831 svn_error_t *(*arg2)(void *,void *,void *,int *) = (svn_error_t *(*)(void *,void *,void *,int *)) 0 ;
3832 PyObject * obj0 = 0 ;
3833 PyObject * obj1 = 0 ;
3834
3835 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_token_compare_set",2,2,&obj0,&obj1)) SWIG_fail;
3836 {
3837 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3838 if (PyErr_Occurred()) {
3839 SWIG_fail;
3840 }
3841 }
3842 {
3843 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void_p_void_p_int__p_svn_error_t);
3844 if (!SWIG_IsOK(res)) {
3845 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns2_t_token_compare_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,void *,void *,int *)""'");
3846 }
3847 }
3848 if (arg1) (arg1)->token_compare = arg2;
3849 resultobj = SWIG_Py_Void();
3850 return resultobj;
3851 fail:
3852 return NULL;
3853 }
3854
3855
_wrap_svn_diff_fns2_t_token_compare_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3856 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_token_compare_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3857 PyObject *resultobj = 0;
3858 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3859 PyObject * obj0 = 0 ;
3860 svn_error_t *(*result)(void *,void *,void *,int *) = 0 ;
3861
3862 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_token_compare_get",1,1,&obj0)) SWIG_fail;
3863 {
3864 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3865 if (PyErr_Occurred()) {
3866 SWIG_fail;
3867 }
3868 }
3869 result = (svn_error_t *(*)(void *,void *,void *,int *)) ((arg1)->token_compare);
3870 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_void_p_void_p_int__p_svn_error_t);
3871 return resultobj;
3872 fail:
3873 return NULL;
3874 }
3875
3876
_wrap_svn_diff_fns2_t_token_discard_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3877 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_token_discard_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3878 PyObject *resultobj = 0;
3879 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3880 void (*arg2)(void *,void *) = (void (*)(void *,void *)) 0 ;
3881 PyObject * obj0 = 0 ;
3882 PyObject * obj1 = 0 ;
3883
3884 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_token_discard_set",2,2,&obj0,&obj1)) SWIG_fail;
3885 {
3886 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3887 if (PyErr_Occurred()) {
3888 SWIG_fail;
3889 }
3890 }
3891 {
3892 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__void);
3893 if (!SWIG_IsOK(res)) {
3894 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns2_t_token_discard_set" "', argument " "2"" of type '" "void (*)(void *,void *)""'");
3895 }
3896 }
3897 if (arg1) (arg1)->token_discard = arg2;
3898 resultobj = SWIG_Py_Void();
3899 return resultobj;
3900 fail:
3901 return NULL;
3902 }
3903
3904
_wrap_svn_diff_fns2_t_token_discard_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3905 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_token_discard_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3906 PyObject *resultobj = 0;
3907 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3908 PyObject * obj0 = 0 ;
3909 void (*result)(void *,void *) = 0 ;
3910
3911 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_token_discard_get",1,1,&obj0)) SWIG_fail;
3912 {
3913 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3914 if (PyErr_Occurred()) {
3915 SWIG_fail;
3916 }
3917 }
3918 result = (void (*)(void *,void *)) ((arg1)->token_discard);
3919 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_void__void);
3920 return resultobj;
3921 fail:
3922 return NULL;
3923 }
3924
3925
_wrap_svn_diff_fns2_t_token_discard_all_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3926 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_token_discard_all_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3927 PyObject *resultobj = 0;
3928 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3929 void (*arg2)(void *) = (void (*)(void *)) 0 ;
3930 PyObject * obj0 = 0 ;
3931 PyObject * obj1 = 0 ;
3932
3933 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_token_discard_all_set",2,2,&obj0,&obj1)) SWIG_fail;
3934 {
3935 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3936 if (PyErr_Occurred()) {
3937 SWIG_fail;
3938 }
3939 }
3940 {
3941 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
3942 if (!SWIG_IsOK(res)) {
3943 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns2_t_token_discard_all_set" "', argument " "2"" of type '" "void (*)(void *)""'");
3944 }
3945 }
3946 if (arg1) (arg1)->token_discard_all = arg2;
3947 resultobj = SWIG_Py_Void();
3948 return resultobj;
3949 fail:
3950 return NULL;
3951 }
3952
3953
_wrap_svn_diff_fns2_t_token_discard_all_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3954 SWIGINTERN PyObject *_wrap_svn_diff_fns2_t_token_discard_all_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3955 PyObject *resultobj = 0;
3956 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3957 PyObject * obj0 = 0 ;
3958 void (*result)(void *) = 0 ;
3959
3960 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_t_token_discard_all_get",1,1,&obj0)) SWIG_fail;
3961 {
3962 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3963 if (PyErr_Occurred()) {
3964 SWIG_fail;
3965 }
3966 }
3967 result = (void (*)(void *)) ((arg1)->token_discard_all);
3968 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
3969 return resultobj;
3970 fail:
3971 return NULL;
3972 }
3973
3974
_wrap_new_svn_diff_fns2_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3975 SWIGINTERN PyObject *_wrap_new_svn_diff_fns2_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3976 PyObject *resultobj = 0;
3977 struct svn_diff_fns2_t *result = 0 ;
3978
3979 if(!PyArg_UnpackTuple(args,(char *)"new_svn_diff_fns2_t",0,0)) SWIG_fail;
3980 {
3981 svn_swig_py_release_py_lock();
3982
3983 result = (struct svn_diff_fns2_t *)calloc(1, sizeof(struct svn_diff_fns2_t));
3984
3985 svn_swig_py_acquire_py_lock();
3986
3987 }
3988 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_fns2_t,
3989 _global_py_pool, args);
3990 return resultobj;
3991 fail:
3992 return NULL;
3993 }
3994
3995
_wrap_delete_svn_diff_fns2_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3996 SWIGINTERN PyObject *_wrap_delete_svn_diff_fns2_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3997 PyObject *resultobj = 0;
3998 struct svn_diff_fns2_t *arg1 = (struct svn_diff_fns2_t *) 0 ;
3999 PyObject * obj0 = 0 ;
4000
4001 if(!PyArg_UnpackTuple(args,(char *)"delete_svn_diff_fns2_t",1,1,&obj0)) SWIG_fail;
4002 {
4003 arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
4004 if (PyErr_Occurred()) {
4005 SWIG_fail;
4006 }
4007 }
4008 {
4009 svn_swig_py_release_py_lock();
4010
4011 free((char *) arg1);
4012
4013 svn_swig_py_acquire_py_lock();
4014
4015 }
4016 resultobj = SWIG_Py_Void();
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
svn_diff_fns2_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4023 SWIGINTERN PyObject *svn_diff_fns2_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4024 PyObject *obj;
4025 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
4026 SWIG_TypeNewClientData(SWIGTYPE_p_svn_diff_fns2_t, SWIG_NewClientData(obj));
4027 return SWIG_Py_Void();
4028 }
4029
_wrap_svn_diff_fns_t_datasource_open_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4030 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_datasource_open_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4031 PyObject *resultobj = 0;
4032 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4033 svn_error_t *(*arg2)(void *,svn_diff_datasource_e) = (svn_error_t *(*)(void *,svn_diff_datasource_e)) 0 ;
4034 PyObject * obj0 = 0 ;
4035 PyObject * obj1 = 0 ;
4036
4037 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_datasource_open_set",2,2,&obj0,&obj1)) SWIG_fail;
4038 {
4039 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4040 if (PyErr_Occurred()) {
4041 SWIG_fail;
4042 }
4043 }
4044 {
4045 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t);
4046 if (!SWIG_IsOK(res)) {
4047 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns_t_datasource_open_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,svn_diff_datasource_e)""'");
4048 }
4049 }
4050 if (arg1) (arg1)->datasource_open = arg2;
4051 resultobj = SWIG_Py_Void();
4052 return resultobj;
4053 fail:
4054 return NULL;
4055 }
4056
4057
_wrap_svn_diff_fns_t_datasource_open_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4058 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_datasource_open_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4059 PyObject *resultobj = 0;
4060 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4061 PyObject * obj0 = 0 ;
4062 svn_error_t *(*result)(void *,svn_diff_datasource_e) = 0 ;
4063
4064 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_datasource_open_get",1,1,&obj0)) SWIG_fail;
4065 {
4066 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4067 if (PyErr_Occurred()) {
4068 SWIG_fail;
4069 }
4070 }
4071 result = (svn_error_t *(*)(void *,svn_diff_datasource_e)) ((arg1)->datasource_open);
4072 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t);
4073 return resultobj;
4074 fail:
4075 return NULL;
4076 }
4077
4078
_wrap_svn_diff_fns_t_datasource_close_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4079 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_datasource_close_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4080 PyObject *resultobj = 0;
4081 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4082 svn_error_t *(*arg2)(void *,svn_diff_datasource_e) = (svn_error_t *(*)(void *,svn_diff_datasource_e)) 0 ;
4083 PyObject * obj0 = 0 ;
4084 PyObject * obj1 = 0 ;
4085
4086 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_datasource_close_set",2,2,&obj0,&obj1)) SWIG_fail;
4087 {
4088 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4089 if (PyErr_Occurred()) {
4090 SWIG_fail;
4091 }
4092 }
4093 {
4094 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t);
4095 if (!SWIG_IsOK(res)) {
4096 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns_t_datasource_close_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,svn_diff_datasource_e)""'");
4097 }
4098 }
4099 if (arg1) (arg1)->datasource_close = arg2;
4100 resultobj = SWIG_Py_Void();
4101 return resultobj;
4102 fail:
4103 return NULL;
4104 }
4105
4106
_wrap_svn_diff_fns_t_datasource_close_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4107 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_datasource_close_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4108 PyObject *resultobj = 0;
4109 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4110 PyObject * obj0 = 0 ;
4111 svn_error_t *(*result)(void *,svn_diff_datasource_e) = 0 ;
4112
4113 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_datasource_close_get",1,1,&obj0)) SWIG_fail;
4114 {
4115 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4116 if (PyErr_Occurred()) {
4117 SWIG_fail;
4118 }
4119 }
4120 result = (svn_error_t *(*)(void *,svn_diff_datasource_e)) ((arg1)->datasource_close);
4121 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t);
4122 return resultobj;
4123 fail:
4124 return NULL;
4125 }
4126
4127
_wrap_svn_diff_fns_t_datasource_get_next_token_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4128 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_datasource_get_next_token_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4129 PyObject *resultobj = 0;
4130 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4131 svn_error_t *(*arg2)(apr_uint32_t *,void **,void *,svn_diff_datasource_e) = (svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)) 0 ;
4132 PyObject * obj0 = 0 ;
4133 PyObject * obj1 = 0 ;
4134
4135 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_datasource_get_next_token_set",2,2,&obj0,&obj1)) SWIG_fail;
4136 {
4137 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4138 if (PyErr_Occurred()) {
4139 SWIG_fail;
4140 }
4141 }
4142 {
4143 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t);
4144 if (!SWIG_IsOK(res)) {
4145 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns_t_datasource_get_next_token_set" "', argument " "2"" of type '" "svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)""'");
4146 }
4147 }
4148 if (arg1) (arg1)->datasource_get_next_token = arg2;
4149 resultobj = SWIG_Py_Void();
4150 return resultobj;
4151 fail:
4152 return NULL;
4153 }
4154
4155
_wrap_svn_diff_fns_t_datasource_get_next_token_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4156 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_datasource_get_next_token_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4157 PyObject *resultobj = 0;
4158 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4159 PyObject * obj0 = 0 ;
4160 svn_error_t *(*result)(apr_uint32_t *,void **,void *,svn_diff_datasource_e) = 0 ;
4161
4162 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_datasource_get_next_token_get",1,1,&obj0)) SWIG_fail;
4163 {
4164 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4165 if (PyErr_Occurred()) {
4166 SWIG_fail;
4167 }
4168 }
4169 result = (svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)) ((arg1)->datasource_get_next_token);
4170 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t);
4171 return resultobj;
4172 fail:
4173 return NULL;
4174 }
4175
4176
_wrap_svn_diff_fns_t_token_compare_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4177 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_token_compare_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4178 PyObject *resultobj = 0;
4179 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4180 svn_error_t *(*arg2)(void *,void *,void *,int *) = (svn_error_t *(*)(void *,void *,void *,int *)) 0 ;
4181 PyObject * obj0 = 0 ;
4182 PyObject * obj1 = 0 ;
4183
4184 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_token_compare_set",2,2,&obj0,&obj1)) SWIG_fail;
4185 {
4186 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4187 if (PyErr_Occurred()) {
4188 SWIG_fail;
4189 }
4190 }
4191 {
4192 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void_p_void_p_int__p_svn_error_t);
4193 if (!SWIG_IsOK(res)) {
4194 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns_t_token_compare_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,void *,void *,int *)""'");
4195 }
4196 }
4197 if (arg1) (arg1)->token_compare = arg2;
4198 resultobj = SWIG_Py_Void();
4199 return resultobj;
4200 fail:
4201 return NULL;
4202 }
4203
4204
_wrap_svn_diff_fns_t_token_compare_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4205 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_token_compare_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4206 PyObject *resultobj = 0;
4207 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4208 PyObject * obj0 = 0 ;
4209 svn_error_t *(*result)(void *,void *,void *,int *) = 0 ;
4210
4211 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_token_compare_get",1,1,&obj0)) SWIG_fail;
4212 {
4213 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4214 if (PyErr_Occurred()) {
4215 SWIG_fail;
4216 }
4217 }
4218 result = (svn_error_t *(*)(void *,void *,void *,int *)) ((arg1)->token_compare);
4219 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_void_p_void_p_int__p_svn_error_t);
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
_wrap_svn_diff_fns_t_token_discard_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4226 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_token_discard_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4227 PyObject *resultobj = 0;
4228 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4229 void (*arg2)(void *,void *) = (void (*)(void *,void *)) 0 ;
4230 PyObject * obj0 = 0 ;
4231 PyObject * obj1 = 0 ;
4232
4233 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_token_discard_set",2,2,&obj0,&obj1)) SWIG_fail;
4234 {
4235 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4236 if (PyErr_Occurred()) {
4237 SWIG_fail;
4238 }
4239 }
4240 {
4241 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__void);
4242 if (!SWIG_IsOK(res)) {
4243 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns_t_token_discard_set" "', argument " "2"" of type '" "void (*)(void *,void *)""'");
4244 }
4245 }
4246 if (arg1) (arg1)->token_discard = arg2;
4247 resultobj = SWIG_Py_Void();
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
_wrap_svn_diff_fns_t_token_discard_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4254 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_token_discard_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4255 PyObject *resultobj = 0;
4256 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4257 PyObject * obj0 = 0 ;
4258 void (*result)(void *,void *) = 0 ;
4259
4260 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_token_discard_get",1,1,&obj0)) SWIG_fail;
4261 {
4262 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4263 if (PyErr_Occurred()) {
4264 SWIG_fail;
4265 }
4266 }
4267 result = (void (*)(void *,void *)) ((arg1)->token_discard);
4268 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_void__void);
4269 return resultobj;
4270 fail:
4271 return NULL;
4272 }
4273
4274
_wrap_svn_diff_fns_t_token_discard_all_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4275 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_token_discard_all_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4276 PyObject *resultobj = 0;
4277 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4278 void (*arg2)(void *) = (void (*)(void *)) 0 ;
4279 PyObject * obj0 = 0 ;
4280 PyObject * obj1 = 0 ;
4281
4282 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_token_discard_all_set",2,2,&obj0,&obj1)) SWIG_fail;
4283 {
4284 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4285 if (PyErr_Occurred()) {
4286 SWIG_fail;
4287 }
4288 }
4289 {
4290 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
4291 if (!SWIG_IsOK(res)) {
4292 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_fns_t_token_discard_all_set" "', argument " "2"" of type '" "void (*)(void *)""'");
4293 }
4294 }
4295 if (arg1) (arg1)->token_discard_all = arg2;
4296 resultobj = SWIG_Py_Void();
4297 return resultobj;
4298 fail:
4299 return NULL;
4300 }
4301
4302
_wrap_svn_diff_fns_t_token_discard_all_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4303 SWIGINTERN PyObject *_wrap_svn_diff_fns_t_token_discard_all_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4304 PyObject *resultobj = 0;
4305 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4306 PyObject * obj0 = 0 ;
4307 void (*result)(void *) = 0 ;
4308
4309 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_t_token_discard_all_get",1,1,&obj0)) SWIG_fail;
4310 {
4311 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4312 if (PyErr_Occurred()) {
4313 SWIG_fail;
4314 }
4315 }
4316 result = (void (*)(void *)) ((arg1)->token_discard_all);
4317 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
_wrap_new_svn_diff_fns_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4324 SWIGINTERN PyObject *_wrap_new_svn_diff_fns_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4325 PyObject *resultobj = 0;
4326 struct svn_diff_fns_t *result = 0 ;
4327
4328 if(!PyArg_UnpackTuple(args,(char *)"new_svn_diff_fns_t",0,0)) SWIG_fail;
4329 {
4330 svn_swig_py_release_py_lock();
4331
4332 result = (struct svn_diff_fns_t *)calloc(1, sizeof(struct svn_diff_fns_t));
4333
4334 svn_swig_py_acquire_py_lock();
4335
4336 }
4337 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_fns_t,
4338 _global_py_pool, args);
4339 return resultobj;
4340 fail:
4341 return NULL;
4342 }
4343
4344
_wrap_delete_svn_diff_fns_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4345 SWIGINTERN PyObject *_wrap_delete_svn_diff_fns_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4346 PyObject *resultobj = 0;
4347 struct svn_diff_fns_t *arg1 = (struct svn_diff_fns_t *) 0 ;
4348 PyObject * obj0 = 0 ;
4349
4350 if(!PyArg_UnpackTuple(args,(char *)"delete_svn_diff_fns_t",1,1,&obj0)) SWIG_fail;
4351 {
4352 arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4353 if (PyErr_Occurred()) {
4354 SWIG_fail;
4355 }
4356 }
4357 {
4358 svn_swig_py_release_py_lock();
4359
4360 free((char *) arg1);
4361
4362 svn_swig_py_acquire_py_lock();
4363
4364 }
4365 resultobj = SWIG_Py_Void();
4366 return resultobj;
4367 fail:
4368 return NULL;
4369 }
4370
4371
svn_diff_fns_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4372 SWIGINTERN PyObject *svn_diff_fns_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4373 PyObject *obj;
4374 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
4375 SWIG_TypeNewClientData(SWIGTYPE_p_svn_diff_fns_t, SWIG_NewClientData(obj));
4376 return SWIG_Py_Void();
4377 }
4378
_wrap_svn_diff_diff_2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4379 SWIGINTERN PyObject *_wrap_svn_diff_diff_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4380 PyObject *resultobj = 0;
4381 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
4382 void *arg2 = (void *) 0 ;
4383 svn_diff_fns2_t *arg3 = (svn_diff_fns2_t *) 0 ;
4384 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4385 apr_pool_t *_global_pool = NULL ;
4386 PyObject *_global_py_pool = NULL ;
4387 svn_diff_t *temp1 ;
4388 PyObject * obj0 = 0 ;
4389 PyObject * obj1 = 0 ;
4390 PyObject * obj2 = 0 ;
4391 svn_error_t *result = 0 ;
4392
4393 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
4394 &_global_py_pool, &_global_pool))
4395 SWIG_fail;
4396 arg4 = _global_pool;
4397 arg1 = &temp1;
4398 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_diff_2",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
4399 {
4400 if (obj0 == Py_None) {
4401 arg2 = NULL;
4402 } else if (SWIG_ConvertPtr(obj0, (void **) &arg2, 0, 0) == -1) {
4403 arg2 = (void *) obj0;
4404 PyErr_Clear();
4405 }
4406 }
4407 {
4408 arg3 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
4409 if (PyErr_Occurred()) {
4410 SWIG_fail;
4411 }
4412 }
4413 if (obj2) {
4414 /* Verify that the user supplied a valid pool */
4415 if (obj2 != Py_None && obj2 != _global_py_pool) {
4416 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
4417 SWIG_arg_fail(svn_argnum_obj2);
4418 SWIG_fail;
4419 }
4420 }
4421 {
4422 svn_swig_py_release_py_lock();
4423
4424 result = (svn_error_t *)svn_diff_diff_2(arg1,arg2,(struct svn_diff_fns2_t const *)arg3,arg4);
4425
4426 svn_swig_py_acquire_py_lock();
4427
4428 }
4429 {
4430 if (result != NULL) {
4431 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
4432 svn_swig_py_svn_exception(result);
4433 else
4434 svn_error_clear(result);
4435 SWIG_fail;
4436 }
4437 Py_INCREF(Py_None);
4438 resultobj = Py_None;
4439 }
4440 {
4441 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4442 _global_py_pool, args))
4443
4444 ;
4445 }
4446 {
4447 Py_XDECREF(_global_py_pool);
4448 }
4449 return resultobj;
4450 fail:
4451 {
4452 Py_XDECREF(_global_py_pool);
4453 }
4454 return NULL;
4455 }
4456
4457
_wrap_svn_diff_diff(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4458 SWIGINTERN PyObject *_wrap_svn_diff_diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 PyObject *resultobj = 0;
4460 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
4461 void *arg2 = (void *) 0 ;
4462 svn_diff_fns_t *arg3 = (svn_diff_fns_t *) 0 ;
4463 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4464 apr_pool_t *_global_pool = NULL ;
4465 PyObject *_global_py_pool = NULL ;
4466 svn_diff_t *temp1 ;
4467 PyObject * obj0 = 0 ;
4468 PyObject * obj1 = 0 ;
4469 PyObject * obj2 = 0 ;
4470 svn_error_t *result = 0 ;
4471
4472 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
4473 &_global_py_pool, &_global_pool))
4474 SWIG_fail;
4475 arg4 = _global_pool;
4476 arg1 = &temp1;
4477 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_diff",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
4478 {
4479 if (obj0 == Py_None) {
4480 arg2 = NULL;
4481 } else if (SWIG_ConvertPtr(obj0, (void **) &arg2, 0, 0) == -1) {
4482 arg2 = (void *) obj0;
4483 PyErr_Clear();
4484 }
4485 }
4486 {
4487 arg3 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
4488 if (PyErr_Occurred()) {
4489 SWIG_fail;
4490 }
4491 }
4492 if (obj2) {
4493 /* Verify that the user supplied a valid pool */
4494 if (obj2 != Py_None && obj2 != _global_py_pool) {
4495 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
4496 SWIG_arg_fail(svn_argnum_obj2);
4497 SWIG_fail;
4498 }
4499 }
4500 {
4501 svn_swig_py_release_py_lock();
4502
4503 result = (svn_error_t *)svn_diff_diff(arg1,arg2,(struct svn_diff_fns_t const *)arg3,arg4);
4504
4505 svn_swig_py_acquire_py_lock();
4506
4507 }
4508 {
4509 if (result != NULL) {
4510 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
4511 svn_swig_py_svn_exception(result);
4512 else
4513 svn_error_clear(result);
4514 SWIG_fail;
4515 }
4516 Py_INCREF(Py_None);
4517 resultobj = Py_None;
4518 }
4519 {
4520 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4521 _global_py_pool, args))
4522
4523 ;
4524 }
4525 {
4526 Py_XDECREF(_global_py_pool);
4527 }
4528 return resultobj;
4529 fail:
4530 {
4531 Py_XDECREF(_global_py_pool);
4532 }
4533 return NULL;
4534 }
4535
4536
_wrap_svn_diff_diff3_2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4537 SWIGINTERN PyObject *_wrap_svn_diff_diff3_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4538 PyObject *resultobj = 0;
4539 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
4540 void *arg2 = (void *) 0 ;
4541 svn_diff_fns2_t *arg3 = (svn_diff_fns2_t *) 0 ;
4542 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4543 apr_pool_t *_global_pool = NULL ;
4544 PyObject *_global_py_pool = NULL ;
4545 svn_diff_t *temp1 ;
4546 PyObject * obj0 = 0 ;
4547 PyObject * obj1 = 0 ;
4548 PyObject * obj2 = 0 ;
4549 svn_error_t *result = 0 ;
4550
4551 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
4552 &_global_py_pool, &_global_pool))
4553 SWIG_fail;
4554 arg4 = _global_pool;
4555 arg1 = &temp1;
4556 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_diff3_2",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
4557 {
4558 if (obj0 == Py_None) {
4559 arg2 = NULL;
4560 } else if (SWIG_ConvertPtr(obj0, (void **) &arg2, 0, 0) == -1) {
4561 arg2 = (void *) obj0;
4562 PyErr_Clear();
4563 }
4564 }
4565 {
4566 arg3 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
4567 if (PyErr_Occurred()) {
4568 SWIG_fail;
4569 }
4570 }
4571 if (obj2) {
4572 /* Verify that the user supplied a valid pool */
4573 if (obj2 != Py_None && obj2 != _global_py_pool) {
4574 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
4575 SWIG_arg_fail(svn_argnum_obj2);
4576 SWIG_fail;
4577 }
4578 }
4579 {
4580 svn_swig_py_release_py_lock();
4581
4582 result = (svn_error_t *)svn_diff_diff3_2(arg1,arg2,(struct svn_diff_fns2_t const *)arg3,arg4);
4583
4584 svn_swig_py_acquire_py_lock();
4585
4586 }
4587 {
4588 if (result != NULL) {
4589 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
4590 svn_swig_py_svn_exception(result);
4591 else
4592 svn_error_clear(result);
4593 SWIG_fail;
4594 }
4595 Py_INCREF(Py_None);
4596 resultobj = Py_None;
4597 }
4598 {
4599 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4600 _global_py_pool, args))
4601
4602 ;
4603 }
4604 {
4605 Py_XDECREF(_global_py_pool);
4606 }
4607 return resultobj;
4608 fail:
4609 {
4610 Py_XDECREF(_global_py_pool);
4611 }
4612 return NULL;
4613 }
4614
4615
_wrap_svn_diff_diff3(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4616 SWIGINTERN PyObject *_wrap_svn_diff_diff3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4617 PyObject *resultobj = 0;
4618 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
4619 void *arg2 = (void *) 0 ;
4620 svn_diff_fns_t *arg3 = (svn_diff_fns_t *) 0 ;
4621 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4622 apr_pool_t *_global_pool = NULL ;
4623 PyObject *_global_py_pool = NULL ;
4624 svn_diff_t *temp1 ;
4625 PyObject * obj0 = 0 ;
4626 PyObject * obj1 = 0 ;
4627 PyObject * obj2 = 0 ;
4628 svn_error_t *result = 0 ;
4629
4630 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
4631 &_global_py_pool, &_global_pool))
4632 SWIG_fail;
4633 arg4 = _global_pool;
4634 arg1 = &temp1;
4635 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_diff3",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
4636 {
4637 if (obj0 == Py_None) {
4638 arg2 = NULL;
4639 } else if (SWIG_ConvertPtr(obj0, (void **) &arg2, 0, 0) == -1) {
4640 arg2 = (void *) obj0;
4641 PyErr_Clear();
4642 }
4643 }
4644 {
4645 arg3 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
4646 if (PyErr_Occurred()) {
4647 SWIG_fail;
4648 }
4649 }
4650 if (obj2) {
4651 /* Verify that the user supplied a valid pool */
4652 if (obj2 != Py_None && obj2 != _global_py_pool) {
4653 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
4654 SWIG_arg_fail(svn_argnum_obj2);
4655 SWIG_fail;
4656 }
4657 }
4658 {
4659 svn_swig_py_release_py_lock();
4660
4661 result = (svn_error_t *)svn_diff_diff3(arg1,arg2,(struct svn_diff_fns_t const *)arg3,arg4);
4662
4663 svn_swig_py_acquire_py_lock();
4664
4665 }
4666 {
4667 if (result != NULL) {
4668 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
4669 svn_swig_py_svn_exception(result);
4670 else
4671 svn_error_clear(result);
4672 SWIG_fail;
4673 }
4674 Py_INCREF(Py_None);
4675 resultobj = Py_None;
4676 }
4677 {
4678 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4679 _global_py_pool, args))
4680
4681 ;
4682 }
4683 {
4684 Py_XDECREF(_global_py_pool);
4685 }
4686 return resultobj;
4687 fail:
4688 {
4689 Py_XDECREF(_global_py_pool);
4690 }
4691 return NULL;
4692 }
4693
4694
_wrap_svn_diff_diff4_2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4695 SWIGINTERN PyObject *_wrap_svn_diff_diff4_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4696 PyObject *resultobj = 0;
4697 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
4698 void *arg2 = (void *) 0 ;
4699 svn_diff_fns2_t *arg3 = (svn_diff_fns2_t *) 0 ;
4700 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4701 apr_pool_t *_global_pool = NULL ;
4702 PyObject *_global_py_pool = NULL ;
4703 svn_diff_t *temp1 ;
4704 PyObject * obj0 = 0 ;
4705 PyObject * obj1 = 0 ;
4706 PyObject * obj2 = 0 ;
4707 svn_error_t *result = 0 ;
4708
4709 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
4710 &_global_py_pool, &_global_pool))
4711 SWIG_fail;
4712 arg4 = _global_pool;
4713 arg1 = &temp1;
4714 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_diff4_2",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
4715 {
4716 if (obj0 == Py_None) {
4717 arg2 = NULL;
4718 } else if (SWIG_ConvertPtr(obj0, (void **) &arg2, 0, 0) == -1) {
4719 arg2 = (void *) obj0;
4720 PyErr_Clear();
4721 }
4722 }
4723 {
4724 arg3 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
4725 if (PyErr_Occurred()) {
4726 SWIG_fail;
4727 }
4728 }
4729 if (obj2) {
4730 /* Verify that the user supplied a valid pool */
4731 if (obj2 != Py_None && obj2 != _global_py_pool) {
4732 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
4733 SWIG_arg_fail(svn_argnum_obj2);
4734 SWIG_fail;
4735 }
4736 }
4737 {
4738 svn_swig_py_release_py_lock();
4739
4740 result = (svn_error_t *)svn_diff_diff4_2(arg1,arg2,(struct svn_diff_fns2_t const *)arg3,arg4);
4741
4742 svn_swig_py_acquire_py_lock();
4743
4744 }
4745 {
4746 if (result != NULL) {
4747 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
4748 svn_swig_py_svn_exception(result);
4749 else
4750 svn_error_clear(result);
4751 SWIG_fail;
4752 }
4753 Py_INCREF(Py_None);
4754 resultobj = Py_None;
4755 }
4756 {
4757 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4758 _global_py_pool, args))
4759
4760 ;
4761 }
4762 {
4763 Py_XDECREF(_global_py_pool);
4764 }
4765 return resultobj;
4766 fail:
4767 {
4768 Py_XDECREF(_global_py_pool);
4769 }
4770 return NULL;
4771 }
4772
4773
_wrap_svn_diff_diff4(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4774 SWIGINTERN PyObject *_wrap_svn_diff_diff4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4775 PyObject *resultobj = 0;
4776 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
4777 void *arg2 = (void *) 0 ;
4778 svn_diff_fns_t *arg3 = (svn_diff_fns_t *) 0 ;
4779 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4780 apr_pool_t *_global_pool = NULL ;
4781 PyObject *_global_py_pool = NULL ;
4782 svn_diff_t *temp1 ;
4783 PyObject * obj0 = 0 ;
4784 PyObject * obj1 = 0 ;
4785 PyObject * obj2 = 0 ;
4786 svn_error_t *result = 0 ;
4787
4788 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
4789 &_global_py_pool, &_global_pool))
4790 SWIG_fail;
4791 arg4 = _global_pool;
4792 arg1 = &temp1;
4793 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_diff4",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
4794 {
4795 if (obj0 == Py_None) {
4796 arg2 = NULL;
4797 } else if (SWIG_ConvertPtr(obj0, (void **) &arg2, 0, 0) == -1) {
4798 arg2 = (void *) obj0;
4799 PyErr_Clear();
4800 }
4801 }
4802 {
4803 arg3 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
4804 if (PyErr_Occurred()) {
4805 SWIG_fail;
4806 }
4807 }
4808 if (obj2) {
4809 /* Verify that the user supplied a valid pool */
4810 if (obj2 != Py_None && obj2 != _global_py_pool) {
4811 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
4812 SWIG_arg_fail(svn_argnum_obj2);
4813 SWIG_fail;
4814 }
4815 }
4816 {
4817 svn_swig_py_release_py_lock();
4818
4819 result = (svn_error_t *)svn_diff_diff4(arg1,arg2,(struct svn_diff_fns_t const *)arg3,arg4);
4820
4821 svn_swig_py_acquire_py_lock();
4822
4823 }
4824 {
4825 if (result != NULL) {
4826 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
4827 svn_swig_py_svn_exception(result);
4828 else
4829 svn_error_clear(result);
4830 SWIG_fail;
4831 }
4832 Py_INCREF(Py_None);
4833 resultobj = Py_None;
4834 }
4835 {
4836 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4837 _global_py_pool, args))
4838
4839 ;
4840 }
4841 {
4842 Py_XDECREF(_global_py_pool);
4843 }
4844 return resultobj;
4845 fail:
4846 {
4847 Py_XDECREF(_global_py_pool);
4848 }
4849 return NULL;
4850 }
4851
4852
_wrap_svn_diff_contains_conflicts(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4853 SWIGINTERN PyObject *_wrap_svn_diff_contains_conflicts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4854 PyObject *resultobj = 0;
4855 svn_diff_t *arg1 = (svn_diff_t *) 0 ;
4856 PyObject * obj0 = 0 ;
4857 svn_boolean_t result;
4858
4859 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_contains_conflicts",1,1,&obj0)) SWIG_fail;
4860 {
4861 arg1 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
4862 if (PyErr_Occurred()) {
4863 SWIG_fail;
4864 }
4865 }
4866 {
4867 svn_swig_py_release_py_lock();
4868
4869 result = (svn_boolean_t)svn_diff_contains_conflicts(arg1);
4870
4871 svn_swig_py_acquire_py_lock();
4872
4873 }
4874 resultobj = SWIG_From_long((long)(result));
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
_wrap_svn_diff_contains_diffs(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4881 SWIGINTERN PyObject *_wrap_svn_diff_contains_diffs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4882 PyObject *resultobj = 0;
4883 svn_diff_t *arg1 = (svn_diff_t *) 0 ;
4884 PyObject * obj0 = 0 ;
4885 svn_boolean_t result;
4886
4887 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_contains_diffs",1,1,&obj0)) SWIG_fail;
4888 {
4889 arg1 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
4890 if (PyErr_Occurred()) {
4891 SWIG_fail;
4892 }
4893 }
4894 {
4895 svn_swig_py_release_py_lock();
4896
4897 result = (svn_boolean_t)svn_diff_contains_diffs(arg1);
4898
4899 svn_swig_py_acquire_py_lock();
4900
4901 }
4902 resultobj = SWIG_From_long((long)(result));
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
_wrap_svn_diff_output_fns_t_output_common_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4909 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_common_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4910 PyObject *resultobj = 0;
4911 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
4912 svn_error_t *(*arg2)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)) 0 ;
4913 PyObject * obj0 = 0 ;
4914 PyObject * obj1 = 0 ;
4915
4916 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_common_set",2,2,&obj0,&obj1)) SWIG_fail;
4917 {
4918 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4919 if (PyErr_Occurred()) {
4920 SWIG_fail;
4921 }
4922 }
4923 {
4924 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t);
4925 if (!SWIG_IsOK(res)) {
4926 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_output_fns_t_output_common_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)""'");
4927 }
4928 }
4929 if (arg1) (arg1)->output_common = arg2;
4930 resultobj = SWIG_Py_Void();
4931 return resultobj;
4932 fail:
4933 return NULL;
4934 }
4935
4936
_wrap_svn_diff_output_fns_t_output_common_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4937 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_common_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4938 PyObject *resultobj = 0;
4939 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
4940 PyObject * obj0 = 0 ;
4941 svn_error_t *(*result)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) = 0 ;
4942
4943 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_common_get",1,1,&obj0)) SWIG_fail;
4944 {
4945 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4946 if (PyErr_Occurred()) {
4947 SWIG_fail;
4948 }
4949 }
4950 result = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)) ((arg1)->output_common);
4951 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t);
4952 return resultobj;
4953 fail:
4954 return NULL;
4955 }
4956
4957
_wrap_svn_diff_output_fns_t_output_diff_modified_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4958 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_diff_modified_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4959 PyObject *resultobj = 0;
4960 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
4961 svn_error_t *(*arg2)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)) 0 ;
4962 PyObject * obj0 = 0 ;
4963 PyObject * obj1 = 0 ;
4964
4965 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_diff_modified_set",2,2,&obj0,&obj1)) SWIG_fail;
4966 {
4967 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4968 if (PyErr_Occurred()) {
4969 SWIG_fail;
4970 }
4971 }
4972 {
4973 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t);
4974 if (!SWIG_IsOK(res)) {
4975 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_output_fns_t_output_diff_modified_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)""'");
4976 }
4977 }
4978 if (arg1) (arg1)->output_diff_modified = arg2;
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
_wrap_svn_diff_output_fns_t_output_diff_modified_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4986 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_diff_modified_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4987 PyObject *resultobj = 0;
4988 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
4989 PyObject * obj0 = 0 ;
4990 svn_error_t *(*result)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) = 0 ;
4991
4992 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_diff_modified_get",1,1,&obj0)) SWIG_fail;
4993 {
4994 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4995 if (PyErr_Occurred()) {
4996 SWIG_fail;
4997 }
4998 }
4999 result = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)) ((arg1)->output_diff_modified);
5000 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t);
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
_wrap_svn_diff_output_fns_t_output_diff_latest_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5007 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_diff_latest_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5008 PyObject *resultobj = 0;
5009 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
5010 svn_error_t *(*arg2)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)) 0 ;
5011 PyObject * obj0 = 0 ;
5012 PyObject * obj1 = 0 ;
5013
5014 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_diff_latest_set",2,2,&obj0,&obj1)) SWIG_fail;
5015 {
5016 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5017 if (PyErr_Occurred()) {
5018 SWIG_fail;
5019 }
5020 }
5021 {
5022 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t);
5023 if (!SWIG_IsOK(res)) {
5024 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_output_fns_t_output_diff_latest_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)""'");
5025 }
5026 }
5027 if (arg1) (arg1)->output_diff_latest = arg2;
5028 resultobj = SWIG_Py_Void();
5029 return resultobj;
5030 fail:
5031 return NULL;
5032 }
5033
5034
_wrap_svn_diff_output_fns_t_output_diff_latest_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5035 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_diff_latest_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5036 PyObject *resultobj = 0;
5037 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
5038 PyObject * obj0 = 0 ;
5039 svn_error_t *(*result)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) = 0 ;
5040
5041 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_diff_latest_get",1,1,&obj0)) SWIG_fail;
5042 {
5043 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5044 if (PyErr_Occurred()) {
5045 SWIG_fail;
5046 }
5047 }
5048 result = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)) ((arg1)->output_diff_latest);
5049 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t);
5050 return resultobj;
5051 fail:
5052 return NULL;
5053 }
5054
5055
_wrap_svn_diff_output_fns_t_output_diff_common_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5056 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_diff_common_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5057 PyObject *resultobj = 0;
5058 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
5059 svn_error_t *(*arg2)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)) 0 ;
5060 PyObject * obj0 = 0 ;
5061 PyObject * obj1 = 0 ;
5062
5063 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_diff_common_set",2,2,&obj0,&obj1)) SWIG_fail;
5064 {
5065 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5066 if (PyErr_Occurred()) {
5067 SWIG_fail;
5068 }
5069 }
5070 {
5071 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t);
5072 if (!SWIG_IsOK(res)) {
5073 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_output_fns_t_output_diff_common_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)""'");
5074 }
5075 }
5076 if (arg1) (arg1)->output_diff_common = arg2;
5077 resultobj = SWIG_Py_Void();
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
_wrap_svn_diff_output_fns_t_output_diff_common_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5084 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_diff_common_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5085 PyObject *resultobj = 0;
5086 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
5087 PyObject * obj0 = 0 ;
5088 svn_error_t *(*result)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) = 0 ;
5089
5090 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_diff_common_get",1,1,&obj0)) SWIG_fail;
5091 {
5092 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5093 if (PyErr_Occurred()) {
5094 SWIG_fail;
5095 }
5096 }
5097 result = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)) ((arg1)->output_diff_common);
5098 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t);
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
_wrap_svn_diff_output_fns_t_output_conflict_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5105 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_conflict_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5106 PyObject *resultobj = 0;
5107 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
5108 svn_error_t *(*arg2)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,svn_diff_t *) = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,svn_diff_t *)) 0 ;
5109 PyObject * obj0 = 0 ;
5110 PyObject * obj1 = 0 ;
5111
5112 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_conflict_set",2,2,&obj0,&obj1)) SWIG_fail;
5113 {
5114 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5115 if (PyErr_Occurred()) {
5116 SWIG_fail;
5117 }
5118 }
5119 {
5120 int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t);
5121 if (!SWIG_IsOK(res)) {
5122 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_diff_output_fns_t_output_conflict_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,svn_diff_t *)""'");
5123 }
5124 }
5125 if (arg1) (arg1)->output_conflict = arg2;
5126 resultobj = SWIG_Py_Void();
5127 return resultobj;
5128 fail:
5129 return NULL;
5130 }
5131
5132
_wrap_svn_diff_output_fns_t_output_conflict_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5133 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_t_output_conflict_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5134 PyObject *resultobj = 0;
5135 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
5136 PyObject * obj0 = 0 ;
5137 svn_error_t *(*result)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,svn_diff_t *) = 0 ;
5138
5139 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_t_output_conflict_get",1,1,&obj0)) SWIG_fail;
5140 {
5141 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5142 if (PyErr_Occurred()) {
5143 SWIG_fail;
5144 }
5145 }
5146 result = (svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,svn_diff_t *)) ((arg1)->output_conflict);
5147 resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t);
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
_wrap_new_svn_diff_output_fns_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5154 SWIGINTERN PyObject *_wrap_new_svn_diff_output_fns_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5155 PyObject *resultobj = 0;
5156 struct svn_diff_output_fns_t *result = 0 ;
5157
5158 if(!PyArg_UnpackTuple(args,(char *)"new_svn_diff_output_fns_t",0,0)) SWIG_fail;
5159 {
5160 svn_swig_py_release_py_lock();
5161
5162 result = (struct svn_diff_output_fns_t *)calloc(1, sizeof(struct svn_diff_output_fns_t));
5163
5164 svn_swig_py_acquire_py_lock();
5165
5166 }
5167 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_output_fns_t,
5168 _global_py_pool, args);
5169 return resultobj;
5170 fail:
5171 return NULL;
5172 }
5173
5174
_wrap_delete_svn_diff_output_fns_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5175 SWIGINTERN PyObject *_wrap_delete_svn_diff_output_fns_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5176 PyObject *resultobj = 0;
5177 struct svn_diff_output_fns_t *arg1 = (struct svn_diff_output_fns_t *) 0 ;
5178 PyObject * obj0 = 0 ;
5179
5180 if(!PyArg_UnpackTuple(args,(char *)"delete_svn_diff_output_fns_t",1,1,&obj0)) SWIG_fail;
5181 {
5182 arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5183 if (PyErr_Occurred()) {
5184 SWIG_fail;
5185 }
5186 }
5187 {
5188 svn_swig_py_release_py_lock();
5189
5190 free((char *) arg1);
5191
5192 svn_swig_py_acquire_py_lock();
5193
5194 }
5195 resultobj = SWIG_Py_Void();
5196 return resultobj;
5197 fail:
5198 return NULL;
5199 }
5200
5201
svn_diff_output_fns_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5202 SWIGINTERN PyObject *svn_diff_output_fns_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5203 PyObject *obj;
5204 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
5205 SWIG_TypeNewClientData(SWIGTYPE_p_svn_diff_output_fns_t, SWIG_NewClientData(obj));
5206 return SWIG_Py_Void();
5207 }
5208
_wrap_svn_diff_output2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5209 SWIGINTERN PyObject *_wrap_svn_diff_output2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5210 PyObject *resultobj = 0;
5211 svn_diff_t *arg1 = (svn_diff_t *) 0 ;
5212 void *arg2 = (void *) 0 ;
5213 svn_diff_output_fns_t *arg3 = (svn_diff_output_fns_t *) 0 ;
5214 svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
5215 void *arg5 = (void *) 0 ;
5216 PyObject * obj0 = 0 ;
5217 PyObject * obj1 = 0 ;
5218 PyObject * obj2 = 0 ;
5219 PyObject * obj3 = 0 ;
5220 svn_error_t *result = 0 ;
5221
5222 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output2",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5223 {
5224 arg1 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
5225 if (PyErr_Occurred()) {
5226 SWIG_fail;
5227 }
5228 }
5229 {
5230 if (obj1 == Py_None) {
5231 arg2 = NULL;
5232 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
5233 arg2 = (void *) obj1;
5234 PyErr_Clear();
5235 }
5236 }
5237 {
5238 arg3 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj2);
5239 if (PyErr_Occurred()) {
5240 SWIG_fail;
5241 }
5242 }
5243 {
5244 arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
5245 arg5 = obj3;
5246 }
5247 {
5248 svn_swig_py_release_py_lock();
5249
5250 result = (svn_error_t *)svn_diff_output2(arg1,arg2,(struct svn_diff_output_fns_t const *)arg3,arg4,arg5);
5251
5252 svn_swig_py_acquire_py_lock();
5253
5254 }
5255 {
5256 if (result != NULL) {
5257 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
5258 svn_swig_py_svn_exception(result);
5259 else
5260 svn_error_clear(result);
5261 SWIG_fail;
5262 }
5263 Py_INCREF(Py_None);
5264 resultobj = Py_None;
5265 }
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
_wrap_svn_diff_output(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5272 SWIGINTERN PyObject *_wrap_svn_diff_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5273 PyObject *resultobj = 0;
5274 svn_diff_t *arg1 = (svn_diff_t *) 0 ;
5275 void *arg2 = (void *) 0 ;
5276 svn_diff_output_fns_t *arg3 = (svn_diff_output_fns_t *) 0 ;
5277 PyObject * obj0 = 0 ;
5278 PyObject * obj1 = 0 ;
5279 PyObject * obj2 = 0 ;
5280 svn_error_t *result = 0 ;
5281
5282 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
5283 {
5284 arg1 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
5285 if (PyErr_Occurred()) {
5286 SWIG_fail;
5287 }
5288 }
5289 {
5290 if (obj1 == Py_None) {
5291 arg2 = NULL;
5292 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
5293 arg2 = (void *) obj1;
5294 PyErr_Clear();
5295 }
5296 }
5297 {
5298 arg3 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj2);
5299 if (PyErr_Occurred()) {
5300 SWIG_fail;
5301 }
5302 }
5303 {
5304 svn_swig_py_release_py_lock();
5305
5306 result = (svn_error_t *)svn_diff_output(arg1,arg2,(struct svn_diff_output_fns_t const *)arg3);
5307
5308 svn_swig_py_acquire_py_lock();
5309
5310 }
5311 {
5312 if (result != NULL) {
5313 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
5314 svn_swig_py_svn_exception(result);
5315 else
5316 svn_error_clear(result);
5317 SWIG_fail;
5318 }
5319 Py_INCREF(Py_None);
5320 resultobj = Py_None;
5321 }
5322 return resultobj;
5323 fail:
5324 return NULL;
5325 }
5326
5327
_wrap_svn_diff_file_options_t_ignore_space_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5328 SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_ignore_space_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5329 PyObject *resultobj = 0;
5330 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5331 svn_diff_file_ignore_space_t arg2 ;
5332 PyObject * obj0 = 0 ;
5333 PyObject * obj1 = 0 ;
5334
5335 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_t_ignore_space_set",2,2,&obj0,&obj1)) SWIG_fail;
5336 {
5337 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5338 if (PyErr_Occurred()) {
5339 SWIG_fail;
5340 }
5341 }
5342 {
5343 arg2 = (svn_diff_file_ignore_space_t)SWIG_As_long (obj1);
5344 if (SWIG_arg_fail(svn_argnum_obj1)) {
5345 SWIG_fail;
5346 }
5347 }
5348 if (arg1) (arg1)->ignore_space = arg2;
5349 resultobj = SWIG_Py_Void();
5350 return resultobj;
5351 fail:
5352 return NULL;
5353 }
5354
5355
_wrap_svn_diff_file_options_t_ignore_space_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5356 SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_ignore_space_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5357 PyObject *resultobj = 0;
5358 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5359 PyObject * obj0 = 0 ;
5360 svn_diff_file_ignore_space_t result;
5361
5362 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_t_ignore_space_get",1,1,&obj0)) SWIG_fail;
5363 {
5364 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5365 if (PyErr_Occurred()) {
5366 SWIG_fail;
5367 }
5368 }
5369 result = (svn_diff_file_ignore_space_t) ((arg1)->ignore_space);
5370 resultobj = SWIG_From_long((long)(result));
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
_wrap_svn_diff_file_options_t_ignore_eol_style_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5377 SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_ignore_eol_style_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5378 PyObject *resultobj = 0;
5379 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5380 svn_boolean_t arg2 ;
5381 PyObject * obj0 = 0 ;
5382 PyObject * obj1 = 0 ;
5383
5384 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_t_ignore_eol_style_set",2,2,&obj0,&obj1)) SWIG_fail;
5385 {
5386 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5387 if (PyErr_Occurred()) {
5388 SWIG_fail;
5389 }
5390 }
5391 {
5392 arg2 = (svn_boolean_t)SWIG_As_long (obj1);
5393 if (SWIG_arg_fail(svn_argnum_obj1)) {
5394 SWIG_fail;
5395 }
5396 }
5397 if (arg1) (arg1)->ignore_eol_style = arg2;
5398 resultobj = SWIG_Py_Void();
5399 return resultobj;
5400 fail:
5401 return NULL;
5402 }
5403
5404
_wrap_svn_diff_file_options_t_ignore_eol_style_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5405 SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_ignore_eol_style_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5406 PyObject *resultobj = 0;
5407 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5408 PyObject * obj0 = 0 ;
5409 svn_boolean_t result;
5410
5411 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_t_ignore_eol_style_get",1,1,&obj0)) SWIG_fail;
5412 {
5413 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5414 if (PyErr_Occurred()) {
5415 SWIG_fail;
5416 }
5417 }
5418 result = (svn_boolean_t) ((arg1)->ignore_eol_style);
5419 resultobj = SWIG_From_long((long)(result));
5420 return resultobj;
5421 fail:
5422 return NULL;
5423 }
5424
5425
_wrap_svn_diff_file_options_t_show_c_function_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5426 SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_show_c_function_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5427 PyObject *resultobj = 0;
5428 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5429 svn_boolean_t arg2 ;
5430 PyObject * obj0 = 0 ;
5431 PyObject * obj1 = 0 ;
5432
5433 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_t_show_c_function_set",2,2,&obj0,&obj1)) SWIG_fail;
5434 {
5435 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5436 if (PyErr_Occurred()) {
5437 SWIG_fail;
5438 }
5439 }
5440 {
5441 arg2 = (svn_boolean_t)SWIG_As_long (obj1);
5442 if (SWIG_arg_fail(svn_argnum_obj1)) {
5443 SWIG_fail;
5444 }
5445 }
5446 if (arg1) (arg1)->show_c_function = arg2;
5447 resultobj = SWIG_Py_Void();
5448 return resultobj;
5449 fail:
5450 return NULL;
5451 }
5452
5453
_wrap_svn_diff_file_options_t_show_c_function_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5454 SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_show_c_function_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5455 PyObject *resultobj = 0;
5456 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5457 PyObject * obj0 = 0 ;
5458 svn_boolean_t result;
5459
5460 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_t_show_c_function_get",1,1,&obj0)) SWIG_fail;
5461 {
5462 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5463 if (PyErr_Occurred()) {
5464 SWIG_fail;
5465 }
5466 }
5467 result = (svn_boolean_t) ((arg1)->show_c_function);
5468 resultobj = SWIG_From_long((long)(result));
5469 return resultobj;
5470 fail:
5471 return NULL;
5472 }
5473
5474
_wrap_svn_diff_file_options_t_context_size_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5475 SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_context_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5476 PyObject *resultobj = 0;
5477 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5478 int arg2 ;
5479 PyObject * obj0 = 0 ;
5480 PyObject * obj1 = 0 ;
5481
5482 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_t_context_size_set",2,2,&obj0,&obj1)) SWIG_fail;
5483 {
5484 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5485 if (PyErr_Occurred()) {
5486 SWIG_fail;
5487 }
5488 }
5489 {
5490 arg2 = (int)SWIG_As_long (obj1);
5491 if (SWIG_arg_fail(svn_argnum_obj1)) {
5492 SWIG_fail;
5493 }
5494 }
5495 if (arg1) (arg1)->context_size = arg2;
5496 resultobj = SWIG_Py_Void();
5497 return resultobj;
5498 fail:
5499 return NULL;
5500 }
5501
5502
_wrap_svn_diff_file_options_t_context_size_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5503 SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_context_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5504 PyObject *resultobj = 0;
5505 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5506 PyObject * obj0 = 0 ;
5507 int result;
5508
5509 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_t_context_size_get",1,1,&obj0)) SWIG_fail;
5510 {
5511 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5512 if (PyErr_Occurred()) {
5513 SWIG_fail;
5514 }
5515 }
5516 result = (int) ((arg1)->context_size);
5517 resultobj = SWIG_From_long((long)(result));
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
_wrap_new_svn_diff_file_options_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5524 SWIGINTERN PyObject *_wrap_new_svn_diff_file_options_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5525 PyObject *resultobj = 0;
5526 struct svn_diff_file_options_t *result = 0 ;
5527
5528 if(!PyArg_UnpackTuple(args,(char *)"new_svn_diff_file_options_t",0,0)) SWIG_fail;
5529 {
5530 svn_swig_py_release_py_lock();
5531
5532 result = (struct svn_diff_file_options_t *)calloc(1, sizeof(struct svn_diff_file_options_t));
5533
5534 svn_swig_py_acquire_py_lock();
5535
5536 }
5537 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_file_options_t,
5538 _global_py_pool, args);
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
_wrap_delete_svn_diff_file_options_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5545 SWIGINTERN PyObject *_wrap_delete_svn_diff_file_options_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5546 PyObject *resultobj = 0;
5547 struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
5548 PyObject * obj0 = 0 ;
5549
5550 if(!PyArg_UnpackTuple(args,(char *)"delete_svn_diff_file_options_t",1,1,&obj0)) SWIG_fail;
5551 {
5552 arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5553 if (PyErr_Occurred()) {
5554 SWIG_fail;
5555 }
5556 }
5557 {
5558 svn_swig_py_release_py_lock();
5559
5560 free((char *) arg1);
5561
5562 svn_swig_py_acquire_py_lock();
5563
5564 }
5565 resultobj = SWIG_Py_Void();
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
svn_diff_file_options_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5572 SWIGINTERN PyObject *svn_diff_file_options_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5573 PyObject *obj;
5574 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
5575 SWIG_TypeNewClientData(SWIGTYPE_p_svn_diff_file_options_t, SWIG_NewClientData(obj));
5576 return SWIG_Py_Void();
5577 }
5578
_wrap_svn_diff_file_options_create(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5579 SWIGINTERN PyObject *_wrap_svn_diff_file_options_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5580 PyObject *resultobj = 0;
5581 apr_pool_t *arg1 = (apr_pool_t *) 0 ;
5582 apr_pool_t *_global_pool = NULL ;
5583 PyObject *_global_py_pool = NULL ;
5584 PyObject * obj0 = 0 ;
5585 svn_diff_file_options_t *result = 0 ;
5586
5587 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
5588 &_global_py_pool, &_global_pool))
5589 SWIG_fail;
5590 arg1 = _global_pool;
5591 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_create",0,1,&obj0)) SWIG_fail;
5592 if (obj0) {
5593 /* Verify that the user supplied a valid pool */
5594 if (obj0 != Py_None && obj0 != _global_py_pool) {
5595 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj0);
5596 SWIG_arg_fail(svn_argnum_obj0);
5597 SWIG_fail;
5598 }
5599 }
5600 {
5601 svn_swig_py_release_py_lock();
5602
5603 result = (svn_diff_file_options_t *)svn_diff_file_options_create(arg1);
5604
5605 svn_swig_py_acquire_py_lock();
5606
5607 }
5608 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_file_options_t,
5609 _global_py_pool, args);
5610 {
5611 Py_XDECREF(_global_py_pool);
5612 }
5613 return resultobj;
5614 fail:
5615 {
5616 Py_XDECREF(_global_py_pool);
5617 }
5618 return NULL;
5619 }
5620
5621
_wrap_svn_diff_file_options_parse(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5622 SWIGINTERN PyObject *_wrap_svn_diff_file_options_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5623 PyObject *resultobj = 0;
5624 svn_diff_file_options_t *arg1 = (svn_diff_file_options_t *) 0 ;
5625 apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
5626 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
5627 apr_pool_t *_global_pool = NULL ;
5628 PyObject *_global_py_pool = NULL ;
5629 PyObject * obj0 = 0 ;
5630 PyObject * obj1 = 0 ;
5631 PyObject * obj2 = 0 ;
5632 svn_error_t *result = 0 ;
5633
5634 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
5635 &_global_py_pool, &_global_pool))
5636 SWIG_fail;
5637 arg3 = _global_pool;
5638 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_options_parse",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
5639 {
5640 arg1 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5641 if (PyErr_Occurred()) {
5642 SWIG_fail;
5643 }
5644 }
5645 {
5646 arg2 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
5647 sizeof(const char *),
5648 svn_swig_py_unwrap_string,
5649 NULL,
5650 _global_pool);
5651 if (PyErr_Occurred())
5652 SWIG_fail;
5653 }
5654 if (obj2) {
5655 /* Verify that the user supplied a valid pool */
5656 if (obj2 != Py_None && obj2 != _global_py_pool) {
5657 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
5658 SWIG_arg_fail(svn_argnum_obj2);
5659 SWIG_fail;
5660 }
5661 }
5662 {
5663 svn_swig_py_release_py_lock();
5664
5665 result = (svn_error_t *)svn_diff_file_options_parse(arg1,(apr_array_header_t const *)arg2,arg3);
5666
5667 svn_swig_py_acquire_py_lock();
5668
5669 }
5670 {
5671 if (result != NULL) {
5672 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
5673 svn_swig_py_svn_exception(result);
5674 else
5675 svn_error_clear(result);
5676 SWIG_fail;
5677 }
5678 Py_INCREF(Py_None);
5679 resultobj = Py_None;
5680 }
5681 {
5682 Py_XDECREF(_global_py_pool);
5683 }
5684 return resultobj;
5685 fail:
5686 {
5687 Py_XDECREF(_global_py_pool);
5688 }
5689 return NULL;
5690 }
5691
5692
_wrap_svn_diff_file_diff_2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5693 SWIGINTERN PyObject *_wrap_svn_diff_file_diff_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5694 PyObject *resultobj = 0;
5695 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
5696 char *arg2 = (char *) 0 ;
5697 char *arg3 = (char *) 0 ;
5698 svn_diff_file_options_t *arg4 = (svn_diff_file_options_t *) 0 ;
5699 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
5700 apr_pool_t *_global_pool = NULL ;
5701 PyObject *_global_py_pool = NULL ;
5702 svn_diff_t *temp1 ;
5703 PyObject * obj0 = 0 ;
5704 PyObject * obj1 = 0 ;
5705 PyObject * obj2 = 0 ;
5706 PyObject * obj3 = 0 ;
5707 svn_error_t *result = 0 ;
5708
5709 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
5710 &_global_py_pool, &_global_pool))
5711 SWIG_fail;
5712 arg5 = _global_pool;
5713 arg1 = &temp1;
5714 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_diff_2",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5715 {
5716 arg2 = svn_swig_py_string_to_cstring(obj0, FALSE, "svn_diff_file_diff_2", "original");
5717 if (PyErr_Occurred()) SWIG_fail;
5718 }
5719 {
5720 arg3 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_diff_file_diff_2", "modified");
5721 if (PyErr_Occurred()) SWIG_fail;
5722 }
5723 {
5724 arg4 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj2);
5725 if (PyErr_Occurred()) {
5726 SWIG_fail;
5727 }
5728 }
5729 if (obj3) {
5730 /* Verify that the user supplied a valid pool */
5731 if (obj3 != Py_None && obj3 != _global_py_pool) {
5732 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
5733 SWIG_arg_fail(svn_argnum_obj3);
5734 SWIG_fail;
5735 }
5736 }
5737 {
5738 svn_swig_py_release_py_lock();
5739
5740 result = (svn_error_t *)svn_diff_file_diff_2(arg1,(char const *)arg2,(char const *)arg3,(struct svn_diff_file_options_t const *)arg4,arg5);
5741
5742 svn_swig_py_acquire_py_lock();
5743
5744 }
5745 {
5746 if (result != NULL) {
5747 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
5748 svn_swig_py_svn_exception(result);
5749 else
5750 svn_error_clear(result);
5751 SWIG_fail;
5752 }
5753 Py_INCREF(Py_None);
5754 resultobj = Py_None;
5755 }
5756 {
5757 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5758 _global_py_pool, args))
5759
5760 ;
5761 }
5762 {
5763 Py_XDECREF(_global_py_pool);
5764 }
5765 return resultobj;
5766 fail:
5767 {
5768 Py_XDECREF(_global_py_pool);
5769 }
5770 return NULL;
5771 }
5772
5773
_wrap_svn_diff_file_diff(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5774 SWIGINTERN PyObject *_wrap_svn_diff_file_diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5775 PyObject *resultobj = 0;
5776 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
5777 char *arg2 = (char *) 0 ;
5778 char *arg3 = (char *) 0 ;
5779 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
5780 apr_pool_t *_global_pool = NULL ;
5781 PyObject *_global_py_pool = NULL ;
5782 svn_diff_t *temp1 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 PyObject * obj2 = 0 ;
5786 svn_error_t *result = 0 ;
5787
5788 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
5789 &_global_py_pool, &_global_pool))
5790 SWIG_fail;
5791 arg4 = _global_pool;
5792 arg1 = &temp1;
5793 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_diff",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
5794 {
5795 arg2 = svn_swig_py_string_to_cstring(obj0, FALSE, "svn_diff_file_diff", "original");
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 {
5799 arg3 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_diff_file_diff", "modified");
5800 if (PyErr_Occurred()) SWIG_fail;
5801 }
5802 if (obj2) {
5803 /* Verify that the user supplied a valid pool */
5804 if (obj2 != Py_None && obj2 != _global_py_pool) {
5805 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
5806 SWIG_arg_fail(svn_argnum_obj2);
5807 SWIG_fail;
5808 }
5809 }
5810 {
5811 svn_swig_py_release_py_lock();
5812
5813 result = (svn_error_t *)svn_diff_file_diff(arg1,(char const *)arg2,(char const *)arg3,arg4);
5814
5815 svn_swig_py_acquire_py_lock();
5816
5817 }
5818 {
5819 if (result != NULL) {
5820 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
5821 svn_swig_py_svn_exception(result);
5822 else
5823 svn_error_clear(result);
5824 SWIG_fail;
5825 }
5826 Py_INCREF(Py_None);
5827 resultobj = Py_None;
5828 }
5829 {
5830 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5831 _global_py_pool, args))
5832
5833 ;
5834 }
5835 {
5836 Py_XDECREF(_global_py_pool);
5837 }
5838 return resultobj;
5839 fail:
5840 {
5841 Py_XDECREF(_global_py_pool);
5842 }
5843 return NULL;
5844 }
5845
5846
_wrap_svn_diff_file_diff3_2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5847 SWIGINTERN PyObject *_wrap_svn_diff_file_diff3_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5848 PyObject *resultobj = 0;
5849 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
5850 char *arg2 = (char *) 0 ;
5851 char *arg3 = (char *) 0 ;
5852 char *arg4 = (char *) 0 ;
5853 svn_diff_file_options_t *arg5 = (svn_diff_file_options_t *) 0 ;
5854 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
5855 apr_pool_t *_global_pool = NULL ;
5856 PyObject *_global_py_pool = NULL ;
5857 svn_diff_t *temp1 ;
5858 PyObject * obj0 = 0 ;
5859 PyObject * obj1 = 0 ;
5860 PyObject * obj2 = 0 ;
5861 PyObject * obj3 = 0 ;
5862 PyObject * obj4 = 0 ;
5863 svn_error_t *result = 0 ;
5864
5865 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
5866 &_global_py_pool, &_global_pool))
5867 SWIG_fail;
5868 arg6 = _global_pool;
5869 arg1 = &temp1;
5870 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_diff3_2",4,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5871 {
5872 arg2 = svn_swig_py_string_to_cstring(obj0, FALSE, "svn_diff_file_diff3_2", "original");
5873 if (PyErr_Occurred()) SWIG_fail;
5874 }
5875 {
5876 arg3 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_diff_file_diff3_2", "modified");
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 arg4 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_diff3_2", "latest");
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 {
5884 arg5 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj3);
5885 if (PyErr_Occurred()) {
5886 SWIG_fail;
5887 }
5888 }
5889 if (obj4) {
5890 /* Verify that the user supplied a valid pool */
5891 if (obj4 != Py_None && obj4 != _global_py_pool) {
5892 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
5893 SWIG_arg_fail(svn_argnum_obj4);
5894 SWIG_fail;
5895 }
5896 }
5897 {
5898 svn_swig_py_release_py_lock();
5899
5900 result = (svn_error_t *)svn_diff_file_diff3_2(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,(struct svn_diff_file_options_t const *)arg5,arg6);
5901
5902 svn_swig_py_acquire_py_lock();
5903
5904 }
5905 {
5906 if (result != NULL) {
5907 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
5908 svn_swig_py_svn_exception(result);
5909 else
5910 svn_error_clear(result);
5911 SWIG_fail;
5912 }
5913 Py_INCREF(Py_None);
5914 resultobj = Py_None;
5915 }
5916 {
5917 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5918 _global_py_pool, args))
5919
5920 ;
5921 }
5922 {
5923 Py_XDECREF(_global_py_pool);
5924 }
5925 return resultobj;
5926 fail:
5927 {
5928 Py_XDECREF(_global_py_pool);
5929 }
5930 return NULL;
5931 }
5932
5933
_wrap_svn_diff_file_diff3(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5934 SWIGINTERN PyObject *_wrap_svn_diff_file_diff3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5935 PyObject *resultobj = 0;
5936 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
5937 char *arg2 = (char *) 0 ;
5938 char *arg3 = (char *) 0 ;
5939 char *arg4 = (char *) 0 ;
5940 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
5941 apr_pool_t *_global_pool = NULL ;
5942 PyObject *_global_py_pool = NULL ;
5943 svn_diff_t *temp1 ;
5944 PyObject * obj0 = 0 ;
5945 PyObject * obj1 = 0 ;
5946 PyObject * obj2 = 0 ;
5947 PyObject * obj3 = 0 ;
5948 svn_error_t *result = 0 ;
5949
5950 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
5951 &_global_py_pool, &_global_pool))
5952 SWIG_fail;
5953 arg5 = _global_pool;
5954 arg1 = &temp1;
5955 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_diff3",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5956 {
5957 arg2 = svn_swig_py_string_to_cstring(obj0, FALSE, "svn_diff_file_diff3", "original");
5958 if (PyErr_Occurred()) SWIG_fail;
5959 }
5960 {
5961 arg3 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_diff_file_diff3", "modified");
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 {
5965 arg4 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_diff3", "latest");
5966 if (PyErr_Occurred()) SWIG_fail;
5967 }
5968 if (obj3) {
5969 /* Verify that the user supplied a valid pool */
5970 if (obj3 != Py_None && obj3 != _global_py_pool) {
5971 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
5972 SWIG_arg_fail(svn_argnum_obj3);
5973 SWIG_fail;
5974 }
5975 }
5976 {
5977 svn_swig_py_release_py_lock();
5978
5979 result = (svn_error_t *)svn_diff_file_diff3(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
5980
5981 svn_swig_py_acquire_py_lock();
5982
5983 }
5984 {
5985 if (result != NULL) {
5986 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
5987 svn_swig_py_svn_exception(result);
5988 else
5989 svn_error_clear(result);
5990 SWIG_fail;
5991 }
5992 Py_INCREF(Py_None);
5993 resultobj = Py_None;
5994 }
5995 {
5996 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5997 _global_py_pool, args))
5998
5999 ;
6000 }
6001 {
6002 Py_XDECREF(_global_py_pool);
6003 }
6004 return resultobj;
6005 fail:
6006 {
6007 Py_XDECREF(_global_py_pool);
6008 }
6009 return NULL;
6010 }
6011
6012
_wrap_svn_diff_file_diff4_2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6013 SWIGINTERN PyObject *_wrap_svn_diff_file_diff4_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6014 PyObject *resultobj = 0;
6015 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
6016 char *arg2 = (char *) 0 ;
6017 char *arg3 = (char *) 0 ;
6018 char *arg4 = (char *) 0 ;
6019 char *arg5 = (char *) 0 ;
6020 svn_diff_file_options_t *arg6 = (svn_diff_file_options_t *) 0 ;
6021 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
6022 apr_pool_t *_global_pool = NULL ;
6023 PyObject *_global_py_pool = NULL ;
6024 svn_diff_t *temp1 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 PyObject * obj2 = 0 ;
6028 PyObject * obj3 = 0 ;
6029 PyObject * obj4 = 0 ;
6030 PyObject * obj5 = 0 ;
6031 svn_error_t *result = 0 ;
6032
6033 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6034 &_global_py_pool, &_global_pool))
6035 SWIG_fail;
6036 arg7 = _global_pool;
6037 arg1 = &temp1;
6038 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_diff4_2",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6039 {
6040 arg2 = svn_swig_py_string_to_cstring(obj0, FALSE, "svn_diff_file_diff4_2", "original");
6041 if (PyErr_Occurred()) SWIG_fail;
6042 }
6043 {
6044 arg3 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_diff_file_diff4_2", "modified");
6045 if (PyErr_Occurred()) SWIG_fail;
6046 }
6047 {
6048 arg4 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_diff4_2", "latest");
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 {
6052 arg5 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_diff4_2", "ancestor");
6053 if (PyErr_Occurred()) SWIG_fail;
6054 }
6055 {
6056 arg6 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj4);
6057 if (PyErr_Occurred()) {
6058 SWIG_fail;
6059 }
6060 }
6061 if (obj5) {
6062 /* Verify that the user supplied a valid pool */
6063 if (obj5 != Py_None && obj5 != _global_py_pool) {
6064 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
6065 SWIG_arg_fail(svn_argnum_obj5);
6066 SWIG_fail;
6067 }
6068 }
6069 {
6070 svn_swig_py_release_py_lock();
6071
6072 result = (svn_error_t *)svn_diff_file_diff4_2(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(struct svn_diff_file_options_t const *)arg6,arg7);
6073
6074 svn_swig_py_acquire_py_lock();
6075
6076 }
6077 {
6078 if (result != NULL) {
6079 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
6080 svn_swig_py_svn_exception(result);
6081 else
6082 svn_error_clear(result);
6083 SWIG_fail;
6084 }
6085 Py_INCREF(Py_None);
6086 resultobj = Py_None;
6087 }
6088 {
6089 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
6090 _global_py_pool, args))
6091
6092 ;
6093 }
6094 {
6095 Py_XDECREF(_global_py_pool);
6096 }
6097 return resultobj;
6098 fail:
6099 {
6100 Py_XDECREF(_global_py_pool);
6101 }
6102 return NULL;
6103 }
6104
6105
_wrap_svn_diff_file_diff4(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6106 SWIGINTERN PyObject *_wrap_svn_diff_file_diff4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6107 PyObject *resultobj = 0;
6108 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
6109 char *arg2 = (char *) 0 ;
6110 char *arg3 = (char *) 0 ;
6111 char *arg4 = (char *) 0 ;
6112 char *arg5 = (char *) 0 ;
6113 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
6114 apr_pool_t *_global_pool = NULL ;
6115 PyObject *_global_py_pool = NULL ;
6116 svn_diff_t *temp1 ;
6117 PyObject * obj0 = 0 ;
6118 PyObject * obj1 = 0 ;
6119 PyObject * obj2 = 0 ;
6120 PyObject * obj3 = 0 ;
6121 PyObject * obj4 = 0 ;
6122 svn_error_t *result = 0 ;
6123
6124 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6125 &_global_py_pool, &_global_pool))
6126 SWIG_fail;
6127 arg6 = _global_pool;
6128 arg1 = &temp1;
6129 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_diff4",4,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
6130 {
6131 arg2 = svn_swig_py_string_to_cstring(obj0, FALSE, "svn_diff_file_diff4", "original");
6132 if (PyErr_Occurred()) SWIG_fail;
6133 }
6134 {
6135 arg3 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_diff_file_diff4", "modified");
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 {
6139 arg4 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_diff4", "latest");
6140 if (PyErr_Occurred()) SWIG_fail;
6141 }
6142 {
6143 arg5 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_diff4", "ancestor");
6144 if (PyErr_Occurred()) SWIG_fail;
6145 }
6146 if (obj4) {
6147 /* Verify that the user supplied a valid pool */
6148 if (obj4 != Py_None && obj4 != _global_py_pool) {
6149 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
6150 SWIG_arg_fail(svn_argnum_obj4);
6151 SWIG_fail;
6152 }
6153 }
6154 {
6155 svn_swig_py_release_py_lock();
6156
6157 result = (svn_error_t *)svn_diff_file_diff4(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,arg6);
6158
6159 svn_swig_py_acquire_py_lock();
6160
6161 }
6162 {
6163 if (result != NULL) {
6164 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
6165 svn_swig_py_svn_exception(result);
6166 else
6167 svn_error_clear(result);
6168 SWIG_fail;
6169 }
6170 Py_INCREF(Py_None);
6171 resultobj = Py_None;
6172 }
6173 {
6174 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
6175 _global_py_pool, args))
6176
6177 ;
6178 }
6179 {
6180 Py_XDECREF(_global_py_pool);
6181 }
6182 return resultobj;
6183 fail:
6184 {
6185 Py_XDECREF(_global_py_pool);
6186 }
6187 return NULL;
6188 }
6189
6190
_wrap_svn_diff_file_output_unified4(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6191 SWIGINTERN PyObject *_wrap_svn_diff_file_output_unified4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6192 PyObject *resultobj = 0;
6193 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6194 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
6195 char *arg3 = (char *) 0 ;
6196 char *arg4 = (char *) 0 ;
6197 char *arg5 = (char *) 0 ;
6198 char *arg6 = (char *) 0 ;
6199 char *arg7 = (char *) 0 ;
6200 char *arg8 = (char *) 0 ;
6201 svn_boolean_t arg9 ;
6202 int arg10 ;
6203 svn_cancel_func_t arg11 = (svn_cancel_func_t) 0 ;
6204 void *arg12 = (void *) 0 ;
6205 apr_pool_t *arg13 = (apr_pool_t *) 0 ;
6206 apr_pool_t *_global_pool = NULL ;
6207 PyObject *_global_py_pool = NULL ;
6208 PyObject * obj0 = 0 ;
6209 PyObject * obj1 = 0 ;
6210 PyObject * obj2 = 0 ;
6211 PyObject * obj3 = 0 ;
6212 PyObject * obj4 = 0 ;
6213 PyObject * obj5 = 0 ;
6214 PyObject * obj6 = 0 ;
6215 PyObject * obj7 = 0 ;
6216 PyObject * obj8 = 0 ;
6217 PyObject * obj9 = 0 ;
6218 PyObject * obj10 = 0 ;
6219 PyObject * obj11 = 0 ;
6220 svn_error_t *result = 0 ;
6221
6222 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6223 &_global_py_pool, &_global_pool))
6224 SWIG_fail;
6225 arg13 = _global_pool;
6226 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_output_unified4",11,12,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
6227 {
6228 if (obj0 == Py_None) {
6229 arg1 = NULL;
6230 }
6231 else {
6232 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6233 if (arg1 == NULL) {
6234 SWIG_fail;
6235 }
6236 }
6237 }
6238 {
6239 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6240 if (PyErr_Occurred()) {
6241 SWIG_fail;
6242 }
6243 }
6244 {
6245 arg3 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_output_unified4", "original_path");
6246 if (PyErr_Occurred()) SWIG_fail;
6247 }
6248 {
6249 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_output_unified4", "modified_path");
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 {
6253 arg5 = svn_swig_py_string_to_cstring(obj4, TRUE, "svn_diff_file_output_unified4", "original_header");
6254 if (PyErr_Occurred()) SWIG_fail;
6255 }
6256 {
6257 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_file_output_unified4", "modified_header");
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 {
6261 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_file_output_unified4", "header_encoding");
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 {
6265 arg8 = svn_swig_py_string_to_cstring(obj7, TRUE, "svn_diff_file_output_unified4", "relative_to_dir");
6266 if (PyErr_Occurred()) SWIG_fail;
6267 }
6268 {
6269 arg9 = (svn_boolean_t)SWIG_As_long (obj8);
6270 if (SWIG_arg_fail(svn_argnum_obj8)) {
6271 SWIG_fail;
6272 }
6273 }
6274 {
6275 arg10 = (int)SWIG_As_long (obj9);
6276 if (SWIG_arg_fail(svn_argnum_obj9)) {
6277 SWIG_fail;
6278 }
6279 }
6280 {
6281 arg11 = (svn_cancel_func_t) svn_swig_py_cancel_func;
6282 arg12 = obj10;
6283 }
6284 if (obj11) {
6285 /* Verify that the user supplied a valid pool */
6286 if (obj11 != Py_None && obj11 != _global_py_pool) {
6287 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
6288 SWIG_arg_fail(svn_argnum_obj11);
6289 SWIG_fail;
6290 }
6291 }
6292 {
6293 svn_swig_py_release_py_lock();
6294
6295 result = (svn_error_t *)svn_diff_file_output_unified4(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,arg9,arg10,arg11,arg12,arg13);
6296
6297 svn_swig_py_acquire_py_lock();
6298
6299 }
6300 {
6301 if (result != NULL) {
6302 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
6303 svn_swig_py_svn_exception(result);
6304 else
6305 svn_error_clear(result);
6306 SWIG_fail;
6307 }
6308 Py_INCREF(Py_None);
6309 resultobj = Py_None;
6310 }
6311 {
6312 Py_XDECREF(_global_py_pool);
6313 }
6314 return resultobj;
6315 fail:
6316 {
6317 Py_XDECREF(_global_py_pool);
6318 }
6319 return NULL;
6320 }
6321
6322
_wrap_svn_diff_file_output_unified3(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6323 SWIGINTERN PyObject *_wrap_svn_diff_file_output_unified3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6324 PyObject *resultobj = 0;
6325 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6326 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
6327 char *arg3 = (char *) 0 ;
6328 char *arg4 = (char *) 0 ;
6329 char *arg5 = (char *) 0 ;
6330 char *arg6 = (char *) 0 ;
6331 char *arg7 = (char *) 0 ;
6332 char *arg8 = (char *) 0 ;
6333 svn_boolean_t arg9 ;
6334 apr_pool_t *arg10 = (apr_pool_t *) 0 ;
6335 apr_pool_t *_global_pool = NULL ;
6336 PyObject *_global_py_pool = NULL ;
6337 PyObject * obj0 = 0 ;
6338 PyObject * obj1 = 0 ;
6339 PyObject * obj2 = 0 ;
6340 PyObject * obj3 = 0 ;
6341 PyObject * obj4 = 0 ;
6342 PyObject * obj5 = 0 ;
6343 PyObject * obj6 = 0 ;
6344 PyObject * obj7 = 0 ;
6345 PyObject * obj8 = 0 ;
6346 PyObject * obj9 = 0 ;
6347 svn_error_t *result = 0 ;
6348
6349 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6350 &_global_py_pool, &_global_pool))
6351 SWIG_fail;
6352 arg10 = _global_pool;
6353 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_output_unified3",9,10,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
6354 {
6355 if (obj0 == Py_None) {
6356 arg1 = NULL;
6357 }
6358 else {
6359 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6360 if (arg1 == NULL) {
6361 SWIG_fail;
6362 }
6363 }
6364 }
6365 {
6366 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6367 if (PyErr_Occurred()) {
6368 SWIG_fail;
6369 }
6370 }
6371 {
6372 arg3 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_output_unified3", "original_path");
6373 if (PyErr_Occurred()) SWIG_fail;
6374 }
6375 {
6376 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_output_unified3", "modified_path");
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 {
6380 arg5 = svn_swig_py_string_to_cstring(obj4, TRUE, "svn_diff_file_output_unified3", "original_header");
6381 if (PyErr_Occurred()) SWIG_fail;
6382 }
6383 {
6384 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_file_output_unified3", "modified_header");
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 {
6388 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_file_output_unified3", "header_encoding");
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 {
6392 arg8 = svn_swig_py_string_to_cstring(obj7, TRUE, "svn_diff_file_output_unified3", "relative_to_dir");
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 {
6396 arg9 = (svn_boolean_t)SWIG_As_long (obj8);
6397 if (SWIG_arg_fail(svn_argnum_obj8)) {
6398 SWIG_fail;
6399 }
6400 }
6401 if (obj9) {
6402 /* Verify that the user supplied a valid pool */
6403 if (obj9 != Py_None && obj9 != _global_py_pool) {
6404 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj9);
6405 SWIG_arg_fail(svn_argnum_obj9);
6406 SWIG_fail;
6407 }
6408 }
6409 {
6410 svn_swig_py_release_py_lock();
6411
6412 result = (svn_error_t *)svn_diff_file_output_unified3(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,arg9,arg10);
6413
6414 svn_swig_py_acquire_py_lock();
6415
6416 }
6417 {
6418 if (result != NULL) {
6419 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
6420 svn_swig_py_svn_exception(result);
6421 else
6422 svn_error_clear(result);
6423 SWIG_fail;
6424 }
6425 Py_INCREF(Py_None);
6426 resultobj = Py_None;
6427 }
6428 {
6429 Py_XDECREF(_global_py_pool);
6430 }
6431 return resultobj;
6432 fail:
6433 {
6434 Py_XDECREF(_global_py_pool);
6435 }
6436 return NULL;
6437 }
6438
6439
_wrap_svn_diff_file_output_unified2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6440 SWIGINTERN PyObject *_wrap_svn_diff_file_output_unified2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6441 PyObject *resultobj = 0;
6442 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6443 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
6444 char *arg3 = (char *) 0 ;
6445 char *arg4 = (char *) 0 ;
6446 char *arg5 = (char *) 0 ;
6447 char *arg6 = (char *) 0 ;
6448 char *arg7 = (char *) 0 ;
6449 apr_pool_t *arg8 = (apr_pool_t *) 0 ;
6450 apr_pool_t *_global_pool = NULL ;
6451 PyObject *_global_py_pool = NULL ;
6452 PyObject * obj0 = 0 ;
6453 PyObject * obj1 = 0 ;
6454 PyObject * obj2 = 0 ;
6455 PyObject * obj3 = 0 ;
6456 PyObject * obj4 = 0 ;
6457 PyObject * obj5 = 0 ;
6458 PyObject * obj6 = 0 ;
6459 PyObject * obj7 = 0 ;
6460 svn_error_t *result = 0 ;
6461
6462 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6463 &_global_py_pool, &_global_pool))
6464 SWIG_fail;
6465 arg8 = _global_pool;
6466 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_output_unified2",7,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6467 {
6468 if (obj0 == Py_None) {
6469 arg1 = NULL;
6470 }
6471 else {
6472 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6473 if (arg1 == NULL) {
6474 SWIG_fail;
6475 }
6476 }
6477 }
6478 {
6479 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6480 if (PyErr_Occurred()) {
6481 SWIG_fail;
6482 }
6483 }
6484 {
6485 arg3 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_output_unified2", "original_path");
6486 if (PyErr_Occurred()) SWIG_fail;
6487 }
6488 {
6489 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_output_unified2", "modified_path");
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 {
6493 arg5 = svn_swig_py_string_to_cstring(obj4, TRUE, "svn_diff_file_output_unified2", "original_header");
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 {
6497 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_file_output_unified2", "modified_header");
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 {
6501 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_file_output_unified2", "header_encoding");
6502 if (PyErr_Occurred()) SWIG_fail;
6503 }
6504 if (obj7) {
6505 /* Verify that the user supplied a valid pool */
6506 if (obj7 != Py_None && obj7 != _global_py_pool) {
6507 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
6508 SWIG_arg_fail(svn_argnum_obj7);
6509 SWIG_fail;
6510 }
6511 }
6512 {
6513 svn_swig_py_release_py_lock();
6514
6515 result = (svn_error_t *)svn_diff_file_output_unified2(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8);
6516
6517 svn_swig_py_acquire_py_lock();
6518
6519 }
6520 {
6521 if (result != NULL) {
6522 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
6523 svn_swig_py_svn_exception(result);
6524 else
6525 svn_error_clear(result);
6526 SWIG_fail;
6527 }
6528 Py_INCREF(Py_None);
6529 resultobj = Py_None;
6530 }
6531 {
6532 Py_XDECREF(_global_py_pool);
6533 }
6534 return resultobj;
6535 fail:
6536 {
6537 Py_XDECREF(_global_py_pool);
6538 }
6539 return NULL;
6540 }
6541
6542
_wrap_svn_diff_file_output_unified(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6543 SWIGINTERN PyObject *_wrap_svn_diff_file_output_unified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6544 PyObject *resultobj = 0;
6545 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6546 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
6547 char *arg3 = (char *) 0 ;
6548 char *arg4 = (char *) 0 ;
6549 char *arg5 = (char *) 0 ;
6550 char *arg6 = (char *) 0 ;
6551 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
6552 apr_pool_t *_global_pool = NULL ;
6553 PyObject *_global_py_pool = NULL ;
6554 PyObject * obj0 = 0 ;
6555 PyObject * obj1 = 0 ;
6556 PyObject * obj2 = 0 ;
6557 PyObject * obj3 = 0 ;
6558 PyObject * obj4 = 0 ;
6559 PyObject * obj5 = 0 ;
6560 PyObject * obj6 = 0 ;
6561 svn_error_t *result = 0 ;
6562
6563 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6564 &_global_py_pool, &_global_pool))
6565 SWIG_fail;
6566 arg7 = _global_pool;
6567 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_output_unified",6,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6568 {
6569 if (obj0 == Py_None) {
6570 arg1 = NULL;
6571 }
6572 else {
6573 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6574 if (arg1 == NULL) {
6575 SWIG_fail;
6576 }
6577 }
6578 }
6579 {
6580 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6581 if (PyErr_Occurred()) {
6582 SWIG_fail;
6583 }
6584 }
6585 {
6586 arg3 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_output_unified", "original_path");
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 {
6590 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_output_unified", "modified_path");
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 {
6594 arg5 = svn_swig_py_string_to_cstring(obj4, TRUE, "svn_diff_file_output_unified", "original_header");
6595 if (PyErr_Occurred()) SWIG_fail;
6596 }
6597 {
6598 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_file_output_unified", "modified_header");
6599 if (PyErr_Occurred()) SWIG_fail;
6600 }
6601 if (obj6) {
6602 /* Verify that the user supplied a valid pool */
6603 if (obj6 != Py_None && obj6 != _global_py_pool) {
6604 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
6605 SWIG_arg_fail(svn_argnum_obj6);
6606 SWIG_fail;
6607 }
6608 }
6609 {
6610 svn_swig_py_release_py_lock();
6611
6612 result = (svn_error_t *)svn_diff_file_output_unified(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,arg7);
6613
6614 svn_swig_py_acquire_py_lock();
6615
6616 }
6617 {
6618 if (result != NULL) {
6619 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
6620 svn_swig_py_svn_exception(result);
6621 else
6622 svn_error_clear(result);
6623 SWIG_fail;
6624 }
6625 Py_INCREF(Py_None);
6626 resultobj = Py_None;
6627 }
6628 {
6629 Py_XDECREF(_global_py_pool);
6630 }
6631 return resultobj;
6632 fail:
6633 {
6634 Py_XDECREF(_global_py_pool);
6635 }
6636 return NULL;
6637 }
6638
6639
_wrap_svn_diff_file_output_merge3(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6640 SWIGINTERN PyObject *_wrap_svn_diff_file_output_merge3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6641 PyObject *resultobj = 0;
6642 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6643 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
6644 char *arg3 = (char *) 0 ;
6645 char *arg4 = (char *) 0 ;
6646 char *arg5 = (char *) 0 ;
6647 char *arg6 = (char *) 0 ;
6648 char *arg7 = (char *) 0 ;
6649 char *arg8 = (char *) 0 ;
6650 char *arg9 = (char *) 0 ;
6651 svn_diff_conflict_display_style_t arg10 ;
6652 svn_cancel_func_t arg11 = (svn_cancel_func_t) 0 ;
6653 void *arg12 = (void *) 0 ;
6654 apr_pool_t *arg13 = (apr_pool_t *) 0 ;
6655 apr_pool_t *_global_pool = NULL ;
6656 PyObject *_global_py_pool = NULL ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 PyObject * obj2 = 0 ;
6660 PyObject * obj3 = 0 ;
6661 PyObject * obj4 = 0 ;
6662 PyObject * obj5 = 0 ;
6663 PyObject * obj6 = 0 ;
6664 PyObject * obj7 = 0 ;
6665 PyObject * obj8 = 0 ;
6666 PyObject * obj9 = 0 ;
6667 PyObject * obj10 = 0 ;
6668 PyObject * obj11 = 0 ;
6669 svn_error_t *result = 0 ;
6670
6671 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6672 &_global_py_pool, &_global_pool))
6673 SWIG_fail;
6674 arg13 = _global_pool;
6675 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_output_merge3",11,12,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
6676 {
6677 if (obj0 == Py_None) {
6678 arg1 = NULL;
6679 }
6680 else {
6681 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6682 if (arg1 == NULL) {
6683 SWIG_fail;
6684 }
6685 }
6686 }
6687 {
6688 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6689 if (PyErr_Occurred()) {
6690 SWIG_fail;
6691 }
6692 }
6693 {
6694 arg3 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_output_merge3", "original_path");
6695 if (PyErr_Occurred()) SWIG_fail;
6696 }
6697 {
6698 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_output_merge3", "modified_path");
6699 if (PyErr_Occurred()) SWIG_fail;
6700 }
6701 {
6702 arg5 = svn_swig_py_string_to_cstring(obj4, FALSE, "svn_diff_file_output_merge3", "latest_path");
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 {
6706 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_file_output_merge3", "conflict_original");
6707 if (PyErr_Occurred()) SWIG_fail;
6708 }
6709 {
6710 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_file_output_merge3", "conflict_modified");
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 {
6714 arg8 = svn_swig_py_string_to_cstring(obj7, TRUE, "svn_diff_file_output_merge3", "conflict_latest");
6715 if (PyErr_Occurred()) SWIG_fail;
6716 }
6717 {
6718 arg9 = svn_swig_py_string_to_cstring(obj8, TRUE, "svn_diff_file_output_merge3", "conflict_separator");
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 {
6722 arg10 = (svn_diff_conflict_display_style_t)SWIG_As_long (obj9);
6723 if (SWIG_arg_fail(svn_argnum_obj9)) {
6724 SWIG_fail;
6725 }
6726 }
6727 {
6728 arg11 = (svn_cancel_func_t) svn_swig_py_cancel_func;
6729 arg12 = obj10;
6730 }
6731 if (obj11) {
6732 /* Verify that the user supplied a valid pool */
6733 if (obj11 != Py_None && obj11 != _global_py_pool) {
6734 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
6735 SWIG_arg_fail(svn_argnum_obj11);
6736 SWIG_fail;
6737 }
6738 }
6739 {
6740 svn_swig_py_release_py_lock();
6741
6742 result = (svn_error_t *)svn_diff_file_output_merge3(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,(char const *)arg9,arg10,arg11,arg12,arg13);
6743
6744 svn_swig_py_acquire_py_lock();
6745
6746 }
6747 {
6748 if (result != NULL) {
6749 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
6750 svn_swig_py_svn_exception(result);
6751 else
6752 svn_error_clear(result);
6753 SWIG_fail;
6754 }
6755 Py_INCREF(Py_None);
6756 resultobj = Py_None;
6757 }
6758 {
6759 Py_XDECREF(_global_py_pool);
6760 }
6761 return resultobj;
6762 fail:
6763 {
6764 Py_XDECREF(_global_py_pool);
6765 }
6766 return NULL;
6767 }
6768
6769
_wrap_svn_diff_file_output_merge2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6770 SWIGINTERN PyObject *_wrap_svn_diff_file_output_merge2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 PyObject *resultobj = 0;
6772 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6773 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
6774 char *arg3 = (char *) 0 ;
6775 char *arg4 = (char *) 0 ;
6776 char *arg5 = (char *) 0 ;
6777 char *arg6 = (char *) 0 ;
6778 char *arg7 = (char *) 0 ;
6779 char *arg8 = (char *) 0 ;
6780 char *arg9 = (char *) 0 ;
6781 svn_diff_conflict_display_style_t arg10 ;
6782 apr_pool_t *arg11 = (apr_pool_t *) 0 ;
6783 apr_pool_t *_global_pool = NULL ;
6784 PyObject *_global_py_pool = NULL ;
6785 PyObject * obj0 = 0 ;
6786 PyObject * obj1 = 0 ;
6787 PyObject * obj2 = 0 ;
6788 PyObject * obj3 = 0 ;
6789 PyObject * obj4 = 0 ;
6790 PyObject * obj5 = 0 ;
6791 PyObject * obj6 = 0 ;
6792 PyObject * obj7 = 0 ;
6793 PyObject * obj8 = 0 ;
6794 PyObject * obj9 = 0 ;
6795 PyObject * obj10 = 0 ;
6796 svn_error_t *result = 0 ;
6797
6798 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6799 &_global_py_pool, &_global_pool))
6800 SWIG_fail;
6801 arg11 = _global_pool;
6802 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_output_merge2",10,11,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
6803 {
6804 if (obj0 == Py_None) {
6805 arg1 = NULL;
6806 }
6807 else {
6808 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6809 if (arg1 == NULL) {
6810 SWIG_fail;
6811 }
6812 }
6813 }
6814 {
6815 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6816 if (PyErr_Occurred()) {
6817 SWIG_fail;
6818 }
6819 }
6820 {
6821 arg3 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_output_merge2", "original_path");
6822 if (PyErr_Occurred()) SWIG_fail;
6823 }
6824 {
6825 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_output_merge2", "modified_path");
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 {
6829 arg5 = svn_swig_py_string_to_cstring(obj4, FALSE, "svn_diff_file_output_merge2", "latest_path");
6830 if (PyErr_Occurred()) SWIG_fail;
6831 }
6832 {
6833 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_file_output_merge2", "conflict_original");
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 {
6837 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_file_output_merge2", "conflict_modified");
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 {
6841 arg8 = svn_swig_py_string_to_cstring(obj7, TRUE, "svn_diff_file_output_merge2", "conflict_latest");
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 {
6845 arg9 = svn_swig_py_string_to_cstring(obj8, TRUE, "svn_diff_file_output_merge2", "conflict_separator");
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 {
6849 arg10 = (svn_diff_conflict_display_style_t)SWIG_As_long (obj9);
6850 if (SWIG_arg_fail(svn_argnum_obj9)) {
6851 SWIG_fail;
6852 }
6853 }
6854 if (obj10) {
6855 /* Verify that the user supplied a valid pool */
6856 if (obj10 != Py_None && obj10 != _global_py_pool) {
6857 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj10);
6858 SWIG_arg_fail(svn_argnum_obj10);
6859 SWIG_fail;
6860 }
6861 }
6862 {
6863 svn_swig_py_release_py_lock();
6864
6865 result = (svn_error_t *)svn_diff_file_output_merge2(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,(char const *)arg9,arg10,arg11);
6866
6867 svn_swig_py_acquire_py_lock();
6868
6869 }
6870 {
6871 if (result != NULL) {
6872 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
6873 svn_swig_py_svn_exception(result);
6874 else
6875 svn_error_clear(result);
6876 SWIG_fail;
6877 }
6878 Py_INCREF(Py_None);
6879 resultobj = Py_None;
6880 }
6881 {
6882 Py_XDECREF(_global_py_pool);
6883 }
6884 return resultobj;
6885 fail:
6886 {
6887 Py_XDECREF(_global_py_pool);
6888 }
6889 return NULL;
6890 }
6891
6892
_wrap_svn_diff_file_output_merge(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6893 SWIGINTERN PyObject *_wrap_svn_diff_file_output_merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6894 PyObject *resultobj = 0;
6895 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6896 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
6897 char *arg3 = (char *) 0 ;
6898 char *arg4 = (char *) 0 ;
6899 char *arg5 = (char *) 0 ;
6900 char *arg6 = (char *) 0 ;
6901 char *arg7 = (char *) 0 ;
6902 char *arg8 = (char *) 0 ;
6903 char *arg9 = (char *) 0 ;
6904 svn_boolean_t arg10 ;
6905 svn_boolean_t arg11 ;
6906 apr_pool_t *arg12 = (apr_pool_t *) 0 ;
6907 apr_pool_t *_global_pool = NULL ;
6908 PyObject *_global_py_pool = NULL ;
6909 PyObject * obj0 = 0 ;
6910 PyObject * obj1 = 0 ;
6911 PyObject * obj2 = 0 ;
6912 PyObject * obj3 = 0 ;
6913 PyObject * obj4 = 0 ;
6914 PyObject * obj5 = 0 ;
6915 PyObject * obj6 = 0 ;
6916 PyObject * obj7 = 0 ;
6917 PyObject * obj8 = 0 ;
6918 PyObject * obj9 = 0 ;
6919 PyObject * obj10 = 0 ;
6920 PyObject * obj11 = 0 ;
6921 svn_error_t *result = 0 ;
6922
6923 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
6924 &_global_py_pool, &_global_pool))
6925 SWIG_fail;
6926 arg12 = _global_pool;
6927 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_file_output_merge",11,12,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
6928 {
6929 if (obj0 == Py_None) {
6930 arg1 = NULL;
6931 }
6932 else {
6933 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6934 if (arg1 == NULL) {
6935 SWIG_fail;
6936 }
6937 }
6938 }
6939 {
6940 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6941 if (PyErr_Occurred()) {
6942 SWIG_fail;
6943 }
6944 }
6945 {
6946 arg3 = svn_swig_py_string_to_cstring(obj2, FALSE, "svn_diff_file_output_merge", "original_path");
6947 if (PyErr_Occurred()) SWIG_fail;
6948 }
6949 {
6950 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_file_output_merge", "modified_path");
6951 if (PyErr_Occurred()) SWIG_fail;
6952 }
6953 {
6954 arg5 = svn_swig_py_string_to_cstring(obj4, FALSE, "svn_diff_file_output_merge", "latest_path");
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 {
6958 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_file_output_merge", "conflict_original");
6959 if (PyErr_Occurred()) SWIG_fail;
6960 }
6961 {
6962 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_file_output_merge", "conflict_modified");
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 {
6966 arg8 = svn_swig_py_string_to_cstring(obj7, TRUE, "svn_diff_file_output_merge", "conflict_latest");
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 {
6970 arg9 = svn_swig_py_string_to_cstring(obj8, TRUE, "svn_diff_file_output_merge", "conflict_separator");
6971 if (PyErr_Occurred()) SWIG_fail;
6972 }
6973 {
6974 arg10 = (svn_boolean_t)SWIG_As_long (obj9);
6975 if (SWIG_arg_fail(svn_argnum_obj9)) {
6976 SWIG_fail;
6977 }
6978 }
6979 {
6980 arg11 = (svn_boolean_t)SWIG_As_long (obj10);
6981 if (SWIG_arg_fail(svn_argnum_obj10)) {
6982 SWIG_fail;
6983 }
6984 }
6985 if (obj11) {
6986 /* Verify that the user supplied a valid pool */
6987 if (obj11 != Py_None && obj11 != _global_py_pool) {
6988 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
6989 SWIG_arg_fail(svn_argnum_obj11);
6990 SWIG_fail;
6991 }
6992 }
6993 {
6994 svn_swig_py_release_py_lock();
6995
6996 result = (svn_error_t *)svn_diff_file_output_merge(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,(char const *)arg9,arg10,arg11,arg12);
6997
6998 svn_swig_py_acquire_py_lock();
6999
7000 }
7001 {
7002 if (result != NULL) {
7003 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
7004 svn_swig_py_svn_exception(result);
7005 else
7006 svn_error_clear(result);
7007 SWIG_fail;
7008 }
7009 Py_INCREF(Py_None);
7010 resultobj = Py_None;
7011 }
7012 {
7013 Py_XDECREF(_global_py_pool);
7014 }
7015 return resultobj;
7016 fail:
7017 {
7018 Py_XDECREF(_global_py_pool);
7019 }
7020 return NULL;
7021 }
7022
7023
_wrap_svn_diff_output_binary(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7024 SWIGINTERN PyObject *_wrap_svn_diff_output_binary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7025 PyObject *resultobj = 0;
7026 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
7027 svn_stream_t *arg2 = (svn_stream_t *) 0 ;
7028 svn_stream_t *arg3 = (svn_stream_t *) 0 ;
7029 svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
7030 void *arg5 = (void *) 0 ;
7031 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
7032 apr_pool_t *_global_pool = NULL ;
7033 PyObject *_global_py_pool = NULL ;
7034 PyObject * obj0 = 0 ;
7035 PyObject * obj1 = 0 ;
7036 PyObject * obj2 = 0 ;
7037 PyObject * obj3 = 0 ;
7038 PyObject * obj4 = 0 ;
7039 svn_error_t *result = 0 ;
7040
7041 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
7042 &_global_py_pool, &_global_pool))
7043 SWIG_fail;
7044 arg6 = _global_pool;
7045 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_binary",4,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7046 {
7047 if (obj0 == Py_None) {
7048 arg1 = NULL;
7049 }
7050 else {
7051 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
7052 if (arg1 == NULL) {
7053 SWIG_fail;
7054 }
7055 }
7056 }
7057 {
7058 if (obj1 == Py_None) {
7059 arg2 = NULL;
7060 }
7061 else {
7062 arg2 = svn_swig_py_make_stream (obj1, _global_pool);
7063 if (arg2 == NULL) {
7064 SWIG_fail;
7065 }
7066 }
7067 }
7068 {
7069 if (obj2 == Py_None) {
7070 arg3 = NULL;
7071 }
7072 else {
7073 arg3 = svn_swig_py_make_stream (obj2, _global_pool);
7074 if (arg3 == NULL) {
7075 SWIG_fail;
7076 }
7077 }
7078 }
7079 {
7080 arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
7081 arg5 = obj3;
7082 }
7083 if (obj4) {
7084 /* Verify that the user supplied a valid pool */
7085 if (obj4 != Py_None && obj4 != _global_py_pool) {
7086 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
7087 SWIG_arg_fail(svn_argnum_obj4);
7088 SWIG_fail;
7089 }
7090 }
7091 {
7092 svn_swig_py_release_py_lock();
7093
7094 result = (svn_error_t *)svn_diff_output_binary(arg1,arg2,arg3,arg4,arg5,arg6);
7095
7096 svn_swig_py_acquire_py_lock();
7097
7098 }
7099 {
7100 if (result != NULL) {
7101 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
7102 svn_swig_py_svn_exception(result);
7103 else
7104 svn_error_clear(result);
7105 SWIG_fail;
7106 }
7107 Py_INCREF(Py_None);
7108 resultobj = Py_None;
7109 }
7110 {
7111 Py_XDECREF(_global_py_pool);
7112 }
7113 return resultobj;
7114 fail:
7115 {
7116 Py_XDECREF(_global_py_pool);
7117 }
7118 return NULL;
7119 }
7120
7121
_wrap_svn_diff_mem_string_diff(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7122 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7123 PyObject *resultobj = 0;
7124 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
7125 svn_string_t *arg2 = (svn_string_t *) 0 ;
7126 svn_string_t *arg3 = (svn_string_t *) 0 ;
7127 svn_diff_file_options_t *arg4 = (svn_diff_file_options_t *) 0 ;
7128 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
7129 apr_pool_t *_global_pool = NULL ;
7130 PyObject *_global_py_pool = NULL ;
7131 svn_diff_t *temp1 ;
7132 svn_string_t value2 ;
7133 svn_string_t value3 ;
7134 PyObject * obj0 = 0 ;
7135 PyObject * obj1 = 0 ;
7136 PyObject * obj2 = 0 ;
7137 PyObject * obj3 = 0 ;
7138 svn_error_t *result = 0 ;
7139
7140 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
7141 &_global_py_pool, &_global_pool))
7142 SWIG_fail;
7143 arg5 = _global_pool;
7144 arg1 = &temp1;
7145 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_diff",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7146 {
7147 if (obj0 == Py_None)
7148 arg2 = NULL;
7149 else {
7150 Py_ssize_t pyStrLen;
7151 if (!PyBytes_Check(obj0)) {
7152 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7153 SWIG_fail;
7154 }
7155 if (PyBytes_AsStringAndSize(obj0, (char **)&(value2.data),
7156 &pyStrLen) == -1) {
7157 SWIG_fail;
7158 }
7159 value2.len = pyStrLen;
7160 arg2 = &value2;
7161 }
7162 }
7163 {
7164 if (obj1 == Py_None)
7165 arg3 = NULL;
7166 else {
7167 Py_ssize_t pyStrLen;
7168 if (!PyBytes_Check(obj1)) {
7169 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7170 SWIG_fail;
7171 }
7172 if (PyBytes_AsStringAndSize(obj1, (char **)&(value3.data),
7173 &pyStrLen) == -1) {
7174 SWIG_fail;
7175 }
7176 value3.len = pyStrLen;
7177 arg3 = &value3;
7178 }
7179 }
7180 {
7181 arg4 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj2);
7182 if (PyErr_Occurred()) {
7183 SWIG_fail;
7184 }
7185 }
7186 if (obj3) {
7187 /* Verify that the user supplied a valid pool */
7188 if (obj3 != Py_None && obj3 != _global_py_pool) {
7189 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
7190 SWIG_arg_fail(svn_argnum_obj3);
7191 SWIG_fail;
7192 }
7193 }
7194 {
7195 svn_swig_py_release_py_lock();
7196
7197 result = (svn_error_t *)svn_diff_mem_string_diff(arg1,(struct svn_string_t const *)arg2,(struct svn_string_t const *)arg3,(struct svn_diff_file_options_t const *)arg4,arg5);
7198
7199 svn_swig_py_acquire_py_lock();
7200
7201 }
7202 {
7203 if (result != NULL) {
7204 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
7205 svn_swig_py_svn_exception(result);
7206 else
7207 svn_error_clear(result);
7208 SWIG_fail;
7209 }
7210 Py_INCREF(Py_None);
7211 resultobj = Py_None;
7212 }
7213 {
7214 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
7215 _global_py_pool, args))
7216
7217 ;
7218 }
7219 {
7220 Py_XDECREF(_global_py_pool);
7221 }
7222 return resultobj;
7223 fail:
7224 {
7225 Py_XDECREF(_global_py_pool);
7226 }
7227 return NULL;
7228 }
7229
7230
_wrap_svn_diff_mem_string_diff3(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7231 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_diff3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7232 PyObject *resultobj = 0;
7233 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
7234 svn_string_t *arg2 = (svn_string_t *) 0 ;
7235 svn_string_t *arg3 = (svn_string_t *) 0 ;
7236 svn_string_t *arg4 = (svn_string_t *) 0 ;
7237 svn_diff_file_options_t *arg5 = (svn_diff_file_options_t *) 0 ;
7238 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
7239 apr_pool_t *_global_pool = NULL ;
7240 PyObject *_global_py_pool = NULL ;
7241 svn_diff_t *temp1 ;
7242 svn_string_t value2 ;
7243 svn_string_t value3 ;
7244 svn_string_t value4 ;
7245 PyObject * obj0 = 0 ;
7246 PyObject * obj1 = 0 ;
7247 PyObject * obj2 = 0 ;
7248 PyObject * obj3 = 0 ;
7249 PyObject * obj4 = 0 ;
7250 svn_error_t *result = 0 ;
7251
7252 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
7253 &_global_py_pool, &_global_pool))
7254 SWIG_fail;
7255 arg6 = _global_pool;
7256 arg1 = &temp1;
7257 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_diff3",4,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7258 {
7259 if (obj0 == Py_None)
7260 arg2 = NULL;
7261 else {
7262 Py_ssize_t pyStrLen;
7263 if (!PyBytes_Check(obj0)) {
7264 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7265 SWIG_fail;
7266 }
7267 if (PyBytes_AsStringAndSize(obj0, (char **)&(value2.data),
7268 &pyStrLen) == -1) {
7269 SWIG_fail;
7270 }
7271 value2.len = pyStrLen;
7272 arg2 = &value2;
7273 }
7274 }
7275 {
7276 if (obj1 == Py_None)
7277 arg3 = NULL;
7278 else {
7279 Py_ssize_t pyStrLen;
7280 if (!PyBytes_Check(obj1)) {
7281 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7282 SWIG_fail;
7283 }
7284 if (PyBytes_AsStringAndSize(obj1, (char **)&(value3.data),
7285 &pyStrLen) == -1) {
7286 SWIG_fail;
7287 }
7288 value3.len = pyStrLen;
7289 arg3 = &value3;
7290 }
7291 }
7292 {
7293 if (obj2 == Py_None)
7294 arg4 = NULL;
7295 else {
7296 Py_ssize_t pyStrLen;
7297 if (!PyBytes_Check(obj2)) {
7298 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7299 SWIG_fail;
7300 }
7301 if (PyBytes_AsStringAndSize(obj2, (char **)&(value4.data),
7302 &pyStrLen) == -1) {
7303 SWIG_fail;
7304 }
7305 value4.len = pyStrLen;
7306 arg4 = &value4;
7307 }
7308 }
7309 {
7310 arg5 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj3);
7311 if (PyErr_Occurred()) {
7312 SWIG_fail;
7313 }
7314 }
7315 if (obj4) {
7316 /* Verify that the user supplied a valid pool */
7317 if (obj4 != Py_None && obj4 != _global_py_pool) {
7318 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
7319 SWIG_arg_fail(svn_argnum_obj4);
7320 SWIG_fail;
7321 }
7322 }
7323 {
7324 svn_swig_py_release_py_lock();
7325
7326 result = (svn_error_t *)svn_diff_mem_string_diff3(arg1,(struct svn_string_t const *)arg2,(struct svn_string_t const *)arg3,(struct svn_string_t const *)arg4,(struct svn_diff_file_options_t const *)arg5,arg6);
7327
7328 svn_swig_py_acquire_py_lock();
7329
7330 }
7331 {
7332 if (result != NULL) {
7333 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
7334 svn_swig_py_svn_exception(result);
7335 else
7336 svn_error_clear(result);
7337 SWIG_fail;
7338 }
7339 Py_INCREF(Py_None);
7340 resultobj = Py_None;
7341 }
7342 {
7343 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
7344 _global_py_pool, args))
7345
7346 ;
7347 }
7348 {
7349 Py_XDECREF(_global_py_pool);
7350 }
7351 return resultobj;
7352 fail:
7353 {
7354 Py_XDECREF(_global_py_pool);
7355 }
7356 return NULL;
7357 }
7358
7359
_wrap_svn_diff_mem_string_diff4(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7360 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_diff4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7361 PyObject *resultobj = 0;
7362 svn_diff_t **arg1 = (svn_diff_t **) 0 ;
7363 svn_string_t *arg2 = (svn_string_t *) 0 ;
7364 svn_string_t *arg3 = (svn_string_t *) 0 ;
7365 svn_string_t *arg4 = (svn_string_t *) 0 ;
7366 svn_string_t *arg5 = (svn_string_t *) 0 ;
7367 svn_diff_file_options_t *arg6 = (svn_diff_file_options_t *) 0 ;
7368 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
7369 apr_pool_t *_global_pool = NULL ;
7370 PyObject *_global_py_pool = NULL ;
7371 svn_diff_t *temp1 ;
7372 svn_string_t value2 ;
7373 svn_string_t value3 ;
7374 svn_string_t value4 ;
7375 svn_string_t value5 ;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 PyObject * obj2 = 0 ;
7379 PyObject * obj3 = 0 ;
7380 PyObject * obj4 = 0 ;
7381 PyObject * obj5 = 0 ;
7382 svn_error_t *result = 0 ;
7383
7384 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
7385 &_global_py_pool, &_global_pool))
7386 SWIG_fail;
7387 arg7 = _global_pool;
7388 arg1 = &temp1;
7389 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_diff4",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
7390 {
7391 if (obj0 == Py_None)
7392 arg2 = NULL;
7393 else {
7394 Py_ssize_t pyStrLen;
7395 if (!PyBytes_Check(obj0)) {
7396 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7397 SWIG_fail;
7398 }
7399 if (PyBytes_AsStringAndSize(obj0, (char **)&(value2.data),
7400 &pyStrLen) == -1) {
7401 SWIG_fail;
7402 }
7403 value2.len = pyStrLen;
7404 arg2 = &value2;
7405 }
7406 }
7407 {
7408 if (obj1 == Py_None)
7409 arg3 = NULL;
7410 else {
7411 Py_ssize_t pyStrLen;
7412 if (!PyBytes_Check(obj1)) {
7413 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7414 SWIG_fail;
7415 }
7416 if (PyBytes_AsStringAndSize(obj1, (char **)&(value3.data),
7417 &pyStrLen) == -1) {
7418 SWIG_fail;
7419 }
7420 value3.len = pyStrLen;
7421 arg3 = &value3;
7422 }
7423 }
7424 {
7425 if (obj2 == Py_None)
7426 arg4 = NULL;
7427 else {
7428 Py_ssize_t pyStrLen;
7429 if (!PyBytes_Check(obj2)) {
7430 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7431 SWIG_fail;
7432 }
7433 if (PyBytes_AsStringAndSize(obj2, (char **)&(value4.data),
7434 &pyStrLen) == -1) {
7435 SWIG_fail;
7436 }
7437 value4.len = pyStrLen;
7438 arg4 = &value4;
7439 }
7440 }
7441 {
7442 if (obj3 == Py_None)
7443 arg5 = NULL;
7444 else {
7445 Py_ssize_t pyStrLen;
7446 if (!PyBytes_Check(obj3)) {
7447 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7448 SWIG_fail;
7449 }
7450 if (PyBytes_AsStringAndSize(obj3, (char **)&(value5.data),
7451 &pyStrLen) == -1) {
7452 SWIG_fail;
7453 }
7454 value5.len = pyStrLen;
7455 arg5 = &value5;
7456 }
7457 }
7458 {
7459 arg6 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj4);
7460 if (PyErr_Occurred()) {
7461 SWIG_fail;
7462 }
7463 }
7464 if (obj5) {
7465 /* Verify that the user supplied a valid pool */
7466 if (obj5 != Py_None && obj5 != _global_py_pool) {
7467 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
7468 SWIG_arg_fail(svn_argnum_obj5);
7469 SWIG_fail;
7470 }
7471 }
7472 {
7473 svn_swig_py_release_py_lock();
7474
7475 result = (svn_error_t *)svn_diff_mem_string_diff4(arg1,(struct svn_string_t const *)arg2,(struct svn_string_t const *)arg3,(struct svn_string_t const *)arg4,(struct svn_string_t const *)arg5,(struct svn_diff_file_options_t const *)arg6,arg7);
7476
7477 svn_swig_py_acquire_py_lock();
7478
7479 }
7480 {
7481 if (result != NULL) {
7482 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
7483 svn_swig_py_svn_exception(result);
7484 else
7485 svn_error_clear(result);
7486 SWIG_fail;
7487 }
7488 Py_INCREF(Py_None);
7489 resultobj = Py_None;
7490 }
7491 {
7492 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
7493 _global_py_pool, args))
7494
7495 ;
7496 }
7497 {
7498 Py_XDECREF(_global_py_pool);
7499 }
7500 return resultobj;
7501 fail:
7502 {
7503 Py_XDECREF(_global_py_pool);
7504 }
7505 return NULL;
7506 }
7507
7508
_wrap_svn_diff_mem_string_output_unified3(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7509 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_unified3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7510 PyObject *resultobj = 0;
7511 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
7512 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
7513 svn_boolean_t arg3 ;
7514 char *arg4 = (char *) 0 ;
7515 char *arg5 = (char *) 0 ;
7516 char *arg6 = (char *) 0 ;
7517 char *arg7 = (char *) 0 ;
7518 svn_string_t *arg8 = (svn_string_t *) 0 ;
7519 svn_string_t *arg9 = (svn_string_t *) 0 ;
7520 int arg10 ;
7521 svn_cancel_func_t arg11 = (svn_cancel_func_t) 0 ;
7522 void *arg12 = (void *) 0 ;
7523 apr_pool_t *arg13 = (apr_pool_t *) 0 ;
7524 apr_pool_t *_global_pool = NULL ;
7525 PyObject *_global_py_pool = NULL ;
7526 svn_string_t value8 ;
7527 svn_string_t value9 ;
7528 PyObject * obj0 = 0 ;
7529 PyObject * obj1 = 0 ;
7530 PyObject * obj2 = 0 ;
7531 PyObject * obj3 = 0 ;
7532 PyObject * obj4 = 0 ;
7533 PyObject * obj5 = 0 ;
7534 PyObject * obj6 = 0 ;
7535 PyObject * obj7 = 0 ;
7536 PyObject * obj8 = 0 ;
7537 PyObject * obj9 = 0 ;
7538 PyObject * obj10 = 0 ;
7539 PyObject * obj11 = 0 ;
7540 svn_error_t *result = 0 ;
7541
7542 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
7543 &_global_py_pool, &_global_pool))
7544 SWIG_fail;
7545 arg13 = _global_pool;
7546 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_output_unified3",11,12,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
7547 {
7548 if (obj0 == Py_None) {
7549 arg1 = NULL;
7550 }
7551 else {
7552 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
7553 if (arg1 == NULL) {
7554 SWIG_fail;
7555 }
7556 }
7557 }
7558 {
7559 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
7560 if (PyErr_Occurred()) {
7561 SWIG_fail;
7562 }
7563 }
7564 {
7565 arg3 = (svn_boolean_t)SWIG_As_long (obj2);
7566 if (SWIG_arg_fail(svn_argnum_obj2)) {
7567 SWIG_fail;
7568 }
7569 }
7570 {
7571 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_mem_string_output_unified3", "hunk_delimiter");
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 arg5 = svn_swig_py_string_to_cstring(obj4, TRUE, "svn_diff_mem_string_output_unified3", "original_header");
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 {
7579 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_mem_string_output_unified3", "modified_header");
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 {
7583 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_mem_string_output_unified3", "header_encoding");
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 {
7587 if (obj7 == Py_None)
7588 arg8 = NULL;
7589 else {
7590 Py_ssize_t pyStrLen;
7591 if (!PyBytes_Check(obj7)) {
7592 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7593 SWIG_fail;
7594 }
7595 if (PyBytes_AsStringAndSize(obj7, (char **)&(value8.data),
7596 &pyStrLen) == -1) {
7597 SWIG_fail;
7598 }
7599 value8.len = pyStrLen;
7600 arg8 = &value8;
7601 }
7602 }
7603 {
7604 if (obj8 == Py_None)
7605 arg9 = NULL;
7606 else {
7607 Py_ssize_t pyStrLen;
7608 if (!PyBytes_Check(obj8)) {
7609 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7610 SWIG_fail;
7611 }
7612 if (PyBytes_AsStringAndSize(obj8, (char **)&(value9.data),
7613 &pyStrLen) == -1) {
7614 SWIG_fail;
7615 }
7616 value9.len = pyStrLen;
7617 arg9 = &value9;
7618 }
7619 }
7620 {
7621 arg10 = (int)SWIG_As_long (obj9);
7622 if (SWIG_arg_fail(svn_argnum_obj9)) {
7623 SWIG_fail;
7624 }
7625 }
7626 {
7627 arg11 = (svn_cancel_func_t) svn_swig_py_cancel_func;
7628 arg12 = obj10;
7629 }
7630 if (obj11) {
7631 /* Verify that the user supplied a valid pool */
7632 if (obj11 != Py_None && obj11 != _global_py_pool) {
7633 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
7634 SWIG_arg_fail(svn_argnum_obj11);
7635 SWIG_fail;
7636 }
7637 }
7638 {
7639 svn_swig_py_release_py_lock();
7640
7641 result = (svn_error_t *)svn_diff_mem_string_output_unified3(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(struct svn_string_t const *)arg8,(struct svn_string_t const *)arg9,arg10,arg11,arg12,arg13);
7642
7643 svn_swig_py_acquire_py_lock();
7644
7645 }
7646 {
7647 if (result != NULL) {
7648 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
7649 svn_swig_py_svn_exception(result);
7650 else
7651 svn_error_clear(result);
7652 SWIG_fail;
7653 }
7654 Py_INCREF(Py_None);
7655 resultobj = Py_None;
7656 }
7657 {
7658 Py_XDECREF(_global_py_pool);
7659 }
7660 return resultobj;
7661 fail:
7662 {
7663 Py_XDECREF(_global_py_pool);
7664 }
7665 return NULL;
7666 }
7667
7668
_wrap_svn_diff_mem_string_output_unified2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7669 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_unified2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7670 PyObject *resultobj = 0;
7671 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
7672 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
7673 svn_boolean_t arg3 ;
7674 char *arg4 = (char *) 0 ;
7675 char *arg5 = (char *) 0 ;
7676 char *arg6 = (char *) 0 ;
7677 char *arg7 = (char *) 0 ;
7678 svn_string_t *arg8 = (svn_string_t *) 0 ;
7679 svn_string_t *arg9 = (svn_string_t *) 0 ;
7680 apr_pool_t *arg10 = (apr_pool_t *) 0 ;
7681 apr_pool_t *_global_pool = NULL ;
7682 PyObject *_global_py_pool = NULL ;
7683 svn_string_t value8 ;
7684 svn_string_t value9 ;
7685 PyObject * obj0 = 0 ;
7686 PyObject * obj1 = 0 ;
7687 PyObject * obj2 = 0 ;
7688 PyObject * obj3 = 0 ;
7689 PyObject * obj4 = 0 ;
7690 PyObject * obj5 = 0 ;
7691 PyObject * obj6 = 0 ;
7692 PyObject * obj7 = 0 ;
7693 PyObject * obj8 = 0 ;
7694 PyObject * obj9 = 0 ;
7695 svn_error_t *result = 0 ;
7696
7697 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
7698 &_global_py_pool, &_global_pool))
7699 SWIG_fail;
7700 arg10 = _global_pool;
7701 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_output_unified2",9,10,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
7702 {
7703 if (obj0 == Py_None) {
7704 arg1 = NULL;
7705 }
7706 else {
7707 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
7708 if (arg1 == NULL) {
7709 SWIG_fail;
7710 }
7711 }
7712 }
7713 {
7714 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
7715 if (PyErr_Occurred()) {
7716 SWIG_fail;
7717 }
7718 }
7719 {
7720 arg3 = (svn_boolean_t)SWIG_As_long (obj2);
7721 if (SWIG_arg_fail(svn_argnum_obj2)) {
7722 SWIG_fail;
7723 }
7724 }
7725 {
7726 arg4 = svn_swig_py_string_to_cstring(obj3, FALSE, "svn_diff_mem_string_output_unified2", "hunk_delimiter");
7727 if (PyErr_Occurred()) SWIG_fail;
7728 }
7729 {
7730 arg5 = svn_swig_py_string_to_cstring(obj4, TRUE, "svn_diff_mem_string_output_unified2", "original_header");
7731 if (PyErr_Occurred()) SWIG_fail;
7732 }
7733 {
7734 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_mem_string_output_unified2", "modified_header");
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 {
7738 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_mem_string_output_unified2", "header_encoding");
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 {
7742 if (obj7 == Py_None)
7743 arg8 = NULL;
7744 else {
7745 Py_ssize_t pyStrLen;
7746 if (!PyBytes_Check(obj7)) {
7747 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7748 SWIG_fail;
7749 }
7750 if (PyBytes_AsStringAndSize(obj7, (char **)&(value8.data),
7751 &pyStrLen) == -1) {
7752 SWIG_fail;
7753 }
7754 value8.len = pyStrLen;
7755 arg8 = &value8;
7756 }
7757 }
7758 {
7759 if (obj8 == Py_None)
7760 arg9 = NULL;
7761 else {
7762 Py_ssize_t pyStrLen;
7763 if (!PyBytes_Check(obj8)) {
7764 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7765 SWIG_fail;
7766 }
7767 if (PyBytes_AsStringAndSize(obj8, (char **)&(value9.data),
7768 &pyStrLen) == -1) {
7769 SWIG_fail;
7770 }
7771 value9.len = pyStrLen;
7772 arg9 = &value9;
7773 }
7774 }
7775 if (obj9) {
7776 /* Verify that the user supplied a valid pool */
7777 if (obj9 != Py_None && obj9 != _global_py_pool) {
7778 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj9);
7779 SWIG_arg_fail(svn_argnum_obj9);
7780 SWIG_fail;
7781 }
7782 }
7783 {
7784 svn_swig_py_release_py_lock();
7785
7786 result = (svn_error_t *)svn_diff_mem_string_output_unified2(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(struct svn_string_t const *)arg8,(struct svn_string_t const *)arg9,arg10);
7787
7788 svn_swig_py_acquire_py_lock();
7789
7790 }
7791 {
7792 if (result != NULL) {
7793 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
7794 svn_swig_py_svn_exception(result);
7795 else
7796 svn_error_clear(result);
7797 SWIG_fail;
7798 }
7799 Py_INCREF(Py_None);
7800 resultobj = Py_None;
7801 }
7802 {
7803 Py_XDECREF(_global_py_pool);
7804 }
7805 return resultobj;
7806 fail:
7807 {
7808 Py_XDECREF(_global_py_pool);
7809 }
7810 return NULL;
7811 }
7812
7813
_wrap_svn_diff_mem_string_output_unified(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7814 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_unified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7815 PyObject *resultobj = 0;
7816 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
7817 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
7818 char *arg3 = (char *) 0 ;
7819 char *arg4 = (char *) 0 ;
7820 char *arg5 = (char *) 0 ;
7821 svn_string_t *arg6 = (svn_string_t *) 0 ;
7822 svn_string_t *arg7 = (svn_string_t *) 0 ;
7823 apr_pool_t *arg8 = (apr_pool_t *) 0 ;
7824 apr_pool_t *_global_pool = NULL ;
7825 PyObject *_global_py_pool = NULL ;
7826 svn_string_t value6 ;
7827 svn_string_t value7 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 PyObject * obj2 = 0 ;
7831 PyObject * obj3 = 0 ;
7832 PyObject * obj4 = 0 ;
7833 PyObject * obj5 = 0 ;
7834 PyObject * obj6 = 0 ;
7835 PyObject * obj7 = 0 ;
7836 svn_error_t *result = 0 ;
7837
7838 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
7839 &_global_py_pool, &_global_pool))
7840 SWIG_fail;
7841 arg8 = _global_pool;
7842 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_output_unified",7,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
7843 {
7844 if (obj0 == Py_None) {
7845 arg1 = NULL;
7846 }
7847 else {
7848 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
7849 if (arg1 == NULL) {
7850 SWIG_fail;
7851 }
7852 }
7853 }
7854 {
7855 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
7856 if (PyErr_Occurred()) {
7857 SWIG_fail;
7858 }
7859 }
7860 {
7861 arg3 = svn_swig_py_string_to_cstring(obj2, TRUE, "svn_diff_mem_string_output_unified", "original_header");
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 {
7865 arg4 = svn_swig_py_string_to_cstring(obj3, TRUE, "svn_diff_mem_string_output_unified", "modified_header");
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 {
7869 arg5 = svn_swig_py_string_to_cstring(obj4, TRUE, "svn_diff_mem_string_output_unified", "header_encoding");
7870 if (PyErr_Occurred()) SWIG_fail;
7871 }
7872 {
7873 if (obj5 == Py_None)
7874 arg6 = NULL;
7875 else {
7876 Py_ssize_t pyStrLen;
7877 if (!PyBytes_Check(obj5)) {
7878 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7879 SWIG_fail;
7880 }
7881 if (PyBytes_AsStringAndSize(obj5, (char **)&(value6.data),
7882 &pyStrLen) == -1) {
7883 SWIG_fail;
7884 }
7885 value6.len = pyStrLen;
7886 arg6 = &value6;
7887 }
7888 }
7889 {
7890 if (obj6 == Py_None)
7891 arg7 = NULL;
7892 else {
7893 Py_ssize_t pyStrLen;
7894 if (!PyBytes_Check(obj6)) {
7895 PyErr_SetString(PyExc_TypeError, "not a bytes object");
7896 SWIG_fail;
7897 }
7898 if (PyBytes_AsStringAndSize(obj6, (char **)&(value7.data),
7899 &pyStrLen) == -1) {
7900 SWIG_fail;
7901 }
7902 value7.len = pyStrLen;
7903 arg7 = &value7;
7904 }
7905 }
7906 if (obj7) {
7907 /* Verify that the user supplied a valid pool */
7908 if (obj7 != Py_None && obj7 != _global_py_pool) {
7909 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
7910 SWIG_arg_fail(svn_argnum_obj7);
7911 SWIG_fail;
7912 }
7913 }
7914 {
7915 svn_swig_py_release_py_lock();
7916
7917 result = (svn_error_t *)svn_diff_mem_string_output_unified(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(struct svn_string_t const *)arg6,(struct svn_string_t const *)arg7,arg8);
7918
7919 svn_swig_py_acquire_py_lock();
7920
7921 }
7922 {
7923 if (result != NULL) {
7924 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
7925 svn_swig_py_svn_exception(result);
7926 else
7927 svn_error_clear(result);
7928 SWIG_fail;
7929 }
7930 Py_INCREF(Py_None);
7931 resultobj = Py_None;
7932 }
7933 {
7934 Py_XDECREF(_global_py_pool);
7935 }
7936 return resultobj;
7937 fail:
7938 {
7939 Py_XDECREF(_global_py_pool);
7940 }
7941 return NULL;
7942 }
7943
7944
_wrap_svn_diff_mem_string_output_merge3(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7945 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_merge3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7946 PyObject *resultobj = 0;
7947 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
7948 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
7949 svn_string_t *arg3 = (svn_string_t *) 0 ;
7950 svn_string_t *arg4 = (svn_string_t *) 0 ;
7951 svn_string_t *arg5 = (svn_string_t *) 0 ;
7952 char *arg6 = (char *) 0 ;
7953 char *arg7 = (char *) 0 ;
7954 char *arg8 = (char *) 0 ;
7955 char *arg9 = (char *) 0 ;
7956 svn_diff_conflict_display_style_t arg10 ;
7957 svn_cancel_func_t arg11 = (svn_cancel_func_t) 0 ;
7958 void *arg12 = (void *) 0 ;
7959 apr_pool_t *arg13 = (apr_pool_t *) 0 ;
7960 apr_pool_t *_global_pool = NULL ;
7961 PyObject *_global_py_pool = NULL ;
7962 svn_string_t value3 ;
7963 svn_string_t value4 ;
7964 svn_string_t value5 ;
7965 PyObject * obj0 = 0 ;
7966 PyObject * obj1 = 0 ;
7967 PyObject * obj2 = 0 ;
7968 PyObject * obj3 = 0 ;
7969 PyObject * obj4 = 0 ;
7970 PyObject * obj5 = 0 ;
7971 PyObject * obj6 = 0 ;
7972 PyObject * obj7 = 0 ;
7973 PyObject * obj8 = 0 ;
7974 PyObject * obj9 = 0 ;
7975 PyObject * obj10 = 0 ;
7976 PyObject * obj11 = 0 ;
7977 svn_error_t *result = 0 ;
7978
7979 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
7980 &_global_py_pool, &_global_pool))
7981 SWIG_fail;
7982 arg13 = _global_pool;
7983 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_output_merge3",11,12,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
7984 {
7985 if (obj0 == Py_None) {
7986 arg1 = NULL;
7987 }
7988 else {
7989 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
7990 if (arg1 == NULL) {
7991 SWIG_fail;
7992 }
7993 }
7994 }
7995 {
7996 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
7997 if (PyErr_Occurred()) {
7998 SWIG_fail;
7999 }
8000 }
8001 {
8002 if (obj2 == Py_None)
8003 arg3 = NULL;
8004 else {
8005 Py_ssize_t pyStrLen;
8006 if (!PyBytes_Check(obj2)) {
8007 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8008 SWIG_fail;
8009 }
8010 if (PyBytes_AsStringAndSize(obj2, (char **)&(value3.data),
8011 &pyStrLen) == -1) {
8012 SWIG_fail;
8013 }
8014 value3.len = pyStrLen;
8015 arg3 = &value3;
8016 }
8017 }
8018 {
8019 if (obj3 == Py_None)
8020 arg4 = NULL;
8021 else {
8022 Py_ssize_t pyStrLen;
8023 if (!PyBytes_Check(obj3)) {
8024 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8025 SWIG_fail;
8026 }
8027 if (PyBytes_AsStringAndSize(obj3, (char **)&(value4.data),
8028 &pyStrLen) == -1) {
8029 SWIG_fail;
8030 }
8031 value4.len = pyStrLen;
8032 arg4 = &value4;
8033 }
8034 }
8035 {
8036 if (obj4 == Py_None)
8037 arg5 = NULL;
8038 else {
8039 Py_ssize_t pyStrLen;
8040 if (!PyBytes_Check(obj4)) {
8041 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8042 SWIG_fail;
8043 }
8044 if (PyBytes_AsStringAndSize(obj4, (char **)&(value5.data),
8045 &pyStrLen) == -1) {
8046 SWIG_fail;
8047 }
8048 value5.len = pyStrLen;
8049 arg5 = &value5;
8050 }
8051 }
8052 {
8053 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_mem_string_output_merge3", "conflict_original");
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 {
8057 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_mem_string_output_merge3", "conflict_modified");
8058 if (PyErr_Occurred()) SWIG_fail;
8059 }
8060 {
8061 arg8 = svn_swig_py_string_to_cstring(obj7, TRUE, "svn_diff_mem_string_output_merge3", "conflict_latest");
8062 if (PyErr_Occurred()) SWIG_fail;
8063 }
8064 {
8065 arg9 = svn_swig_py_string_to_cstring(obj8, TRUE, "svn_diff_mem_string_output_merge3", "conflict_separator");
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 arg10 = (svn_diff_conflict_display_style_t)SWIG_As_long (obj9);
8070 if (SWIG_arg_fail(svn_argnum_obj9)) {
8071 SWIG_fail;
8072 }
8073 }
8074 {
8075 arg11 = (svn_cancel_func_t) svn_swig_py_cancel_func;
8076 arg12 = obj10;
8077 }
8078 if (obj11) {
8079 /* Verify that the user supplied a valid pool */
8080 if (obj11 != Py_None && obj11 != _global_py_pool) {
8081 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
8082 SWIG_arg_fail(svn_argnum_obj11);
8083 SWIG_fail;
8084 }
8085 }
8086 {
8087 svn_swig_py_release_py_lock();
8088
8089 result = (svn_error_t *)svn_diff_mem_string_output_merge3(arg1,arg2,(struct svn_string_t const *)arg3,(struct svn_string_t const *)arg4,(struct svn_string_t const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,(char const *)arg9,arg10,arg11,arg12,arg13);
8090
8091 svn_swig_py_acquire_py_lock();
8092
8093 }
8094 {
8095 if (result != NULL) {
8096 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
8097 svn_swig_py_svn_exception(result);
8098 else
8099 svn_error_clear(result);
8100 SWIG_fail;
8101 }
8102 Py_INCREF(Py_None);
8103 resultobj = Py_None;
8104 }
8105 {
8106 Py_XDECREF(_global_py_pool);
8107 }
8108 return resultobj;
8109 fail:
8110 {
8111 Py_XDECREF(_global_py_pool);
8112 }
8113 return NULL;
8114 }
8115
8116
_wrap_svn_diff_mem_string_output_merge2(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8117 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_merge2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8118 PyObject *resultobj = 0;
8119 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
8120 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
8121 svn_string_t *arg3 = (svn_string_t *) 0 ;
8122 svn_string_t *arg4 = (svn_string_t *) 0 ;
8123 svn_string_t *arg5 = (svn_string_t *) 0 ;
8124 char *arg6 = (char *) 0 ;
8125 char *arg7 = (char *) 0 ;
8126 char *arg8 = (char *) 0 ;
8127 char *arg9 = (char *) 0 ;
8128 svn_diff_conflict_display_style_t arg10 ;
8129 apr_pool_t *arg11 = (apr_pool_t *) 0 ;
8130 apr_pool_t *_global_pool = NULL ;
8131 PyObject *_global_py_pool = NULL ;
8132 svn_string_t value3 ;
8133 svn_string_t value4 ;
8134 svn_string_t value5 ;
8135 PyObject * obj0 = 0 ;
8136 PyObject * obj1 = 0 ;
8137 PyObject * obj2 = 0 ;
8138 PyObject * obj3 = 0 ;
8139 PyObject * obj4 = 0 ;
8140 PyObject * obj5 = 0 ;
8141 PyObject * obj6 = 0 ;
8142 PyObject * obj7 = 0 ;
8143 PyObject * obj8 = 0 ;
8144 PyObject * obj9 = 0 ;
8145 PyObject * obj10 = 0 ;
8146 svn_error_t *result = 0 ;
8147
8148 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
8149 &_global_py_pool, &_global_pool))
8150 SWIG_fail;
8151 arg11 = _global_pool;
8152 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_output_merge2",10,11,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
8153 {
8154 if (obj0 == Py_None) {
8155 arg1 = NULL;
8156 }
8157 else {
8158 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
8159 if (arg1 == NULL) {
8160 SWIG_fail;
8161 }
8162 }
8163 }
8164 {
8165 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
8166 if (PyErr_Occurred()) {
8167 SWIG_fail;
8168 }
8169 }
8170 {
8171 if (obj2 == Py_None)
8172 arg3 = NULL;
8173 else {
8174 Py_ssize_t pyStrLen;
8175 if (!PyBytes_Check(obj2)) {
8176 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8177 SWIG_fail;
8178 }
8179 if (PyBytes_AsStringAndSize(obj2, (char **)&(value3.data),
8180 &pyStrLen) == -1) {
8181 SWIG_fail;
8182 }
8183 value3.len = pyStrLen;
8184 arg3 = &value3;
8185 }
8186 }
8187 {
8188 if (obj3 == Py_None)
8189 arg4 = NULL;
8190 else {
8191 Py_ssize_t pyStrLen;
8192 if (!PyBytes_Check(obj3)) {
8193 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8194 SWIG_fail;
8195 }
8196 if (PyBytes_AsStringAndSize(obj3, (char **)&(value4.data),
8197 &pyStrLen) == -1) {
8198 SWIG_fail;
8199 }
8200 value4.len = pyStrLen;
8201 arg4 = &value4;
8202 }
8203 }
8204 {
8205 if (obj4 == Py_None)
8206 arg5 = NULL;
8207 else {
8208 Py_ssize_t pyStrLen;
8209 if (!PyBytes_Check(obj4)) {
8210 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8211 SWIG_fail;
8212 }
8213 if (PyBytes_AsStringAndSize(obj4, (char **)&(value5.data),
8214 &pyStrLen) == -1) {
8215 SWIG_fail;
8216 }
8217 value5.len = pyStrLen;
8218 arg5 = &value5;
8219 }
8220 }
8221 {
8222 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_mem_string_output_merge2", "conflict_original");
8223 if (PyErr_Occurred()) SWIG_fail;
8224 }
8225 {
8226 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_mem_string_output_merge2", "conflict_modified");
8227 if (PyErr_Occurred()) SWIG_fail;
8228 }
8229 {
8230 arg8 = svn_swig_py_string_to_cstring(obj7, TRUE, "svn_diff_mem_string_output_merge2", "conflict_latest");
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 {
8234 arg9 = svn_swig_py_string_to_cstring(obj8, TRUE, "svn_diff_mem_string_output_merge2", "conflict_separator");
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 {
8238 arg10 = (svn_diff_conflict_display_style_t)SWIG_As_long (obj9);
8239 if (SWIG_arg_fail(svn_argnum_obj9)) {
8240 SWIG_fail;
8241 }
8242 }
8243 if (obj10) {
8244 /* Verify that the user supplied a valid pool */
8245 if (obj10 != Py_None && obj10 != _global_py_pool) {
8246 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj10);
8247 SWIG_arg_fail(svn_argnum_obj10);
8248 SWIG_fail;
8249 }
8250 }
8251 {
8252 svn_swig_py_release_py_lock();
8253
8254 result = (svn_error_t *)svn_diff_mem_string_output_merge2(arg1,arg2,(struct svn_string_t const *)arg3,(struct svn_string_t const *)arg4,(struct svn_string_t const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,(char const *)arg9,arg10,arg11);
8255
8256 svn_swig_py_acquire_py_lock();
8257
8258 }
8259 {
8260 if (result != NULL) {
8261 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
8262 svn_swig_py_svn_exception(result);
8263 else
8264 svn_error_clear(result);
8265 SWIG_fail;
8266 }
8267 Py_INCREF(Py_None);
8268 resultobj = Py_None;
8269 }
8270 {
8271 Py_XDECREF(_global_py_pool);
8272 }
8273 return resultobj;
8274 fail:
8275 {
8276 Py_XDECREF(_global_py_pool);
8277 }
8278 return NULL;
8279 }
8280
8281
_wrap_svn_diff_mem_string_output_merge(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8282 SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8283 PyObject *resultobj = 0;
8284 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
8285 svn_diff_t *arg2 = (svn_diff_t *) 0 ;
8286 svn_string_t *arg3 = (svn_string_t *) 0 ;
8287 svn_string_t *arg4 = (svn_string_t *) 0 ;
8288 svn_string_t *arg5 = (svn_string_t *) 0 ;
8289 char *arg6 = (char *) 0 ;
8290 char *arg7 = (char *) 0 ;
8291 char *arg8 = (char *) 0 ;
8292 char *arg9 = (char *) 0 ;
8293 svn_boolean_t arg10 ;
8294 svn_boolean_t arg11 ;
8295 apr_pool_t *arg12 = (apr_pool_t *) 0 ;
8296 apr_pool_t *_global_pool = NULL ;
8297 PyObject *_global_py_pool = NULL ;
8298 svn_string_t value3 ;
8299 svn_string_t value4 ;
8300 svn_string_t value5 ;
8301 PyObject * obj0 = 0 ;
8302 PyObject * obj1 = 0 ;
8303 PyObject * obj2 = 0 ;
8304 PyObject * obj3 = 0 ;
8305 PyObject * obj4 = 0 ;
8306 PyObject * obj5 = 0 ;
8307 PyObject * obj6 = 0 ;
8308 PyObject * obj7 = 0 ;
8309 PyObject * obj8 = 0 ;
8310 PyObject * obj9 = 0 ;
8311 PyObject * obj10 = 0 ;
8312 PyObject * obj11 = 0 ;
8313 svn_error_t *result = 0 ;
8314
8315 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
8316 &_global_py_pool, &_global_pool))
8317 SWIG_fail;
8318 arg12 = _global_pool;
8319 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_mem_string_output_merge",11,12,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
8320 {
8321 if (obj0 == Py_None) {
8322 arg1 = NULL;
8323 }
8324 else {
8325 arg1 = svn_swig_py_make_stream (obj0, _global_pool);
8326 if (arg1 == NULL) {
8327 SWIG_fail;
8328 }
8329 }
8330 }
8331 {
8332 arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
8333 if (PyErr_Occurred()) {
8334 SWIG_fail;
8335 }
8336 }
8337 {
8338 if (obj2 == Py_None)
8339 arg3 = NULL;
8340 else {
8341 Py_ssize_t pyStrLen;
8342 if (!PyBytes_Check(obj2)) {
8343 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8344 SWIG_fail;
8345 }
8346 if (PyBytes_AsStringAndSize(obj2, (char **)&(value3.data),
8347 &pyStrLen) == -1) {
8348 SWIG_fail;
8349 }
8350 value3.len = pyStrLen;
8351 arg3 = &value3;
8352 }
8353 }
8354 {
8355 if (obj3 == Py_None)
8356 arg4 = NULL;
8357 else {
8358 Py_ssize_t pyStrLen;
8359 if (!PyBytes_Check(obj3)) {
8360 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8361 SWIG_fail;
8362 }
8363 if (PyBytes_AsStringAndSize(obj3, (char **)&(value4.data),
8364 &pyStrLen) == -1) {
8365 SWIG_fail;
8366 }
8367 value4.len = pyStrLen;
8368 arg4 = &value4;
8369 }
8370 }
8371 {
8372 if (obj4 == Py_None)
8373 arg5 = NULL;
8374 else {
8375 Py_ssize_t pyStrLen;
8376 if (!PyBytes_Check(obj4)) {
8377 PyErr_SetString(PyExc_TypeError, "not a bytes object");
8378 SWIG_fail;
8379 }
8380 if (PyBytes_AsStringAndSize(obj4, (char **)&(value5.data),
8381 &pyStrLen) == -1) {
8382 SWIG_fail;
8383 }
8384 value5.len = pyStrLen;
8385 arg5 = &value5;
8386 }
8387 }
8388 {
8389 arg6 = svn_swig_py_string_to_cstring(obj5, TRUE, "svn_diff_mem_string_output_merge", "conflict_original");
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 {
8393 arg7 = svn_swig_py_string_to_cstring(obj6, TRUE, "svn_diff_mem_string_output_merge", "conflict_modified");
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 {
8397 arg8 = svn_swig_py_string_to_cstring(obj7, TRUE, "svn_diff_mem_string_output_merge", "conflict_latest");
8398 if (PyErr_Occurred()) SWIG_fail;
8399 }
8400 {
8401 arg9 = svn_swig_py_string_to_cstring(obj8, TRUE, "svn_diff_mem_string_output_merge", "conflict_separator");
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 {
8405 arg10 = (svn_boolean_t)SWIG_As_long (obj9);
8406 if (SWIG_arg_fail(svn_argnum_obj9)) {
8407 SWIG_fail;
8408 }
8409 }
8410 {
8411 arg11 = (svn_boolean_t)SWIG_As_long (obj10);
8412 if (SWIG_arg_fail(svn_argnum_obj10)) {
8413 SWIG_fail;
8414 }
8415 }
8416 if (obj11) {
8417 /* Verify that the user supplied a valid pool */
8418 if (obj11 != Py_None && obj11 != _global_py_pool) {
8419 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
8420 SWIG_arg_fail(svn_argnum_obj11);
8421 SWIG_fail;
8422 }
8423 }
8424 {
8425 svn_swig_py_release_py_lock();
8426
8427 result = (svn_error_t *)svn_diff_mem_string_output_merge(arg1,arg2,(struct svn_string_t const *)arg3,(struct svn_string_t const *)arg4,(struct svn_string_t const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,(char const *)arg9,arg10,arg11,arg12);
8428
8429 svn_swig_py_acquire_py_lock();
8430
8431 }
8432 {
8433 if (result != NULL) {
8434 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
8435 svn_swig_py_svn_exception(result);
8436 else
8437 svn_error_clear(result);
8438 SWIG_fail;
8439 }
8440 Py_INCREF(Py_None);
8441 resultobj = Py_None;
8442 }
8443 {
8444 Py_XDECREF(_global_py_pool);
8445 }
8446 return resultobj;
8447 fail:
8448 {
8449 Py_XDECREF(_global_py_pool);
8450 }
8451 return NULL;
8452 }
8453
8454
_wrap_svn_diff_hunk_readline_diff_text(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8455 SWIGINTERN PyObject *_wrap_svn_diff_hunk_readline_diff_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8458 svn_stringbuf_t **arg2 = (svn_stringbuf_t **) 0 ;
8459 char **arg3 = (char **) 0 ;
8460 svn_boolean_t *arg4 = (svn_boolean_t *) 0 ;
8461 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
8462 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
8463 apr_pool_t *_global_pool = NULL ;
8464 PyObject *_global_py_pool = NULL ;
8465 svn_stringbuf_t *temp2 ;
8466 char *temp3 ;
8467 svn_boolean_t temp4 ;
8468 int res4 = SWIG_TMPOBJ ;
8469 PyObject * obj0 = 0 ;
8470 PyObject * obj1 = 0 ;
8471 PyObject * obj2 = 0 ;
8472 svn_error_t *result = 0 ;
8473
8474 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
8475 &_global_py_pool, &_global_pool))
8476 SWIG_fail;
8477 arg5 = _global_pool;
8478 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
8479 &_global_py_pool, &_global_pool))
8480 SWIG_fail;
8481 arg6 = _global_pool;
8482 arg2 = &temp2;
8483 arg3 = &temp3;
8484 arg4 = &temp4;
8485 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_readline_diff_text",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
8486 {
8487 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8488 if (PyErr_Occurred()) {
8489 SWIG_fail;
8490 }
8491 }
8492 if (obj1) {
8493 /* Verify that the user supplied a valid pool */
8494 if (obj1 != Py_None && obj1 != _global_py_pool) {
8495 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
8496 SWIG_arg_fail(svn_argnum_obj1);
8497 SWIG_fail;
8498 }
8499 }
8500 if (obj2) {
8501 /* Verify that the user supplied a valid pool */
8502 if (obj2 != Py_None && obj2 != _global_py_pool) {
8503 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
8504 SWIG_arg_fail(svn_argnum_obj2);
8505 SWIG_fail;
8506 }
8507 }
8508 {
8509 svn_swig_py_release_py_lock();
8510
8511 result = (svn_error_t *)svn_diff_hunk_readline_diff_text(arg1,arg2,(char const **)arg3,arg4,arg5,arg6);
8512
8513 svn_swig_py_acquire_py_lock();
8514
8515 }
8516 {
8517 if (result != NULL) {
8518 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
8519 svn_swig_py_svn_exception(result);
8520 else
8521 svn_error_clear(result);
8522 SWIG_fail;
8523 }
8524 Py_INCREF(Py_None);
8525 resultobj = Py_None;
8526 }
8527 {
8528 PyObject *s;
8529 if (*arg2 == NULL) {
8530 Py_INCREF(Py_None);
8531 s = Py_None;
8532 } else {
8533 s = PyBytes_FromStringAndSize((*arg2)->data, (*arg2)->len);
8534 if (s == NULL)
8535 SWIG_fail;
8536 }
8537 resultobj = SWIG_Python_AppendOutput(resultobj, s);
8538 }
8539 {
8540 PyObject *s;
8541 if (*arg3 == NULL) {
8542 Py_INCREF(Py_None);
8543 s = Py_None;
8544 }
8545 else {
8546 s = PyBytes_FromString(*arg3);
8547 if (s == NULL)
8548 SWIG_fail;
8549 }
8550 resultobj = SWIG_Python_AppendOutput(resultobj, s);
8551 }
8552 if (SWIG_IsTmpObj(res4)) {
8553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
8554 } else {
8555 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
8557 }
8558 {
8559 Py_XDECREF(_global_py_pool);
8560 }
8561 {
8562 Py_XDECREF(_global_py_pool);
8563 }
8564 return resultobj;
8565 fail:
8566 {
8567 Py_XDECREF(_global_py_pool);
8568 }
8569 {
8570 Py_XDECREF(_global_py_pool);
8571 }
8572 return NULL;
8573 }
8574
8575
_wrap_svn_diff_hunk_readline_original_text(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8576 SWIGINTERN PyObject *_wrap_svn_diff_hunk_readline_original_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8577 PyObject *resultobj = 0;
8578 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8579 svn_stringbuf_t **arg2 = (svn_stringbuf_t **) 0 ;
8580 char **arg3 = (char **) 0 ;
8581 svn_boolean_t *arg4 = (svn_boolean_t *) 0 ;
8582 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
8583 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
8584 apr_pool_t *_global_pool = NULL ;
8585 PyObject *_global_py_pool = NULL ;
8586 svn_stringbuf_t *temp2 ;
8587 char *temp3 ;
8588 svn_boolean_t temp4 ;
8589 int res4 = SWIG_TMPOBJ ;
8590 PyObject * obj0 = 0 ;
8591 PyObject * obj1 = 0 ;
8592 PyObject * obj2 = 0 ;
8593 svn_error_t *result = 0 ;
8594
8595 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
8596 &_global_py_pool, &_global_pool))
8597 SWIG_fail;
8598 arg5 = _global_pool;
8599 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
8600 &_global_py_pool, &_global_pool))
8601 SWIG_fail;
8602 arg6 = _global_pool;
8603 arg2 = &temp2;
8604 arg3 = &temp3;
8605 arg4 = &temp4;
8606 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_readline_original_text",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
8607 {
8608 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8609 if (PyErr_Occurred()) {
8610 SWIG_fail;
8611 }
8612 }
8613 if (obj1) {
8614 /* Verify that the user supplied a valid pool */
8615 if (obj1 != Py_None && obj1 != _global_py_pool) {
8616 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
8617 SWIG_arg_fail(svn_argnum_obj1);
8618 SWIG_fail;
8619 }
8620 }
8621 if (obj2) {
8622 /* Verify that the user supplied a valid pool */
8623 if (obj2 != Py_None && obj2 != _global_py_pool) {
8624 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
8625 SWIG_arg_fail(svn_argnum_obj2);
8626 SWIG_fail;
8627 }
8628 }
8629 {
8630 svn_swig_py_release_py_lock();
8631
8632 result = (svn_error_t *)svn_diff_hunk_readline_original_text(arg1,arg2,(char const **)arg3,arg4,arg5,arg6);
8633
8634 svn_swig_py_acquire_py_lock();
8635
8636 }
8637 {
8638 if (result != NULL) {
8639 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
8640 svn_swig_py_svn_exception(result);
8641 else
8642 svn_error_clear(result);
8643 SWIG_fail;
8644 }
8645 Py_INCREF(Py_None);
8646 resultobj = Py_None;
8647 }
8648 {
8649 PyObject *s;
8650 if (*arg2 == NULL) {
8651 Py_INCREF(Py_None);
8652 s = Py_None;
8653 } else {
8654 s = PyBytes_FromStringAndSize((*arg2)->data, (*arg2)->len);
8655 if (s == NULL)
8656 SWIG_fail;
8657 }
8658 resultobj = SWIG_Python_AppendOutput(resultobj, s);
8659 }
8660 {
8661 PyObject *s;
8662 if (*arg3 == NULL) {
8663 Py_INCREF(Py_None);
8664 s = Py_None;
8665 }
8666 else {
8667 s = PyBytes_FromString(*arg3);
8668 if (s == NULL)
8669 SWIG_fail;
8670 }
8671 resultobj = SWIG_Python_AppendOutput(resultobj, s);
8672 }
8673 if (SWIG_IsTmpObj(res4)) {
8674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
8675 } else {
8676 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
8678 }
8679 {
8680 Py_XDECREF(_global_py_pool);
8681 }
8682 {
8683 Py_XDECREF(_global_py_pool);
8684 }
8685 return resultobj;
8686 fail:
8687 {
8688 Py_XDECREF(_global_py_pool);
8689 }
8690 {
8691 Py_XDECREF(_global_py_pool);
8692 }
8693 return NULL;
8694 }
8695
8696
_wrap_svn_diff_hunk_readline_modified_text(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8697 SWIGINTERN PyObject *_wrap_svn_diff_hunk_readline_modified_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8698 PyObject *resultobj = 0;
8699 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8700 svn_stringbuf_t **arg2 = (svn_stringbuf_t **) 0 ;
8701 char **arg3 = (char **) 0 ;
8702 svn_boolean_t *arg4 = (svn_boolean_t *) 0 ;
8703 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
8704 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
8705 apr_pool_t *_global_pool = NULL ;
8706 PyObject *_global_py_pool = NULL ;
8707 svn_stringbuf_t *temp2 ;
8708 char *temp3 ;
8709 svn_boolean_t temp4 ;
8710 int res4 = SWIG_TMPOBJ ;
8711 PyObject * obj0 = 0 ;
8712 PyObject * obj1 = 0 ;
8713 PyObject * obj2 = 0 ;
8714 svn_error_t *result = 0 ;
8715
8716 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
8717 &_global_py_pool, &_global_pool))
8718 SWIG_fail;
8719 arg5 = _global_pool;
8720 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
8721 &_global_py_pool, &_global_pool))
8722 SWIG_fail;
8723 arg6 = _global_pool;
8724 arg2 = &temp2;
8725 arg3 = &temp3;
8726 arg4 = &temp4;
8727 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_readline_modified_text",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
8728 {
8729 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8730 if (PyErr_Occurred()) {
8731 SWIG_fail;
8732 }
8733 }
8734 if (obj1) {
8735 /* Verify that the user supplied a valid pool */
8736 if (obj1 != Py_None && obj1 != _global_py_pool) {
8737 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
8738 SWIG_arg_fail(svn_argnum_obj1);
8739 SWIG_fail;
8740 }
8741 }
8742 if (obj2) {
8743 /* Verify that the user supplied a valid pool */
8744 if (obj2 != Py_None && obj2 != _global_py_pool) {
8745 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
8746 SWIG_arg_fail(svn_argnum_obj2);
8747 SWIG_fail;
8748 }
8749 }
8750 {
8751 svn_swig_py_release_py_lock();
8752
8753 result = (svn_error_t *)svn_diff_hunk_readline_modified_text(arg1,arg2,(char const **)arg3,arg4,arg5,arg6);
8754
8755 svn_swig_py_acquire_py_lock();
8756
8757 }
8758 {
8759 if (result != NULL) {
8760 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
8761 svn_swig_py_svn_exception(result);
8762 else
8763 svn_error_clear(result);
8764 SWIG_fail;
8765 }
8766 Py_INCREF(Py_None);
8767 resultobj = Py_None;
8768 }
8769 {
8770 PyObject *s;
8771 if (*arg2 == NULL) {
8772 Py_INCREF(Py_None);
8773 s = Py_None;
8774 } else {
8775 s = PyBytes_FromStringAndSize((*arg2)->data, (*arg2)->len);
8776 if (s == NULL)
8777 SWIG_fail;
8778 }
8779 resultobj = SWIG_Python_AppendOutput(resultobj, s);
8780 }
8781 {
8782 PyObject *s;
8783 if (*arg3 == NULL) {
8784 Py_INCREF(Py_None);
8785 s = Py_None;
8786 }
8787 else {
8788 s = PyBytes_FromString(*arg3);
8789 if (s == NULL)
8790 SWIG_fail;
8791 }
8792 resultobj = SWIG_Python_AppendOutput(resultobj, s);
8793 }
8794 if (SWIG_IsTmpObj(res4)) {
8795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
8796 } else {
8797 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
8799 }
8800 {
8801 Py_XDECREF(_global_py_pool);
8802 }
8803 {
8804 Py_XDECREF(_global_py_pool);
8805 }
8806 return resultobj;
8807 fail:
8808 {
8809 Py_XDECREF(_global_py_pool);
8810 }
8811 {
8812 Py_XDECREF(_global_py_pool);
8813 }
8814 return NULL;
8815 }
8816
8817
_wrap_svn_diff_hunk_reset_diff_text(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8818 SWIGINTERN PyObject *_wrap_svn_diff_hunk_reset_diff_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8819 PyObject *resultobj = 0;
8820 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8821 PyObject * obj0 = 0 ;
8822
8823 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_reset_diff_text",1,1,&obj0)) SWIG_fail;
8824 {
8825 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8826 if (PyErr_Occurred()) {
8827 SWIG_fail;
8828 }
8829 }
8830 {
8831 svn_swig_py_release_py_lock();
8832
8833 svn_diff_hunk_reset_diff_text(arg1);
8834
8835 svn_swig_py_acquire_py_lock();
8836
8837 }
8838 resultobj = SWIG_Py_Void();
8839 return resultobj;
8840 fail:
8841 return NULL;
8842 }
8843
8844
_wrap_svn_diff_hunk_reset_original_text(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8845 SWIGINTERN PyObject *_wrap_svn_diff_hunk_reset_original_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8846 PyObject *resultobj = 0;
8847 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8848 PyObject * obj0 = 0 ;
8849
8850 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_reset_original_text",1,1,&obj0)) SWIG_fail;
8851 {
8852 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8853 if (PyErr_Occurred()) {
8854 SWIG_fail;
8855 }
8856 }
8857 {
8858 svn_swig_py_release_py_lock();
8859
8860 svn_diff_hunk_reset_original_text(arg1);
8861
8862 svn_swig_py_acquire_py_lock();
8863
8864 }
8865 resultobj = SWIG_Py_Void();
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
_wrap_svn_diff_hunk_reset_modified_text(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8872 SWIGINTERN PyObject *_wrap_svn_diff_hunk_reset_modified_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8873 PyObject *resultobj = 0;
8874 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8875 PyObject * obj0 = 0 ;
8876
8877 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_reset_modified_text",1,1,&obj0)) SWIG_fail;
8878 {
8879 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8880 if (PyErr_Occurred()) {
8881 SWIG_fail;
8882 }
8883 }
8884 {
8885 svn_swig_py_release_py_lock();
8886
8887 svn_diff_hunk_reset_modified_text(arg1);
8888
8889 svn_swig_py_acquire_py_lock();
8890
8891 }
8892 resultobj = SWIG_Py_Void();
8893 return resultobj;
8894 fail:
8895 return NULL;
8896 }
8897
8898
_wrap_svn_diff_hunk_get_original_start(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8899 SWIGINTERN PyObject *_wrap_svn_diff_hunk_get_original_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8900 PyObject *resultobj = 0;
8901 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8902 PyObject * obj0 = 0 ;
8903 svn_linenum_t result;
8904
8905 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_get_original_start",1,1,&obj0)) SWIG_fail;
8906 {
8907 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8908 if (PyErr_Occurred()) {
8909 SWIG_fail;
8910 }
8911 }
8912 {
8913 svn_swig_py_release_py_lock();
8914
8915 result = (svn_linenum_t)svn_diff_hunk_get_original_start((struct svn_diff_hunk_t const *)arg1);
8916
8917 svn_swig_py_acquire_py_lock();
8918
8919 }
8920 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8921 return resultobj;
8922 fail:
8923 return NULL;
8924 }
8925
8926
_wrap_svn_diff_hunk_get_original_length(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8927 SWIGINTERN PyObject *_wrap_svn_diff_hunk_get_original_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8928 PyObject *resultobj = 0;
8929 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8930 PyObject * obj0 = 0 ;
8931 svn_linenum_t result;
8932
8933 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_get_original_length",1,1,&obj0)) SWIG_fail;
8934 {
8935 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8936 if (PyErr_Occurred()) {
8937 SWIG_fail;
8938 }
8939 }
8940 {
8941 svn_swig_py_release_py_lock();
8942
8943 result = (svn_linenum_t)svn_diff_hunk_get_original_length((struct svn_diff_hunk_t const *)arg1);
8944
8945 svn_swig_py_acquire_py_lock();
8946
8947 }
8948 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8949 return resultobj;
8950 fail:
8951 return NULL;
8952 }
8953
8954
_wrap_svn_diff_hunk_get_modified_start(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8955 SWIGINTERN PyObject *_wrap_svn_diff_hunk_get_modified_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8956 PyObject *resultobj = 0;
8957 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8958 PyObject * obj0 = 0 ;
8959 svn_linenum_t result;
8960
8961 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_get_modified_start",1,1,&obj0)) SWIG_fail;
8962 {
8963 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8964 if (PyErr_Occurred()) {
8965 SWIG_fail;
8966 }
8967 }
8968 {
8969 svn_swig_py_release_py_lock();
8970
8971 result = (svn_linenum_t)svn_diff_hunk_get_modified_start((struct svn_diff_hunk_t const *)arg1);
8972
8973 svn_swig_py_acquire_py_lock();
8974
8975 }
8976 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8977 return resultobj;
8978 fail:
8979 return NULL;
8980 }
8981
8982
_wrap_svn_diff_hunk_get_modified_length(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8983 SWIGINTERN PyObject *_wrap_svn_diff_hunk_get_modified_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8984 PyObject *resultobj = 0;
8985 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
8986 PyObject * obj0 = 0 ;
8987 svn_linenum_t result;
8988
8989 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_get_modified_length",1,1,&obj0)) SWIG_fail;
8990 {
8991 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
8992 if (PyErr_Occurred()) {
8993 SWIG_fail;
8994 }
8995 }
8996 {
8997 svn_swig_py_release_py_lock();
8998
8999 result = (svn_linenum_t)svn_diff_hunk_get_modified_length((struct svn_diff_hunk_t const *)arg1);
9000
9001 svn_swig_py_acquire_py_lock();
9002
9003 }
9004 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
_wrap_svn_diff_hunk_get_leading_context(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9011 SWIGINTERN PyObject *_wrap_svn_diff_hunk_get_leading_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9012 PyObject *resultobj = 0;
9013 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
9014 PyObject * obj0 = 0 ;
9015 svn_linenum_t result;
9016
9017 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_get_leading_context",1,1,&obj0)) SWIG_fail;
9018 {
9019 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
9020 if (PyErr_Occurred()) {
9021 SWIG_fail;
9022 }
9023 }
9024 {
9025 svn_swig_py_release_py_lock();
9026
9027 result = (svn_linenum_t)svn_diff_hunk_get_leading_context((struct svn_diff_hunk_t const *)arg1);
9028
9029 svn_swig_py_acquire_py_lock();
9030
9031 }
9032 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9033 return resultobj;
9034 fail:
9035 return NULL;
9036 }
9037
9038
_wrap_svn_diff_hunk_get_trailing_context(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9039 SWIGINTERN PyObject *_wrap_svn_diff_hunk_get_trailing_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9040 PyObject *resultobj = 0;
9041 svn_diff_hunk_t *arg1 = (svn_diff_hunk_t *) 0 ;
9042 PyObject * obj0 = 0 ;
9043 svn_linenum_t result;
9044
9045 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_hunk_get_trailing_context",1,1,&obj0)) SWIG_fail;
9046 {
9047 arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
9048 if (PyErr_Occurred()) {
9049 SWIG_fail;
9050 }
9051 }
9052 {
9053 svn_swig_py_release_py_lock();
9054
9055 result = (svn_linenum_t)svn_diff_hunk_get_trailing_context((struct svn_diff_hunk_t const *)arg1);
9056
9057 svn_swig_py_acquire_py_lock();
9058
9059 }
9060 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9061 return resultobj;
9062 fail:
9063 return NULL;
9064 }
9065
9066
_wrap_svn_prop_patch_t_name_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9067 SWIGINTERN PyObject *_wrap_svn_prop_patch_t_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9068 PyObject *resultobj = 0;
9069 struct svn_prop_patch_t *arg1 = (struct svn_prop_patch_t *) 0 ;
9070 char *arg2 = (char *) 0 ;
9071 PyObject * obj0 = 0 ;
9072 PyObject * obj1 = 0 ;
9073
9074 if(!PyArg_UnpackTuple(args,(char *)"svn_prop_patch_t_name_set",2,2,&obj0,&obj1)) SWIG_fail;
9075 {
9076 arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
9077 if (PyErr_Occurred()) {
9078 SWIG_fail;
9079 }
9080 }
9081 {
9082 arg2 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_prop_patch_t_name_set", "name");
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 {
9086 apr_size_t len = strlen(arg2) + 1;
9087 char *copied;
9088 if (arg1->name) free((char *)arg1->name);
9089 copied = malloc(len);
9090 memcpy(copied, arg2, len);
9091 arg1->name = copied;
9092 }
9093 resultobj = SWIG_Py_Void();
9094 return resultobj;
9095 fail:
9096 return NULL;
9097 }
9098
9099
_wrap_svn_prop_patch_t_name_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9100 SWIGINTERN PyObject *_wrap_svn_prop_patch_t_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9101 PyObject *resultobj = 0;
9102 struct svn_prop_patch_t *arg1 = (struct svn_prop_patch_t *) 0 ;
9103 PyObject * obj0 = 0 ;
9104 char *result = 0 ;
9105
9106 if(!PyArg_UnpackTuple(args,(char *)"svn_prop_patch_t_name_get",1,1,&obj0)) SWIG_fail;
9107 {
9108 arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
9109 if (PyErr_Occurred()) {
9110 SWIG_fail;
9111 }
9112 }
9113 result = (char *) ((arg1)->name);
9114 resultobj = SWIG_FromCharPtr((const char *)result);
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
_wrap_svn_prop_patch_t_operation_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9121 SWIGINTERN PyObject *_wrap_svn_prop_patch_t_operation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 PyObject *resultobj = 0;
9123 struct svn_prop_patch_t *arg1 = (struct svn_prop_patch_t *) 0 ;
9124 svn_diff_operation_kind_t arg2 ;
9125 PyObject * obj0 = 0 ;
9126 PyObject * obj1 = 0 ;
9127
9128 if(!PyArg_UnpackTuple(args,(char *)"svn_prop_patch_t_operation_set",2,2,&obj0,&obj1)) SWIG_fail;
9129 {
9130 arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
9131 if (PyErr_Occurred()) {
9132 SWIG_fail;
9133 }
9134 }
9135 {
9136 arg2 = (svn_diff_operation_kind_t)SWIG_As_long (obj1);
9137 if (SWIG_arg_fail(svn_argnum_obj1)) {
9138 SWIG_fail;
9139 }
9140 }
9141 if (arg1) (arg1)->operation = arg2;
9142 resultobj = SWIG_Py_Void();
9143 return resultobj;
9144 fail:
9145 return NULL;
9146 }
9147
9148
_wrap_svn_prop_patch_t_operation_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9149 SWIGINTERN PyObject *_wrap_svn_prop_patch_t_operation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9150 PyObject *resultobj = 0;
9151 struct svn_prop_patch_t *arg1 = (struct svn_prop_patch_t *) 0 ;
9152 PyObject * obj0 = 0 ;
9153 svn_diff_operation_kind_t result;
9154
9155 if(!PyArg_UnpackTuple(args,(char *)"svn_prop_patch_t_operation_get",1,1,&obj0)) SWIG_fail;
9156 {
9157 arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
9158 if (PyErr_Occurred()) {
9159 SWIG_fail;
9160 }
9161 }
9162 result = (svn_diff_operation_kind_t) ((arg1)->operation);
9163 resultobj = SWIG_From_long((long)(result));
9164 return resultobj;
9165 fail:
9166 return NULL;
9167 }
9168
9169
_wrap_svn_prop_patch_t_hunks_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9170 SWIGINTERN PyObject *_wrap_svn_prop_patch_t_hunks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9171 PyObject *resultobj = 0;
9172 struct svn_prop_patch_t *arg1 = (struct svn_prop_patch_t *) 0 ;
9173 apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
9174 PyObject * obj0 = 0 ;
9175 PyObject * obj1 = 0 ;
9176
9177 if(!PyArg_UnpackTuple(args,(char *)"svn_prop_patch_t_hunks_set",2,2,&obj0,&obj1)) SWIG_fail;
9178 {
9179 arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
9180 if (PyErr_Occurred()) {
9181 SWIG_fail;
9182 }
9183 }
9184 {
9185 arg2 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
9186 if (PyErr_Occurred()) {
9187 SWIG_fail;
9188 }
9189 }
9190 if (arg1) (arg1)->hunks = arg2;
9191 resultobj = SWIG_Py_Void();
9192 return resultobj;
9193 fail:
9194 return NULL;
9195 }
9196
9197
_wrap_svn_prop_patch_t_hunks_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9198 SWIGINTERN PyObject *_wrap_svn_prop_patch_t_hunks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9199 PyObject *resultobj = 0;
9200 struct svn_prop_patch_t *arg1 = (struct svn_prop_patch_t *) 0 ;
9201 PyObject * obj0 = 0 ;
9202 apr_array_header_t *result = 0 ;
9203
9204 if(!PyArg_UnpackTuple(args,(char *)"svn_prop_patch_t_hunks_get",1,1,&obj0)) SWIG_fail;
9205 {
9206 arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
9207 if (PyErr_Occurred()) {
9208 SWIG_fail;
9209 }
9210 }
9211 result = (apr_array_header_t *) ((arg1)->hunks);
9212 {
9213 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_pointerlist_to_list(result, SWIGTYPE_p_svn_diff_hunk_t,
9214 _global_py_pool))
9215
9216 ;
9217 if (PyErr_Occurred()) {
9218 SWIG_fail;
9219 }
9220 }
9221 return resultobj;
9222 fail:
9223 return NULL;
9224 }
9225
9226
_wrap_new_svn_prop_patch_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9227 SWIGINTERN PyObject *_wrap_new_svn_prop_patch_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 struct svn_prop_patch_t *result = 0 ;
9230
9231 if(!PyArg_UnpackTuple(args,(char *)"new_svn_prop_patch_t",0,0)) SWIG_fail;
9232 {
9233 svn_swig_py_release_py_lock();
9234
9235 result = (struct svn_prop_patch_t *)calloc(1, sizeof(struct svn_prop_patch_t));
9236
9237 svn_swig_py_acquire_py_lock();
9238
9239 }
9240 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_prop_patch_t,
9241 _global_py_pool, args);
9242 return resultobj;
9243 fail:
9244 return NULL;
9245 }
9246
9247
_wrap_delete_svn_prop_patch_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9248 SWIGINTERN PyObject *_wrap_delete_svn_prop_patch_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9249 PyObject *resultobj = 0;
9250 struct svn_prop_patch_t *arg1 = (struct svn_prop_patch_t *) 0 ;
9251 PyObject * obj0 = 0 ;
9252
9253 if(!PyArg_UnpackTuple(args,(char *)"delete_svn_prop_patch_t",1,1,&obj0)) SWIG_fail;
9254 {
9255 arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
9256 if (PyErr_Occurred()) {
9257 SWIG_fail;
9258 }
9259 }
9260 {
9261 svn_swig_py_release_py_lock();
9262
9263 free((char *) arg1);
9264
9265 svn_swig_py_acquire_py_lock();
9266
9267 }
9268 resultobj = SWIG_Py_Void();
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
svn_prop_patch_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9275 SWIGINTERN PyObject *svn_prop_patch_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9276 PyObject *obj;
9277 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
9278 SWIG_TypeNewClientData(SWIGTYPE_p_svn_prop_patch_t, SWIG_NewClientData(obj));
9279 return SWIG_Py_Void();
9280 }
9281
_wrap_svn_diff_get_binary_diff_original_stream(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9282 SWIGINTERN PyObject *_wrap_svn_diff_get_binary_diff_original_stream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283 PyObject *resultobj = 0;
9284 svn_diff_binary_patch_t *arg1 = (svn_diff_binary_patch_t *) 0 ;
9285 apr_pool_t *arg2 = (apr_pool_t *) 0 ;
9286 apr_pool_t *_global_pool = NULL ;
9287 PyObject *_global_py_pool = NULL ;
9288 PyObject * obj0 = 0 ;
9289 PyObject * obj1 = 0 ;
9290 svn_stream_t *result = 0 ;
9291
9292 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
9293 &_global_py_pool, &_global_pool))
9294 SWIG_fail;
9295 arg2 = _global_pool;
9296 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_get_binary_diff_original_stream",1,2,&obj0,&obj1)) SWIG_fail;
9297 {
9298 arg1 = (svn_diff_binary_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_binary_patch_t, svn_argnum_obj0);
9299 if (PyErr_Occurred()) {
9300 SWIG_fail;
9301 }
9302 }
9303 if (obj1) {
9304 /* Verify that the user supplied a valid pool */
9305 if (obj1 != Py_None && obj1 != _global_py_pool) {
9306 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
9307 SWIG_arg_fail(svn_argnum_obj1);
9308 SWIG_fail;
9309 }
9310 }
9311 {
9312 svn_swig_py_release_py_lock();
9313
9314 result = (svn_stream_t *)svn_diff_get_binary_diff_original_stream((struct svn_diff_binary_patch_t const *)arg1,arg2);
9315
9316 svn_swig_py_acquire_py_lock();
9317
9318 }
9319 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_stream_t,
9320 _global_py_pool, args);
9321 {
9322 Py_XDECREF(_global_py_pool);
9323 }
9324 return resultobj;
9325 fail:
9326 {
9327 Py_XDECREF(_global_py_pool);
9328 }
9329 return NULL;
9330 }
9331
9332
_wrap_svn_diff_get_binary_diff_result_stream(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9333 SWIGINTERN PyObject *_wrap_svn_diff_get_binary_diff_result_stream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9334 PyObject *resultobj = 0;
9335 svn_diff_binary_patch_t *arg1 = (svn_diff_binary_patch_t *) 0 ;
9336 apr_pool_t *arg2 = (apr_pool_t *) 0 ;
9337 apr_pool_t *_global_pool = NULL ;
9338 PyObject *_global_py_pool = NULL ;
9339 PyObject * obj0 = 0 ;
9340 PyObject * obj1 = 0 ;
9341 svn_stream_t *result = 0 ;
9342
9343 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
9344 &_global_py_pool, &_global_pool))
9345 SWIG_fail;
9346 arg2 = _global_pool;
9347 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_get_binary_diff_result_stream",1,2,&obj0,&obj1)) SWIG_fail;
9348 {
9349 arg1 = (svn_diff_binary_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_binary_patch_t, svn_argnum_obj0);
9350 if (PyErr_Occurred()) {
9351 SWIG_fail;
9352 }
9353 }
9354 if (obj1) {
9355 /* Verify that the user supplied a valid pool */
9356 if (obj1 != Py_None && obj1 != _global_py_pool) {
9357 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
9358 SWIG_arg_fail(svn_argnum_obj1);
9359 SWIG_fail;
9360 }
9361 }
9362 {
9363 svn_swig_py_release_py_lock();
9364
9365 result = (svn_stream_t *)svn_diff_get_binary_diff_result_stream((struct svn_diff_binary_patch_t const *)arg1,arg2);
9366
9367 svn_swig_py_acquire_py_lock();
9368
9369 }
9370 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_stream_t,
9371 _global_py_pool, args);
9372 {
9373 Py_XDECREF(_global_py_pool);
9374 }
9375 return resultobj;
9376 fail:
9377 {
9378 Py_XDECREF(_global_py_pool);
9379 }
9380 return NULL;
9381 }
9382
9383
_wrap_svn_patch_t_old_filename_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9384 SWIGINTERN PyObject *_wrap_svn_patch_t_old_filename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9385 PyObject *resultobj = 0;
9386 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9387 char *arg2 = (char *) 0 ;
9388 PyObject * obj0 = 0 ;
9389 PyObject * obj1 = 0 ;
9390
9391 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_old_filename_set",2,2,&obj0,&obj1)) SWIG_fail;
9392 {
9393 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9394 if (PyErr_Occurred()) {
9395 SWIG_fail;
9396 }
9397 }
9398 {
9399 arg2 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_patch_t_old_filename_set", "old_filename");
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 {
9403 apr_size_t len = strlen(arg2) + 1;
9404 char *copied;
9405 if (arg1->old_filename) free((char *)arg1->old_filename);
9406 copied = malloc(len);
9407 memcpy(copied, arg2, len);
9408 arg1->old_filename = copied;
9409 }
9410 resultobj = SWIG_Py_Void();
9411 return resultobj;
9412 fail:
9413 return NULL;
9414 }
9415
9416
_wrap_svn_patch_t_old_filename_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9417 SWIGINTERN PyObject *_wrap_svn_patch_t_old_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9418 PyObject *resultobj = 0;
9419 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9420 PyObject * obj0 = 0 ;
9421 char *result = 0 ;
9422
9423 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_old_filename_get",1,1,&obj0)) SWIG_fail;
9424 {
9425 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9426 if (PyErr_Occurred()) {
9427 SWIG_fail;
9428 }
9429 }
9430 result = (char *) ((arg1)->old_filename);
9431 resultobj = SWIG_FromCharPtr((const char *)result);
9432 return resultobj;
9433 fail:
9434 return NULL;
9435 }
9436
9437
_wrap_svn_patch_t_new_filename_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9438 SWIGINTERN PyObject *_wrap_svn_patch_t_new_filename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9439 PyObject *resultobj = 0;
9440 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9441 char *arg2 = (char *) 0 ;
9442 PyObject * obj0 = 0 ;
9443 PyObject * obj1 = 0 ;
9444
9445 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_new_filename_set",2,2,&obj0,&obj1)) SWIG_fail;
9446 {
9447 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9448 if (PyErr_Occurred()) {
9449 SWIG_fail;
9450 }
9451 }
9452 {
9453 arg2 = svn_swig_py_string_to_cstring(obj1, FALSE, "svn_patch_t_new_filename_set", "new_filename");
9454 if (PyErr_Occurred()) SWIG_fail;
9455 }
9456 {
9457 apr_size_t len = strlen(arg2) + 1;
9458 char *copied;
9459 if (arg1->new_filename) free((char *)arg1->new_filename);
9460 copied = malloc(len);
9461 memcpy(copied, arg2, len);
9462 arg1->new_filename = copied;
9463 }
9464 resultobj = SWIG_Py_Void();
9465 return resultobj;
9466 fail:
9467 return NULL;
9468 }
9469
9470
_wrap_svn_patch_t_new_filename_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9471 SWIGINTERN PyObject *_wrap_svn_patch_t_new_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9472 PyObject *resultobj = 0;
9473 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9474 PyObject * obj0 = 0 ;
9475 char *result = 0 ;
9476
9477 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_new_filename_get",1,1,&obj0)) SWIG_fail;
9478 {
9479 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9480 if (PyErr_Occurred()) {
9481 SWIG_fail;
9482 }
9483 }
9484 result = (char *) ((arg1)->new_filename);
9485 resultobj = SWIG_FromCharPtr((const char *)result);
9486 return resultobj;
9487 fail:
9488 return NULL;
9489 }
9490
9491
_wrap_svn_patch_t_hunks_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9492 SWIGINTERN PyObject *_wrap_svn_patch_t_hunks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9493 PyObject *resultobj = 0;
9494 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9495 apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
9496 PyObject * obj0 = 0 ;
9497 PyObject * obj1 = 0 ;
9498
9499 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_hunks_set",2,2,&obj0,&obj1)) SWIG_fail;
9500 {
9501 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9502 if (PyErr_Occurred()) {
9503 SWIG_fail;
9504 }
9505 }
9506 {
9507 arg2 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
9508 if (PyErr_Occurred()) {
9509 SWIG_fail;
9510 }
9511 }
9512 if (arg1) (arg1)->hunks = arg2;
9513 resultobj = SWIG_Py_Void();
9514 return resultobj;
9515 fail:
9516 return NULL;
9517 }
9518
9519
_wrap_svn_patch_t_hunks_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9520 SWIGINTERN PyObject *_wrap_svn_patch_t_hunks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9521 PyObject *resultobj = 0;
9522 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9523 PyObject * obj0 = 0 ;
9524 apr_array_header_t *result = 0 ;
9525
9526 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_hunks_get",1,1,&obj0)) SWIG_fail;
9527 {
9528 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9529 if (PyErr_Occurred()) {
9530 SWIG_fail;
9531 }
9532 }
9533 result = (apr_array_header_t *) ((arg1)->hunks);
9534 {
9535 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_pointerlist_to_list(result, SWIGTYPE_p_svn_diff_hunk_t,
9536 _global_py_pool))
9537
9538 ;
9539 if (PyErr_Occurred()) {
9540 SWIG_fail;
9541 }
9542 }
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
_wrap_svn_patch_t_prop_patches_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9549 SWIGINTERN PyObject *_wrap_svn_patch_t_prop_patches_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9550 PyObject *resultobj = 0;
9551 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9552 apr_hash_t *arg2 = (apr_hash_t *) 0 ;
9553 PyObject * obj0 = 0 ;
9554 PyObject * obj1 = 0 ;
9555
9556 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_prop_patches_set",2,2,&obj0,&obj1)) SWIG_fail;
9557 {
9558 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9559 if (PyErr_Occurred()) {
9560 SWIG_fail;
9561 }
9562 }
9563 {
9564 arg2 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
9565 if (PyErr_Occurred()) {
9566 SWIG_fail;
9567 }
9568 }
9569 if (arg1) (arg1)->prop_patches = arg2;
9570 resultobj = SWIG_Py_Void();
9571 return resultobj;
9572 fail:
9573 return NULL;
9574 }
9575
9576
_wrap_svn_patch_t_prop_patches_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9577 SWIGINTERN PyObject *_wrap_svn_patch_t_prop_patches_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9578 PyObject *resultobj = 0;
9579 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9580 PyObject * obj0 = 0 ;
9581 apr_hash_t *result = 0 ;
9582
9583 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_prop_patches_get",1,1,&obj0)) SWIG_fail;
9584 {
9585 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9586 if (PyErr_Occurred()) {
9587 SWIG_fail;
9588 }
9589 }
9590 result = (apr_hash_t *) ((arg1)->prop_patches);
9591 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_apr_hash_t,
9592 _global_py_pool, args);
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
_wrap_svn_patch_t_operation_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9599 SWIGINTERN PyObject *_wrap_svn_patch_t_operation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9600 PyObject *resultobj = 0;
9601 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9602 svn_diff_operation_kind_t arg2 ;
9603 PyObject * obj0 = 0 ;
9604 PyObject * obj1 = 0 ;
9605
9606 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_operation_set",2,2,&obj0,&obj1)) SWIG_fail;
9607 {
9608 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9609 if (PyErr_Occurred()) {
9610 SWIG_fail;
9611 }
9612 }
9613 {
9614 arg2 = (svn_diff_operation_kind_t)SWIG_As_long (obj1);
9615 if (SWIG_arg_fail(svn_argnum_obj1)) {
9616 SWIG_fail;
9617 }
9618 }
9619 if (arg1) (arg1)->operation = arg2;
9620 resultobj = SWIG_Py_Void();
9621 return resultobj;
9622 fail:
9623 return NULL;
9624 }
9625
9626
_wrap_svn_patch_t_operation_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9627 SWIGINTERN PyObject *_wrap_svn_patch_t_operation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9628 PyObject *resultobj = 0;
9629 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9630 PyObject * obj0 = 0 ;
9631 svn_diff_operation_kind_t result;
9632
9633 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_operation_get",1,1,&obj0)) SWIG_fail;
9634 {
9635 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9636 if (PyErr_Occurred()) {
9637 SWIG_fail;
9638 }
9639 }
9640 result = (svn_diff_operation_kind_t) ((arg1)->operation);
9641 resultobj = SWIG_From_long((long)(result));
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
_wrap_svn_patch_t_reverse_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9648 SWIGINTERN PyObject *_wrap_svn_patch_t_reverse_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9649 PyObject *resultobj = 0;
9650 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9651 svn_boolean_t arg2 ;
9652 PyObject * obj0 = 0 ;
9653 PyObject * obj1 = 0 ;
9654
9655 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_reverse_set",2,2,&obj0,&obj1)) SWIG_fail;
9656 {
9657 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9658 if (PyErr_Occurred()) {
9659 SWIG_fail;
9660 }
9661 }
9662 {
9663 arg2 = (svn_boolean_t)SWIG_As_long (obj1);
9664 if (SWIG_arg_fail(svn_argnum_obj1)) {
9665 SWIG_fail;
9666 }
9667 }
9668 if (arg1) (arg1)->reverse = arg2;
9669 resultobj = SWIG_Py_Void();
9670 return resultobj;
9671 fail:
9672 return NULL;
9673 }
9674
9675
_wrap_svn_patch_t_reverse_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9676 SWIGINTERN PyObject *_wrap_svn_patch_t_reverse_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9677 PyObject *resultobj = 0;
9678 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9679 PyObject * obj0 = 0 ;
9680 svn_boolean_t result;
9681
9682 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_reverse_get",1,1,&obj0)) SWIG_fail;
9683 {
9684 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9685 if (PyErr_Occurred()) {
9686 SWIG_fail;
9687 }
9688 }
9689 result = (svn_boolean_t) ((arg1)->reverse);
9690 resultobj = SWIG_From_long((long)(result));
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
_wrap_svn_patch_t_mergeinfo_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9697 SWIGINTERN PyObject *_wrap_svn_patch_t_mergeinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9698 PyObject *resultobj = 0;
9699 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9700 svn_mergeinfo_t arg2 = (svn_mergeinfo_t) 0 ;
9701 apr_pool_t *_global_pool = NULL ;
9702 PyObject *_global_py_pool = NULL ;
9703 PyObject * obj0 = 0 ;
9704 PyObject * obj1 = 0 ;
9705
9706 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_mergeinfo_set",2,2,&obj0,&obj1)) SWIG_fail;
9707 {
9708 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9709 if (PyErr_Occurred()) {
9710 SWIG_fail;
9711 }
9712 }
9713 {
9714 if (_global_pool == NULL)
9715 {
9716 if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
9717 &_global_py_pool, &_global_pool))
9718 SWIG_fail;
9719 }
9720
9721 arg2 = svn_swig_py_mergeinfo_from_dict(obj1, _global_pool);
9722 if (PyErr_Occurred()) {
9723 SWIG_fail;
9724 }
9725 }
9726 if (arg1) (arg1)->mergeinfo = arg2;
9727 resultobj = SWIG_Py_Void();
9728 return resultobj;
9729 fail:
9730 return NULL;
9731 }
9732
9733
_wrap_svn_patch_t_mergeinfo_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9734 SWIGINTERN PyObject *_wrap_svn_patch_t_mergeinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9735 PyObject *resultobj = 0;
9736 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9737 PyObject * obj0 = 0 ;
9738 svn_mergeinfo_t result;
9739
9740 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_mergeinfo_get",1,1,&obj0)) SWIG_fail;
9741 {
9742 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9743 if (PyErr_Occurred()) {
9744 SWIG_fail;
9745 }
9746 }
9747 result = (svn_mergeinfo_t) ((arg1)->mergeinfo);
9748 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_apr_hash_t,
9749 _global_py_pool, args);
9750 return resultobj;
9751 fail:
9752 return NULL;
9753 }
9754
9755
_wrap_svn_patch_t_reverse_mergeinfo_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9756 SWIGINTERN PyObject *_wrap_svn_patch_t_reverse_mergeinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9757 PyObject *resultobj = 0;
9758 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9759 svn_mergeinfo_t arg2 = (svn_mergeinfo_t) 0 ;
9760 PyObject * obj0 = 0 ;
9761 PyObject * obj1 = 0 ;
9762
9763 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_reverse_mergeinfo_set",2,2,&obj0,&obj1)) SWIG_fail;
9764 {
9765 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9766 if (PyErr_Occurred()) {
9767 SWIG_fail;
9768 }
9769 }
9770 {
9771 arg2 = (svn_mergeinfo_t)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
9772 if (PyErr_Occurred()) {
9773 SWIG_fail;
9774 }
9775 }
9776 if (arg1) (arg1)->reverse_mergeinfo = arg2;
9777 resultobj = SWIG_Py_Void();
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
_wrap_svn_patch_t_reverse_mergeinfo_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9784 SWIGINTERN PyObject *_wrap_svn_patch_t_reverse_mergeinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9785 PyObject *resultobj = 0;
9786 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9787 PyObject * obj0 = 0 ;
9788 svn_mergeinfo_t result;
9789
9790 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_reverse_mergeinfo_get",1,1,&obj0)) SWIG_fail;
9791 {
9792 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9793 if (PyErr_Occurred()) {
9794 SWIG_fail;
9795 }
9796 }
9797 result = (svn_mergeinfo_t) ((arg1)->reverse_mergeinfo);
9798 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_apr_hash_t,
9799 _global_py_pool, args);
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
_wrap_svn_patch_t_binary_patch_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9806 SWIGINTERN PyObject *_wrap_svn_patch_t_binary_patch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 PyObject *resultobj = 0;
9808 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9809 svn_diff_binary_patch_t *arg2 = (svn_diff_binary_patch_t *) 0 ;
9810 PyObject * obj0 = 0 ;
9811 PyObject * obj1 = 0 ;
9812
9813 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_binary_patch_set",2,2,&obj0,&obj1)) SWIG_fail;
9814 {
9815 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9816 if (PyErr_Occurred()) {
9817 SWIG_fail;
9818 }
9819 }
9820 {
9821 arg2 = (svn_diff_binary_patch_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_binary_patch_t, svn_argnum_obj1);
9822 if (PyErr_Occurred()) {
9823 SWIG_fail;
9824 }
9825 }
9826 if (arg1) (arg1)->binary_patch = arg2;
9827 resultobj = SWIG_Py_Void();
9828 return resultobj;
9829 fail:
9830 return NULL;
9831 }
9832
9833
_wrap_svn_patch_t_binary_patch_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9834 SWIGINTERN PyObject *_wrap_svn_patch_t_binary_patch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9835 PyObject *resultobj = 0;
9836 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9837 PyObject * obj0 = 0 ;
9838 svn_diff_binary_patch_t *result = 0 ;
9839
9840 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_binary_patch_get",1,1,&obj0)) SWIG_fail;
9841 {
9842 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9843 if (PyErr_Occurred()) {
9844 SWIG_fail;
9845 }
9846 }
9847 result = (svn_diff_binary_patch_t *) ((arg1)->binary_patch);
9848 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_binary_patch_t,
9849 _global_py_pool, args);
9850 return resultobj;
9851 fail:
9852 return NULL;
9853 }
9854
9855
_wrap_svn_patch_t_old_executable_bit_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9856 SWIGINTERN PyObject *_wrap_svn_patch_t_old_executable_bit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9857 PyObject *resultobj = 0;
9858 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9859 svn_tristate_t arg2 ;
9860 PyObject * obj0 = 0 ;
9861 PyObject * obj1 = 0 ;
9862
9863 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_old_executable_bit_set",2,2,&obj0,&obj1)) SWIG_fail;
9864 {
9865 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9866 if (PyErr_Occurred()) {
9867 SWIG_fail;
9868 }
9869 }
9870 {
9871 arg2 = (svn_tristate_t)SWIG_As_long (obj1);
9872 if (SWIG_arg_fail(svn_argnum_obj1)) {
9873 SWIG_fail;
9874 }
9875 }
9876 if (arg1) (arg1)->old_executable_bit = arg2;
9877 resultobj = SWIG_Py_Void();
9878 return resultobj;
9879 fail:
9880 return NULL;
9881 }
9882
9883
_wrap_svn_patch_t_old_executable_bit_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9884 SWIGINTERN PyObject *_wrap_svn_patch_t_old_executable_bit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9885 PyObject *resultobj = 0;
9886 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9887 PyObject * obj0 = 0 ;
9888 svn_tristate_t result;
9889
9890 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_old_executable_bit_get",1,1,&obj0)) SWIG_fail;
9891 {
9892 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9893 if (PyErr_Occurred()) {
9894 SWIG_fail;
9895 }
9896 }
9897 result = (svn_tristate_t) ((arg1)->old_executable_bit);
9898 resultobj = SWIG_From_long((long)(result));
9899 return resultobj;
9900 fail:
9901 return NULL;
9902 }
9903
9904
_wrap_svn_patch_t_new_executable_bit_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9905 SWIGINTERN PyObject *_wrap_svn_patch_t_new_executable_bit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9906 PyObject *resultobj = 0;
9907 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9908 svn_tristate_t arg2 ;
9909 PyObject * obj0 = 0 ;
9910 PyObject * obj1 = 0 ;
9911
9912 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_new_executable_bit_set",2,2,&obj0,&obj1)) SWIG_fail;
9913 {
9914 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9915 if (PyErr_Occurred()) {
9916 SWIG_fail;
9917 }
9918 }
9919 {
9920 arg2 = (svn_tristate_t)SWIG_As_long (obj1);
9921 if (SWIG_arg_fail(svn_argnum_obj1)) {
9922 SWIG_fail;
9923 }
9924 }
9925 if (arg1) (arg1)->new_executable_bit = arg2;
9926 resultobj = SWIG_Py_Void();
9927 return resultobj;
9928 fail:
9929 return NULL;
9930 }
9931
9932
_wrap_svn_patch_t_new_executable_bit_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9933 SWIGINTERN PyObject *_wrap_svn_patch_t_new_executable_bit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9934 PyObject *resultobj = 0;
9935 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9936 PyObject * obj0 = 0 ;
9937 svn_tristate_t result;
9938
9939 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_new_executable_bit_get",1,1,&obj0)) SWIG_fail;
9940 {
9941 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9942 if (PyErr_Occurred()) {
9943 SWIG_fail;
9944 }
9945 }
9946 result = (svn_tristate_t) ((arg1)->new_executable_bit);
9947 resultobj = SWIG_From_long((long)(result));
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
_wrap_svn_patch_t_old_symlink_bit_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9954 SWIGINTERN PyObject *_wrap_svn_patch_t_old_symlink_bit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9955 PyObject *resultobj = 0;
9956 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9957 svn_tristate_t arg2 ;
9958 PyObject * obj0 = 0 ;
9959 PyObject * obj1 = 0 ;
9960
9961 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_old_symlink_bit_set",2,2,&obj0,&obj1)) SWIG_fail;
9962 {
9963 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9964 if (PyErr_Occurred()) {
9965 SWIG_fail;
9966 }
9967 }
9968 {
9969 arg2 = (svn_tristate_t)SWIG_As_long (obj1);
9970 if (SWIG_arg_fail(svn_argnum_obj1)) {
9971 SWIG_fail;
9972 }
9973 }
9974 if (arg1) (arg1)->old_symlink_bit = arg2;
9975 resultobj = SWIG_Py_Void();
9976 return resultobj;
9977 fail:
9978 return NULL;
9979 }
9980
9981
_wrap_svn_patch_t_old_symlink_bit_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9982 SWIGINTERN PyObject *_wrap_svn_patch_t_old_symlink_bit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9983 PyObject *resultobj = 0;
9984 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
9985 PyObject * obj0 = 0 ;
9986 svn_tristate_t result;
9987
9988 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_old_symlink_bit_get",1,1,&obj0)) SWIG_fail;
9989 {
9990 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
9991 if (PyErr_Occurred()) {
9992 SWIG_fail;
9993 }
9994 }
9995 result = (svn_tristate_t) ((arg1)->old_symlink_bit);
9996 resultobj = SWIG_From_long((long)(result));
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
_wrap_svn_patch_t_new_symlink_bit_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10003 SWIGINTERN PyObject *_wrap_svn_patch_t_new_symlink_bit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004 PyObject *resultobj = 0;
10005 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
10006 svn_tristate_t arg2 ;
10007 PyObject * obj0 = 0 ;
10008 PyObject * obj1 = 0 ;
10009
10010 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_new_symlink_bit_set",2,2,&obj0,&obj1)) SWIG_fail;
10011 {
10012 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
10013 if (PyErr_Occurred()) {
10014 SWIG_fail;
10015 }
10016 }
10017 {
10018 arg2 = (svn_tristate_t)SWIG_As_long (obj1);
10019 if (SWIG_arg_fail(svn_argnum_obj1)) {
10020 SWIG_fail;
10021 }
10022 }
10023 if (arg1) (arg1)->new_symlink_bit = arg2;
10024 resultobj = SWIG_Py_Void();
10025 return resultobj;
10026 fail:
10027 return NULL;
10028 }
10029
10030
_wrap_svn_patch_t_new_symlink_bit_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10031 SWIGINTERN PyObject *_wrap_svn_patch_t_new_symlink_bit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10032 PyObject *resultobj = 0;
10033 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
10034 PyObject * obj0 = 0 ;
10035 svn_tristate_t result;
10036
10037 if(!PyArg_UnpackTuple(args,(char *)"svn_patch_t_new_symlink_bit_get",1,1,&obj0)) SWIG_fail;
10038 {
10039 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
10040 if (PyErr_Occurred()) {
10041 SWIG_fail;
10042 }
10043 }
10044 result = (svn_tristate_t) ((arg1)->new_symlink_bit);
10045 resultobj = SWIG_From_long((long)(result));
10046 return resultobj;
10047 fail:
10048 return NULL;
10049 }
10050
10051
_wrap_new_svn_patch_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10052 SWIGINTERN PyObject *_wrap_new_svn_patch_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10053 PyObject *resultobj = 0;
10054 struct svn_patch_t *result = 0 ;
10055
10056 if(!PyArg_UnpackTuple(args,(char *)"new_svn_patch_t",0,0)) SWIG_fail;
10057 {
10058 svn_swig_py_release_py_lock();
10059
10060 result = (struct svn_patch_t *)calloc(1, sizeof(struct svn_patch_t));
10061
10062 svn_swig_py_acquire_py_lock();
10063
10064 }
10065 resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_patch_t,
10066 _global_py_pool, args);
10067 return resultobj;
10068 fail:
10069 return NULL;
10070 }
10071
10072
_wrap_delete_svn_patch_t(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10073 SWIGINTERN PyObject *_wrap_delete_svn_patch_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10074 PyObject *resultobj = 0;
10075 struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
10076 PyObject * obj0 = 0 ;
10077
10078 if(!PyArg_UnpackTuple(args,(char *)"delete_svn_patch_t",1,1,&obj0)) SWIG_fail;
10079 {
10080 arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
10081 if (PyErr_Occurred()) {
10082 SWIG_fail;
10083 }
10084 }
10085 {
10086 svn_swig_py_release_py_lock();
10087
10088 free((char *) arg1);
10089
10090 svn_swig_py_acquire_py_lock();
10091
10092 }
10093 resultobj = SWIG_Py_Void();
10094 return resultobj;
10095 fail:
10096 return NULL;
10097 }
10098
10099
svn_patch_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10100 SWIGINTERN PyObject *svn_patch_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10101 PyObject *obj;
10102 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
10103 SWIG_TypeNewClientData(SWIGTYPE_p_svn_patch_t, SWIG_NewClientData(obj));
10104 return SWIG_Py_Void();
10105 }
10106
_wrap_svn_diff_open_patch_file(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10107 SWIGINTERN PyObject *_wrap_svn_diff_open_patch_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10108 PyObject *resultobj = 0;
10109 svn_patch_file_t **arg1 = (svn_patch_file_t **) 0 ;
10110 char *arg2 = (char *) 0 ;
10111 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
10112 apr_pool_t *_global_pool = NULL ;
10113 PyObject *_global_py_pool = NULL ;
10114 svn_patch_file_t *temp1 ;
10115 PyObject * obj0 = 0 ;
10116 PyObject * obj1 = 0 ;
10117 svn_error_t *result = 0 ;
10118
10119 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
10120 &_global_py_pool, &_global_pool))
10121 SWIG_fail;
10122 arg3 = _global_pool;
10123 arg1 = &temp1;
10124 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_open_patch_file",1,2,&obj0,&obj1)) SWIG_fail;
10125 {
10126 arg2 = svn_swig_py_string_to_cstring(obj0, FALSE, "svn_diff_open_patch_file", "local_abspath");
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 if (obj1) {
10130 /* Verify that the user supplied a valid pool */
10131 if (obj1 != Py_None && obj1 != _global_py_pool) {
10132 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
10133 SWIG_arg_fail(svn_argnum_obj1);
10134 SWIG_fail;
10135 }
10136 }
10137 {
10138 svn_swig_py_release_py_lock();
10139
10140 result = (svn_error_t *)svn_diff_open_patch_file(arg1,(char const *)arg2,arg3);
10141
10142 svn_swig_py_acquire_py_lock();
10143
10144 }
10145 {
10146 if (result != NULL) {
10147 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10148 svn_swig_py_svn_exception(result);
10149 else
10150 svn_error_clear(result);
10151 SWIG_fail;
10152 }
10153 Py_INCREF(Py_None);
10154 resultobj = Py_None;
10155 }
10156 {
10157 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_patch_file_t,
10158 _global_py_pool, args))
10159
10160 ;
10161 }
10162 {
10163 Py_XDECREF(_global_py_pool);
10164 }
10165 return resultobj;
10166 fail:
10167 {
10168 Py_XDECREF(_global_py_pool);
10169 }
10170 return NULL;
10171 }
10172
10173
_wrap_svn_diff_parse_next_patch(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10174 SWIGINTERN PyObject *_wrap_svn_diff_parse_next_patch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10175 PyObject *resultobj = 0;
10176 svn_patch_t **arg1 = (svn_patch_t **) 0 ;
10177 svn_patch_file_t *arg2 = (svn_patch_file_t *) 0 ;
10178 svn_boolean_t arg3 ;
10179 svn_boolean_t arg4 ;
10180 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
10181 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
10182 apr_pool_t *_global_pool = NULL ;
10183 PyObject *_global_py_pool = NULL ;
10184 svn_patch_t *temp1 ;
10185 PyObject * obj0 = 0 ;
10186 PyObject * obj1 = 0 ;
10187 PyObject * obj2 = 0 ;
10188 PyObject * obj3 = 0 ;
10189 PyObject * obj4 = 0 ;
10190 svn_error_t *result = 0 ;
10191
10192 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
10193 &_global_py_pool, &_global_pool))
10194 SWIG_fail;
10195 arg5 = _global_pool;
10196 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
10197 &_global_py_pool, &_global_pool))
10198 SWIG_fail;
10199 arg6 = _global_pool;
10200 arg1 = &temp1;
10201 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_parse_next_patch",3,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10202 {
10203 arg2 = (svn_patch_file_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_file_t, svn_argnum_obj0);
10204 if (PyErr_Occurred()) {
10205 SWIG_fail;
10206 }
10207 }
10208 {
10209 arg3 = (svn_boolean_t)SWIG_As_long (obj1);
10210 if (SWIG_arg_fail(svn_argnum_obj1)) {
10211 SWIG_fail;
10212 }
10213 }
10214 {
10215 arg4 = (svn_boolean_t)SWIG_As_long (obj2);
10216 if (SWIG_arg_fail(svn_argnum_obj2)) {
10217 SWIG_fail;
10218 }
10219 }
10220 if (obj3) {
10221 /* Verify that the user supplied a valid pool */
10222 if (obj3 != Py_None && obj3 != _global_py_pool) {
10223 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
10224 SWIG_arg_fail(svn_argnum_obj3);
10225 SWIG_fail;
10226 }
10227 }
10228 if (obj4) {
10229 /* Verify that the user supplied a valid pool */
10230 if (obj4 != Py_None && obj4 != _global_py_pool) {
10231 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
10232 SWIG_arg_fail(svn_argnum_obj4);
10233 SWIG_fail;
10234 }
10235 }
10236 {
10237 svn_swig_py_release_py_lock();
10238
10239 result = (svn_error_t *)svn_diff_parse_next_patch(arg1,arg2,arg3,arg4,arg5,arg6);
10240
10241 svn_swig_py_acquire_py_lock();
10242
10243 }
10244 {
10245 if (result != NULL) {
10246 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10247 svn_swig_py_svn_exception(result);
10248 else
10249 svn_error_clear(result);
10250 SWIG_fail;
10251 }
10252 Py_INCREF(Py_None);
10253 resultobj = Py_None;
10254 }
10255 {
10256 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_patch_t,
10257 _global_py_pool, args))
10258
10259 ;
10260 }
10261 {
10262 Py_XDECREF(_global_py_pool);
10263 }
10264 {
10265 Py_XDECREF(_global_py_pool);
10266 }
10267 return resultobj;
10268 fail:
10269 {
10270 Py_XDECREF(_global_py_pool);
10271 }
10272 {
10273 Py_XDECREF(_global_py_pool);
10274 }
10275 return NULL;
10276 }
10277
10278
_wrap_svn_diff_close_patch_file(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10279 SWIGINTERN PyObject *_wrap_svn_diff_close_patch_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10280 PyObject *resultobj = 0;
10281 svn_patch_file_t *arg1 = (svn_patch_file_t *) 0 ;
10282 apr_pool_t *arg2 = (apr_pool_t *) 0 ;
10283 apr_pool_t *_global_pool = NULL ;
10284 PyObject *_global_py_pool = NULL ;
10285 PyObject * obj0 = 0 ;
10286 PyObject * obj1 = 0 ;
10287 svn_error_t *result = 0 ;
10288
10289 if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
10290 &_global_py_pool, &_global_pool))
10291 SWIG_fail;
10292 arg2 = _global_pool;
10293 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_close_patch_file",1,2,&obj0,&obj1)) SWIG_fail;
10294 {
10295 arg1 = (svn_patch_file_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_file_t, svn_argnum_obj0);
10296 if (PyErr_Occurred()) {
10297 SWIG_fail;
10298 }
10299 }
10300 if (obj1) {
10301 /* Verify that the user supplied a valid pool */
10302 if (obj1 != Py_None && obj1 != _global_py_pool) {
10303 SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
10304 SWIG_arg_fail(svn_argnum_obj1);
10305 SWIG_fail;
10306 }
10307 }
10308 {
10309 svn_swig_py_release_py_lock();
10310
10311 result = (svn_error_t *)svn_diff_close_patch_file(arg1,arg2);
10312
10313 svn_swig_py_acquire_py_lock();
10314
10315 }
10316 {
10317 if (result != NULL) {
10318 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10319 svn_swig_py_svn_exception(result);
10320 else
10321 svn_error_clear(result);
10322 SWIG_fail;
10323 }
10324 Py_INCREF(Py_None);
10325 resultobj = Py_None;
10326 }
10327 {
10328 Py_XDECREF(_global_py_pool);
10329 }
10330 return resultobj;
10331 fail:
10332 {
10333 Py_XDECREF(_global_py_pool);
10334 }
10335 return NULL;
10336 }
10337
10338
svn_diff_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10339 SWIGINTERN PyObject *svn_diff_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10340 PyObject *obj;
10341 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
10342 SWIG_TypeNewClientData(SWIGTYPE_p_svn_diff_t, SWIG_NewClientData(obj));
10343 return SWIG_Py_Void();
10344 }
10345
svn_diff_hunk_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10346 SWIGINTERN PyObject *svn_diff_hunk_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10347 PyObject *obj;
10348 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
10349 SWIG_TypeNewClientData(SWIGTYPE_p_svn_diff_hunk_t, SWIG_NewClientData(obj));
10350 return SWIG_Py_Void();
10351 }
10352
svn_diff_binary_patch_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10353 SWIGINTERN PyObject *svn_diff_binary_patch_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10354 PyObject *obj;
10355 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
10356 SWIG_TypeNewClientData(SWIGTYPE_p_svn_diff_binary_patch_t, SWIG_NewClientData(obj));
10357 return SWIG_Py_Void();
10358 }
10359
svn_patch_file_t_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10360 SWIGINTERN PyObject *svn_patch_file_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10361 PyObject *obj;
10362 if (!PyArg_UnpackTuple(args,(char *)"swigregister", 1, 1,&obj)) return NULL;
10363 SWIG_TypeNewClientData(SWIGTYPE_p_svn_patch_file_t, SWIG_NewClientData(obj));
10364 return SWIG_Py_Void();
10365 }
10366
_wrap_svn_diff_fns2_invoke_datasources_open(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10367 SWIGINTERN PyObject *_wrap_svn_diff_fns2_invoke_datasources_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10368 PyObject *resultobj = 0;
10369 svn_diff_fns2_t *arg1 = (svn_diff_fns2_t *) 0 ;
10370 void *arg2 = (void *) 0 ;
10371 apr_off_t *arg3 = (apr_off_t *) 0 ;
10372 apr_off_t *arg4 = (apr_off_t *) 0 ;
10373 svn_diff_datasource_e *arg5 = (svn_diff_datasource_e *) 0 ;
10374 apr_size_t arg6 ;
10375 PyObject * obj0 = 0 ;
10376 PyObject * obj1 = 0 ;
10377 PyObject * obj2 = 0 ;
10378 PyObject * obj3 = 0 ;
10379 PyObject * obj4 = 0 ;
10380 PyObject * obj5 = 0 ;
10381 svn_error_t *result = 0 ;
10382
10383 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_invoke_datasources_open",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10384 {
10385 arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
10386 if (PyErr_Occurred()) {
10387 SWIG_fail;
10388 }
10389 }
10390 {
10391 if (obj1 == Py_None) {
10392 arg2 = NULL;
10393 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
10394 arg2 = (void *) obj1;
10395 PyErr_Clear();
10396 }
10397 }
10398 {
10399 arg3 = (apr_off_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_apr_off_t, svn_argnum_obj2);
10400 if (PyErr_Occurred()) {
10401 SWIG_fail;
10402 }
10403 }
10404 {
10405 arg4 = (apr_off_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_apr_off_t, svn_argnum_obj3);
10406 if (PyErr_Occurred()) {
10407 SWIG_fail;
10408 }
10409 }
10410 {
10411 arg5 = (svn_diff_datasource_e *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_diff_datasource_e, svn_argnum_obj4);
10412 if (PyErr_Occurred()) {
10413 SWIG_fail;
10414 }
10415 }
10416 {
10417 arg6 = (apr_size_t)SWIG_As_unsigned_SS_long (obj5);
10418 if (SWIG_arg_fail(svn_argnum_obj5)) {
10419 SWIG_fail;
10420 }
10421 }
10422 {
10423 svn_swig_py_release_py_lock();
10424
10425 result = (svn_error_t *)svn_diff_fns2_invoke_datasources_open(arg1,arg2,arg3,arg4,(enum svn_diff_datasource_e const *)arg5,arg6);
10426
10427 svn_swig_py_acquire_py_lock();
10428
10429 }
10430 {
10431 if (result != NULL) {
10432 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10433 svn_swig_py_svn_exception(result);
10434 else
10435 svn_error_clear(result);
10436 SWIG_fail;
10437 }
10438 Py_INCREF(Py_None);
10439 resultobj = Py_None;
10440 }
10441 return resultobj;
10442 fail:
10443 return NULL;
10444 }
10445
10446
_wrap_svn_diff_fns2_invoke_datasource_close(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10447 SWIGINTERN PyObject *_wrap_svn_diff_fns2_invoke_datasource_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10448 PyObject *resultobj = 0;
10449 svn_diff_fns2_t *arg1 = (svn_diff_fns2_t *) 0 ;
10450 void *arg2 = (void *) 0 ;
10451 svn_diff_datasource_e arg3 ;
10452 PyObject * obj0 = 0 ;
10453 PyObject * obj1 = 0 ;
10454 PyObject * obj2 = 0 ;
10455 svn_error_t *result = 0 ;
10456
10457 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_invoke_datasource_close",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
10458 {
10459 arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
10460 if (PyErr_Occurred()) {
10461 SWIG_fail;
10462 }
10463 }
10464 {
10465 if (obj1 == Py_None) {
10466 arg2 = NULL;
10467 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
10468 arg2 = (void *) obj1;
10469 PyErr_Clear();
10470 }
10471 }
10472 {
10473 arg3 = (svn_diff_datasource_e)SWIG_As_long (obj2);
10474 if (SWIG_arg_fail(svn_argnum_obj2)) {
10475 SWIG_fail;
10476 }
10477 }
10478 {
10479 svn_swig_py_release_py_lock();
10480
10481 result = (svn_error_t *)svn_diff_fns2_invoke_datasource_close(arg1,arg2,arg3);
10482
10483 svn_swig_py_acquire_py_lock();
10484
10485 }
10486 {
10487 if (result != NULL) {
10488 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10489 svn_swig_py_svn_exception(result);
10490 else
10491 svn_error_clear(result);
10492 SWIG_fail;
10493 }
10494 Py_INCREF(Py_None);
10495 resultobj = Py_None;
10496 }
10497 return resultobj;
10498 fail:
10499 return NULL;
10500 }
10501
10502
_wrap_svn_diff_fns2_invoke_datasource_get_next_token(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10503 SWIGINTERN PyObject *_wrap_svn_diff_fns2_invoke_datasource_get_next_token(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10504 PyObject *resultobj = 0;
10505 svn_diff_fns2_t *arg1 = (svn_diff_fns2_t *) 0 ;
10506 apr_uint32_t *arg2 = (apr_uint32_t *) 0 ;
10507 void **arg3 = (void **) 0 ;
10508 void *arg4 = (void *) 0 ;
10509 svn_diff_datasource_e arg5 ;
10510 apr_uint32_t temp2 ;
10511 int res2 = SWIG_TMPOBJ ;
10512 void *temp3 ;
10513 PyObject * obj0 = 0 ;
10514 PyObject * obj1 = 0 ;
10515 PyObject * obj2 = 0 ;
10516 svn_error_t *result = 0 ;
10517
10518 arg2 = &temp2;
10519 arg3 = &temp3;
10520 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_invoke_datasource_get_next_token",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
10521 {
10522 arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
10523 if (PyErr_Occurred()) {
10524 SWIG_fail;
10525 }
10526 }
10527 {
10528 if (obj1 == Py_None) {
10529 arg4 = NULL;
10530 } else if (SWIG_ConvertPtr(obj1, (void **) &arg4, 0, 0) == -1) {
10531 arg4 = (void *) obj1;
10532 PyErr_Clear();
10533 }
10534 }
10535 {
10536 arg5 = (svn_diff_datasource_e)SWIG_As_long (obj2);
10537 if (SWIG_arg_fail(svn_argnum_obj2)) {
10538 SWIG_fail;
10539 }
10540 }
10541 {
10542 svn_swig_py_release_py_lock();
10543
10544 result = (svn_error_t *)svn_diff_fns2_invoke_datasource_get_next_token(arg1,arg2,arg3,arg4,arg5);
10545
10546 svn_swig_py_acquire_py_lock();
10547
10548 }
10549 {
10550 if (result != NULL) {
10551 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10552 svn_swig_py_svn_exception(result);
10553 else
10554 svn_error_clear(result);
10555 SWIG_fail;
10556 }
10557 Py_INCREF(Py_None);
10558 resultobj = Py_None;
10559 }
10560 if (SWIG_IsTmpObj(res2)) {
10561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_long((*arg2)));
10562 } else {
10563 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_apr_uint32_t, new_flags));
10565 }
10566 {
10567 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg3, SWIGTYPE_p_void,
10568 _global_py_pool, args))
10569
10570 ;
10571 }
10572 return resultobj;
10573 fail:
10574 return NULL;
10575 }
10576
10577
_wrap_svn_diff_fns2_invoke_token_compare(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10578 SWIGINTERN PyObject *_wrap_svn_diff_fns2_invoke_token_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10579 PyObject *resultobj = 0;
10580 svn_diff_fns2_t *arg1 = (svn_diff_fns2_t *) 0 ;
10581 void *arg2 = (void *) 0 ;
10582 void *arg3 = (void *) 0 ;
10583 void *arg4 = (void *) 0 ;
10584 int *arg5 = (int *) 0 ;
10585 int temp5 ;
10586 int res5 = SWIG_TMPOBJ ;
10587 PyObject * obj0 = 0 ;
10588 PyObject * obj1 = 0 ;
10589 PyObject * obj2 = 0 ;
10590 PyObject * obj3 = 0 ;
10591 svn_error_t *result = 0 ;
10592
10593 arg5 = &temp5;
10594 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_invoke_token_compare",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10595 {
10596 arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
10597 if (PyErr_Occurred()) {
10598 SWIG_fail;
10599 }
10600 }
10601 {
10602 if (obj1 == Py_None) {
10603 arg2 = NULL;
10604 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
10605 arg2 = (void *) obj1;
10606 PyErr_Clear();
10607 }
10608 }
10609 {
10610 arg3 = (void *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
10611 if (PyErr_Occurred()) {
10612 SWIG_fail;
10613 }
10614 }
10615 {
10616 arg4 = (void *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_void, svn_argnum_obj3);
10617 if (PyErr_Occurred()) {
10618 SWIG_fail;
10619 }
10620 }
10621 {
10622 svn_swig_py_release_py_lock();
10623
10624 result = (svn_error_t *)svn_diff_fns2_invoke_token_compare(arg1,arg2,arg3,arg4,arg5);
10625
10626 svn_swig_py_acquire_py_lock();
10627
10628 }
10629 {
10630 if (result != NULL) {
10631 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10632 svn_swig_py_svn_exception(result);
10633 else
10634 svn_error_clear(result);
10635 SWIG_fail;
10636 }
10637 Py_INCREF(Py_None);
10638 resultobj = Py_None;
10639 }
10640 if (SWIG_IsTmpObj(res5)) {
10641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
10642 } else {
10643 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
10645 }
10646 return resultobj;
10647 fail:
10648 return NULL;
10649 }
10650
10651
_wrap_svn_diff_fns2_invoke_token_discard(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10652 SWIGINTERN PyObject *_wrap_svn_diff_fns2_invoke_token_discard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10653 PyObject *resultobj = 0;
10654 svn_diff_fns2_t *arg1 = (svn_diff_fns2_t *) 0 ;
10655 void *arg2 = (void *) 0 ;
10656 void *arg3 = (void *) 0 ;
10657 PyObject * obj0 = 0 ;
10658 PyObject * obj1 = 0 ;
10659 PyObject * obj2 = 0 ;
10660
10661 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_invoke_token_discard",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
10662 {
10663 arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
10664 if (PyErr_Occurred()) {
10665 SWIG_fail;
10666 }
10667 }
10668 {
10669 if (obj1 == Py_None) {
10670 arg2 = NULL;
10671 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
10672 arg2 = (void *) obj1;
10673 PyErr_Clear();
10674 }
10675 }
10676 {
10677 arg3 = (void *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
10678 if (PyErr_Occurred()) {
10679 SWIG_fail;
10680 }
10681 }
10682 {
10683 svn_swig_py_release_py_lock();
10684
10685 svn_diff_fns2_invoke_token_discard(arg1,arg2,arg3);
10686
10687 svn_swig_py_acquire_py_lock();
10688
10689 }
10690 resultobj = SWIG_Py_Void();
10691 return resultobj;
10692 fail:
10693 return NULL;
10694 }
10695
10696
_wrap_svn_diff_fns2_invoke_token_discard_all(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10697 SWIGINTERN PyObject *_wrap_svn_diff_fns2_invoke_token_discard_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10698 PyObject *resultobj = 0;
10699 svn_diff_fns2_t *arg1 = (svn_diff_fns2_t *) 0 ;
10700 void *arg2 = (void *) 0 ;
10701 PyObject * obj0 = 0 ;
10702 PyObject * obj1 = 0 ;
10703
10704 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns2_invoke_token_discard_all",2,2,&obj0,&obj1)) SWIG_fail;
10705 {
10706 arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
10707 if (PyErr_Occurred()) {
10708 SWIG_fail;
10709 }
10710 }
10711 {
10712 if (obj1 == Py_None) {
10713 arg2 = NULL;
10714 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
10715 arg2 = (void *) obj1;
10716 PyErr_Clear();
10717 }
10718 }
10719 {
10720 svn_swig_py_release_py_lock();
10721
10722 svn_diff_fns2_invoke_token_discard_all(arg1,arg2);
10723
10724 svn_swig_py_acquire_py_lock();
10725
10726 }
10727 resultobj = SWIG_Py_Void();
10728 return resultobj;
10729 fail:
10730 return NULL;
10731 }
10732
10733
_wrap_svn_diff_fns_invoke_datasource_open(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10734 SWIGINTERN PyObject *_wrap_svn_diff_fns_invoke_datasource_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10735 PyObject *resultobj = 0;
10736 svn_diff_fns_t *arg1 = (svn_diff_fns_t *) 0 ;
10737 void *arg2 = (void *) 0 ;
10738 svn_diff_datasource_e arg3 ;
10739 PyObject * obj0 = 0 ;
10740 PyObject * obj1 = 0 ;
10741 PyObject * obj2 = 0 ;
10742 svn_error_t *result = 0 ;
10743
10744 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_invoke_datasource_open",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
10745 {
10746 arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
10747 if (PyErr_Occurred()) {
10748 SWIG_fail;
10749 }
10750 }
10751 {
10752 if (obj1 == Py_None) {
10753 arg2 = NULL;
10754 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
10755 arg2 = (void *) obj1;
10756 PyErr_Clear();
10757 }
10758 }
10759 {
10760 arg3 = (svn_diff_datasource_e)SWIG_As_long (obj2);
10761 if (SWIG_arg_fail(svn_argnum_obj2)) {
10762 SWIG_fail;
10763 }
10764 }
10765 {
10766 svn_swig_py_release_py_lock();
10767
10768 result = (svn_error_t *)svn_diff_fns_invoke_datasource_open(arg1,arg2,arg3);
10769
10770 svn_swig_py_acquire_py_lock();
10771
10772 }
10773 {
10774 if (result != NULL) {
10775 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10776 svn_swig_py_svn_exception(result);
10777 else
10778 svn_error_clear(result);
10779 SWIG_fail;
10780 }
10781 Py_INCREF(Py_None);
10782 resultobj = Py_None;
10783 }
10784 return resultobj;
10785 fail:
10786 return NULL;
10787 }
10788
10789
_wrap_svn_diff_fns_invoke_datasource_close(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10790 SWIGINTERN PyObject *_wrap_svn_diff_fns_invoke_datasource_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10791 PyObject *resultobj = 0;
10792 svn_diff_fns_t *arg1 = (svn_diff_fns_t *) 0 ;
10793 void *arg2 = (void *) 0 ;
10794 svn_diff_datasource_e arg3 ;
10795 PyObject * obj0 = 0 ;
10796 PyObject * obj1 = 0 ;
10797 PyObject * obj2 = 0 ;
10798 svn_error_t *result = 0 ;
10799
10800 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_invoke_datasource_close",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
10801 {
10802 arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
10803 if (PyErr_Occurred()) {
10804 SWIG_fail;
10805 }
10806 }
10807 {
10808 if (obj1 == Py_None) {
10809 arg2 = NULL;
10810 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
10811 arg2 = (void *) obj1;
10812 PyErr_Clear();
10813 }
10814 }
10815 {
10816 arg3 = (svn_diff_datasource_e)SWIG_As_long (obj2);
10817 if (SWIG_arg_fail(svn_argnum_obj2)) {
10818 SWIG_fail;
10819 }
10820 }
10821 {
10822 svn_swig_py_release_py_lock();
10823
10824 result = (svn_error_t *)svn_diff_fns_invoke_datasource_close(arg1,arg2,arg3);
10825
10826 svn_swig_py_acquire_py_lock();
10827
10828 }
10829 {
10830 if (result != NULL) {
10831 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10832 svn_swig_py_svn_exception(result);
10833 else
10834 svn_error_clear(result);
10835 SWIG_fail;
10836 }
10837 Py_INCREF(Py_None);
10838 resultobj = Py_None;
10839 }
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
_wrap_svn_diff_fns_invoke_datasource_get_next_token(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10846 SWIGINTERN PyObject *_wrap_svn_diff_fns_invoke_datasource_get_next_token(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10847 PyObject *resultobj = 0;
10848 svn_diff_fns_t *arg1 = (svn_diff_fns_t *) 0 ;
10849 apr_uint32_t *arg2 = (apr_uint32_t *) 0 ;
10850 void **arg3 = (void **) 0 ;
10851 void *arg4 = (void *) 0 ;
10852 svn_diff_datasource_e arg5 ;
10853 apr_uint32_t temp2 ;
10854 int res2 = SWIG_TMPOBJ ;
10855 void *temp3 ;
10856 PyObject * obj0 = 0 ;
10857 PyObject * obj1 = 0 ;
10858 PyObject * obj2 = 0 ;
10859 svn_error_t *result = 0 ;
10860
10861 arg2 = &temp2;
10862 arg3 = &temp3;
10863 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_invoke_datasource_get_next_token",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
10864 {
10865 arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
10866 if (PyErr_Occurred()) {
10867 SWIG_fail;
10868 }
10869 }
10870 {
10871 if (obj1 == Py_None) {
10872 arg4 = NULL;
10873 } else if (SWIG_ConvertPtr(obj1, (void **) &arg4, 0, 0) == -1) {
10874 arg4 = (void *) obj1;
10875 PyErr_Clear();
10876 }
10877 }
10878 {
10879 arg5 = (svn_diff_datasource_e)SWIG_As_long (obj2);
10880 if (SWIG_arg_fail(svn_argnum_obj2)) {
10881 SWIG_fail;
10882 }
10883 }
10884 {
10885 svn_swig_py_release_py_lock();
10886
10887 result = (svn_error_t *)svn_diff_fns_invoke_datasource_get_next_token(arg1,arg2,arg3,arg4,arg5);
10888
10889 svn_swig_py_acquire_py_lock();
10890
10891 }
10892 {
10893 if (result != NULL) {
10894 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10895 svn_swig_py_svn_exception(result);
10896 else
10897 svn_error_clear(result);
10898 SWIG_fail;
10899 }
10900 Py_INCREF(Py_None);
10901 resultobj = Py_None;
10902 }
10903 if (SWIG_IsTmpObj(res2)) {
10904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_long((*arg2)));
10905 } else {
10906 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_apr_uint32_t, new_flags));
10908 }
10909 {
10910 resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg3, SWIGTYPE_p_void,
10911 _global_py_pool, args))
10912
10913 ;
10914 }
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
_wrap_svn_diff_fns_invoke_token_compare(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10921 SWIGINTERN PyObject *_wrap_svn_diff_fns_invoke_token_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10922 PyObject *resultobj = 0;
10923 svn_diff_fns_t *arg1 = (svn_diff_fns_t *) 0 ;
10924 void *arg2 = (void *) 0 ;
10925 void *arg3 = (void *) 0 ;
10926 void *arg4 = (void *) 0 ;
10927 int *arg5 = (int *) 0 ;
10928 int temp5 ;
10929 int res5 = SWIG_TMPOBJ ;
10930 PyObject * obj0 = 0 ;
10931 PyObject * obj1 = 0 ;
10932 PyObject * obj2 = 0 ;
10933 PyObject * obj3 = 0 ;
10934 svn_error_t *result = 0 ;
10935
10936 arg5 = &temp5;
10937 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_invoke_token_compare",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10938 {
10939 arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
10940 if (PyErr_Occurred()) {
10941 SWIG_fail;
10942 }
10943 }
10944 {
10945 if (obj1 == Py_None) {
10946 arg2 = NULL;
10947 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
10948 arg2 = (void *) obj1;
10949 PyErr_Clear();
10950 }
10951 }
10952 {
10953 arg3 = (void *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
10954 if (PyErr_Occurred()) {
10955 SWIG_fail;
10956 }
10957 }
10958 {
10959 arg4 = (void *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_void, svn_argnum_obj3);
10960 if (PyErr_Occurred()) {
10961 SWIG_fail;
10962 }
10963 }
10964 {
10965 svn_swig_py_release_py_lock();
10966
10967 result = (svn_error_t *)svn_diff_fns_invoke_token_compare(arg1,arg2,arg3,arg4,arg5);
10968
10969 svn_swig_py_acquire_py_lock();
10970
10971 }
10972 {
10973 if (result != NULL) {
10974 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
10975 svn_swig_py_svn_exception(result);
10976 else
10977 svn_error_clear(result);
10978 SWIG_fail;
10979 }
10980 Py_INCREF(Py_None);
10981 resultobj = Py_None;
10982 }
10983 if (SWIG_IsTmpObj(res5)) {
10984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
10985 } else {
10986 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
10988 }
10989 return resultobj;
10990 fail:
10991 return NULL;
10992 }
10993
10994
_wrap_svn_diff_fns_invoke_token_discard(PyObject * SWIGUNUSEDPARM (self),PyObject * args)10995 SWIGINTERN PyObject *_wrap_svn_diff_fns_invoke_token_discard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10996 PyObject *resultobj = 0;
10997 svn_diff_fns_t *arg1 = (svn_diff_fns_t *) 0 ;
10998 void *arg2 = (void *) 0 ;
10999 void *arg3 = (void *) 0 ;
11000 PyObject * obj0 = 0 ;
11001 PyObject * obj1 = 0 ;
11002 PyObject * obj2 = 0 ;
11003
11004 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_invoke_token_discard",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
11005 {
11006 arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
11007 if (PyErr_Occurred()) {
11008 SWIG_fail;
11009 }
11010 }
11011 {
11012 if (obj1 == Py_None) {
11013 arg2 = NULL;
11014 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
11015 arg2 = (void *) obj1;
11016 PyErr_Clear();
11017 }
11018 }
11019 {
11020 arg3 = (void *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
11021 if (PyErr_Occurred()) {
11022 SWIG_fail;
11023 }
11024 }
11025 {
11026 svn_swig_py_release_py_lock();
11027
11028 svn_diff_fns_invoke_token_discard(arg1,arg2,arg3);
11029
11030 svn_swig_py_acquire_py_lock();
11031
11032 }
11033 resultobj = SWIG_Py_Void();
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
_wrap_svn_diff_fns_invoke_token_discard_all(PyObject * SWIGUNUSEDPARM (self),PyObject * args)11040 SWIGINTERN PyObject *_wrap_svn_diff_fns_invoke_token_discard_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11041 PyObject *resultobj = 0;
11042 svn_diff_fns_t *arg1 = (svn_diff_fns_t *) 0 ;
11043 void *arg2 = (void *) 0 ;
11044 PyObject * obj0 = 0 ;
11045 PyObject * obj1 = 0 ;
11046
11047 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_fns_invoke_token_discard_all",2,2,&obj0,&obj1)) SWIG_fail;
11048 {
11049 arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
11050 if (PyErr_Occurred()) {
11051 SWIG_fail;
11052 }
11053 }
11054 {
11055 if (obj1 == Py_None) {
11056 arg2 = NULL;
11057 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
11058 arg2 = (void *) obj1;
11059 PyErr_Clear();
11060 }
11061 }
11062 {
11063 svn_swig_py_release_py_lock();
11064
11065 svn_diff_fns_invoke_token_discard_all(arg1,arg2);
11066
11067 svn_swig_py_acquire_py_lock();
11068
11069 }
11070 resultobj = SWIG_Py_Void();
11071 return resultobj;
11072 fail:
11073 return NULL;
11074 }
11075
11076
_wrap_svn_diff_output_fns_invoke_output_common(PyObject * SWIGUNUSEDPARM (self),PyObject * args)11077 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_invoke_output_common(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11078 PyObject *resultobj = 0;
11079 svn_diff_output_fns_t *arg1 = (svn_diff_output_fns_t *) 0 ;
11080 void *arg2 = (void *) 0 ;
11081 apr_off_t arg3 ;
11082 apr_off_t arg4 ;
11083 apr_off_t arg5 ;
11084 apr_off_t arg6 ;
11085 apr_off_t arg7 ;
11086 apr_off_t arg8 ;
11087 PyObject * obj0 = 0 ;
11088 PyObject * obj1 = 0 ;
11089 PyObject * obj2 = 0 ;
11090 PyObject * obj3 = 0 ;
11091 PyObject * obj4 = 0 ;
11092 PyObject * obj5 = 0 ;
11093 PyObject * obj6 = 0 ;
11094 PyObject * obj7 = 0 ;
11095 svn_error_t *result = 0 ;
11096
11097 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_invoke_output_common",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
11098 {
11099 arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
11100 if (PyErr_Occurred()) {
11101 SWIG_fail;
11102 }
11103 }
11104 {
11105 if (obj1 == Py_None) {
11106 arg2 = NULL;
11107 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
11108 arg2 = (void *) obj1;
11109 PyErr_Clear();
11110 }
11111 }
11112 arg3 = (apr_off_t) PyLong_AsLongLong(obj2);
11113 arg4 = (apr_off_t) PyLong_AsLongLong(obj3);
11114 arg5 = (apr_off_t) PyLong_AsLongLong(obj4);
11115 arg6 = (apr_off_t) PyLong_AsLongLong(obj5);
11116 arg7 = (apr_off_t) PyLong_AsLongLong(obj6);
11117 arg8 = (apr_off_t) PyLong_AsLongLong(obj7);
11118 {
11119 svn_swig_py_release_py_lock();
11120
11121 result = (svn_error_t *)svn_diff_output_fns_invoke_output_common(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
11122
11123 svn_swig_py_acquire_py_lock();
11124
11125 }
11126 {
11127 if (result != NULL) {
11128 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
11129 svn_swig_py_svn_exception(result);
11130 else
11131 svn_error_clear(result);
11132 SWIG_fail;
11133 }
11134 Py_INCREF(Py_None);
11135 resultobj = Py_None;
11136 }
11137 return resultobj;
11138 fail:
11139 return NULL;
11140 }
11141
11142
_wrap_svn_diff_output_fns_invoke_output_diff_modified(PyObject * SWIGUNUSEDPARM (self),PyObject * args)11143 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_invoke_output_diff_modified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11144 PyObject *resultobj = 0;
11145 svn_diff_output_fns_t *arg1 = (svn_diff_output_fns_t *) 0 ;
11146 void *arg2 = (void *) 0 ;
11147 apr_off_t arg3 ;
11148 apr_off_t arg4 ;
11149 apr_off_t arg5 ;
11150 apr_off_t arg6 ;
11151 apr_off_t arg7 ;
11152 apr_off_t arg8 ;
11153 PyObject * obj0 = 0 ;
11154 PyObject * obj1 = 0 ;
11155 PyObject * obj2 = 0 ;
11156 PyObject * obj3 = 0 ;
11157 PyObject * obj4 = 0 ;
11158 PyObject * obj5 = 0 ;
11159 PyObject * obj6 = 0 ;
11160 PyObject * obj7 = 0 ;
11161 svn_error_t *result = 0 ;
11162
11163 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_invoke_output_diff_modified",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
11164 {
11165 arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
11166 if (PyErr_Occurred()) {
11167 SWIG_fail;
11168 }
11169 }
11170 {
11171 if (obj1 == Py_None) {
11172 arg2 = NULL;
11173 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
11174 arg2 = (void *) obj1;
11175 PyErr_Clear();
11176 }
11177 }
11178 arg3 = (apr_off_t) PyLong_AsLongLong(obj2);
11179 arg4 = (apr_off_t) PyLong_AsLongLong(obj3);
11180 arg5 = (apr_off_t) PyLong_AsLongLong(obj4);
11181 arg6 = (apr_off_t) PyLong_AsLongLong(obj5);
11182 arg7 = (apr_off_t) PyLong_AsLongLong(obj6);
11183 arg8 = (apr_off_t) PyLong_AsLongLong(obj7);
11184 {
11185 svn_swig_py_release_py_lock();
11186
11187 result = (svn_error_t *)svn_diff_output_fns_invoke_output_diff_modified(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
11188
11189 svn_swig_py_acquire_py_lock();
11190
11191 }
11192 {
11193 if (result != NULL) {
11194 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
11195 svn_swig_py_svn_exception(result);
11196 else
11197 svn_error_clear(result);
11198 SWIG_fail;
11199 }
11200 Py_INCREF(Py_None);
11201 resultobj = Py_None;
11202 }
11203 return resultobj;
11204 fail:
11205 return NULL;
11206 }
11207
11208
_wrap_svn_diff_output_fns_invoke_output_diff_latest(PyObject * SWIGUNUSEDPARM (self),PyObject * args)11209 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_invoke_output_diff_latest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11210 PyObject *resultobj = 0;
11211 svn_diff_output_fns_t *arg1 = (svn_diff_output_fns_t *) 0 ;
11212 void *arg2 = (void *) 0 ;
11213 apr_off_t arg3 ;
11214 apr_off_t arg4 ;
11215 apr_off_t arg5 ;
11216 apr_off_t arg6 ;
11217 apr_off_t arg7 ;
11218 apr_off_t arg8 ;
11219 PyObject * obj0 = 0 ;
11220 PyObject * obj1 = 0 ;
11221 PyObject * obj2 = 0 ;
11222 PyObject * obj3 = 0 ;
11223 PyObject * obj4 = 0 ;
11224 PyObject * obj5 = 0 ;
11225 PyObject * obj6 = 0 ;
11226 PyObject * obj7 = 0 ;
11227 svn_error_t *result = 0 ;
11228
11229 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_invoke_output_diff_latest",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
11230 {
11231 arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
11232 if (PyErr_Occurred()) {
11233 SWIG_fail;
11234 }
11235 }
11236 {
11237 if (obj1 == Py_None) {
11238 arg2 = NULL;
11239 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
11240 arg2 = (void *) obj1;
11241 PyErr_Clear();
11242 }
11243 }
11244 arg3 = (apr_off_t) PyLong_AsLongLong(obj2);
11245 arg4 = (apr_off_t) PyLong_AsLongLong(obj3);
11246 arg5 = (apr_off_t) PyLong_AsLongLong(obj4);
11247 arg6 = (apr_off_t) PyLong_AsLongLong(obj5);
11248 arg7 = (apr_off_t) PyLong_AsLongLong(obj6);
11249 arg8 = (apr_off_t) PyLong_AsLongLong(obj7);
11250 {
11251 svn_swig_py_release_py_lock();
11252
11253 result = (svn_error_t *)svn_diff_output_fns_invoke_output_diff_latest(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
11254
11255 svn_swig_py_acquire_py_lock();
11256
11257 }
11258 {
11259 if (result != NULL) {
11260 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
11261 svn_swig_py_svn_exception(result);
11262 else
11263 svn_error_clear(result);
11264 SWIG_fail;
11265 }
11266 Py_INCREF(Py_None);
11267 resultobj = Py_None;
11268 }
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
_wrap_svn_diff_output_fns_invoke_output_diff_common(PyObject * SWIGUNUSEDPARM (self),PyObject * args)11275 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_invoke_output_diff_common(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11276 PyObject *resultobj = 0;
11277 svn_diff_output_fns_t *arg1 = (svn_diff_output_fns_t *) 0 ;
11278 void *arg2 = (void *) 0 ;
11279 apr_off_t arg3 ;
11280 apr_off_t arg4 ;
11281 apr_off_t arg5 ;
11282 apr_off_t arg6 ;
11283 apr_off_t arg7 ;
11284 apr_off_t arg8 ;
11285 PyObject * obj0 = 0 ;
11286 PyObject * obj1 = 0 ;
11287 PyObject * obj2 = 0 ;
11288 PyObject * obj3 = 0 ;
11289 PyObject * obj4 = 0 ;
11290 PyObject * obj5 = 0 ;
11291 PyObject * obj6 = 0 ;
11292 PyObject * obj7 = 0 ;
11293 svn_error_t *result = 0 ;
11294
11295 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_invoke_output_diff_common",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
11296 {
11297 arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
11298 if (PyErr_Occurred()) {
11299 SWIG_fail;
11300 }
11301 }
11302 {
11303 if (obj1 == Py_None) {
11304 arg2 = NULL;
11305 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
11306 arg2 = (void *) obj1;
11307 PyErr_Clear();
11308 }
11309 }
11310 arg3 = (apr_off_t) PyLong_AsLongLong(obj2);
11311 arg4 = (apr_off_t) PyLong_AsLongLong(obj3);
11312 arg5 = (apr_off_t) PyLong_AsLongLong(obj4);
11313 arg6 = (apr_off_t) PyLong_AsLongLong(obj5);
11314 arg7 = (apr_off_t) PyLong_AsLongLong(obj6);
11315 arg8 = (apr_off_t) PyLong_AsLongLong(obj7);
11316 {
11317 svn_swig_py_release_py_lock();
11318
11319 result = (svn_error_t *)svn_diff_output_fns_invoke_output_diff_common(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
11320
11321 svn_swig_py_acquire_py_lock();
11322
11323 }
11324 {
11325 if (result != NULL) {
11326 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
11327 svn_swig_py_svn_exception(result);
11328 else
11329 svn_error_clear(result);
11330 SWIG_fail;
11331 }
11332 Py_INCREF(Py_None);
11333 resultobj = Py_None;
11334 }
11335 return resultobj;
11336 fail:
11337 return NULL;
11338 }
11339
11340
_wrap_svn_diff_output_fns_invoke_output_conflict(PyObject * SWIGUNUSEDPARM (self),PyObject * args)11341 SWIGINTERN PyObject *_wrap_svn_diff_output_fns_invoke_output_conflict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11342 PyObject *resultobj = 0;
11343 svn_diff_output_fns_t *arg1 = (svn_diff_output_fns_t *) 0 ;
11344 void *arg2 = (void *) 0 ;
11345 apr_off_t arg3 ;
11346 apr_off_t arg4 ;
11347 apr_off_t arg5 ;
11348 apr_off_t arg6 ;
11349 apr_off_t arg7 ;
11350 apr_off_t arg8 ;
11351 svn_diff_t *arg9 = (svn_diff_t *) 0 ;
11352 PyObject * obj0 = 0 ;
11353 PyObject * obj1 = 0 ;
11354 PyObject * obj2 = 0 ;
11355 PyObject * obj3 = 0 ;
11356 PyObject * obj4 = 0 ;
11357 PyObject * obj5 = 0 ;
11358 PyObject * obj6 = 0 ;
11359 PyObject * obj7 = 0 ;
11360 PyObject * obj8 = 0 ;
11361 svn_error_t *result = 0 ;
11362
11363 if(!PyArg_UnpackTuple(args,(char *)"svn_diff_output_fns_invoke_output_conflict",9,9,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
11364 {
11365 arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
11366 if (PyErr_Occurred()) {
11367 SWIG_fail;
11368 }
11369 }
11370 {
11371 if (obj1 == Py_None) {
11372 arg2 = NULL;
11373 } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
11374 arg2 = (void *) obj1;
11375 PyErr_Clear();
11376 }
11377 }
11378 arg3 = (apr_off_t) PyLong_AsLongLong(obj2);
11379 arg4 = (apr_off_t) PyLong_AsLongLong(obj3);
11380 arg5 = (apr_off_t) PyLong_AsLongLong(obj4);
11381 arg6 = (apr_off_t) PyLong_AsLongLong(obj5);
11382 arg7 = (apr_off_t) PyLong_AsLongLong(obj6);
11383 arg8 = (apr_off_t) PyLong_AsLongLong(obj7);
11384 {
11385 arg9 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj8, SWIGTYPE_p_svn_diff_t, svn_argnum_obj8);
11386 if (PyErr_Occurred()) {
11387 SWIG_fail;
11388 }
11389 }
11390 {
11391 svn_swig_py_release_py_lock();
11392
11393 result = (svn_error_t *)svn_diff_output_fns_invoke_output_conflict(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11394
11395 svn_swig_py_acquire_py_lock();
11396
11397 }
11398 {
11399 if (result != NULL) {
11400 if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
11401 svn_swig_py_svn_exception(result);
11402 else
11403 svn_error_clear(result);
11404 SWIG_fail;
11405 }
11406 Py_INCREF(Py_None);
11407 resultobj = Py_None;
11408 }
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 static PyMethodDef SwigMethods[] = {
11416 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
11417 { (char *)"svn_diff_version", _wrap_svn_diff_version, METH_VARARGS, (char *)"svn_diff_version() -> svn_version_t const *"},
11418 { (char *)"svn_diff_fns2_t_datasources_open_set", _wrap_svn_diff_fns2_t_datasources_open_set, METH_VARARGS, (char *)"svn_diff_fns2_t_datasources_open_set(svn_diff_fns2_t self, svn_error_t *(*)(void *,apr_off_t *,apr_off_t *,svn_diff_datasource_e const *,apr_size_t) datasources_open)"},
11419 { (char *)"svn_diff_fns2_t_datasources_open_get", _wrap_svn_diff_fns2_t_datasources_open_get, METH_VARARGS, (char *)"svn_diff_fns2_t_datasources_open_get(svn_diff_fns2_t self) -> svn_error_t *(*)(void *,apr_off_t *,apr_off_t *,svn_diff_datasource_e const *,apr_size_t)"},
11420 { (char *)"svn_diff_fns2_t_datasource_close_set", _wrap_svn_diff_fns2_t_datasource_close_set, METH_VARARGS, (char *)"svn_diff_fns2_t_datasource_close_set(svn_diff_fns2_t self, svn_error_t *(*)(void *,svn_diff_datasource_e) datasource_close)"},
11421 { (char *)"svn_diff_fns2_t_datasource_close_get", _wrap_svn_diff_fns2_t_datasource_close_get, METH_VARARGS, (char *)"svn_diff_fns2_t_datasource_close_get(svn_diff_fns2_t self) -> svn_error_t *(*)(void *,svn_diff_datasource_e)"},
11422 { (char *)"svn_diff_fns2_t_datasource_get_next_token_set", _wrap_svn_diff_fns2_t_datasource_get_next_token_set, METH_VARARGS, (char *)"svn_diff_fns2_t_datasource_get_next_token_set(svn_diff_fns2_t self, svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e) datasource_get_next_token)"},
11423 { (char *)"svn_diff_fns2_t_datasource_get_next_token_get", _wrap_svn_diff_fns2_t_datasource_get_next_token_get, METH_VARARGS, (char *)"svn_diff_fns2_t_datasource_get_next_token_get(svn_diff_fns2_t self) -> svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)"},
11424 { (char *)"svn_diff_fns2_t_token_compare_set", _wrap_svn_diff_fns2_t_token_compare_set, METH_VARARGS, (char *)"svn_diff_fns2_t_token_compare_set(svn_diff_fns2_t self, svn_error_t *(*)(void *,void *,void *,int *) token_compare)"},
11425 { (char *)"svn_diff_fns2_t_token_compare_get", _wrap_svn_diff_fns2_t_token_compare_get, METH_VARARGS, (char *)"svn_diff_fns2_t_token_compare_get(svn_diff_fns2_t self) -> svn_error_t *(*)(void *,void *,void *,int *)"},
11426 { (char *)"svn_diff_fns2_t_token_discard_set", _wrap_svn_diff_fns2_t_token_discard_set, METH_VARARGS, (char *)"svn_diff_fns2_t_token_discard_set(svn_diff_fns2_t self, void (*)(void *,void *) token_discard)"},
11427 { (char *)"svn_diff_fns2_t_token_discard_get", _wrap_svn_diff_fns2_t_token_discard_get, METH_VARARGS, (char *)"svn_diff_fns2_t_token_discard_get(svn_diff_fns2_t self) -> void (*)(void *,void *)"},
11428 { (char *)"svn_diff_fns2_t_token_discard_all_set", _wrap_svn_diff_fns2_t_token_discard_all_set, METH_VARARGS, (char *)"svn_diff_fns2_t_token_discard_all_set(svn_diff_fns2_t self, void (*)(void *) token_discard_all)"},
11429 { (char *)"svn_diff_fns2_t_token_discard_all_get", _wrap_svn_diff_fns2_t_token_discard_all_get, METH_VARARGS, (char *)"svn_diff_fns2_t_token_discard_all_get(svn_diff_fns2_t self) -> void (*)(void *)"},
11430 { (char *)"new_svn_diff_fns2_t", _wrap_new_svn_diff_fns2_t, METH_VARARGS, (char *)"new_svn_diff_fns2_t() -> svn_diff_fns2_t"},
11431 { (char *)"delete_svn_diff_fns2_t", _wrap_delete_svn_diff_fns2_t, METH_VARARGS, (char *)"delete_svn_diff_fns2_t(svn_diff_fns2_t self)"},
11432 { (char *)"svn_diff_fns2_t_swigregister", svn_diff_fns2_t_swigregister, METH_VARARGS, NULL},
11433 { (char *)"svn_diff_fns_t_datasource_open_set", _wrap_svn_diff_fns_t_datasource_open_set, METH_VARARGS, (char *)"svn_diff_fns_t_datasource_open_set(svn_diff_fns_t self, svn_error_t *(*)(void *,svn_diff_datasource_e) datasource_open)"},
11434 { (char *)"svn_diff_fns_t_datasource_open_get", _wrap_svn_diff_fns_t_datasource_open_get, METH_VARARGS, (char *)"svn_diff_fns_t_datasource_open_get(svn_diff_fns_t self) -> svn_error_t *(*)(void *,svn_diff_datasource_e)"},
11435 { (char *)"svn_diff_fns_t_datasource_close_set", _wrap_svn_diff_fns_t_datasource_close_set, METH_VARARGS, (char *)"svn_diff_fns_t_datasource_close_set(svn_diff_fns_t self, svn_error_t *(*)(void *,svn_diff_datasource_e) datasource_close)"},
11436 { (char *)"svn_diff_fns_t_datasource_close_get", _wrap_svn_diff_fns_t_datasource_close_get, METH_VARARGS, (char *)"svn_diff_fns_t_datasource_close_get(svn_diff_fns_t self) -> svn_error_t *(*)(void *,svn_diff_datasource_e)"},
11437 { (char *)"svn_diff_fns_t_datasource_get_next_token_set", _wrap_svn_diff_fns_t_datasource_get_next_token_set, METH_VARARGS, (char *)"svn_diff_fns_t_datasource_get_next_token_set(svn_diff_fns_t self, svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e) datasource_get_next_token)"},
11438 { (char *)"svn_diff_fns_t_datasource_get_next_token_get", _wrap_svn_diff_fns_t_datasource_get_next_token_get, METH_VARARGS, (char *)"svn_diff_fns_t_datasource_get_next_token_get(svn_diff_fns_t self) -> svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)"},
11439 { (char *)"svn_diff_fns_t_token_compare_set", _wrap_svn_diff_fns_t_token_compare_set, METH_VARARGS, (char *)"svn_diff_fns_t_token_compare_set(svn_diff_fns_t self, svn_error_t *(*)(void *,void *,void *,int *) token_compare)"},
11440 { (char *)"svn_diff_fns_t_token_compare_get", _wrap_svn_diff_fns_t_token_compare_get, METH_VARARGS, (char *)"svn_diff_fns_t_token_compare_get(svn_diff_fns_t self) -> svn_error_t *(*)(void *,void *,void *,int *)"},
11441 { (char *)"svn_diff_fns_t_token_discard_set", _wrap_svn_diff_fns_t_token_discard_set, METH_VARARGS, (char *)"svn_diff_fns_t_token_discard_set(svn_diff_fns_t self, void (*)(void *,void *) token_discard)"},
11442 { (char *)"svn_diff_fns_t_token_discard_get", _wrap_svn_diff_fns_t_token_discard_get, METH_VARARGS, (char *)"svn_diff_fns_t_token_discard_get(svn_diff_fns_t self) -> void (*)(void *,void *)"},
11443 { (char *)"svn_diff_fns_t_token_discard_all_set", _wrap_svn_diff_fns_t_token_discard_all_set, METH_VARARGS, (char *)"svn_diff_fns_t_token_discard_all_set(svn_diff_fns_t self, void (*)(void *) token_discard_all)"},
11444 { (char *)"svn_diff_fns_t_token_discard_all_get", _wrap_svn_diff_fns_t_token_discard_all_get, METH_VARARGS, (char *)"svn_diff_fns_t_token_discard_all_get(svn_diff_fns_t self) -> void (*)(void *)"},
11445 { (char *)"new_svn_diff_fns_t", _wrap_new_svn_diff_fns_t, METH_VARARGS, (char *)"new_svn_diff_fns_t() -> svn_diff_fns_t"},
11446 { (char *)"delete_svn_diff_fns_t", _wrap_delete_svn_diff_fns_t, METH_VARARGS, (char *)"delete_svn_diff_fns_t(svn_diff_fns_t self)"},
11447 { (char *)"svn_diff_fns_t_swigregister", svn_diff_fns_t_swigregister, METH_VARARGS, NULL},
11448 { (char *)"svn_diff_diff_2", _wrap_svn_diff_diff_2, METH_VARARGS, (char *)"svn_diff_diff_2(void * diff_baton, svn_diff_fns2_t diff_fns, apr_pool_t pool) -> svn_error_t"},
11449 { (char *)"svn_diff_diff", _wrap_svn_diff_diff, METH_VARARGS, (char *)"svn_diff_diff(void * diff_baton, svn_diff_fns_t diff_fns, apr_pool_t pool) -> svn_error_t"},
11450 { (char *)"svn_diff_diff3_2", _wrap_svn_diff_diff3_2, METH_VARARGS, (char *)"svn_diff_diff3_2(void * diff_baton, svn_diff_fns2_t diff_fns, apr_pool_t pool) -> svn_error_t"},
11451 { (char *)"svn_diff_diff3", _wrap_svn_diff_diff3, METH_VARARGS, (char *)"svn_diff_diff3(void * diff_baton, svn_diff_fns_t diff_fns, apr_pool_t pool) -> svn_error_t"},
11452 { (char *)"svn_diff_diff4_2", _wrap_svn_diff_diff4_2, METH_VARARGS, (char *)"svn_diff_diff4_2(void * diff_baton, svn_diff_fns2_t diff_fns, apr_pool_t pool) -> svn_error_t"},
11453 { (char *)"svn_diff_diff4", _wrap_svn_diff_diff4, METH_VARARGS, (char *)"svn_diff_diff4(void * diff_baton, svn_diff_fns_t diff_fns, apr_pool_t pool) -> svn_error_t"},
11454 { (char *)"svn_diff_contains_conflicts", _wrap_svn_diff_contains_conflicts, METH_VARARGS, (char *)"svn_diff_contains_conflicts(svn_diff_t * diff) -> svn_boolean_t"},
11455 { (char *)"svn_diff_contains_diffs", _wrap_svn_diff_contains_diffs, METH_VARARGS, (char *)"svn_diff_contains_diffs(svn_diff_t * diff) -> svn_boolean_t"},
11456 { (char *)"svn_diff_output_fns_t_output_common_set", _wrap_svn_diff_output_fns_t_output_common_set, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_common_set(svn_diff_output_fns_t self, svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) output_common)"},
11457 { (char *)"svn_diff_output_fns_t_output_common_get", _wrap_svn_diff_output_fns_t_output_common_get, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_common_get(svn_diff_output_fns_t self) -> svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)"},
11458 { (char *)"svn_diff_output_fns_t_output_diff_modified_set", _wrap_svn_diff_output_fns_t_output_diff_modified_set, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_diff_modified_set(svn_diff_output_fns_t self, svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) output_diff_modified)"},
11459 { (char *)"svn_diff_output_fns_t_output_diff_modified_get", _wrap_svn_diff_output_fns_t_output_diff_modified_get, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_diff_modified_get(svn_diff_output_fns_t self) -> svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)"},
11460 { (char *)"svn_diff_output_fns_t_output_diff_latest_set", _wrap_svn_diff_output_fns_t_output_diff_latest_set, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_diff_latest_set(svn_diff_output_fns_t self, svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) output_diff_latest)"},
11461 { (char *)"svn_diff_output_fns_t_output_diff_latest_get", _wrap_svn_diff_output_fns_t_output_diff_latest_get, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_diff_latest_get(svn_diff_output_fns_t self) -> svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)"},
11462 { (char *)"svn_diff_output_fns_t_output_diff_common_set", _wrap_svn_diff_output_fns_t_output_diff_common_set, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_diff_common_set(svn_diff_output_fns_t self, svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t) output_diff_common)"},
11463 { (char *)"svn_diff_output_fns_t_output_diff_common_get", _wrap_svn_diff_output_fns_t_output_diff_common_get, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_diff_common_get(svn_diff_output_fns_t self) -> svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)"},
11464 { (char *)"svn_diff_output_fns_t_output_conflict_set", _wrap_svn_diff_output_fns_t_output_conflict_set, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_conflict_set(svn_diff_output_fns_t self, svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,svn_diff_t *) output_conflict)"},
11465 { (char *)"svn_diff_output_fns_t_output_conflict_get", _wrap_svn_diff_output_fns_t_output_conflict_get, METH_VARARGS, (char *)"svn_diff_output_fns_t_output_conflict_get(svn_diff_output_fns_t self) -> svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,svn_diff_t *)"},
11466 { (char *)"new_svn_diff_output_fns_t", _wrap_new_svn_diff_output_fns_t, METH_VARARGS, (char *)"new_svn_diff_output_fns_t() -> svn_diff_output_fns_t"},
11467 { (char *)"delete_svn_diff_output_fns_t", _wrap_delete_svn_diff_output_fns_t, METH_VARARGS, (char *)"delete_svn_diff_output_fns_t(svn_diff_output_fns_t self)"},
11468 { (char *)"svn_diff_output_fns_t_swigregister", svn_diff_output_fns_t_swigregister, METH_VARARGS, NULL},
11469 { (char *)"svn_diff_output2", _wrap_svn_diff_output2, METH_VARARGS, (char *)"svn_diff_output2(svn_diff_t * diff, void * output_baton, svn_diff_output_fns_t output_fns, svn_cancel_func_t cancel_func) -> svn_error_t"},
11470 { (char *)"svn_diff_output", _wrap_svn_diff_output, METH_VARARGS, (char *)"svn_diff_output(svn_diff_t * diff, void * output_baton, svn_diff_output_fns_t output_fns) -> svn_error_t"},
11471 { (char *)"svn_diff_file_options_t_ignore_space_set", _wrap_svn_diff_file_options_t_ignore_space_set, METH_VARARGS, (char *)"svn_diff_file_options_t_ignore_space_set(svn_diff_file_options_t self, svn_diff_file_ignore_space_t ignore_space)"},
11472 { (char *)"svn_diff_file_options_t_ignore_space_get", _wrap_svn_diff_file_options_t_ignore_space_get, METH_VARARGS, (char *)"svn_diff_file_options_t_ignore_space_get(svn_diff_file_options_t self) -> svn_diff_file_ignore_space_t"},
11473 { (char *)"svn_diff_file_options_t_ignore_eol_style_set", _wrap_svn_diff_file_options_t_ignore_eol_style_set, METH_VARARGS, (char *)"svn_diff_file_options_t_ignore_eol_style_set(svn_diff_file_options_t self, svn_boolean_t ignore_eol_style)"},
11474 { (char *)"svn_diff_file_options_t_ignore_eol_style_get", _wrap_svn_diff_file_options_t_ignore_eol_style_get, METH_VARARGS, (char *)"svn_diff_file_options_t_ignore_eol_style_get(svn_diff_file_options_t self) -> svn_boolean_t"},
11475 { (char *)"svn_diff_file_options_t_show_c_function_set", _wrap_svn_diff_file_options_t_show_c_function_set, METH_VARARGS, (char *)"svn_diff_file_options_t_show_c_function_set(svn_diff_file_options_t self, svn_boolean_t show_c_function)"},
11476 { (char *)"svn_diff_file_options_t_show_c_function_get", _wrap_svn_diff_file_options_t_show_c_function_get, METH_VARARGS, (char *)"svn_diff_file_options_t_show_c_function_get(svn_diff_file_options_t self) -> svn_boolean_t"},
11477 { (char *)"svn_diff_file_options_t_context_size_set", _wrap_svn_diff_file_options_t_context_size_set, METH_VARARGS, (char *)"svn_diff_file_options_t_context_size_set(svn_diff_file_options_t self, int context_size)"},
11478 { (char *)"svn_diff_file_options_t_context_size_get", _wrap_svn_diff_file_options_t_context_size_get, METH_VARARGS, (char *)"svn_diff_file_options_t_context_size_get(svn_diff_file_options_t self) -> int"},
11479 { (char *)"new_svn_diff_file_options_t", _wrap_new_svn_diff_file_options_t, METH_VARARGS, (char *)"new_svn_diff_file_options_t() -> svn_diff_file_options_t"},
11480 { (char *)"delete_svn_diff_file_options_t", _wrap_delete_svn_diff_file_options_t, METH_VARARGS, (char *)"delete_svn_diff_file_options_t(svn_diff_file_options_t self)"},
11481 { (char *)"svn_diff_file_options_t_swigregister", svn_diff_file_options_t_swigregister, METH_VARARGS, NULL},
11482 { (char *)"svn_diff_file_options_create", _wrap_svn_diff_file_options_create, METH_VARARGS, (char *)"svn_diff_file_options_create(apr_pool_t pool) -> svn_diff_file_options_t"},
11483 { (char *)"svn_diff_file_options_parse", _wrap_svn_diff_file_options_parse, METH_VARARGS, (char *)"svn_diff_file_options_parse(svn_diff_file_options_t options, apr_array_header_t args, apr_pool_t pool) -> svn_error_t"},
11484 { (char *)"svn_diff_file_diff_2", _wrap_svn_diff_file_diff_2, METH_VARARGS, (char *)"svn_diff_file_diff_2(char const * original, char const * modified, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t"},
11485 { (char *)"svn_diff_file_diff", _wrap_svn_diff_file_diff, METH_VARARGS, (char *)"svn_diff_file_diff(char const * original, char const * modified, apr_pool_t pool) -> svn_error_t"},
11486 { (char *)"svn_diff_file_diff3_2", _wrap_svn_diff_file_diff3_2, METH_VARARGS, (char *)"svn_diff_file_diff3_2(char const * original, char const * modified, char const * latest, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t"},
11487 { (char *)"svn_diff_file_diff3", _wrap_svn_diff_file_diff3, METH_VARARGS, (char *)"svn_diff_file_diff3(char const * original, char const * modified, char const * latest, apr_pool_t pool) -> svn_error_t"},
11488 { (char *)"svn_diff_file_diff4_2", _wrap_svn_diff_file_diff4_2, METH_VARARGS, (char *)"svn_diff_file_diff4_2(char const * original, char const * modified, char const * latest, char const * ancestor, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t"},
11489 { (char *)"svn_diff_file_diff4", _wrap_svn_diff_file_diff4, METH_VARARGS, (char *)"svn_diff_file_diff4(char const * original, char const * modified, char const * latest, char const * ancestor, apr_pool_t pool) -> svn_error_t"},
11490 { (char *)"svn_diff_file_output_unified4", _wrap_svn_diff_file_output_unified4, METH_VARARGS, (char *)"svn_diff_file_output_unified4(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, char const * original_header, char const * modified_header, char const * header_encoding, char const * relative_to_dir, svn_boolean_t show_c_function, int context_size, svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t"},
11491 { (char *)"svn_diff_file_output_unified3", _wrap_svn_diff_file_output_unified3, METH_VARARGS, (char *)"svn_diff_file_output_unified3(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, char const * original_header, char const * modified_header, char const * header_encoding, char const * relative_to_dir, svn_boolean_t show_c_function, apr_pool_t pool) -> svn_error_t"},
11492 { (char *)"svn_diff_file_output_unified2", _wrap_svn_diff_file_output_unified2, METH_VARARGS, (char *)"svn_diff_file_output_unified2(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, char const * original_header, char const * modified_header, char const * header_encoding, apr_pool_t pool) -> svn_error_t"},
11493 { (char *)"svn_diff_file_output_unified", _wrap_svn_diff_file_output_unified, METH_VARARGS, (char *)"svn_diff_file_output_unified(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, char const * original_header, char const * modified_header, apr_pool_t pool) -> svn_error_t"},
11494 { (char *)"svn_diff_file_output_merge3", _wrap_svn_diff_file_output_merge3, METH_VARARGS, (char *)"svn_diff_file_output_merge3(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, char const * latest_path, char const * conflict_original, char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, svn_diff_conflict_display_style_t conflict_style, svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t"},
11495 { (char *)"svn_diff_file_output_merge2", _wrap_svn_diff_file_output_merge2, METH_VARARGS, (char *)"svn_diff_file_output_merge2(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, char const * latest_path, char const * conflict_original, char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, svn_diff_conflict_display_style_t conflict_style, apr_pool_t pool) -> svn_error_t"},
11496 { (char *)"svn_diff_file_output_merge", _wrap_svn_diff_file_output_merge, METH_VARARGS, (char *)"svn_diff_file_output_merge(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, char const * latest_path, char const * conflict_original, char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, svn_boolean_t display_original_in_conflict, svn_boolean_t display_resolved_conflicts, apr_pool_t pool) -> svn_error_t"},
11497 { (char *)"svn_diff_output_binary", _wrap_svn_diff_output_binary, METH_VARARGS, (char *)"svn_diff_output_binary(svn_stream_t * output_stream, svn_stream_t * original, svn_stream_t * latest, svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t"},
11498 { (char *)"svn_diff_mem_string_diff", _wrap_svn_diff_mem_string_diff, METH_VARARGS, (char *)"svn_diff_mem_string_diff(svn_string_t const * original, svn_string_t const * modified, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t"},
11499 { (char *)"svn_diff_mem_string_diff3", _wrap_svn_diff_mem_string_diff3, METH_VARARGS, (char *)"svn_diff_mem_string_diff3(svn_string_t const * original, svn_string_t const * modified, svn_string_t const * latest, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t"},
11500 { (char *)"svn_diff_mem_string_diff4", _wrap_svn_diff_mem_string_diff4, METH_VARARGS, (char *)"svn_diff_mem_string_diff4(svn_string_t const * original, svn_string_t const * modified, svn_string_t const * latest, svn_string_t const * ancestor, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t"},
11501 { (char *)"svn_diff_mem_string_output_unified3", _wrap_svn_diff_mem_string_output_unified3, METH_VARARGS, (char *)"svn_diff_mem_string_output_unified3(svn_stream_t * output_stream, svn_diff_t * diff, svn_boolean_t with_diff_header, char const * hunk_delimiter, char const * original_header, char const * modified_header, char const * header_encoding, svn_string_t const * original, svn_string_t const * modified, int context_size, svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t"},
11502 { (char *)"svn_diff_mem_string_output_unified2", _wrap_svn_diff_mem_string_output_unified2, METH_VARARGS, (char *)"svn_diff_mem_string_output_unified2(svn_stream_t * output_stream, svn_diff_t * diff, svn_boolean_t with_diff_header, char const * hunk_delimiter, char const * original_header, char const * modified_header, char const * header_encoding, svn_string_t const * original, svn_string_t const * modified, apr_pool_t pool) -> svn_error_t"},
11503 { (char *)"svn_diff_mem_string_output_unified", _wrap_svn_diff_mem_string_output_unified, METH_VARARGS, (char *)"svn_diff_mem_string_output_unified(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_header, char const * modified_header, char const * header_encoding, svn_string_t const * original, svn_string_t const * modified, apr_pool_t pool) -> svn_error_t"},
11504 { (char *)"svn_diff_mem_string_output_merge3", _wrap_svn_diff_mem_string_output_merge3, METH_VARARGS, (char *)"svn_diff_mem_string_output_merge3(svn_stream_t * output_stream, svn_diff_t * diff, svn_string_t const * original, svn_string_t const * modified, svn_string_t const * latest, char const * conflict_original, char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, svn_diff_conflict_display_style_t style, svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t"},
11505 { (char *)"svn_diff_mem_string_output_merge2", _wrap_svn_diff_mem_string_output_merge2, METH_VARARGS, (char *)"svn_diff_mem_string_output_merge2(svn_stream_t * output_stream, svn_diff_t * diff, svn_string_t const * original, svn_string_t const * modified, svn_string_t const * latest, char const * conflict_original, char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, svn_diff_conflict_display_style_t style, apr_pool_t pool) -> svn_error_t"},
11506 { (char *)"svn_diff_mem_string_output_merge", _wrap_svn_diff_mem_string_output_merge, METH_VARARGS, (char *)"svn_diff_mem_string_output_merge(svn_stream_t * output_stream, svn_diff_t * diff, svn_string_t const * original, svn_string_t const * modified, svn_string_t const * latest, char const * conflict_original, char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, svn_boolean_t display_original_in_conflict, svn_boolean_t display_resolved_conflicts, apr_pool_t pool) -> svn_error_t"},
11507 { (char *)"svn_diff_hunk_readline_diff_text", _wrap_svn_diff_hunk_readline_diff_text, METH_VARARGS, (char *)"svn_diff_hunk_readline_diff_text(svn_diff_hunk_t * hunk, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
11508 { (char *)"svn_diff_hunk_readline_original_text", _wrap_svn_diff_hunk_readline_original_text, METH_VARARGS, (char *)"svn_diff_hunk_readline_original_text(svn_diff_hunk_t * hunk, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
11509 { (char *)"svn_diff_hunk_readline_modified_text", _wrap_svn_diff_hunk_readline_modified_text, METH_VARARGS, (char *)"svn_diff_hunk_readline_modified_text(svn_diff_hunk_t * hunk, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
11510 { (char *)"svn_diff_hunk_reset_diff_text", _wrap_svn_diff_hunk_reset_diff_text, METH_VARARGS, (char *)"svn_diff_hunk_reset_diff_text(svn_diff_hunk_t * hunk)"},
11511 { (char *)"svn_diff_hunk_reset_original_text", _wrap_svn_diff_hunk_reset_original_text, METH_VARARGS, (char *)"svn_diff_hunk_reset_original_text(svn_diff_hunk_t * hunk)"},
11512 { (char *)"svn_diff_hunk_reset_modified_text", _wrap_svn_diff_hunk_reset_modified_text, METH_VARARGS, (char *)"svn_diff_hunk_reset_modified_text(svn_diff_hunk_t * hunk)"},
11513 { (char *)"svn_diff_hunk_get_original_start", _wrap_svn_diff_hunk_get_original_start, METH_VARARGS, (char *)"svn_diff_hunk_get_original_start(svn_diff_hunk_t const * hunk) -> svn_linenum_t"},
11514 { (char *)"svn_diff_hunk_get_original_length", _wrap_svn_diff_hunk_get_original_length, METH_VARARGS, (char *)"svn_diff_hunk_get_original_length(svn_diff_hunk_t const * hunk) -> svn_linenum_t"},
11515 { (char *)"svn_diff_hunk_get_modified_start", _wrap_svn_diff_hunk_get_modified_start, METH_VARARGS, (char *)"svn_diff_hunk_get_modified_start(svn_diff_hunk_t const * hunk) -> svn_linenum_t"},
11516 { (char *)"svn_diff_hunk_get_modified_length", _wrap_svn_diff_hunk_get_modified_length, METH_VARARGS, (char *)"svn_diff_hunk_get_modified_length(svn_diff_hunk_t const * hunk) -> svn_linenum_t"},
11517 { (char *)"svn_diff_hunk_get_leading_context", _wrap_svn_diff_hunk_get_leading_context, METH_VARARGS, (char *)"svn_diff_hunk_get_leading_context(svn_diff_hunk_t const * hunk) -> svn_linenum_t"},
11518 { (char *)"svn_diff_hunk_get_trailing_context", _wrap_svn_diff_hunk_get_trailing_context, METH_VARARGS, (char *)"svn_diff_hunk_get_trailing_context(svn_diff_hunk_t const * hunk) -> svn_linenum_t"},
11519 { (char *)"svn_prop_patch_t_name_set", _wrap_svn_prop_patch_t_name_set, METH_VARARGS, (char *)"svn_prop_patch_t_name_set(svn_prop_patch_t self, char const * name)"},
11520 { (char *)"svn_prop_patch_t_name_get", _wrap_svn_prop_patch_t_name_get, METH_VARARGS, (char *)"svn_prop_patch_t_name_get(svn_prop_patch_t self) -> char const *"},
11521 { (char *)"svn_prop_patch_t_operation_set", _wrap_svn_prop_patch_t_operation_set, METH_VARARGS, (char *)"svn_prop_patch_t_operation_set(svn_prop_patch_t self, svn_diff_operation_kind_t operation)"},
11522 { (char *)"svn_prop_patch_t_operation_get", _wrap_svn_prop_patch_t_operation_get, METH_VARARGS, (char *)"svn_prop_patch_t_operation_get(svn_prop_patch_t self) -> svn_diff_operation_kind_t"},
11523 { (char *)"svn_prop_patch_t_hunks_set", _wrap_svn_prop_patch_t_hunks_set, METH_VARARGS, (char *)"svn_prop_patch_t_hunks_set(svn_prop_patch_t self, apr_array_header_t hunks)"},
11524 { (char *)"svn_prop_patch_t_hunks_get", _wrap_svn_prop_patch_t_hunks_get, METH_VARARGS, (char *)"svn_prop_patch_t_hunks_get(svn_prop_patch_t self) -> apr_array_header_t"},
11525 { (char *)"new_svn_prop_patch_t", _wrap_new_svn_prop_patch_t, METH_VARARGS, (char *)"new_svn_prop_patch_t() -> svn_prop_patch_t"},
11526 { (char *)"delete_svn_prop_patch_t", _wrap_delete_svn_prop_patch_t, METH_VARARGS, (char *)"delete_svn_prop_patch_t(svn_prop_patch_t self)"},
11527 { (char *)"svn_prop_patch_t_swigregister", svn_prop_patch_t_swigregister, METH_VARARGS, NULL},
11528 { (char *)"svn_diff_get_binary_diff_original_stream", _wrap_svn_diff_get_binary_diff_original_stream, METH_VARARGS, (char *)"svn_diff_get_binary_diff_original_stream(svn_diff_binary_patch_t const * bpatch, apr_pool_t result_pool) -> svn_stream_t *"},
11529 { (char *)"svn_diff_get_binary_diff_result_stream", _wrap_svn_diff_get_binary_diff_result_stream, METH_VARARGS, (char *)"svn_diff_get_binary_diff_result_stream(svn_diff_binary_patch_t const * bpatch, apr_pool_t result_pool) -> svn_stream_t *"},
11530 { (char *)"svn_patch_t_old_filename_set", _wrap_svn_patch_t_old_filename_set, METH_VARARGS, (char *)"svn_patch_t_old_filename_set(svn_patch_t self, char const * old_filename)"},
11531 { (char *)"svn_patch_t_old_filename_get", _wrap_svn_patch_t_old_filename_get, METH_VARARGS, (char *)"svn_patch_t_old_filename_get(svn_patch_t self) -> char const *"},
11532 { (char *)"svn_patch_t_new_filename_set", _wrap_svn_patch_t_new_filename_set, METH_VARARGS, (char *)"svn_patch_t_new_filename_set(svn_patch_t self, char const * new_filename)"},
11533 { (char *)"svn_patch_t_new_filename_get", _wrap_svn_patch_t_new_filename_get, METH_VARARGS, (char *)"svn_patch_t_new_filename_get(svn_patch_t self) -> char const *"},
11534 { (char *)"svn_patch_t_hunks_set", _wrap_svn_patch_t_hunks_set, METH_VARARGS, (char *)"svn_patch_t_hunks_set(svn_patch_t self, apr_array_header_t hunks)"},
11535 { (char *)"svn_patch_t_hunks_get", _wrap_svn_patch_t_hunks_get, METH_VARARGS, (char *)"svn_patch_t_hunks_get(svn_patch_t self) -> apr_array_header_t"},
11536 { (char *)"svn_patch_t_prop_patches_set", _wrap_svn_patch_t_prop_patches_set, METH_VARARGS, (char *)"svn_patch_t_prop_patches_set(svn_patch_t self, apr_hash_t prop_patches)"},
11537 { (char *)"svn_patch_t_prop_patches_get", _wrap_svn_patch_t_prop_patches_get, METH_VARARGS, (char *)"svn_patch_t_prop_patches_get(svn_patch_t self) -> apr_hash_t"},
11538 { (char *)"svn_patch_t_operation_set", _wrap_svn_patch_t_operation_set, METH_VARARGS, (char *)"svn_patch_t_operation_set(svn_patch_t self, svn_diff_operation_kind_t operation)"},
11539 { (char *)"svn_patch_t_operation_get", _wrap_svn_patch_t_operation_get, METH_VARARGS, (char *)"svn_patch_t_operation_get(svn_patch_t self) -> svn_diff_operation_kind_t"},
11540 { (char *)"svn_patch_t_reverse_set", _wrap_svn_patch_t_reverse_set, METH_VARARGS, (char *)"svn_patch_t_reverse_set(svn_patch_t self, svn_boolean_t reverse)"},
11541 { (char *)"svn_patch_t_reverse_get", _wrap_svn_patch_t_reverse_get, METH_VARARGS, (char *)"svn_patch_t_reverse_get(svn_patch_t self) -> svn_boolean_t"},
11542 { (char *)"svn_patch_t_mergeinfo_set", _wrap_svn_patch_t_mergeinfo_set, METH_VARARGS, (char *)"svn_patch_t_mergeinfo_set(svn_patch_t self, apr_hash_t mergeinfo)"},
11543 { (char *)"svn_patch_t_mergeinfo_get", _wrap_svn_patch_t_mergeinfo_get, METH_VARARGS, (char *)"svn_patch_t_mergeinfo_get(svn_patch_t self) -> apr_hash_t"},
11544 { (char *)"svn_patch_t_reverse_mergeinfo_set", _wrap_svn_patch_t_reverse_mergeinfo_set, METH_VARARGS, (char *)"svn_patch_t_reverse_mergeinfo_set(svn_patch_t self, apr_hash_t reverse_mergeinfo)"},
11545 { (char *)"svn_patch_t_reverse_mergeinfo_get", _wrap_svn_patch_t_reverse_mergeinfo_get, METH_VARARGS, (char *)"svn_patch_t_reverse_mergeinfo_get(svn_patch_t self) -> apr_hash_t"},
11546 { (char *)"svn_patch_t_binary_patch_set", _wrap_svn_patch_t_binary_patch_set, METH_VARARGS, (char *)"svn_patch_t_binary_patch_set(svn_patch_t self, svn_diff_binary_patch_t * binary_patch)"},
11547 { (char *)"svn_patch_t_binary_patch_get", _wrap_svn_patch_t_binary_patch_get, METH_VARARGS, (char *)"svn_patch_t_binary_patch_get(svn_patch_t self) -> svn_diff_binary_patch_t *"},
11548 { (char *)"svn_patch_t_old_executable_bit_set", _wrap_svn_patch_t_old_executable_bit_set, METH_VARARGS, (char *)"svn_patch_t_old_executable_bit_set(svn_patch_t self, svn_tristate_t old_executable_bit)"},
11549 { (char *)"svn_patch_t_old_executable_bit_get", _wrap_svn_patch_t_old_executable_bit_get, METH_VARARGS, (char *)"svn_patch_t_old_executable_bit_get(svn_patch_t self) -> svn_tristate_t"},
11550 { (char *)"svn_patch_t_new_executable_bit_set", _wrap_svn_patch_t_new_executable_bit_set, METH_VARARGS, (char *)"svn_patch_t_new_executable_bit_set(svn_patch_t self, svn_tristate_t new_executable_bit)"},
11551 { (char *)"svn_patch_t_new_executable_bit_get", _wrap_svn_patch_t_new_executable_bit_get, METH_VARARGS, (char *)"svn_patch_t_new_executable_bit_get(svn_patch_t self) -> svn_tristate_t"},
11552 { (char *)"svn_patch_t_old_symlink_bit_set", _wrap_svn_patch_t_old_symlink_bit_set, METH_VARARGS, (char *)"svn_patch_t_old_symlink_bit_set(svn_patch_t self, svn_tristate_t old_symlink_bit)"},
11553 { (char *)"svn_patch_t_old_symlink_bit_get", _wrap_svn_patch_t_old_symlink_bit_get, METH_VARARGS, (char *)"svn_patch_t_old_symlink_bit_get(svn_patch_t self) -> svn_tristate_t"},
11554 { (char *)"svn_patch_t_new_symlink_bit_set", _wrap_svn_patch_t_new_symlink_bit_set, METH_VARARGS, (char *)"svn_patch_t_new_symlink_bit_set(svn_patch_t self, svn_tristate_t new_symlink_bit)"},
11555 { (char *)"svn_patch_t_new_symlink_bit_get", _wrap_svn_patch_t_new_symlink_bit_get, METH_VARARGS, (char *)"svn_patch_t_new_symlink_bit_get(svn_patch_t self) -> svn_tristate_t"},
11556 { (char *)"new_svn_patch_t", _wrap_new_svn_patch_t, METH_VARARGS, (char *)"new_svn_patch_t() -> svn_patch_t"},
11557 { (char *)"delete_svn_patch_t", _wrap_delete_svn_patch_t, METH_VARARGS, (char *)"delete_svn_patch_t(svn_patch_t self)"},
11558 { (char *)"svn_patch_t_swigregister", svn_patch_t_swigregister, METH_VARARGS, NULL},
11559 { (char *)"svn_diff_open_patch_file", _wrap_svn_diff_open_patch_file, METH_VARARGS, (char *)"svn_diff_open_patch_file(char const * local_abspath, apr_pool_t result_pool) -> svn_error_t"},
11560 { (char *)"svn_diff_parse_next_patch", _wrap_svn_diff_parse_next_patch, METH_VARARGS, (char *)"svn_diff_parse_next_patch(svn_patch_file_t * patch_file, svn_boolean_t reverse, svn_boolean_t ignore_whitespace, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
11561 { (char *)"svn_diff_close_patch_file", _wrap_svn_diff_close_patch_file, METH_VARARGS, (char *)"svn_diff_close_patch_file(svn_patch_file_t * patch_file, apr_pool_t scratch_pool) -> svn_error_t"},
11562 { (char *)"svn_diff_t_swigregister", svn_diff_t_swigregister, METH_VARARGS, NULL},
11563 { (char *)"svn_diff_hunk_t_swigregister", svn_diff_hunk_t_swigregister, METH_VARARGS, NULL},
11564 { (char *)"svn_diff_binary_patch_t_swigregister", svn_diff_binary_patch_t_swigregister, METH_VARARGS, NULL},
11565 { (char *)"svn_patch_file_t_swigregister", svn_patch_file_t_swigregister, METH_VARARGS, NULL},
11566 { (char *)"svn_diff_fns2_invoke_datasources_open", _wrap_svn_diff_fns2_invoke_datasources_open, METH_VARARGS, (char *)"svn_diff_fns2_invoke_datasources_open(svn_diff_fns2_t _obj, void * diff_baton, apr_off_t * prefix_lines, apr_off_t * suffix_lines, svn_diff_datasource_e const * datasources, apr_size_t datasources_len) -> svn_error_t"},
11567 { (char *)"svn_diff_fns2_invoke_datasource_close", _wrap_svn_diff_fns2_invoke_datasource_close, METH_VARARGS, (char *)"svn_diff_fns2_invoke_datasource_close(svn_diff_fns2_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"},
11568 { (char *)"svn_diff_fns2_invoke_datasource_get_next_token", _wrap_svn_diff_fns2_invoke_datasource_get_next_token, METH_VARARGS, (char *)"svn_diff_fns2_invoke_datasource_get_next_token(svn_diff_fns2_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"},
11569 { (char *)"svn_diff_fns2_invoke_token_compare", _wrap_svn_diff_fns2_invoke_token_compare, METH_VARARGS, (char *)"svn_diff_fns2_invoke_token_compare(svn_diff_fns2_t _obj, void * diff_baton, void * ltoken, void * rtoken) -> svn_error_t"},
11570 { (char *)"svn_diff_fns2_invoke_token_discard", _wrap_svn_diff_fns2_invoke_token_discard, METH_VARARGS, (char *)"svn_diff_fns2_invoke_token_discard(svn_diff_fns2_t _obj, void * diff_baton, void * token)"},
11571 { (char *)"svn_diff_fns2_invoke_token_discard_all", _wrap_svn_diff_fns2_invoke_token_discard_all, METH_VARARGS, (char *)"svn_diff_fns2_invoke_token_discard_all(svn_diff_fns2_t _obj, void * diff_baton)"},
11572 { (char *)"svn_diff_fns_invoke_datasource_open", _wrap_svn_diff_fns_invoke_datasource_open, METH_VARARGS, (char *)"svn_diff_fns_invoke_datasource_open(svn_diff_fns_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"},
11573 { (char *)"svn_diff_fns_invoke_datasource_close", _wrap_svn_diff_fns_invoke_datasource_close, METH_VARARGS, (char *)"svn_diff_fns_invoke_datasource_close(svn_diff_fns_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"},
11574 { (char *)"svn_diff_fns_invoke_datasource_get_next_token", _wrap_svn_diff_fns_invoke_datasource_get_next_token, METH_VARARGS, (char *)"svn_diff_fns_invoke_datasource_get_next_token(svn_diff_fns_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"},
11575 { (char *)"svn_diff_fns_invoke_token_compare", _wrap_svn_diff_fns_invoke_token_compare, METH_VARARGS, (char *)"svn_diff_fns_invoke_token_compare(svn_diff_fns_t _obj, void * diff_baton, void * ltoken, void * rtoken) -> svn_error_t"},
11576 { (char *)"svn_diff_fns_invoke_token_discard", _wrap_svn_diff_fns_invoke_token_discard, METH_VARARGS, (char *)"svn_diff_fns_invoke_token_discard(svn_diff_fns_t _obj, void * diff_baton, void * token)"},
11577 { (char *)"svn_diff_fns_invoke_token_discard_all", _wrap_svn_diff_fns_invoke_token_discard_all, METH_VARARGS, (char *)"svn_diff_fns_invoke_token_discard_all(svn_diff_fns_t _obj, void * diff_baton)"},
11578 { (char *)"svn_diff_output_fns_invoke_output_common", _wrap_svn_diff_output_fns_invoke_output_common, METH_VARARGS, (char *)"svn_diff_output_fns_invoke_output_common(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length) -> svn_error_t"},
11579 { (char *)"svn_diff_output_fns_invoke_output_diff_modified", _wrap_svn_diff_output_fns_invoke_output_diff_modified, METH_VARARGS, (char *)"svn_diff_output_fns_invoke_output_diff_modified(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length) -> svn_error_t"},
11580 { (char *)"svn_diff_output_fns_invoke_output_diff_latest", _wrap_svn_diff_output_fns_invoke_output_diff_latest, METH_VARARGS, (char *)"svn_diff_output_fns_invoke_output_diff_latest(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length) -> svn_error_t"},
11581 { (char *)"svn_diff_output_fns_invoke_output_diff_common", _wrap_svn_diff_output_fns_invoke_output_diff_common, METH_VARARGS, (char *)"svn_diff_output_fns_invoke_output_diff_common(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length) -> svn_error_t"},
11582 { (char *)"svn_diff_output_fns_invoke_output_conflict", _wrap_svn_diff_output_fns_invoke_output_conflict, METH_VARARGS, (char *)"svn_diff_output_fns_invoke_output_conflict(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length, svn_diff_t * resolved_diff) -> svn_error_t"},
11583 { NULL, NULL, 0, NULL }
11584 };
11585
11586
11587 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
11588
11589 static swig_type_info _swigt__p_apr_array_header_t = {"_p_apr_array_header_t", "apr_array_header_t *|svn_rangelist_t *", 0, 0, (void*)0, 0};
11590 static swig_type_info _swigt__p_apr_hash_t = {"_p_apr_hash_t", "svn_mergeinfo_t|apr_hash_t *", 0, 0, (void*)0, 0};
11591 static swig_type_info _swigt__p_apr_int32_t = {"_p_apr_int32_t", "apr_int32_t *|time_t *", 0, 0, (void*)0, 0};
11592 static swig_type_info _swigt__p_apr_int64_t = {"_p_apr_int64_t", "apr_int64_t *|svn_filesize_t *|apr_time_t *", 0, 0, (void*)0, 0};
11593 static swig_type_info _swigt__p_apr_off_t = {"_p_apr_off_t", "apr_off_t *", 0, 0, (void*)0, 0};
11594 static swig_type_info _swigt__p_apr_pool_t = {"_p_apr_pool_t", "apr_pool_t *", 0, 0, (void*)0, 0};
11595 static swig_type_info _swigt__p_apr_uint32_t = {"_p_apr_uint32_t", "apr_uint32_t *", 0, 0, (void*)0, 0};
11596 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
11597 static swig_type_info _swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_opt_subcommand_t *|svn_error_t *(*)(apr_getopt_t *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
11598 static swig_type_info _swigt__p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t = {"_p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t", "svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)", 0, 0, (void*)0, 0};
11599 static swig_type_info _swigt__p_f_p_void__p_svn_error_t = {"_p_f_p_void__p_svn_error_t", "svn_cancel_func_t|svn_error_t *(*)(void *)", 0, 0, (void*)0, 0};
11600 static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "void (*)(void *)", 0, 0, (void*)0, 0};
11601 static swig_type_info _swigt__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t = {"_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t", "svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t)", 0, 0, (void*)0, 0};
11602 static swig_type_info _swigt__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t = {"_p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t", "svn_error_t *(*)(void *,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,apr_off_t,svn_diff_t *)", 0, 0, (void*)0, 0};
11603 static swig_type_info _swigt__p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t = {"_p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t", "svn_error_t *(*)(void *,apr_off_t *,apr_off_t *,svn_diff_datasource_e const *,apr_size_t)", 0, 0, (void*)0, 0};
11604 static swig_type_info _swigt__p_f_p_void_p_void__void = {"_p_f_p_void_p_void__void", "void (*)(void *,void *)", 0, 0, (void*)0, 0};
11605 static swig_type_info _swigt__p_f_p_void_p_void_p_void_p_int__p_svn_error_t = {"_p_f_p_void_p_void_p_void_p_int__p_svn_error_t", "svn_error_t *(*)(void *,void *,void *,int *)", 0, 0, (void*)0, 0};
11606 static swig_type_info _swigt__p_f_p_void_svn_diff_datasource_e__p_svn_error_t = {"_p_f_p_void_svn_diff_datasource_e__p_svn_error_t", "svn_error_t *(*)(void *,svn_diff_datasource_e)", 0, 0, (void*)0, 0};
11607 static swig_type_info _swigt__p_int = {"_p_int", "int *|svn_boolean_t *|apr_status_t *", 0, 0, (void*)0, 0};
11608 static swig_type_info _swigt__p_long = {"_p_long", "long *|svn_revnum_t *", 0, 0, (void*)0, 0};
11609 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
11610 static swig_type_info _swigt__p_p_svn_diff_t = {"_p_p_svn_diff_t", "struct svn_diff_t **|svn_diff_t **", 0, 0, (void*)0, 0};
11611 static swig_type_info _swigt__p_p_svn_patch_file_t = {"_p_p_svn_patch_file_t", "struct svn_patch_file_t **|svn_patch_file_t **", 0, 0, (void*)0, 0};
11612 static swig_type_info _swigt__p_p_svn_patch_t = {"_p_p_svn_patch_t", "struct svn_patch_t **|svn_patch_t **", 0, 0, (void*)0, 0};
11613 static swig_type_info _swigt__p_p_svn_stringbuf_t = {"_p_p_svn_stringbuf_t", "struct svn_stringbuf_t **|svn_stringbuf_t **", 0, 0, (void*)0, 0};
11614 static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
11615 static swig_type_info _swigt__p_svn_auth_baton_t = {"_p_svn_auth_baton_t", "struct svn_auth_baton_t *|svn_auth_baton_t *", 0, 0, (void*)0, 0};
11616 static swig_type_info _swigt__p_svn_auth_cred_simple_t = {"_p_svn_auth_cred_simple_t", "struct svn_auth_cred_simple_t *|svn_auth_cred_simple_t *", 0, 0, (void*)0, 0};
11617 static swig_type_info _swigt__p_svn_auth_cred_ssl_client_cert_pw_t = {"_p_svn_auth_cred_ssl_client_cert_pw_t", "struct svn_auth_cred_ssl_client_cert_pw_t *|svn_auth_cred_ssl_client_cert_pw_t *", 0, 0, (void*)0, 0};
11618 static swig_type_info _swigt__p_svn_auth_cred_ssl_client_cert_t = {"_p_svn_auth_cred_ssl_client_cert_t", "struct svn_auth_cred_ssl_client_cert_t *|svn_auth_cred_ssl_client_cert_t *", 0, 0, (void*)0, 0};
11619 static swig_type_info _swigt__p_svn_auth_cred_ssl_server_trust_t = {"_p_svn_auth_cred_ssl_server_trust_t", "struct svn_auth_cred_ssl_server_trust_t *|svn_auth_cred_ssl_server_trust_t *", 0, 0, (void*)0, 0};
11620 static swig_type_info _swigt__p_svn_auth_cred_username_t = {"_p_svn_auth_cred_username_t", "struct svn_auth_cred_username_t *|svn_auth_cred_username_t *", 0, 0, (void*)0, 0};
11621 static swig_type_info _swigt__p_svn_auth_iterstate_t = {"_p_svn_auth_iterstate_t", "struct svn_auth_iterstate_t *|svn_auth_iterstate_t *", 0, 0, (void*)0, 0};
11622 static swig_type_info _swigt__p_svn_auth_provider_object_t = {"_p_svn_auth_provider_object_t", "struct svn_auth_provider_object_t *|svn_auth_provider_object_t *", 0, 0, (void*)0, 0};
11623 static swig_type_info _swigt__p_svn_auth_provider_t = {"_p_svn_auth_provider_t", "struct svn_auth_provider_t *|svn_auth_provider_t *", 0, 0, (void*)0, 0};
11624 static swig_type_info _swigt__p_svn_auth_ssl_server_cert_info_t = {"_p_svn_auth_ssl_server_cert_info_t", "struct svn_auth_ssl_server_cert_info_t *|svn_auth_ssl_server_cert_info_t *", 0, 0, (void*)0, 0};
11625 static swig_type_info _swigt__p_svn_cache_config_t = {"_p_svn_cache_config_t", "struct svn_cache_config_t *|svn_cache_config_t *", 0, 0, (void*)0, 0};
11626 static swig_type_info _swigt__p_svn_checksum_ctx_t = {"_p_svn_checksum_ctx_t", "struct svn_checksum_ctx_t *|svn_checksum_ctx_t *", 0, 0, (void*)0, 0};
11627 static swig_type_info _swigt__p_svn_checksum_kind_t = {"_p_svn_checksum_kind_t", "enum svn_checksum_kind_t *|svn_checksum_kind_t *", 0, 0, (void*)0, 0};
11628 static swig_type_info _swigt__p_svn_checksum_t = {"_p_svn_checksum_t", "struct svn_checksum_t *|svn_checksum_t *", 0, 0, (void*)0, 0};
11629 static swig_type_info _swigt__p_svn_client__shelf_version_t = {"_p_svn_client__shelf_version_t", "svn_client__shelf_version_t *", 0, 0, (void*)0, 0};
11630 static swig_type_info _swigt__p_svn_client_conflict_option_t = {"_p_svn_client_conflict_option_t", "svn_client_conflict_option_t *", 0, 0, (void*)0, 0};
11631 static swig_type_info _swigt__p_svn_commit_info_t = {"_p_svn_commit_info_t", "struct svn_commit_info_t *|svn_commit_info_t *", 0, 0, (void*)0, 0};
11632 static swig_type_info _swigt__p_svn_config_t = {"_p_svn_config_t", "struct svn_config_t *|svn_config_t *", 0, 0, (void*)0, 0};
11633 static swig_type_info _swigt__p_svn_depth_t = {"_p_svn_depth_t", "enum svn_depth_t *|svn_depth_t *", 0, 0, (void*)0, 0};
11634 static swig_type_info _swigt__p_svn_diff_binary_patch_t = {"_p_svn_diff_binary_patch_t", "struct svn_diff_binary_patch_t *|svn_diff_binary_patch_t *", 0, 0, (void*)0, 0};
11635 static swig_type_info _swigt__p_svn_diff_conflict_display_style_t = {"_p_svn_diff_conflict_display_style_t", "enum svn_diff_conflict_display_style_t *|svn_diff_conflict_display_style_t *", 0, 0, (void*)0, 0};
11636 static swig_type_info _swigt__p_svn_diff_datasource_e = {"_p_svn_diff_datasource_e", "enum svn_diff_datasource_e *|svn_diff_datasource_e *", 0, 0, (void*)0, 0};
11637 static swig_type_info _swigt__p_svn_diff_file_ignore_space_t = {"_p_svn_diff_file_ignore_space_t", "enum svn_diff_file_ignore_space_t *|svn_diff_file_ignore_space_t *", 0, 0, (void*)0, 0};
11638 static swig_type_info _swigt__p_svn_diff_file_options_t = {"_p_svn_diff_file_options_t", "struct svn_diff_file_options_t *|svn_diff_file_options_t *", 0, 0, (void*)0, 0};
11639 static swig_type_info _swigt__p_svn_diff_fns2_t = {"_p_svn_diff_fns2_t", "struct svn_diff_fns2_t *|svn_diff_fns2_t *", 0, 0, (void*)0, 0};
11640 static swig_type_info _swigt__p_svn_diff_fns_t = {"_p_svn_diff_fns_t", "struct svn_diff_fns_t *|svn_diff_fns_t *", 0, 0, (void*)0, 0};
11641 static swig_type_info _swigt__p_svn_diff_hunk_t = {"_p_svn_diff_hunk_t", "struct svn_diff_hunk_t *|svn_diff_hunk_t *", 0, 0, (void*)0, 0};
11642 static swig_type_info _swigt__p_svn_diff_operation_kind_e = {"_p_svn_diff_operation_kind_e", "svn_diff_operation_kind_t *|enum svn_diff_operation_kind_e *", 0, 0, (void*)0, 0};
11643 static swig_type_info _swigt__p_svn_diff_output_fns_t = {"_p_svn_diff_output_fns_t", "struct svn_diff_output_fns_t *|svn_diff_output_fns_t *", 0, 0, (void*)0, 0};
11644 static swig_type_info _swigt__p_svn_diff_t = {"_p_svn_diff_t", "struct svn_diff_t *|svn_diff_t *", 0, 0, (void*)0, 0};
11645 static swig_type_info _swigt__p_svn_dirent_t = {"_p_svn_dirent_t", "struct svn_dirent_t *|svn_dirent_t *", 0, 0, (void*)0, 0};
11646 static swig_type_info _swigt__p_svn_errno_t = {"_p_svn_errno_t", "enum svn_errno_t *|svn_errno_t *", 0, 0, (void*)0, 0};
11647 static swig_type_info _swigt__p_svn_error_t = {"_p_svn_error_t", "svn_error_t *", 0, 0, (void*)0, 0};
11648 static swig_type_info _swigt__p_svn_fs_lock_target_t = {"_p_svn_fs_lock_target_t", "svn_fs_lock_target_t *", 0, 0, (void*)0, 0};
11649 static swig_type_info _swigt__p_svn_io_dirent2_t = {"_p_svn_io_dirent2_t", "struct svn_io_dirent2_t *|svn_io_dirent2_t *", 0, 0, (void*)0, 0};
11650 static swig_type_info _swigt__p_svn_io_dirent_t = {"_p_svn_io_dirent_t", "struct svn_io_dirent_t *|svn_io_dirent_t *", 0, 0, (void*)0, 0};
11651 static swig_type_info _swigt__p_svn_io_file_del_t = {"_p_svn_io_file_del_t", "enum svn_io_file_del_t *|svn_io_file_del_t *", 0, 0, (void*)0, 0};
11652 static swig_type_info _swigt__p_svn_location_segment_t = {"_p_svn_location_segment_t", "struct svn_location_segment_t *|svn_location_segment_t *", 0, 0, (void*)0, 0};
11653 static swig_type_info _swigt__p_svn_lock_t = {"_p_svn_lock_t", "struct svn_lock_t *|svn_lock_t *", 0, 0, (void*)0, 0};
11654 static swig_type_info _swigt__p_svn_log_changed_path2_t = {"_p_svn_log_changed_path2_t", "struct svn_log_changed_path2_t *|svn_log_changed_path2_t *", 0, 0, (void*)0, 0};
11655 static swig_type_info _swigt__p_svn_log_changed_path_t = {"_p_svn_log_changed_path_t", "struct svn_log_changed_path_t *|svn_log_changed_path_t *", 0, 0, (void*)0, 0};
11656 static swig_type_info _swigt__p_svn_log_entry_t = {"_p_svn_log_entry_t", "struct svn_log_entry_t *|svn_log_entry_t *", 0, 0, (void*)0, 0};
11657 static swig_type_info _swigt__p_svn_merge_range_t = {"_p_svn_merge_range_t", "struct svn_merge_range_t *|svn_merge_range_t *", 0, 0, (void*)0, 0};
11658 static swig_type_info _swigt__p_svn_mergeinfo_inheritance_t = {"_p_svn_mergeinfo_inheritance_t", "enum svn_mergeinfo_inheritance_t *|svn_mergeinfo_inheritance_t *", 0, 0, (void*)0, 0};
11659 static swig_type_info _swigt__p_svn_node_kind_t = {"_p_svn_node_kind_t", "enum svn_node_kind_t *|svn_node_kind_t *", 0, 0, (void*)0, 0};
11660 static swig_type_info _swigt__p_svn_opt_revision_range_t = {"_p_svn_opt_revision_range_t", "struct svn_opt_revision_range_t *|svn_opt_revision_range_t *", 0, 0, (void*)0, 0};
11661 static swig_type_info _swigt__p_svn_opt_revision_t = {"_p_svn_opt_revision_t", "struct svn_opt_revision_t *|svn_opt_revision_t *", 0, 0, (void*)0, 0};
11662 static swig_type_info _swigt__p_svn_opt_revision_value_t = {"_p_svn_opt_revision_value_t", "union svn_opt_revision_value_t *|svn_opt_revision_value_t *", 0, 0, (void*)0, 0};
11663 static swig_type_info _swigt__p_svn_opt_subcommand_desc2_t = {"_p_svn_opt_subcommand_desc2_t", "struct svn_opt_subcommand_desc2_t *|svn_opt_subcommand_desc2_t *", 0, 0, (void*)0, 0};
11664 static swig_type_info _swigt__p_svn_opt_subcommand_desc3_t = {"_p_svn_opt_subcommand_desc3_t", "struct svn_opt_subcommand_desc3_t *|svn_opt_subcommand_desc3_t *", 0, 0, (void*)0, 0};
11665 static swig_type_info _swigt__p_svn_opt_subcommand_desc_t = {"_p_svn_opt_subcommand_desc_t", "struct svn_opt_subcommand_desc_t *|svn_opt_subcommand_desc_t *", 0, 0, (void*)0, 0};
11666 static swig_type_info _swigt__p_svn_patch_file_t = {"_p_svn_patch_file_t", "struct svn_patch_file_t *|svn_patch_file_t *", 0, 0, (void*)0, 0};
11667 static swig_type_info _swigt__p_svn_patch_t = {"_p_svn_patch_t", "struct svn_patch_t *|svn_patch_t *", 0, 0, (void*)0, 0};
11668 static swig_type_info _swigt__p_svn_prop_inherited_item_t = {"_p_svn_prop_inherited_item_t", "struct svn_prop_inherited_item_t *|svn_prop_inherited_item_t *", 0, 0, (void*)0, 0};
11669 static swig_type_info _swigt__p_svn_prop_kind = {"_p_svn_prop_kind", "svn_prop_kind_t *|enum svn_prop_kind *", 0, 0, (void*)0, 0};
11670 static swig_type_info _swigt__p_svn_prop_patch_t = {"_p_svn_prop_patch_t", "struct svn_prop_patch_t *|svn_prop_patch_t *", 0, 0, (void*)0, 0};
11671 static swig_type_info _swigt__p_svn_stream_mark_t = {"_p_svn_stream_mark_t", "struct svn_stream_mark_t *|svn_stream_mark_t *", 0, 0, (void*)0, 0};
11672 static swig_type_info _swigt__p_svn_stream_t = {"_p_svn_stream_t", "struct svn_stream_t *|svn_stream_t *", 0, 0, (void*)0, 0};
11673 static swig_type_info _swigt__p_svn_string_t = {"_p_svn_string_t", "struct svn_string_t *|svn_string_t *", 0, 0, (void*)0, 0};
11674 static swig_type_info _swigt__p_svn_stringbuf_t = {"_p_svn_stringbuf_t", "struct svn_stringbuf_t *|svn_stringbuf_t *", 0, 0, (void*)0, 0};
11675 static swig_type_info _swigt__p_svn_tristate_t = {"_p_svn_tristate_t", "enum svn_tristate_t *|svn_tristate_t *", 0, 0, (void*)0, 0};
11676 static swig_type_info _swigt__p_svn_version_checklist_t = {"_p_svn_version_checklist_t", "struct svn_version_checklist_t *|svn_version_checklist_t *", 0, 0, (void*)0, 0};
11677 static swig_type_info _swigt__p_svn_version_ext_linked_lib_t = {"_p_svn_version_ext_linked_lib_t", "struct svn_version_ext_linked_lib_t *|svn_version_ext_linked_lib_t *", 0, 0, (void*)0, 0};
11678 static swig_type_info _swigt__p_svn_version_ext_loaded_lib_t = {"_p_svn_version_ext_loaded_lib_t", "struct svn_version_ext_loaded_lib_t *|svn_version_ext_loaded_lib_t *", 0, 0, (void*)0, 0};
11679 static swig_type_info _swigt__p_svn_version_extended_t = {"_p_svn_version_extended_t", "struct svn_version_extended_t *|svn_version_extended_t *", 0, 0, (void*)0, 0};
11680 static swig_type_info _swigt__p_svn_version_t = {"_p_svn_version_t", "struct svn_version_t *|svn_version_t *", 0, 0, (void*)0, 0};
11681 static swig_type_info _swigt__p_svn_wc_external_item2_t = {"_p_svn_wc_external_item2_t", "svn_wc_external_item2_t *", 0, 0, (void*)0, 0};
11682 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|svn_linenum_t *", 0, 0, (void*)0, 0};
11683 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
11684
11685 static swig_type_info *swig_type_initial[] = {
11686 &_swigt__p_apr_array_header_t,
11687 &_swigt__p_apr_hash_t,
11688 &_swigt__p_apr_int32_t,
11689 &_swigt__p_apr_int64_t,
11690 &_swigt__p_apr_off_t,
11691 &_swigt__p_apr_pool_t,
11692 &_swigt__p_apr_uint32_t,
11693 &_swigt__p_char,
11694 &_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
11695 &_swigt__p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t,
11696 &_swigt__p_f_p_void__p_svn_error_t,
11697 &_swigt__p_f_p_void__void,
11698 &_swigt__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t,
11699 &_swigt__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t,
11700 &_swigt__p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t,
11701 &_swigt__p_f_p_void_p_void__void,
11702 &_swigt__p_f_p_void_p_void_p_void_p_int__p_svn_error_t,
11703 &_swigt__p_f_p_void_svn_diff_datasource_e__p_svn_error_t,
11704 &_swigt__p_int,
11705 &_swigt__p_long,
11706 &_swigt__p_p_char,
11707 &_swigt__p_p_svn_diff_t,
11708 &_swigt__p_p_svn_patch_file_t,
11709 &_swigt__p_p_svn_patch_t,
11710 &_swigt__p_p_svn_stringbuf_t,
11711 &_swigt__p_p_void,
11712 &_swigt__p_svn_auth_baton_t,
11713 &_swigt__p_svn_auth_cred_simple_t,
11714 &_swigt__p_svn_auth_cred_ssl_client_cert_pw_t,
11715 &_swigt__p_svn_auth_cred_ssl_client_cert_t,
11716 &_swigt__p_svn_auth_cred_ssl_server_trust_t,
11717 &_swigt__p_svn_auth_cred_username_t,
11718 &_swigt__p_svn_auth_iterstate_t,
11719 &_swigt__p_svn_auth_provider_object_t,
11720 &_swigt__p_svn_auth_provider_t,
11721 &_swigt__p_svn_auth_ssl_server_cert_info_t,
11722 &_swigt__p_svn_cache_config_t,
11723 &_swigt__p_svn_checksum_ctx_t,
11724 &_swigt__p_svn_checksum_kind_t,
11725 &_swigt__p_svn_checksum_t,
11726 &_swigt__p_svn_client__shelf_version_t,
11727 &_swigt__p_svn_client_conflict_option_t,
11728 &_swigt__p_svn_commit_info_t,
11729 &_swigt__p_svn_config_t,
11730 &_swigt__p_svn_depth_t,
11731 &_swigt__p_svn_diff_binary_patch_t,
11732 &_swigt__p_svn_diff_conflict_display_style_t,
11733 &_swigt__p_svn_diff_datasource_e,
11734 &_swigt__p_svn_diff_file_ignore_space_t,
11735 &_swigt__p_svn_diff_file_options_t,
11736 &_swigt__p_svn_diff_fns2_t,
11737 &_swigt__p_svn_diff_fns_t,
11738 &_swigt__p_svn_diff_hunk_t,
11739 &_swigt__p_svn_diff_operation_kind_e,
11740 &_swigt__p_svn_diff_output_fns_t,
11741 &_swigt__p_svn_diff_t,
11742 &_swigt__p_svn_dirent_t,
11743 &_swigt__p_svn_errno_t,
11744 &_swigt__p_svn_error_t,
11745 &_swigt__p_svn_fs_lock_target_t,
11746 &_swigt__p_svn_io_dirent2_t,
11747 &_swigt__p_svn_io_dirent_t,
11748 &_swigt__p_svn_io_file_del_t,
11749 &_swigt__p_svn_location_segment_t,
11750 &_swigt__p_svn_lock_t,
11751 &_swigt__p_svn_log_changed_path2_t,
11752 &_swigt__p_svn_log_changed_path_t,
11753 &_swigt__p_svn_log_entry_t,
11754 &_swigt__p_svn_merge_range_t,
11755 &_swigt__p_svn_mergeinfo_inheritance_t,
11756 &_swigt__p_svn_node_kind_t,
11757 &_swigt__p_svn_opt_revision_range_t,
11758 &_swigt__p_svn_opt_revision_t,
11759 &_swigt__p_svn_opt_revision_value_t,
11760 &_swigt__p_svn_opt_subcommand_desc2_t,
11761 &_swigt__p_svn_opt_subcommand_desc3_t,
11762 &_swigt__p_svn_opt_subcommand_desc_t,
11763 &_swigt__p_svn_patch_file_t,
11764 &_swigt__p_svn_patch_t,
11765 &_swigt__p_svn_prop_inherited_item_t,
11766 &_swigt__p_svn_prop_kind,
11767 &_swigt__p_svn_prop_patch_t,
11768 &_swigt__p_svn_stream_mark_t,
11769 &_swigt__p_svn_stream_t,
11770 &_swigt__p_svn_string_t,
11771 &_swigt__p_svn_stringbuf_t,
11772 &_swigt__p_svn_tristate_t,
11773 &_swigt__p_svn_version_checklist_t,
11774 &_swigt__p_svn_version_ext_linked_lib_t,
11775 &_swigt__p_svn_version_ext_loaded_lib_t,
11776 &_swigt__p_svn_version_extended_t,
11777 &_swigt__p_svn_version_t,
11778 &_swigt__p_svn_wc_external_item2_t,
11779 &_swigt__p_unsigned_long,
11780 &_swigt__p_void,
11781 };
11782
11783 static swig_cast_info _swigc__p_apr_array_header_t[] = { {&_swigt__p_apr_array_header_t, 0, 0, 0},{0, 0, 0, 0}};
11784 static swig_cast_info _swigc__p_apr_hash_t[] = { {&_swigt__p_apr_hash_t, 0, 0, 0},{0, 0, 0, 0}};
11785 static swig_cast_info _swigc__p_apr_int32_t[] = { {&_swigt__p_apr_int32_t, 0, 0, 0},{0, 0, 0, 0}};
11786 static swig_cast_info _swigc__p_apr_int64_t[] = { {&_swigt__p_apr_int64_t, 0, 0, 0},{0, 0, 0, 0}};
11787 static swig_cast_info _swigc__p_apr_off_t[] = { {&_swigt__p_apr_off_t, 0, 0, 0},{0, 0, 0, 0}};
11788 static swig_cast_info _swigc__p_apr_pool_t[] = { {&_swigt__p_apr_pool_t, 0, 0, 0},{0, 0, 0, 0}};
11789 static swig_cast_info _swigc__p_apr_uint32_t[] = { {&_swigt__p_apr_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
11790 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
11791 static swig_cast_info _swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11792 static swig_cast_info _swigc__p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t[] = { {&_swigt__p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11793 static swig_cast_info _swigc__p_f_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11794 static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
11795 static swig_cast_info _swigc__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11796 static swig_cast_info _swigc__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11797 static swig_cast_info _swigc__p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11798 static swig_cast_info _swigc__p_f_p_void_p_void__void[] = { {&_swigt__p_f_p_void_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
11799 static swig_cast_info _swigc__p_f_p_void_p_void_p_void_p_int__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_void_p_void_p_int__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11800 static swig_cast_info _swigc__p_f_p_void_svn_diff_datasource_e__p_svn_error_t[] = { {&_swigt__p_f_p_void_svn_diff_datasource_e__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11801 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
11802 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
11803 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
11804 static swig_cast_info _swigc__p_p_svn_diff_t[] = { {&_swigt__p_p_svn_diff_t, 0, 0, 0},{0, 0, 0, 0}};
11805 static swig_cast_info _swigc__p_p_svn_patch_file_t[] = { {&_swigt__p_p_svn_patch_file_t, 0, 0, 0},{0, 0, 0, 0}};
11806 static swig_cast_info _swigc__p_p_svn_patch_t[] = { {&_swigt__p_p_svn_patch_t, 0, 0, 0},{0, 0, 0, 0}};
11807 static swig_cast_info _swigc__p_p_svn_stringbuf_t[] = { {&_swigt__p_p_svn_stringbuf_t, 0, 0, 0},{0, 0, 0, 0}};
11808 static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
11809 static swig_cast_info _swigc__p_svn_auth_baton_t[] = { {&_swigt__p_svn_auth_baton_t, 0, 0, 0},{0, 0, 0, 0}};
11810 static swig_cast_info _swigc__p_svn_auth_cred_simple_t[] = { {&_swigt__p_svn_auth_cred_simple_t, 0, 0, 0},{0, 0, 0, 0}};
11811 static swig_cast_info _swigc__p_svn_auth_cred_ssl_client_cert_pw_t[] = { {&_swigt__p_svn_auth_cred_ssl_client_cert_pw_t, 0, 0, 0},{0, 0, 0, 0}};
11812 static swig_cast_info _swigc__p_svn_auth_cred_ssl_client_cert_t[] = { {&_swigt__p_svn_auth_cred_ssl_client_cert_t, 0, 0, 0},{0, 0, 0, 0}};
11813 static swig_cast_info _swigc__p_svn_auth_cred_ssl_server_trust_t[] = { {&_swigt__p_svn_auth_cred_ssl_server_trust_t, 0, 0, 0},{0, 0, 0, 0}};
11814 static swig_cast_info _swigc__p_svn_auth_cred_username_t[] = { {&_swigt__p_svn_auth_cred_username_t, 0, 0, 0},{0, 0, 0, 0}};
11815 static swig_cast_info _swigc__p_svn_auth_iterstate_t[] = { {&_swigt__p_svn_auth_iterstate_t, 0, 0, 0},{0, 0, 0, 0}};
11816 static swig_cast_info _swigc__p_svn_auth_provider_object_t[] = { {&_swigt__p_svn_auth_provider_object_t, 0, 0, 0},{0, 0, 0, 0}};
11817 static swig_cast_info _swigc__p_svn_auth_provider_t[] = { {&_swigt__p_svn_auth_provider_t, 0, 0, 0},{0, 0, 0, 0}};
11818 static swig_cast_info _swigc__p_svn_auth_ssl_server_cert_info_t[] = { {&_swigt__p_svn_auth_ssl_server_cert_info_t, 0, 0, 0},{0, 0, 0, 0}};
11819 static swig_cast_info _swigc__p_svn_cache_config_t[] = { {&_swigt__p_svn_cache_config_t, 0, 0, 0},{0, 0, 0, 0}};
11820 static swig_cast_info _swigc__p_svn_checksum_ctx_t[] = { {&_swigt__p_svn_checksum_ctx_t, 0, 0, 0},{0, 0, 0, 0}};
11821 static swig_cast_info _swigc__p_svn_checksum_kind_t[] = { {&_swigt__p_svn_checksum_kind_t, 0, 0, 0},{0, 0, 0, 0}};
11822 static swig_cast_info _swigc__p_svn_checksum_t[] = { {&_swigt__p_svn_checksum_t, 0, 0, 0},{0, 0, 0, 0}};
11823 static swig_cast_info _swigc__p_svn_client__shelf_version_t[] = { {&_swigt__p_svn_client__shelf_version_t, 0, 0, 0},{0, 0, 0, 0}};
11824 static swig_cast_info _swigc__p_svn_client_conflict_option_t[] = { {&_swigt__p_svn_client_conflict_option_t, 0, 0, 0},{0, 0, 0, 0}};
11825 static swig_cast_info _swigc__p_svn_commit_info_t[] = { {&_swigt__p_svn_commit_info_t, 0, 0, 0},{0, 0, 0, 0}};
11826 static swig_cast_info _swigc__p_svn_config_t[] = { {&_swigt__p_svn_config_t, 0, 0, 0},{0, 0, 0, 0}};
11827 static swig_cast_info _swigc__p_svn_depth_t[] = { {&_swigt__p_svn_depth_t, 0, 0, 0},{0, 0, 0, 0}};
11828 static swig_cast_info _swigc__p_svn_diff_binary_patch_t[] = { {&_swigt__p_svn_diff_binary_patch_t, 0, 0, 0},{0, 0, 0, 0}};
11829 static swig_cast_info _swigc__p_svn_diff_conflict_display_style_t[] = { {&_swigt__p_svn_diff_conflict_display_style_t, 0, 0, 0},{0, 0, 0, 0}};
11830 static swig_cast_info _swigc__p_svn_diff_datasource_e[] = { {&_swigt__p_svn_diff_datasource_e, 0, 0, 0},{0, 0, 0, 0}};
11831 static swig_cast_info _swigc__p_svn_diff_file_ignore_space_t[] = { {&_swigt__p_svn_diff_file_ignore_space_t, 0, 0, 0},{0, 0, 0, 0}};
11832 static swig_cast_info _swigc__p_svn_diff_file_options_t[] = { {&_swigt__p_svn_diff_file_options_t, 0, 0, 0},{0, 0, 0, 0}};
11833 static swig_cast_info _swigc__p_svn_diff_fns2_t[] = { {&_swigt__p_svn_diff_fns2_t, 0, 0, 0},{0, 0, 0, 0}};
11834 static swig_cast_info _swigc__p_svn_diff_fns_t[] = { {&_swigt__p_svn_diff_fns_t, 0, 0, 0},{0, 0, 0, 0}};
11835 static swig_cast_info _swigc__p_svn_diff_hunk_t[] = { {&_swigt__p_svn_diff_hunk_t, 0, 0, 0},{0, 0, 0, 0}};
11836 static swig_cast_info _swigc__p_svn_diff_operation_kind_e[] = { {&_swigt__p_svn_diff_operation_kind_e, 0, 0, 0},{0, 0, 0, 0}};
11837 static swig_cast_info _swigc__p_svn_diff_output_fns_t[] = { {&_swigt__p_svn_diff_output_fns_t, 0, 0, 0},{0, 0, 0, 0}};
11838 static swig_cast_info _swigc__p_svn_diff_t[] = { {&_swigt__p_svn_diff_t, 0, 0, 0},{0, 0, 0, 0}};
11839 static swig_cast_info _swigc__p_svn_dirent_t[] = { {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
11840 static swig_cast_info _swigc__p_svn_errno_t[] = { {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
11841 static swig_cast_info _swigc__p_svn_error_t[] = { {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11842 static swig_cast_info _swigc__p_svn_fs_lock_target_t[] = { {&_swigt__p_svn_fs_lock_target_t, 0, 0, 0},{0, 0, 0, 0}};
11843 static swig_cast_info _swigc__p_svn_io_dirent2_t[] = { {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
11844 static swig_cast_info _swigc__p_svn_io_dirent_t[] = { {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
11845 static swig_cast_info _swigc__p_svn_io_file_del_t[] = { {&_swigt__p_svn_io_file_del_t, 0, 0, 0},{0, 0, 0, 0}};
11846 static swig_cast_info _swigc__p_svn_location_segment_t[] = { {&_swigt__p_svn_location_segment_t, 0, 0, 0},{0, 0, 0, 0}};
11847 static swig_cast_info _swigc__p_svn_lock_t[] = { {&_swigt__p_svn_lock_t, 0, 0, 0},{0, 0, 0, 0}};
11848 static swig_cast_info _swigc__p_svn_log_changed_path2_t[] = { {&_swigt__p_svn_log_changed_path2_t, 0, 0, 0},{0, 0, 0, 0}};
11849 static swig_cast_info _swigc__p_svn_log_changed_path_t[] = { {&_swigt__p_svn_log_changed_path_t, 0, 0, 0},{0, 0, 0, 0}};
11850 static swig_cast_info _swigc__p_svn_log_entry_t[] = { {&_swigt__p_svn_log_entry_t, 0, 0, 0},{0, 0, 0, 0}};
11851 static swig_cast_info _swigc__p_svn_merge_range_t[] = { {&_swigt__p_svn_merge_range_t, 0, 0, 0},{0, 0, 0, 0}};
11852 static swig_cast_info _swigc__p_svn_mergeinfo_inheritance_t[] = { {&_swigt__p_svn_mergeinfo_inheritance_t, 0, 0, 0},{0, 0, 0, 0}};
11853 static swig_cast_info _swigc__p_svn_node_kind_t[] = { {&_swigt__p_svn_node_kind_t, 0, 0, 0},{0, 0, 0, 0}};
11854 static swig_cast_info _swigc__p_svn_opt_revision_range_t[] = { {&_swigt__p_svn_opt_revision_range_t, 0, 0, 0},{0, 0, 0, 0}};
11855 static swig_cast_info _swigc__p_svn_opt_revision_t[] = { {&_swigt__p_svn_opt_revision_t, 0, 0, 0},{0, 0, 0, 0}};
11856 static swig_cast_info _swigc__p_svn_opt_revision_value_t[] = { {&_swigt__p_svn_opt_revision_value_t, 0, 0, 0},{0, 0, 0, 0}};
11857 static swig_cast_info _swigc__p_svn_opt_subcommand_desc2_t[] = { {&_swigt__p_svn_opt_subcommand_desc2_t, 0, 0, 0},{0, 0, 0, 0}};
11858 static swig_cast_info _swigc__p_svn_opt_subcommand_desc3_t[] = { {&_swigt__p_svn_opt_subcommand_desc3_t, 0, 0, 0},{0, 0, 0, 0}};
11859 static swig_cast_info _swigc__p_svn_opt_subcommand_desc_t[] = { {&_swigt__p_svn_opt_subcommand_desc_t, 0, 0, 0},{0, 0, 0, 0}};
11860 static swig_cast_info _swigc__p_svn_patch_file_t[] = { {&_swigt__p_svn_patch_file_t, 0, 0, 0},{0, 0, 0, 0}};
11861 static swig_cast_info _swigc__p_svn_patch_t[] = { {&_swigt__p_svn_patch_t, 0, 0, 0},{0, 0, 0, 0}};
11862 static swig_cast_info _swigc__p_svn_prop_inherited_item_t[] = { {&_swigt__p_svn_prop_inherited_item_t, 0, 0, 0},{0, 0, 0, 0}};
11863 static swig_cast_info _swigc__p_svn_prop_kind[] = { {&_swigt__p_svn_prop_kind, 0, 0, 0},{0, 0, 0, 0}};
11864 static swig_cast_info _swigc__p_svn_prop_patch_t[] = { {&_swigt__p_svn_prop_patch_t, 0, 0, 0},{0, 0, 0, 0}};
11865 static swig_cast_info _swigc__p_svn_stream_mark_t[] = { {&_swigt__p_svn_stream_mark_t, 0, 0, 0},{0, 0, 0, 0}};
11866 static swig_cast_info _swigc__p_svn_stream_t[] = { {&_swigt__p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
11867 static swig_cast_info _swigc__p_svn_string_t[] = { {&_swigt__p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
11868 static swig_cast_info _swigc__p_svn_stringbuf_t[] = { {&_swigt__p_svn_stringbuf_t, 0, 0, 0},{0, 0, 0, 0}};
11869 static swig_cast_info _swigc__p_svn_tristate_t[] = { {&_swigt__p_svn_tristate_t, 0, 0, 0},{0, 0, 0, 0}};
11870 static swig_cast_info _swigc__p_svn_version_checklist_t[] = { {&_swigt__p_svn_version_checklist_t, 0, 0, 0},{0, 0, 0, 0}};
11871 static swig_cast_info _swigc__p_svn_version_ext_linked_lib_t[] = { {&_swigt__p_svn_version_ext_linked_lib_t, 0, 0, 0},{0, 0, 0, 0}};
11872 static swig_cast_info _swigc__p_svn_version_ext_loaded_lib_t[] = { {&_swigt__p_svn_version_ext_loaded_lib_t, 0, 0, 0},{0, 0, 0, 0}};
11873 static swig_cast_info _swigc__p_svn_version_extended_t[] = { {&_swigt__p_svn_version_extended_t, 0, 0, 0},{0, 0, 0, 0}};
11874 static swig_cast_info _swigc__p_svn_version_t[] = { {&_swigt__p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
11875 static swig_cast_info _swigc__p_svn_wc_external_item2_t[] = { {&_swigt__p_svn_wc_external_item2_t, 0, 0, 0},{0, 0, 0, 0}};
11876 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
11877 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
11878
11879 static swig_cast_info *swig_cast_initial[] = {
11880 _swigc__p_apr_array_header_t,
11881 _swigc__p_apr_hash_t,
11882 _swigc__p_apr_int32_t,
11883 _swigc__p_apr_int64_t,
11884 _swigc__p_apr_off_t,
11885 _swigc__p_apr_pool_t,
11886 _swigc__p_apr_uint32_t,
11887 _swigc__p_char,
11888 _swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
11889 _swigc__p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t,
11890 _swigc__p_f_p_void__p_svn_error_t,
11891 _swigc__p_f_p_void__void,
11892 _swigc__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t__p_svn_error_t,
11893 _swigc__p_f_p_void_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_apr_off_t_p_svn_diff_t__p_svn_error_t,
11894 _swigc__p_f_p_void_p_apr_off_t_p_apr_off_t_p_q_const__svn_diff_datasource_e_apr_size_t__p_svn_error_t,
11895 _swigc__p_f_p_void_p_void__void,
11896 _swigc__p_f_p_void_p_void_p_void_p_int__p_svn_error_t,
11897 _swigc__p_f_p_void_svn_diff_datasource_e__p_svn_error_t,
11898 _swigc__p_int,
11899 _swigc__p_long,
11900 _swigc__p_p_char,
11901 _swigc__p_p_svn_diff_t,
11902 _swigc__p_p_svn_patch_file_t,
11903 _swigc__p_p_svn_patch_t,
11904 _swigc__p_p_svn_stringbuf_t,
11905 _swigc__p_p_void,
11906 _swigc__p_svn_auth_baton_t,
11907 _swigc__p_svn_auth_cred_simple_t,
11908 _swigc__p_svn_auth_cred_ssl_client_cert_pw_t,
11909 _swigc__p_svn_auth_cred_ssl_client_cert_t,
11910 _swigc__p_svn_auth_cred_ssl_server_trust_t,
11911 _swigc__p_svn_auth_cred_username_t,
11912 _swigc__p_svn_auth_iterstate_t,
11913 _swigc__p_svn_auth_provider_object_t,
11914 _swigc__p_svn_auth_provider_t,
11915 _swigc__p_svn_auth_ssl_server_cert_info_t,
11916 _swigc__p_svn_cache_config_t,
11917 _swigc__p_svn_checksum_ctx_t,
11918 _swigc__p_svn_checksum_kind_t,
11919 _swigc__p_svn_checksum_t,
11920 _swigc__p_svn_client__shelf_version_t,
11921 _swigc__p_svn_client_conflict_option_t,
11922 _swigc__p_svn_commit_info_t,
11923 _swigc__p_svn_config_t,
11924 _swigc__p_svn_depth_t,
11925 _swigc__p_svn_diff_binary_patch_t,
11926 _swigc__p_svn_diff_conflict_display_style_t,
11927 _swigc__p_svn_diff_datasource_e,
11928 _swigc__p_svn_diff_file_ignore_space_t,
11929 _swigc__p_svn_diff_file_options_t,
11930 _swigc__p_svn_diff_fns2_t,
11931 _swigc__p_svn_diff_fns_t,
11932 _swigc__p_svn_diff_hunk_t,
11933 _swigc__p_svn_diff_operation_kind_e,
11934 _swigc__p_svn_diff_output_fns_t,
11935 _swigc__p_svn_diff_t,
11936 _swigc__p_svn_dirent_t,
11937 _swigc__p_svn_errno_t,
11938 _swigc__p_svn_error_t,
11939 _swigc__p_svn_fs_lock_target_t,
11940 _swigc__p_svn_io_dirent2_t,
11941 _swigc__p_svn_io_dirent_t,
11942 _swigc__p_svn_io_file_del_t,
11943 _swigc__p_svn_location_segment_t,
11944 _swigc__p_svn_lock_t,
11945 _swigc__p_svn_log_changed_path2_t,
11946 _swigc__p_svn_log_changed_path_t,
11947 _swigc__p_svn_log_entry_t,
11948 _swigc__p_svn_merge_range_t,
11949 _swigc__p_svn_mergeinfo_inheritance_t,
11950 _swigc__p_svn_node_kind_t,
11951 _swigc__p_svn_opt_revision_range_t,
11952 _swigc__p_svn_opt_revision_t,
11953 _swigc__p_svn_opt_revision_value_t,
11954 _swigc__p_svn_opt_subcommand_desc2_t,
11955 _swigc__p_svn_opt_subcommand_desc3_t,
11956 _swigc__p_svn_opt_subcommand_desc_t,
11957 _swigc__p_svn_patch_file_t,
11958 _swigc__p_svn_patch_t,
11959 _swigc__p_svn_prop_inherited_item_t,
11960 _swigc__p_svn_prop_kind,
11961 _swigc__p_svn_prop_patch_t,
11962 _swigc__p_svn_stream_mark_t,
11963 _swigc__p_svn_stream_t,
11964 _swigc__p_svn_string_t,
11965 _swigc__p_svn_stringbuf_t,
11966 _swigc__p_svn_tristate_t,
11967 _swigc__p_svn_version_checklist_t,
11968 _swigc__p_svn_version_ext_linked_lib_t,
11969 _swigc__p_svn_version_ext_loaded_lib_t,
11970 _swigc__p_svn_version_extended_t,
11971 _swigc__p_svn_version_t,
11972 _swigc__p_svn_wc_external_item2_t,
11973 _swigc__p_unsigned_long,
11974 _swigc__p_void,
11975 };
11976
11977
11978 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
11979
11980 static swig_const_info swig_const_table[] = {
11981 {0, 0, 0, 0.0, 0, 0}};
11982
11983 #ifdef __cplusplus
11984 }
11985 #endif
11986 /* -----------------------------------------------------------------------------
11987 * Type initialization:
11988 * This problem is tough by the requirement that no dynamic
11989 * memory is used. Also, since swig_type_info structures store pointers to
11990 * swig_cast_info structures and swig_cast_info structures store pointers back
11991 * to swig_type_info structures, we need some lookup code at initialization.
11992 * The idea is that swig generates all the structures that are needed.
11993 * The runtime then collects these partially filled structures.
11994 * The SWIG_InitializeModule function takes these initial arrays out of
11995 * swig_module, and does all the lookup, filling in the swig_module.types
11996 * array with the correct data and linking the correct swig_cast_info
11997 * structures together.
11998 *
11999 * The generated swig_type_info structures are assigned statically to an initial
12000 * array. We just loop through that array, and handle each type individually.
12001 * First we lookup if this type has been already loaded, and if so, use the
12002 * loaded structure instead of the generated one. Then we have to fill in the
12003 * cast linked list. The cast data is initially stored in something like a
12004 * two-dimensional array. Each row corresponds to a type (there are the same
12005 * number of rows as there are in the swig_type_initial array). Each entry in
12006 * a column is one of the swig_cast_info structures for that type.
12007 * The cast_initial array is actually an array of arrays, because each row has
12008 * a variable number of columns. So to actually build the cast linked list,
12009 * we find the array of casts associated with the type, and loop through it
12010 * adding the casts to the list. The one last trick we need to do is making
12011 * sure the type pointer in the swig_cast_info struct is correct.
12012 *
12013 * First off, we lookup the cast->type name to see if it is already loaded.
12014 * There are three cases to handle:
12015 * 1) If the cast->type has already been loaded AND the type we are adding
12016 * casting info to has not been loaded (it is in this module), THEN we
12017 * replace the cast->type pointer with the type pointer that has already
12018 * been loaded.
12019 * 2) If BOTH types (the one we are adding casting info to, and the
12020 * cast->type) are loaded, THEN the cast info has already been loaded by
12021 * the previous module so we just ignore it.
12022 * 3) Finally, if cast->type has not already been loaded, then we add that
12023 * swig_cast_info to the linked list (because the cast->type) pointer will
12024 * be correct.
12025 * ----------------------------------------------------------------------------- */
12026
12027 #ifdef __cplusplus
12028 extern "C" {
12029 #if 0
12030 } /* c-mode */
12031 #endif
12032 #endif
12033
12034 #if 0
12035 #define SWIGRUNTIME_DEBUG
12036 #endif
12037
12038
12039 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)12040 SWIG_InitializeModule(void *clientdata) {
12041 size_t i;
12042 swig_module_info *module_head, *iter;
12043 int init;
12044
12045 /* check to see if the circular list has been setup, if not, set it up */
12046 if (swig_module.next==0) {
12047 /* Initialize the swig_module */
12048 swig_module.type_initial = swig_type_initial;
12049 swig_module.cast_initial = swig_cast_initial;
12050 swig_module.next = &swig_module;
12051 init = 1;
12052 } else {
12053 init = 0;
12054 }
12055
12056 /* Try and load any already created modules */
12057 module_head = SWIG_GetModule(clientdata);
12058 if (!module_head) {
12059 /* This is the first module loaded for this interpreter */
12060 /* so set the swig module into the interpreter */
12061 SWIG_SetModule(clientdata, &swig_module);
12062 } else {
12063 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
12064 iter=module_head;
12065 do {
12066 if (iter==&swig_module) {
12067 /* Our module is already in the list, so there's nothing more to do. */
12068 return;
12069 }
12070 iter=iter->next;
12071 } while (iter!= module_head);
12072
12073 /* otherwise we must add our module into the list */
12074 swig_module.next = module_head->next;
12075 module_head->next = &swig_module;
12076 }
12077
12078 /* When multiple interpreters are used, a module could have already been initialized in
12079 a different interpreter, but not yet have a pointer in this interpreter.
12080 In this case, we do not want to continue adding types... everything should be
12081 set up already */
12082 if (init == 0) return;
12083
12084 /* Now work on filling in swig_module.types */
12085 #ifdef SWIGRUNTIME_DEBUG
12086 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
12087 #endif
12088 for (i = 0; i < swig_module.size; ++i) {
12089 swig_type_info *type = 0;
12090 swig_type_info *ret;
12091 swig_cast_info *cast;
12092
12093 #ifdef SWIGRUNTIME_DEBUG
12094 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
12095 #endif
12096
12097 /* if there is another module already loaded */
12098 if (swig_module.next != &swig_module) {
12099 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
12100 }
12101 if (type) {
12102 /* Overwrite clientdata field */
12103 #ifdef SWIGRUNTIME_DEBUG
12104 printf("SWIG_InitializeModule: found type %s\n", type->name);
12105 #endif
12106 if (swig_module.type_initial[i]->clientdata) {
12107 type->clientdata = swig_module.type_initial[i]->clientdata;
12108 #ifdef SWIGRUNTIME_DEBUG
12109 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
12110 #endif
12111 }
12112 } else {
12113 type = swig_module.type_initial[i];
12114 }
12115
12116 /* Insert casting types */
12117 cast = swig_module.cast_initial[i];
12118 while (cast->type) {
12119 /* Don't need to add information already in the list */
12120 ret = 0;
12121 #ifdef SWIGRUNTIME_DEBUG
12122 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
12123 #endif
12124 if (swig_module.next != &swig_module) {
12125 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
12126 #ifdef SWIGRUNTIME_DEBUG
12127 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
12128 #endif
12129 }
12130 if (ret) {
12131 if (type == swig_module.type_initial[i]) {
12132 #ifdef SWIGRUNTIME_DEBUG
12133 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
12134 #endif
12135 cast->type = ret;
12136 ret = 0;
12137 } else {
12138 /* Check for casting already in the list */
12139 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
12140 #ifdef SWIGRUNTIME_DEBUG
12141 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
12142 #endif
12143 if (!ocast) ret = 0;
12144 }
12145 }
12146
12147 if (!ret) {
12148 #ifdef SWIGRUNTIME_DEBUG
12149 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
12150 #endif
12151 if (type->cast) {
12152 type->cast->prev = cast;
12153 cast->next = type->cast;
12154 }
12155 type->cast = cast;
12156 }
12157 cast++;
12158 }
12159 /* Set entry in modules->types array equal to the type */
12160 swig_module.types[i] = type;
12161 }
12162 swig_module.types[i] = 0;
12163
12164 #ifdef SWIGRUNTIME_DEBUG
12165 printf("**** SWIG_InitializeModule: Cast List ******\n");
12166 for (i = 0; i < swig_module.size; ++i) {
12167 int j = 0;
12168 swig_cast_info *cast = swig_module.cast_initial[i];
12169 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
12170 while (cast->type) {
12171 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
12172 cast++;
12173 ++j;
12174 }
12175 printf("---- Total casts: %d\n",j);
12176 }
12177 printf("**** SWIG_InitializeModule: Cast List ******\n");
12178 #endif
12179 }
12180
12181 /* This function will propagate the clientdata field of type to
12182 * any new swig_type_info structures that have been added into the list
12183 * of equivalent types. It is like calling
12184 * SWIG_TypeClientData(type, clientdata) a second time.
12185 */
12186 SWIGRUNTIME void
SWIG_PropagateClientData(void)12187 SWIG_PropagateClientData(void) {
12188 size_t i;
12189 swig_cast_info *equiv;
12190 static int init_run = 0;
12191
12192 if (init_run) return;
12193 init_run = 1;
12194
12195 for (i = 0; i < swig_module.size; i++) {
12196 if (swig_module.types[i]->clientdata) {
12197 equiv = swig_module.types[i]->cast;
12198 while (equiv) {
12199 if (!equiv->converter) {
12200 if (equiv->type && !equiv->type->clientdata)
12201 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
12202 }
12203 equiv = equiv->next;
12204 }
12205 }
12206 }
12207 }
12208
12209 #ifdef __cplusplus
12210 #if 0
12211 {
12212 /* c-mode */
12213 #endif
12214 }
12215 #endif
12216
12217
12218
12219 #ifdef __cplusplus
12220 extern "C" {
12221 #endif
12222
12223 /* Python-specific SWIG API */
12224 #define SWIG_newvarlink() SWIG_Python_newvarlink()
12225 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
12226 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
12227
12228 /* -----------------------------------------------------------------------------
12229 * global variable support code.
12230 * ----------------------------------------------------------------------------- */
12231
12232 typedef struct swig_globalvar {
12233 char *name; /* Name of global variable */
12234 PyObject *(*get_attr)(void); /* Return the current value */
12235 int (*set_attr)(PyObject *); /* Set the value */
12236 struct swig_globalvar *next;
12237 } swig_globalvar;
12238
12239 typedef struct swig_varlinkobject {
12240 PyObject_HEAD
12241 swig_globalvar *vars;
12242 } swig_varlinkobject;
12243
12244 SWIGINTERN PyObject *
swig_varlink_repr(swig_varlinkobject * SWIGUNUSEDPARM (v))12245 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
12246 #if PY_VERSION_HEX >= 0x03000000
12247 return PyUnicode_InternFromString("<Swig global variables>");
12248 #else
12249 return PyString_FromString("<Swig global variables>");
12250 #endif
12251 }
12252
12253 SWIGINTERN PyObject *
swig_varlink_str(swig_varlinkobject * v)12254 swig_varlink_str(swig_varlinkobject *v) {
12255 #if PY_VERSION_HEX >= 0x03000000
12256 PyObject *str = PyUnicode_InternFromString("(");
12257 PyObject *tail;
12258 PyObject *joined;
12259 swig_globalvar *var;
12260 for (var = v->vars; var; var=var->next) {
12261 tail = PyUnicode_FromString(var->name);
12262 joined = PyUnicode_Concat(str, tail);
12263 Py_DecRef(str);
12264 Py_DecRef(tail);
12265 str = joined;
12266 if (var->next) {
12267 tail = PyUnicode_InternFromString(", ");
12268 joined = PyUnicode_Concat(str, tail);
12269 Py_DecRef(str);
12270 Py_DecRef(tail);
12271 str = joined;
12272 }
12273 }
12274 tail = PyUnicode_InternFromString(")");
12275 joined = PyUnicode_Concat(str, tail);
12276 Py_DecRef(str);
12277 Py_DecRef(tail);
12278 str = joined;
12279 #else
12280 PyObject *str = PyString_FromString("(");
12281 swig_globalvar *var;
12282 for (var = v->vars; var; var=var->next) {
12283 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
12284 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
12285 }
12286 PyString_ConcatAndDel(&str,PyString_FromString(")"));
12287 #endif
12288 return str;
12289 }
12290
12291 SWIGINTERN int
swig_varlink_print(swig_varlinkobject * v,FILE * fp,int SWIGUNUSEDPARM (flags))12292 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
12293 char *tmp;
12294 PyObject *str = swig_varlink_str(v);
12295 fprintf(fp,"Swig global variables ");
12296 fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
12297 SWIG_Python_str_DelForPy3(tmp);
12298 Py_DECREF(str);
12299 return 0;
12300 }
12301
12302 SWIGINTERN void
swig_varlink_dealloc(swig_varlinkobject * v)12303 swig_varlink_dealloc(swig_varlinkobject *v) {
12304 swig_globalvar *var = v->vars;
12305 while (var) {
12306 swig_globalvar *n = var->next;
12307 free(var->name);
12308 free(var);
12309 var = n;
12310 }
12311 }
12312
12313 SWIGINTERN PyObject *
swig_varlink_getattr(swig_varlinkobject * v,char * n)12314 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
12315 PyObject *res = NULL;
12316 swig_globalvar *var = v->vars;
12317 while (var) {
12318 if (strcmp(var->name,n) == 0) {
12319 res = (*var->get_attr)();
12320 break;
12321 }
12322 var = var->next;
12323 }
12324 if (res == NULL && !PyErr_Occurred()) {
12325 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
12326 }
12327 return res;
12328 }
12329
12330 SWIGINTERN int
swig_varlink_setattr(swig_varlinkobject * v,char * n,PyObject * p)12331 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
12332 int res = 1;
12333 swig_globalvar *var = v->vars;
12334 while (var) {
12335 if (strcmp(var->name,n) == 0) {
12336 res = (*var->set_attr)(p);
12337 break;
12338 }
12339 var = var->next;
12340 }
12341 if (res == 1 && !PyErr_Occurred()) {
12342 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
12343 }
12344 return res;
12345 }
12346
12347 SWIGINTERN PyTypeObject*
swig_varlink_type(void)12348 swig_varlink_type(void) {
12349 static char varlink__doc__[] = "Swig var link object";
12350 static PyTypeObject varlink_type;
12351 static int type_init = 0;
12352 if (!type_init) {
12353 const PyTypeObject tmp = {
12354 #if PY_VERSION_HEX >= 0x03000000
12355 PyVarObject_HEAD_INIT(NULL, 0)
12356 #else
12357 PyObject_HEAD_INIT(NULL)
12358 0, /* ob_size */
12359 #endif
12360 (char *)"swigvarlink", /* tp_name */
12361 sizeof(swig_varlinkobject), /* tp_basicsize */
12362 0, /* tp_itemsize */
12363 (destructor) swig_varlink_dealloc, /* tp_dealloc */
12364 (printfunc) swig_varlink_print, /* tp_print */
12365 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
12366 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
12367 0, /* tp_compare */
12368 (reprfunc) swig_varlink_repr, /* tp_repr */
12369 0, /* tp_as_number */
12370 0, /* tp_as_sequence */
12371 0, /* tp_as_mapping */
12372 0, /* tp_hash */
12373 0, /* tp_call */
12374 (reprfunc) swig_varlink_str, /* tp_str */
12375 0, /* tp_getattro */
12376 0, /* tp_setattro */
12377 0, /* tp_as_buffer */
12378 0, /* tp_flags */
12379 varlink__doc__, /* tp_doc */
12380 0, /* tp_traverse */
12381 0, /* tp_clear */
12382 0, /* tp_richcompare */
12383 0, /* tp_weaklistoffset */
12384 #if PY_VERSION_HEX >= 0x02020000
12385 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
12386 #endif
12387 #if PY_VERSION_HEX >= 0x02030000
12388 0, /* tp_del */
12389 #endif
12390 #if PY_VERSION_HEX >= 0x02060000
12391 0, /* tp_version_tag */
12392 #endif
12393 #if PY_VERSION_HEX >= 0x03040000
12394 0, /* tp_finalize */
12395 #endif
12396 #ifdef COUNT_ALLOCS
12397 0, /* tp_allocs */
12398 0, /* tp_frees */
12399 0, /* tp_maxalloc */
12400 #if PY_VERSION_HEX >= 0x02050000
12401 0, /* tp_prev */
12402 #endif
12403 0 /* tp_next */
12404 #endif
12405 };
12406 varlink_type = tmp;
12407 type_init = 1;
12408 #if PY_VERSION_HEX < 0x02020000
12409 varlink_type.ob_type = &PyType_Type;
12410 #else
12411 if (PyType_Ready(&varlink_type) < 0)
12412 return NULL;
12413 #endif
12414 }
12415 return &varlink_type;
12416 }
12417
12418 /* Create a variable linking object for use later */
12419 SWIGINTERN PyObject *
SWIG_Python_newvarlink(void)12420 SWIG_Python_newvarlink(void) {
12421 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
12422 if (result) {
12423 result->vars = 0;
12424 }
12425 return ((PyObject*) result);
12426 }
12427
12428 SWIGINTERN void
SWIG_Python_addvarlink(PyObject * p,char * name,PyObject * (* get_attr)(void),int (* set_attr)(PyObject * p))12429 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
12430 swig_varlinkobject *v = (swig_varlinkobject *) p;
12431 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
12432 if (gv) {
12433 size_t size = strlen(name)+1;
12434 gv->name = (char *)malloc(size);
12435 if (gv->name) {
12436 strncpy(gv->name,name,size);
12437 gv->get_attr = get_attr;
12438 gv->set_attr = set_attr;
12439 gv->next = v->vars;
12440 }
12441 }
12442 v->vars = gv;
12443 }
12444
12445 SWIGINTERN PyObject *
SWIG_globals(void)12446 SWIG_globals(void) {
12447 static PyObject *_SWIG_globals = 0;
12448 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
12449 return _SWIG_globals;
12450 }
12451
12452 /* -----------------------------------------------------------------------------
12453 * constants/methods manipulation
12454 * ----------------------------------------------------------------------------- */
12455
12456 /* Install Constants */
12457 SWIGINTERN void
SWIG_Python_InstallConstants(PyObject * d,swig_const_info constants[])12458 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
12459 PyObject *obj = 0;
12460 size_t i;
12461 for (i = 0; constants[i].type; ++i) {
12462 switch(constants[i].type) {
12463 case SWIG_PY_POINTER:
12464 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
12465 break;
12466 case SWIG_PY_BINARY:
12467 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
12468 break;
12469 default:
12470 obj = 0;
12471 break;
12472 }
12473 if (obj) {
12474 PyDict_SetItemString(d, constants[i].name, obj);
12475 Py_DECREF(obj);
12476 }
12477 }
12478 }
12479
12480 /* -----------------------------------------------------------------------------*/
12481 /* Fix SwigMethods to carry the callback ptrs when needed */
12482 /* -----------------------------------------------------------------------------*/
12483
12484 SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef * methods,swig_const_info * const_table,swig_type_info ** types,swig_type_info ** types_initial)12485 SWIG_Python_FixMethods(PyMethodDef *methods,
12486 swig_const_info *const_table,
12487 swig_type_info **types,
12488 swig_type_info **types_initial) {
12489 size_t i;
12490 for (i = 0; methods[i].ml_name; ++i) {
12491 const char *c = methods[i].ml_doc;
12492 if (!c) continue;
12493 c = strstr(c, "swig_ptr: ");
12494 if (c) {
12495 int j;
12496 swig_const_info *ci = 0;
12497 const char *name = c + 10;
12498 for (j = 0; const_table[j].type; ++j) {
12499 if (strncmp(const_table[j].name, name,
12500 strlen(const_table[j].name)) == 0) {
12501 ci = &(const_table[j]);
12502 break;
12503 }
12504 }
12505 if (ci) {
12506 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
12507 if (ptr) {
12508 size_t shift = (ci->ptype) - types;
12509 swig_type_info *ty = types_initial[shift];
12510 size_t ldoc = (c - methods[i].ml_doc);
12511 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
12512 char *ndoc = (char*)malloc(ldoc + lptr + 10);
12513 if (ndoc) {
12514 char *buff = ndoc;
12515 strncpy(buff, methods[i].ml_doc, ldoc);
12516 buff += ldoc;
12517 strncpy(buff, "swig_ptr: ", 10);
12518 buff += 10;
12519 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
12520 methods[i].ml_doc = ndoc;
12521 }
12522 }
12523 }
12524 }
12525 }
12526 }
12527
12528 #ifdef __cplusplus
12529 }
12530 #endif
12531
12532 /* -----------------------------------------------------------------------------*
12533 * Partial Init method
12534 * -----------------------------------------------------------------------------*/
12535
12536 #ifdef __cplusplus
12537 extern "C"
12538 #endif
12539
12540 SWIGEXPORT
12541 #if PY_VERSION_HEX >= 0x03000000
12542 PyObject*
12543 #else
12544 void
12545 #endif
SWIG_init(void)12546 SWIG_init(void) {
12547 PyObject *m, *d, *md;
12548 #if PY_VERSION_HEX >= 0x03000000
12549 static struct PyModuleDef SWIG_module = {
12550 # if PY_VERSION_HEX >= 0x03020000
12551 PyModuleDef_HEAD_INIT,
12552 # else
12553 {
12554 PyObject_HEAD_INIT(NULL)
12555 NULL, /* m_init */
12556 0, /* m_index */
12557 NULL, /* m_copy */
12558 },
12559 # endif
12560 (char *) SWIG_name,
12561 NULL,
12562 -1,
12563 SwigMethods,
12564 NULL,
12565 NULL,
12566 NULL,
12567 NULL
12568 };
12569 #endif
12570
12571 #if defined(SWIGPYTHON_BUILTIN)
12572 static SwigPyClientData SwigPyObject_clientdata = {
12573 0, 0, 0, 0, 0, 0, 0
12574 };
12575 static PyGetSetDef this_getset_def = {
12576 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
12577 };
12578 static SwigPyGetSet thisown_getset_closure = {
12579 (PyCFunction) SwigPyObject_own,
12580 (PyCFunction) SwigPyObject_own
12581 };
12582 static PyGetSetDef thisown_getset_def = {
12583 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
12584 };
12585 PyTypeObject *builtin_pytype;
12586 int builtin_base_count;
12587 swig_type_info *builtin_basetype;
12588 PyObject *tuple;
12589 PyGetSetDescrObject *static_getset;
12590 PyTypeObject *metatype;
12591 PyTypeObject *swigpyobject;
12592 SwigPyClientData *cd;
12593 PyObject *public_interface, *public_symbol;
12594 PyObject *this_descr;
12595 PyObject *thisown_descr;
12596 PyObject *self = 0;
12597 int i;
12598
12599 (void)builtin_pytype;
12600 (void)builtin_base_count;
12601 (void)builtin_basetype;
12602 (void)tuple;
12603 (void)static_getset;
12604 (void)self;
12605
12606 /* Metaclass is used to implement static member variables */
12607 metatype = SwigPyObjectType();
12608 assert(metatype);
12609 #endif
12610
12611 /* Fix SwigMethods to carry the callback ptrs when needed */
12612 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
12613
12614 #if PY_VERSION_HEX >= 0x03000000
12615 m = PyModule_Create(&SWIG_module);
12616 #else
12617 m = Py_InitModule((char *) SWIG_name, SwigMethods);
12618 #endif
12619
12620 md = d = PyModule_GetDict(m);
12621 (void)md;
12622
12623 SWIG_InitializeModule(0);
12624
12625 #ifdef SWIGPYTHON_BUILTIN
12626 swigpyobject = SwigPyObject_TypeOnce();
12627
12628 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
12629 assert(SwigPyObject_stype);
12630 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
12631 if (!cd) {
12632 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
12633 SwigPyObject_clientdata.pytype = swigpyobject;
12634 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
12635 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
12636 # if PY_VERSION_HEX >= 0x03000000
12637 return NULL;
12638 # else
12639 return;
12640 # endif
12641 }
12642
12643 /* All objects have a 'this' attribute */
12644 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
12645 (void)this_descr;
12646
12647 /* All objects have a 'thisown' attribute */
12648 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
12649 (void)thisown_descr;
12650
12651 public_interface = PyList_New(0);
12652 public_symbol = 0;
12653 (void)public_symbol;
12654
12655 PyDict_SetItemString(md, "__all__", public_interface);
12656 Py_DECREF(public_interface);
12657 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
12658 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
12659 for (i = 0; swig_const_table[i].name != 0; ++i)
12660 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
12661 #endif
12662
12663 SWIG_InstallConstants(d,swig_const_table);
12664
12665 SWIG_Python_SetConstant(d, "svn_diff_datasource_original",SWIG_From_long((long)(svn_diff_datasource_original)));
12666 SWIG_Python_SetConstant(d, "svn_diff_datasource_modified",SWIG_From_long((long)(svn_diff_datasource_modified)));
12667 SWIG_Python_SetConstant(d, "svn_diff_datasource_latest",SWIG_From_long((long)(svn_diff_datasource_latest)));
12668 SWIG_Python_SetConstant(d, "svn_diff_datasource_ancestor",SWIG_From_long((long)(svn_diff_datasource_ancestor)));
12669 SWIG_Python_SetConstant(d, "svn_diff_conflict_display_modified_latest",SWIG_From_long((long)(svn_diff_conflict_display_modified_latest)));
12670 SWIG_Python_SetConstant(d, "svn_diff_conflict_display_resolved_modified_latest",SWIG_From_long((long)(svn_diff_conflict_display_resolved_modified_latest)));
12671 SWIG_Python_SetConstant(d, "svn_diff_conflict_display_modified_original_latest",SWIG_From_long((long)(svn_diff_conflict_display_modified_original_latest)));
12672 SWIG_Python_SetConstant(d, "svn_diff_conflict_display_modified",SWIG_From_long((long)(svn_diff_conflict_display_modified)));
12673 SWIG_Python_SetConstant(d, "svn_diff_conflict_display_latest",SWIG_From_long((long)(svn_diff_conflict_display_latest)));
12674 SWIG_Python_SetConstant(d, "svn_diff_conflict_display_only_conflicts",SWIG_From_long((long)(svn_diff_conflict_display_only_conflicts)));
12675 SWIG_Python_SetConstant(d, "svn_diff_file_ignore_space_none",SWIG_From_long((long)(svn_diff_file_ignore_space_none)));
12676 SWIG_Python_SetConstant(d, "svn_diff_file_ignore_space_change",SWIG_From_long((long)(svn_diff_file_ignore_space_change)));
12677 SWIG_Python_SetConstant(d, "svn_diff_file_ignore_space_all",SWIG_From_long((long)(svn_diff_file_ignore_space_all)));
12678 SWIG_Python_SetConstant(d, "svn_diff_op_unchanged",SWIG_From_long((long)(svn_diff_op_unchanged)));
12679 SWIG_Python_SetConstant(d, "svn_diff_op_added",SWIG_From_long((long)(svn_diff_op_added)));
12680 SWIG_Python_SetConstant(d, "svn_diff_op_deleted",SWIG_From_long((long)(svn_diff_op_deleted)));
12681 SWIG_Python_SetConstant(d, "svn_diff_op_copied",SWIG_From_long((long)(svn_diff_op_copied)));
12682 SWIG_Python_SetConstant(d, "svn_diff_op_moved",SWIG_From_long((long)(svn_diff_op_moved)));
12683 SWIG_Python_SetConstant(d, "svn_diff_op_modified",SWIG_From_long((long)(svn_diff_op_modified)));
12684 #if PY_VERSION_HEX >= 0x03000000
12685 return m;
12686 #else
12687 return;
12688 #endif
12689 }
12690
12691