~ubuntu-branches/debian/sid/subversion/sid

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/python/svn_diff.c

  • Committer: Package Import Robot
  • Author(s): James McCoy
  • Date: 2015-08-07 21:32:47 UTC
  • mfrom: (0.2.15) (4.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20150807213247-ozyewtmgsr6tkewl
Tags: 1.9.0-1
* Upload to unstable
* New upstream release.
  + Security fixes
    - CVE-2015-3184: Mixed anonymous/authenticated path-based authz with
      httpd 2.4
    - CVE-2015-3187: svn_repos_trace_node_locations() reveals paths hidden
      by authz
* Add >= 2.7 requirement for python-all-dev Build-Depends, needed to run
  tests.
* Remove Build-Conflicts against ruby-test-unit.  (Closes: #791844)
* Remove patches/apache_module_dependency in favor of expressing the
  dependencies in authz_svn.load/dav_svn.load.
* Build-Depend on apache2-dev (>= 2.4.16) to ensure ap_some_authn_required()
  is available when building mod_authz_svn and Depend on apache2-bin (>=
  2.4.16) for runtime support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 2.0.9
4
 
 * 
5
 
 * This file is not intended to be easily readable and contains a number of 
 
3
 * Version 2.0.12
 
4
 *
 
5
 * This file is not intended to be easily readable and contains a number of
6
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. 
 
7
 * changes to this file unless you know what you are doing--modify the SWIG
 
8
 * interface file instead.
9
9
 * ----------------------------------------------------------------------------- */
10
10
 
11
11
#define SWIGPYTHON
43
43
#ifndef SWIGUNUSED
44
44
# if defined(__GNUC__)
45
45
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
46
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
46
#     define SWIGUNUSED __attribute__ ((__unused__))
47
47
#   else
48
48
#     define SWIGUNUSED
49
49
#   endif
50
50
# elif defined(__ICC)
51
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
 
51
#   define SWIGUNUSED __attribute__ ((__unused__))
52
52
# else
53
 
#   define SWIGUNUSED 
 
53
#   define SWIGUNUSED
54
54
# endif
55
55
#endif
56
56
 
57
57
#ifndef SWIG_MSC_UNSUPPRESS_4505
58
58
# if defined(_MSC_VER)
59
59
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
60
 
# endif 
 
60
# endif
61
61
#endif
62
62
 
63
63
#ifndef SWIGUNUSEDPARM
64
64
# ifdef __cplusplus
65
65
#   define SWIGUNUSEDPARM(p)
66
66
# else
67
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
67
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
68
68
# endif
69
69
#endif
70
70
 
107
107
#   define SWIGSTDCALL __stdcall
108
108
# else
109
109
#   define SWIGSTDCALL
110
 
# endif 
 
110
# endif
111
111
#endif
112
112
 
113
113
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
122
122
 
123
123
 
124
124
 
125
 
/* Python.h has to appear first */
126
 
#include <Python.h>
 
125
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
 
126
/* Use debug wrappers with the Python release dll */
 
127
# undef _DEBUG
 
128
# include <Python.h>
 
129
# define _DEBUG
 
130
#else
 
131
# include <Python.h>
 
132
#endif
127
133
 
128
134
/* -----------------------------------------------------------------------------
129
135
 * swigrun.swg
149
155
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
150
156
  creating a static or dynamic library from the SWIG runtime code.
151
157
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
152
 
  
 
158
 
153
159
  But only do this if strictly necessary, ie, if you have problems
154
160
  with your compiler or suchlike.
155
161
*/
175
181
#define SWIG_POINTER_OWN           0x1
176
182
 
177
183
 
178
 
/* 
 
184
/*
179
185
   Flags/methods for returning states.
180
 
   
181
 
   The SWIG conversion methods, as ConvertPtr, return an integer 
 
186
 
 
187
   The SWIG conversion methods, as ConvertPtr, return an integer
182
188
   that tells if the conversion was successful or not. And if not,
183
189
   an error code can be returned (see swigerrors.swg for the codes).
184
 
   
 
190
 
185
191
   Use the following macros/flags to set or process the returning
186
192
   states.
187
 
   
 
193
 
188
194
   In old versions of SWIG, code such as the following was usually written:
189
195
 
190
196
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
217
223
    } else {
218
224
      // fail code
219
225
    }
220
 
    
 
226
 
221
227
   I.e., now SWIG_ConvertPtr can return new objects and you can
222
228
   identify the case and take care of the deallocation. Of course that
223
229
   also requires SWIG_ConvertPtr to return new result values, such as
224
230
 
225
 
      int SWIG_ConvertPtr(obj, ptr,...) {         
226
 
        if (<obj is ok>) {                             
227
 
          if (<need new object>) {                     
228
 
            *ptr = <ptr to new allocated object>; 
229
 
            return SWIG_NEWOBJ;                
230
 
          } else {                                     
231
 
            *ptr = <ptr to old object>;        
232
 
            return SWIG_OLDOBJ;                
233
 
          }                                    
234
 
        } else {                                       
235
 
          return SWIG_BADOBJ;                  
236
 
        }                                              
 
231
      int SWIG_ConvertPtr(obj, ptr,...) {
 
232
        if (<obj is ok>) {
 
233
          if (<need new object>) {
 
234
            *ptr = <ptr to new allocated object>;
 
235
            return SWIG_NEWOBJ;
 
236
          } else {
 
237
            *ptr = <ptr to old object>;
 
238
            return SWIG_OLDOBJ;
 
239
          }
 
240
        } else {
 
241
          return SWIG_BADOBJ;
 
242
        }
237
243
      }
238
244
 
239
245
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
247
253
       int fooi(int);
248
254
 
249
255
   and you call
250
 
 
 
256
 
251
257
      food(1)   // cast rank '1'  (1 -> 1.0)
252
258
      fooi(1)   // cast rank '0'
253
259
 
254
260
   just use the SWIG_AddCast()/SWIG_CheckState()
255
261
*/
256
262
 
257
 
#define SWIG_OK                    (0) 
 
263
#define SWIG_OK                    (0)
258
264
#define SWIG_ERROR                 (-1)
259
265
#define SWIG_IsOK(r)               (r >= 0)
260
 
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
 
266
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
261
267
 
262
268
/* The CastRankLimit says how many bits are used for the cast rank */
263
269
#define SWIG_CASTRANKLIMIT         (1 << 8)
288
294
#  endif
289
295
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
290
296
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
291
 
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
 
297
SWIGINTERNINLINE int SWIG_AddCast(int r) {
292
298
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
293
299
}
294
 
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
295
 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
 
300
SWIGINTERNINLINE int SWIG_CheckState(int r) {
 
301
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
296
302
}
297
303
#else /* no cast-rank mode */
298
 
#  define SWIG_AddCast
 
304
#  define SWIG_AddCast(r) (r)
299
305
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
300
306
#endif
301
307
 
339
345
  void                    *clientdata;          /* Language specific module data */
340
346
} swig_module_info;
341
347
 
342
 
/* 
 
348
/*
343
349
  Compare two type names skipping the space characters, therefore
344
350
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
345
351
 
359
365
 
360
366
/*
361
367
  Check type equivalence in a name list like <name1>|<name2>|...
 
368
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 
369
*/
 
370
SWIGRUNTIME int
 
371
SWIG_TypeCmp(const char *nb, const char *tb) {
 
372
  int equiv = 1;
 
373
  const char* te = tb + strlen(tb);
 
374
  const char* ne = nb;
 
375
  while (equiv != 0 && *ne) {
 
376
    for (nb = ne; *ne; ++ne) {
 
377
      if (*ne == '|') break;
 
378
    }
 
379
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
 
380
    if (*ne) ++ne;
 
381
  }
 
382
  return equiv;
 
383
}
 
384
 
 
385
/*
 
386
  Check type equivalence in a name list like <name1>|<name2>|...
362
387
  Return 0 if not equal, 1 if equal
363
388
*/
364
389
SWIGRUNTIME int
365
390
SWIG_TypeEquiv(const char *nb, const char *tb) {
366
 
  int equiv = 0;
367
 
  const char* te = tb + strlen(tb);
368
 
  const char* ne = nb;
369
 
  while (!equiv && *ne) {
370
 
    for (nb = ne; *ne; ++ne) {
371
 
      if (*ne == '|') break;
372
 
    }
373
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
374
 
    if (*ne) ++ne;
375
 
  }
376
 
  return equiv;
377
 
}
378
 
 
379
 
/*
380
 
  Check type equivalence in a name list like <name1>|<name2>|...
381
 
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
382
 
*/
383
 
SWIGRUNTIME int
384
 
SWIG_TypeCompare(const char *nb, const char *tb) {
385
 
  int equiv = 0;
386
 
  const char* te = tb + strlen(tb);
387
 
  const char* ne = nb;
388
 
  while (!equiv && *ne) {
389
 
    for (nb = ne; *ne; ++ne) {
390
 
      if (*ne == '|') break;
391
 
    }
392
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
393
 
    if (*ne) ++ne;
394
 
  }
395
 
  return equiv;
396
 
}
397
 
 
 
391
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 
392
}
398
393
 
399
394
/*
400
395
  Check the typename
423
418
  return 0;
424
419
}
425
420
 
426
 
/* 
 
421
/*
427
422
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
428
423
*/
429
424
SWIGRUNTIME swig_cast_info *
458
453
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
459
454
}
460
455
 
461
 
/* 
 
456
/*
462
457
   Dynamic pointer casting. Down an inheritance hierarchy
463
458
*/
464
459
SWIGRUNTIME swig_type_info *
502
497
    return type->name;
503
498
}
504
499
 
505
 
/* 
 
500
/*
506
501
   Set the clientdata field for a type
507
502
*/
508
503
SWIGRUNTIME void
510
505
  swig_cast_info *cast = ti->cast;
511
506
  /* if (ti->clientdata == clientdata) return; */
512
507
  ti->clientdata = clientdata;
513
 
  
 
508
 
514
509
  while (cast) {
515
510
    if (!cast->converter) {
516
511
      swig_type_info *tc = cast->type;
517
512
      if (!tc->clientdata) {
518
513
        SWIG_TypeClientData(tc, clientdata);
519
514
      }
520
 
    }    
 
515
    }
521
516
    cast = cast->next;
522
517
  }
523
518
}
526
521
  SWIG_TypeClientData(ti, clientdata);
527
522
  ti->owndata = 1;
528
523
}
529
 
  
 
524
 
530
525
/*
531
526
  Search for a swig_type_info structure only by mangled name
532
527
  Search is a O(log #types)
533
 
  
534
 
  We start searching at module start, and finish searching when start == end.  
 
528
 
 
529
  We start searching at module start, and finish searching when start == end.
535
530
  Note: if start == end at the beginning of the function, we go all the way around
536
531
  the circular list.
537
532
*/
538
533
SWIGRUNTIME swig_type_info *
539
 
SWIG_MangledTypeQueryModule(swig_module_info *start, 
540
 
                            swig_module_info *end, 
 
534
SWIG_MangledTypeQueryModule(swig_module_info *start,
 
535
                            swig_module_info *end,
541
536
                            const char *name) {
542
537
  swig_module_info *iter = start;
543
538
  do {
546
541
      register size_t r = iter->size - 1;
547
542
      do {
548
543
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
549
 
        register size_t i = (l + r) >> 1; 
 
544
        register size_t i = (l + r) >> 1;
550
545
        const char *iname = iter->types[i]->name;
551
546
        if (iname) {
552
547
          register int compare = strcmp(name, iname);
553
 
          if (compare == 0) {       
 
548
          if (compare == 0) {
554
549
            return iter->types[i];
555
550
          } else if (compare < 0) {
556
551
            if (i) {
575
570
  Search for a swig_type_info structure for either a mangled name or a human readable name.
576
571
  It first searches the mangled names of the types, which is a O(log #types)
577
572
  If a type is not found it then searches the human readable names, which is O(#types).
578
 
  
579
 
  We start searching at module start, and finish searching when start == end.  
 
573
 
 
574
  We start searching at module start, and finish searching when start == end.
580
575
  Note: if start == end at the beginning of the function, we go all the way around
581
576
  the circular list.
582
577
*/
583
578
SWIGRUNTIME swig_type_info *
584
 
SWIG_TypeQueryModule(swig_module_info *start, 
585
 
                     swig_module_info *end, 
 
579
SWIG_TypeQueryModule(swig_module_info *start,
 
580
                     swig_module_info *end,
586
581
                     const char *name) {
587
582
  /* STEP 1: Search the name field using binary search */
588
583
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
601
596
      iter = iter->next;
602
597
    } while (iter != end);
603
598
  }
604
 
  
 
599
 
605
600
  /* neither found a match */
606
601
  return 0;
607
602
}
608
603
 
609
 
/* 
 
604
/*
610
605
   Pack binary data into a string
611
606
*/
612
607
SWIGRUNTIME char *
622
617
  return c;
623
618
}
624
619
 
625
 
/* 
 
620
/*
626
621
   Unpack binary data from a string
627
622
*/
628
623
SWIGRUNTIME const char *
636
631
      uu = ((d - '0') << 4);
637
632
    else if ((d >= 'a') && (d <= 'f'))
638
633
      uu = ((d - ('a'-10)) << 4);
639
 
    else 
 
634
    else
640
635
      return (char *) 0;
641
636
    d = *(c++);
642
637
    if ((d >= '0') && (d <= '9'))
643
638
      uu |= (d - '0');
644
639
    else if ((d >= 'a') && (d <= 'f'))
645
640
      uu |= (d - ('a'-10));
646
 
    else 
 
641
    else
647
642
      return (char *) 0;
648
643
    *u = uu;
649
644
  }
650
645
  return c;
651
646
}
652
647
 
653
 
/* 
 
648
/*
654
649
   Pack 'void *' into a string buffer.
655
650
*/
656
651
SWIGRUNTIME char *
710
705
#endif
711
706
 
712
707
/*  Errors in SWIG */
713
 
#define  SWIG_UnknownError         -1 
714
 
#define  SWIG_IOError              -2 
715
 
#define  SWIG_RuntimeError         -3 
716
 
#define  SWIG_IndexError           -4 
717
 
#define  SWIG_TypeError            -5 
718
 
#define  SWIG_DivisionByZero       -6 
719
 
#define  SWIG_OverflowError        -7 
720
 
#define  SWIG_SyntaxError          -8 
721
 
#define  SWIG_ValueError           -9 
 
708
#define  SWIG_UnknownError         -1
 
709
#define  SWIG_IOError              -2
 
710
#define  SWIG_RuntimeError         -3
 
711
#define  SWIG_IndexError           -4
 
712
#define  SWIG_TypeError            -5
 
713
#define  SWIG_DivisionByZero       -6
 
714
#define  SWIG_OverflowError        -7
 
715
#define  SWIG_SyntaxError          -8
 
716
#define  SWIG_ValueError           -9
722
717
#define  SWIG_SystemError          -10
723
718
#define  SWIG_AttributeError       -11
724
 
#define  SWIG_MemoryError          -12 
 
719
#define  SWIG_MemoryError          -12
725
720
#define  SWIG_NullReferenceError   -13
726
721
 
727
722
 
1582
1577
}
1583
1578
 
1584
1579
SWIGRUNTIME int
1585
 
SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1586
 
{
1587
 
  char *str;
1588
 
#ifdef METH_NOARGS
1589
 
  PyObject *repr = SwigPyObject_repr(v);
1590
 
#else
1591
 
  PyObject *repr = SwigPyObject_repr(v, NULL);
1592
 
#endif
1593
 
  if (repr) {
1594
 
    str = SWIG_Python_str_AsChar(repr); 
1595
 
    fputs(str, fp);
1596
 
    SWIG_Python_str_DelForPy3(str);
1597
 
    Py_DECREF(repr);
1598
 
    return 0; 
1599
 
  } else {
1600
 
    return 1; 
1601
 
  }
1602
 
}
1603
 
 
1604
 
SWIGRUNTIME PyObject *
1605
 
SwigPyObject_str(SwigPyObject *v)
1606
 
{
1607
 
  char result[SWIG_BUFFER_SIZE];
1608
 
  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1609
 
    SWIG_Python_str_FromChar(result) : 0;
1610
 
}
1611
 
 
1612
 
SWIGRUNTIME int
1613
1580
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1614
1581
{
1615
1582
  void *i = v->ptr;
1801
1768
static PyMethodDef
1802
1769
swigobject_methods[] = {
1803
1770
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1804
 
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
 
1771
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
1805
1772
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1806
1773
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
1807
1774
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1894
1861
      sizeof(SwigPyObject),                 /* tp_basicsize */
1895
1862
      0,                                    /* tp_itemsize */
1896
1863
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
1897
 
      (printfunc)SwigPyObject_print,        /* tp_print */
 
1864
      0,                                    /* tp_print */
1898
1865
#if PY_VERSION_HEX < 0x02020000
1899
1866
      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
1900
1867
#else
1912
1879
      0,                                    /* tp_as_mapping */
1913
1880
      (hashfunc)0,                          /* tp_hash */
1914
1881
      (ternaryfunc)0,                       /* tp_call */
1915
 
      (reprfunc)SwigPyObject_str,           /* tp_str */
 
1882
      0,                                    /* tp_str */
1916
1883
      PyObject_GenericGetAttr,              /* tp_getattro */
1917
1884
      0,                                    /* tp_setattro */
1918
1885
      0,                                    /* tp_as_buffer */
2289
2256
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2290
2257
  int res;
2291
2258
  SwigPyObject *sobj;
 
2259
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2292
2260
 
2293
2261
  if (!obj)
2294
2262
    return SWIG_ERROR;
2295
 
  if (obj == Py_None) {
 
2263
  if (obj == Py_None && !implicit_conv) {
2296
2264
    if (ptr)
2297
2265
      *ptr = 0;
2298
2266
    return SWIG_OK;
2341
2309
    }
2342
2310
    res = SWIG_OK;
2343
2311
  } else {
2344
 
    if (flags & SWIG_POINTER_IMPLICIT_CONV) {
 
2312
    if (implicit_conv) {
2345
2313
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2346
2314
      if (data && !data->implicitconv) {
2347
2315
        PyObject *klass = data->klass;
2376
2344
        }
2377
2345
      }
2378
2346
    }
 
2347
    if (!SWIG_IsOK(res) && obj == Py_None) {
 
2348
      if (ptr)
 
2349
        *ptr = 0;
 
2350
      if (PyErr_Occurred())
 
2351
        PyErr_Clear();
 
2352
      res = SWIG_OK;
 
2353
    }
2379
2354
  }
2380
2355
  return res;
2381
2356
}
2875
2850
  PyObject *descr;
2876
2851
  PyObject *encoded_name;
2877
2852
  descrsetfunc f;
2878
 
  int res;
 
2853
  int res = -1;
2879
2854
 
2880
2855
# ifdef Py_USING_UNICODE
2881
2856
  if (PyString_Check(name)) {
2898
2873
      goto done;
2899
2874
  }
2900
2875
 
2901
 
  res = -1;
2902
2876
  descr = _PyType_Lookup(tp, name);
2903
2877
  f = NULL;
2904
2878
  if (descr != NULL)
2950
2924
#define SWIGTYPE_p_char swig_types[7]
2951
2925
#define SWIGTYPE_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[8]
2952
2926
#define SWIGTYPE_p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t swig_types[9]
2953
 
#define SWIGTYPE_p_f_p_void__void swig_types[10]
2954
 
#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[11]
2955
 
#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[12]
2956
 
#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[13]
2957
 
#define SWIGTYPE_p_f_p_void_p_void__void swig_types[14]
2958
 
#define SWIGTYPE_p_f_p_void_p_void_p_void_p_int__p_svn_error_t swig_types[15]
2959
 
#define SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t swig_types[16]
2960
 
#define SWIGTYPE_p_int swig_types[17]
2961
 
#define SWIGTYPE_p_long swig_types[18]
2962
 
#define SWIGTYPE_p_p_char swig_types[19]
2963
 
#define SWIGTYPE_p_p_svn_diff_t swig_types[20]
2964
 
#define SWIGTYPE_p_p_svn_patch_file_t swig_types[21]
2965
 
#define SWIGTYPE_p_p_svn_patch_t swig_types[22]
2966
 
#define SWIGTYPE_p_p_svn_stringbuf_t swig_types[23]
2967
 
#define SWIGTYPE_p_p_void swig_types[24]
2968
 
#define SWIGTYPE_p_svn_auth_baton_t swig_types[25]
2969
 
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[26]
2970
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[27]
2971
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[28]
2972
 
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[29]
2973
 
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[30]
2974
 
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[31]
2975
 
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[32]
2976
 
#define SWIGTYPE_p_svn_auth_provider_t swig_types[33]
2977
 
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[34]
2978
 
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[35]
2979
 
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[36]
2980
 
#define SWIGTYPE_p_svn_checksum_t swig_types[37]
2981
 
#define SWIGTYPE_p_svn_commit_info_t swig_types[38]
2982
 
#define SWIGTYPE_p_svn_config_t swig_types[39]
2983
 
#define SWIGTYPE_p_svn_depth_t swig_types[40]
2984
 
#define SWIGTYPE_p_svn_diff_conflict_display_style_t swig_types[41]
2985
 
#define SWIGTYPE_p_svn_diff_datasource_e swig_types[42]
2986
 
#define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[43]
2987
 
#define SWIGTYPE_p_svn_diff_file_options_t swig_types[44]
2988
 
#define SWIGTYPE_p_svn_diff_fns2_t swig_types[45]
2989
 
#define SWIGTYPE_p_svn_diff_fns_t swig_types[46]
2990
 
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[47]
2991
 
#define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[48]
2992
 
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[49]
2993
 
#define SWIGTYPE_p_svn_diff_t swig_types[50]
2994
 
#define SWIGTYPE_p_svn_dirent_t swig_types[51]
2995
 
#define SWIGTYPE_p_svn_errno_t swig_types[52]
2996
 
#define SWIGTYPE_p_svn_error_t swig_types[53]
2997
 
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[54]
2998
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[55]
2999
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[56]
3000
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[57]
3001
 
#define SWIGTYPE_p_svn_lock_t swig_types[58]
3002
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[59]
3003
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[60]
3004
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[61]
3005
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[62]
3006
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[63]
3007
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[64]
3008
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[65]
3009
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[66]
3010
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[67]
3011
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[68]
3012
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[69]
3013
 
#define SWIGTYPE_p_svn_patch_file_t swig_types[70]
3014
 
#define SWIGTYPE_p_svn_patch_t swig_types[71]
3015
 
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[72]
3016
 
#define SWIGTYPE_p_svn_prop_kind swig_types[73]
3017
 
#define SWIGTYPE_p_svn_prop_patch_t swig_types[74]
3018
 
#define SWIGTYPE_p_svn_stream_mark_t swig_types[75]
3019
 
#define SWIGTYPE_p_svn_stream_t swig_types[76]
3020
 
#define SWIGTYPE_p_svn_string_t swig_types[77]
3021
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[78]
3022
 
#define SWIGTYPE_p_svn_tristate_t swig_types[79]
3023
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[80]
3024
 
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[81]
3025
 
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[82]
3026
 
#define SWIGTYPE_p_svn_version_extended_t swig_types[83]
3027
 
#define SWIGTYPE_p_svn_version_t swig_types[84]
3028
 
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[85]
3029
 
#define SWIGTYPE_p_unsigned_long swig_types[86]
3030
 
#define SWIGTYPE_p_void swig_types[87]
3031
 
static swig_type_info *swig_types[89];
3032
 
static swig_module_info swig_module = {swig_types, 88, 0, 0, 0, 0};
 
2927
#define SWIGTYPE_p_f_p_void__p_svn_error_t swig_types[10]
 
2928
#define SWIGTYPE_p_f_p_void__void swig_types[11]
 
2929
#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]
 
2930
#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]
 
2931
#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]
 
2932
#define SWIGTYPE_p_f_p_void_p_void__void swig_types[15]
 
2933
#define SWIGTYPE_p_f_p_void_p_void_p_void_p_int__p_svn_error_t swig_types[16]
 
2934
#define SWIGTYPE_p_f_p_void_svn_diff_datasource_e__p_svn_error_t swig_types[17]
 
2935
#define SWIGTYPE_p_int swig_types[18]
 
2936
#define SWIGTYPE_p_long swig_types[19]
 
2937
#define SWIGTYPE_p_p_char swig_types[20]
 
2938
#define SWIGTYPE_p_p_svn_diff_t swig_types[21]
 
2939
#define SWIGTYPE_p_p_svn_patch_file_t swig_types[22]
 
2940
#define SWIGTYPE_p_p_svn_patch_t swig_types[23]
 
2941
#define SWIGTYPE_p_p_svn_stringbuf_t swig_types[24]
 
2942
#define SWIGTYPE_p_p_void swig_types[25]
 
2943
#define SWIGTYPE_p_svn_auth_baton_t swig_types[26]
 
2944
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[27]
 
2945
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[28]
 
2946
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[29]
 
2947
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[30]
 
2948
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[31]
 
2949
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[32]
 
2950
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[33]
 
2951
#define SWIGTYPE_p_svn_auth_provider_t swig_types[34]
 
2952
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[35]
 
2953
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[36]
 
2954
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[37]
 
2955
#define SWIGTYPE_p_svn_checksum_t swig_types[38]
 
2956
#define SWIGTYPE_p_svn_commit_info_t swig_types[39]
 
2957
#define SWIGTYPE_p_svn_config_t swig_types[40]
 
2958
#define SWIGTYPE_p_svn_depth_t swig_types[41]
 
2959
#define SWIGTYPE_p_svn_diff_conflict_display_style_t swig_types[42]
 
2960
#define SWIGTYPE_p_svn_diff_datasource_e swig_types[43]
 
2961
#define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[44]
 
2962
#define SWIGTYPE_p_svn_diff_file_options_t swig_types[45]
 
2963
#define SWIGTYPE_p_svn_diff_fns2_t swig_types[46]
 
2964
#define SWIGTYPE_p_svn_diff_fns_t swig_types[47]
 
2965
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[48]
 
2966
#define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[49]
 
2967
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[50]
 
2968
#define SWIGTYPE_p_svn_diff_t swig_types[51]
 
2969
#define SWIGTYPE_p_svn_dirent_t swig_types[52]
 
2970
#define SWIGTYPE_p_svn_errno_t swig_types[53]
 
2971
#define SWIGTYPE_p_svn_error_t swig_types[54]
 
2972
#define SWIGTYPE_p_svn_fs_lock_target_t swig_types[55]
 
2973
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[56]
 
2974
#define SWIGTYPE_p_svn_io_dirent_t swig_types[57]
 
2975
#define SWIGTYPE_p_svn_io_file_del_t swig_types[58]
 
2976
#define SWIGTYPE_p_svn_location_segment_t swig_types[59]
 
2977
#define SWIGTYPE_p_svn_lock_t swig_types[60]
 
2978
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[61]
 
2979
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[62]
 
2980
#define SWIGTYPE_p_svn_log_entry_t swig_types[63]
 
2981
#define SWIGTYPE_p_svn_merge_range_t swig_types[64]
 
2982
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[65]
 
2983
#define SWIGTYPE_p_svn_node_kind_t swig_types[66]
 
2984
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[67]
 
2985
#define SWIGTYPE_p_svn_opt_revision_t swig_types[68]
 
2986
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[69]
 
2987
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[70]
 
2988
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[71]
 
2989
#define SWIGTYPE_p_svn_patch_file_t swig_types[72]
 
2990
#define SWIGTYPE_p_svn_patch_t swig_types[73]
 
2991
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[74]
 
2992
#define SWIGTYPE_p_svn_prop_kind swig_types[75]
 
2993
#define SWIGTYPE_p_svn_prop_patch_t swig_types[76]
 
2994
#define SWIGTYPE_p_svn_stream_mark_t swig_types[77]
 
2995
#define SWIGTYPE_p_svn_stream_t swig_types[78]
 
2996
#define SWIGTYPE_p_svn_string_t swig_types[79]
 
2997
#define SWIGTYPE_p_svn_stringbuf_t swig_types[80]
 
2998
#define SWIGTYPE_p_svn_tristate_t swig_types[81]
 
2999
#define SWIGTYPE_p_svn_version_checklist_t swig_types[82]
 
3000
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[83]
 
3001
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[84]
 
3002
#define SWIGTYPE_p_svn_version_extended_t swig_types[85]
 
3003
#define SWIGTYPE_p_svn_version_t swig_types[86]
 
3004
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[87]
 
3005
#define SWIGTYPE_p_unsigned_long swig_types[88]
 
3006
#define SWIGTYPE_p_void swig_types[89]
 
3007
static swig_type_info *swig_types[91];
 
3008
static swig_module_info swig_module = {swig_types, 90, 0, 0, 0, 0};
3033
3009
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3034
3010
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3035
3011
 
3053
3029
#endif
3054
3030
#define SWIG_name    "_diff"
3055
3031
 
3056
 
#define SWIGVERSION 0x020009 
 
3032
#define SWIGVERSION 0x020012 
3057
3033
#define SWIG_VERSION SWIGVERSION
3058
3034
 
3059
3035
 
3497
3473
      return SWIG_OK;
3498
3474
    } else {
3499
3475
      PyErr_Clear();
 
3476
#if PY_VERSION_HEX >= 0x03000000
 
3477
      {
 
3478
        long v = PyLong_AsLong(obj);
 
3479
        if (!PyErr_Occurred()) {
 
3480
          if (v < 0) {
 
3481
            return SWIG_OverflowError;
 
3482
          }
 
3483
        } else {
 
3484
          PyErr_Clear();
 
3485
        }
 
3486
      }
 
3487
#endif
3500
3488
    }
3501
3489
  }
3502
3490
#ifdef SWIG_PYTHON_CAST_MODE
3554
3542
    svn_swig_py_acquire_py_lock();
3555
3543
    
3556
3544
  }
3557
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_version_t,
 
3545
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_version_t,
3558
3546
    _global_py_pool, args);
3559
3547
  return resultobj;
3560
3548
fail:
3571
3559
  
3572
3560
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns2_t_datasources_open_set",&obj0,&obj1)) SWIG_fail;
3573
3561
  {
3574
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3562
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3575
3563
    if (PyErr_Occurred()) {
3576
3564
      SWIG_fail;
3577
3565
    }
3598
3586
  
3599
3587
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns2_t_datasources_open_get",&obj0)) SWIG_fail;
3600
3588
  {
3601
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3589
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3602
3590
    if (PyErr_Occurred()) {
3603
3591
      SWIG_fail;
3604
3592
    }
3620
3608
  
3621
3609
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns2_t_datasource_close_set",&obj0,&obj1)) SWIG_fail;
3622
3610
  {
3623
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3611
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3624
3612
    if (PyErr_Occurred()) {
3625
3613
      SWIG_fail;
3626
3614
    }
3647
3635
  
3648
3636
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns2_t_datasource_close_get",&obj0)) SWIG_fail;
3649
3637
  {
3650
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3638
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3651
3639
    if (PyErr_Occurred()) {
3652
3640
      SWIG_fail;
3653
3641
    }
3669
3657
  
3670
3658
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns2_t_datasource_get_next_token_set",&obj0,&obj1)) SWIG_fail;
3671
3659
  {
3672
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3660
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3673
3661
    if (PyErr_Occurred()) {
3674
3662
      SWIG_fail;
3675
3663
    }
3696
3684
  
3697
3685
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns2_t_datasource_get_next_token_get",&obj0)) SWIG_fail;
3698
3686
  {
3699
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3687
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3700
3688
    if (PyErr_Occurred()) {
3701
3689
      SWIG_fail;
3702
3690
    }
3718
3706
  
3719
3707
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns2_t_token_compare_set",&obj0,&obj1)) SWIG_fail;
3720
3708
  {
3721
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3709
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3722
3710
    if (PyErr_Occurred()) {
3723
3711
      SWIG_fail;
3724
3712
    }
3745
3733
  
3746
3734
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns2_t_token_compare_get",&obj0)) SWIG_fail;
3747
3735
  {
3748
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3736
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3749
3737
    if (PyErr_Occurred()) {
3750
3738
      SWIG_fail;
3751
3739
    }
3767
3755
  
3768
3756
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns2_t_token_discard_set",&obj0,&obj1)) SWIG_fail;
3769
3757
  {
3770
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3758
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3771
3759
    if (PyErr_Occurred()) {
3772
3760
      SWIG_fail;
3773
3761
    }
3794
3782
  
3795
3783
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns2_t_token_discard_get",&obj0)) SWIG_fail;
3796
3784
  {
3797
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3785
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3798
3786
    if (PyErr_Occurred()) {
3799
3787
      SWIG_fail;
3800
3788
    }
3816
3804
  
3817
3805
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns2_t_token_discard_all_set",&obj0,&obj1)) SWIG_fail;
3818
3806
  {
3819
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3807
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3820
3808
    if (PyErr_Occurred()) {
3821
3809
      SWIG_fail;
3822
3810
    }
3843
3831
  
3844
3832
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns2_t_token_discard_all_get",&obj0)) SWIG_fail;
3845
3833
  {
3846
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3834
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3847
3835
    if (PyErr_Occurred()) {
3848
3836
      SWIG_fail;
3849
3837
    }
3869
3857
    svn_swig_py_acquire_py_lock();
3870
3858
    
3871
3859
  }
3872
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_diff_fns2_t,
 
3860
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_fns2_t,
3873
3861
    _global_py_pool, args);
3874
3862
  return resultobj;
3875
3863
fail:
3884
3872
  
3885
3873
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_diff_fns2_t",&obj0)) SWIG_fail;
3886
3874
  {
3887
 
    arg1 = (struct svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
3875
    arg1 = (struct svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
3888
3876
    if (PyErr_Occurred()) {
3889
3877
      SWIG_fail;
3890
3878
    }
3920
3908
  
3921
3909
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns_t_datasource_open_set",&obj0,&obj1)) SWIG_fail;
3922
3910
  {
3923
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
3911
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
3924
3912
    if (PyErr_Occurred()) {
3925
3913
      SWIG_fail;
3926
3914
    }
3947
3935
  
3948
3936
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns_t_datasource_open_get",&obj0)) SWIG_fail;
3949
3937
  {
3950
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
3938
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
3951
3939
    if (PyErr_Occurred()) {
3952
3940
      SWIG_fail;
3953
3941
    }
3969
3957
  
3970
3958
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns_t_datasource_close_set",&obj0,&obj1)) SWIG_fail;
3971
3959
  {
3972
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
3960
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
3973
3961
    if (PyErr_Occurred()) {
3974
3962
      SWIG_fail;
3975
3963
    }
3996
3984
  
3997
3985
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns_t_datasource_close_get",&obj0)) SWIG_fail;
3998
3986
  {
3999
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
3987
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4000
3988
    if (PyErr_Occurred()) {
4001
3989
      SWIG_fail;
4002
3990
    }
4018
4006
  
4019
4007
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns_t_datasource_get_next_token_set",&obj0,&obj1)) SWIG_fail;
4020
4008
  {
4021
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4009
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4022
4010
    if (PyErr_Occurred()) {
4023
4011
      SWIG_fail;
4024
4012
    }
4045
4033
  
4046
4034
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns_t_datasource_get_next_token_get",&obj0)) SWIG_fail;
4047
4035
  {
4048
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4036
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4049
4037
    if (PyErr_Occurred()) {
4050
4038
      SWIG_fail;
4051
4039
    }
4067
4055
  
4068
4056
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns_t_token_compare_set",&obj0,&obj1)) SWIG_fail;
4069
4057
  {
4070
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4058
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4071
4059
    if (PyErr_Occurred()) {
4072
4060
      SWIG_fail;
4073
4061
    }
4094
4082
  
4095
4083
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns_t_token_compare_get",&obj0)) SWIG_fail;
4096
4084
  {
4097
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4085
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4098
4086
    if (PyErr_Occurred()) {
4099
4087
      SWIG_fail;
4100
4088
    }
4116
4104
  
4117
4105
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns_t_token_discard_set",&obj0,&obj1)) SWIG_fail;
4118
4106
  {
4119
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4107
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4120
4108
    if (PyErr_Occurred()) {
4121
4109
      SWIG_fail;
4122
4110
    }
4143
4131
  
4144
4132
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns_t_token_discard_get",&obj0)) SWIG_fail;
4145
4133
  {
4146
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4134
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4147
4135
    if (PyErr_Occurred()) {
4148
4136
      SWIG_fail;
4149
4137
    }
4165
4153
  
4166
4154
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns_t_token_discard_all_set",&obj0,&obj1)) SWIG_fail;
4167
4155
  {
4168
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4156
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4169
4157
    if (PyErr_Occurred()) {
4170
4158
      SWIG_fail;
4171
4159
    }
4192
4180
  
4193
4181
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_fns_t_token_discard_all_get",&obj0)) SWIG_fail;
4194
4182
  {
4195
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4183
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4196
4184
    if (PyErr_Occurred()) {
4197
4185
      SWIG_fail;
4198
4186
    }
4218
4206
    svn_swig_py_acquire_py_lock();
4219
4207
    
4220
4208
  }
4221
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_diff_fns_t,
 
4209
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_fns_t,
4222
4210
    _global_py_pool, args);
4223
4211
  return resultobj;
4224
4212
fail:
4233
4221
  
4234
4222
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_diff_fns_t",&obj0)) SWIG_fail;
4235
4223
  {
4236
 
    arg1 = (struct svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
4224
    arg1 = (struct svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
4237
4225
    if (PyErr_Occurred()) {
4238
4226
      SWIG_fail;
4239
4227
    }
4289
4277
    }
4290
4278
  }
4291
4279
  {
4292
 
    arg3 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
 
4280
    arg3 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
4293
4281
    if (PyErr_Occurred()) {
4294
4282
      SWIG_fail;
4295
4283
    }
4322
4310
    resultobj = Py_None;
4323
4311
  }
4324
4312
  {
4325
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
4313
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4326
4314
        _global_py_pool, args))
4327
4315
    
4328
4316
    ;
4368
4356
    }
4369
4357
  }
4370
4358
  {
4371
 
    arg3 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
 
4359
    arg3 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
4372
4360
    if (PyErr_Occurred()) {
4373
4361
      SWIG_fail;
4374
4362
    }
4401
4389
    resultobj = Py_None;
4402
4390
  }
4403
4391
  {
4404
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
4392
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4405
4393
        _global_py_pool, args))
4406
4394
    
4407
4395
    ;
4447
4435
    }
4448
4436
  }
4449
4437
  {
4450
 
    arg3 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
 
4438
    arg3 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
4451
4439
    if (PyErr_Occurred()) {
4452
4440
      SWIG_fail;
4453
4441
    }
4480
4468
    resultobj = Py_None;
4481
4469
  }
4482
4470
  {
4483
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
4471
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4484
4472
        _global_py_pool, args))
4485
4473
    
4486
4474
    ;
4526
4514
    }
4527
4515
  }
4528
4516
  {
4529
 
    arg3 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
 
4517
    arg3 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
4530
4518
    if (PyErr_Occurred()) {
4531
4519
      SWIG_fail;
4532
4520
    }
4559
4547
    resultobj = Py_None;
4560
4548
  }
4561
4549
  {
4562
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
4550
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4563
4551
        _global_py_pool, args))
4564
4552
    
4565
4553
    ;
4605
4593
    }
4606
4594
  }
4607
4595
  {
4608
 
    arg3 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
 
4596
    arg3 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj1);
4609
4597
    if (PyErr_Occurred()) {
4610
4598
      SWIG_fail;
4611
4599
    }
4638
4626
    resultobj = Py_None;
4639
4627
  }
4640
4628
  {
4641
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
4629
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4642
4630
        _global_py_pool, args))
4643
4631
    
4644
4632
    ;
4684
4672
    }
4685
4673
  }
4686
4674
  {
4687
 
    arg3 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
 
4675
    arg3 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj1);
4688
4676
    if (PyErr_Occurred()) {
4689
4677
      SWIG_fail;
4690
4678
    }
4717
4705
    resultobj = Py_None;
4718
4706
  }
4719
4707
  {
4720
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
4708
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
4721
4709
        _global_py_pool, args))
4722
4710
    
4723
4711
    ;
4742
4730
  
4743
4731
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_contains_conflicts",&obj0)) SWIG_fail;
4744
4732
  {
4745
 
    arg1 = (svn_diff_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
 
4733
    arg1 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
4746
4734
    if (PyErr_Occurred()) {
4747
4735
      SWIG_fail;
4748
4736
    }
4770
4758
  
4771
4759
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_contains_diffs",&obj0)) SWIG_fail;
4772
4760
  {
4773
 
    arg1 = (svn_diff_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
 
4761
    arg1 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
4774
4762
    if (PyErr_Occurred()) {
4775
4763
      SWIG_fail;
4776
4764
    }
4799
4787
  
4800
4788
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_output_fns_t_output_common_set",&obj0,&obj1)) SWIG_fail;
4801
4789
  {
4802
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4790
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4803
4791
    if (PyErr_Occurred()) {
4804
4792
      SWIG_fail;
4805
4793
    }
4826
4814
  
4827
4815
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_output_fns_t_output_common_get",&obj0)) SWIG_fail;
4828
4816
  {
4829
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4817
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4830
4818
    if (PyErr_Occurred()) {
4831
4819
      SWIG_fail;
4832
4820
    }
4848
4836
  
4849
4837
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_output_fns_t_output_diff_modified_set",&obj0,&obj1)) SWIG_fail;
4850
4838
  {
4851
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4839
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4852
4840
    if (PyErr_Occurred()) {
4853
4841
      SWIG_fail;
4854
4842
    }
4875
4863
  
4876
4864
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_output_fns_t_output_diff_modified_get",&obj0)) SWIG_fail;
4877
4865
  {
4878
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4866
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4879
4867
    if (PyErr_Occurred()) {
4880
4868
      SWIG_fail;
4881
4869
    }
4897
4885
  
4898
4886
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_output_fns_t_output_diff_latest_set",&obj0,&obj1)) SWIG_fail;
4899
4887
  {
4900
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4888
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4901
4889
    if (PyErr_Occurred()) {
4902
4890
      SWIG_fail;
4903
4891
    }
4924
4912
  
4925
4913
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_output_fns_t_output_diff_latest_get",&obj0)) SWIG_fail;
4926
4914
  {
4927
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4915
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4928
4916
    if (PyErr_Occurred()) {
4929
4917
      SWIG_fail;
4930
4918
    }
4946
4934
  
4947
4935
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_output_fns_t_output_diff_common_set",&obj0,&obj1)) SWIG_fail;
4948
4936
  {
4949
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4937
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4950
4938
    if (PyErr_Occurred()) {
4951
4939
      SWIG_fail;
4952
4940
    }
4973
4961
  
4974
4962
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_output_fns_t_output_diff_common_get",&obj0)) SWIG_fail;
4975
4963
  {
4976
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4964
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4977
4965
    if (PyErr_Occurred()) {
4978
4966
      SWIG_fail;
4979
4967
    }
4995
4983
  
4996
4984
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_output_fns_t_output_conflict_set",&obj0,&obj1)) SWIG_fail;
4997
4985
  {
4998
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
4986
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
4999
4987
    if (PyErr_Occurred()) {
5000
4988
      SWIG_fail;
5001
4989
    }
5022
5010
  
5023
5011
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_output_fns_t_output_conflict_get",&obj0)) SWIG_fail;
5024
5012
  {
5025
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
5013
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5026
5014
    if (PyErr_Occurred()) {
5027
5015
      SWIG_fail;
5028
5016
    }
5048
5036
    svn_swig_py_acquire_py_lock();
5049
5037
    
5050
5038
  }
5051
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_diff_output_fns_t,
 
5039
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_output_fns_t,
5052
5040
    _global_py_pool, args);
5053
5041
  return resultobj;
5054
5042
fail:
5063
5051
  
5064
5052
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_diff_output_fns_t",&obj0)) SWIG_fail;
5065
5053
  {
5066
 
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
5054
    arg1 = (struct svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
5067
5055
    if (PyErr_Occurred()) {
5068
5056
      SWIG_fail;
5069
5057
    }
5090
5078
  return SWIG_Py_Void();
5091
5079
}
5092
5080
 
 
5081
SWIGINTERN PyObject *_wrap_svn_diff_output2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5082
  PyObject *resultobj = 0;
 
5083
  svn_diff_t *arg1 = (svn_diff_t *) 0 ;
 
5084
  void *arg2 = (void *) 0 ;
 
5085
  svn_diff_output_fns_t *arg3 = (svn_diff_output_fns_t *) 0 ;
 
5086
  svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
 
5087
  void *arg5 = (void *) 0 ;
 
5088
  PyObject * obj0 = 0 ;
 
5089
  PyObject * obj1 = 0 ;
 
5090
  PyObject * obj2 = 0 ;
 
5091
  PyObject * obj3 = 0 ;
 
5092
  svn_error_t *result = 0 ;
 
5093
  
 
5094
  if (!PyArg_ParseTuple(args,(char *)"OOOO:svn_diff_output2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
5095
  {
 
5096
    arg1 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
 
5097
    if (PyErr_Occurred()) {
 
5098
      SWIG_fail;
 
5099
    }
 
5100
  }
 
5101
  {
 
5102
    if (obj1 == Py_None) {
 
5103
      arg2 = NULL;
 
5104
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
 
5105
      arg2 = (void *) obj1;
 
5106
      PyErr_Clear();
 
5107
    }
 
5108
  }
 
5109
  {
 
5110
    arg3 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj2);
 
5111
    if (PyErr_Occurred()) {
 
5112
      SWIG_fail;
 
5113
    }
 
5114
  }
 
5115
  {
 
5116
    arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
5117
    arg5 = obj3;
 
5118
  }
 
5119
  {
 
5120
    svn_swig_py_release_py_lock();
 
5121
    
 
5122
    result = (svn_error_t *)svn_diff_output2(arg1,arg2,(struct svn_diff_output_fns_t const *)arg3,arg4,arg5);
 
5123
    
 
5124
    svn_swig_py_acquire_py_lock();
 
5125
    
 
5126
  }
 
5127
  {
 
5128
    if (result != NULL) {
 
5129
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
5130
      svn_swig_py_svn_exception(result);
 
5131
      else
 
5132
      svn_error_clear(result);
 
5133
      SWIG_fail;
 
5134
    }
 
5135
    Py_INCREF(Py_None);
 
5136
    resultobj = Py_None;
 
5137
  }
 
5138
  return resultobj;
 
5139
fail:
 
5140
  return NULL;
 
5141
}
 
5142
 
 
5143
 
5093
5144
SWIGINTERN PyObject *_wrap_svn_diff_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5094
5145
  PyObject *resultobj = 0;
5095
5146
  svn_diff_t *arg1 = (svn_diff_t *) 0 ;
5102
5153
  
5103
5154
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_diff_output",&obj0,&obj1,&obj2)) SWIG_fail;
5104
5155
  {
5105
 
    arg1 = (svn_diff_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
 
5156
    arg1 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_t, svn_argnum_obj0);
5106
5157
    if (PyErr_Occurred()) {
5107
5158
      SWIG_fail;
5108
5159
    }
5116
5167
    }
5117
5168
  }
5118
5169
  {
5119
 
    arg3 = (svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj2);
 
5170
    arg3 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj2);
5120
5171
    if (PyErr_Occurred()) {
5121
5172
      SWIG_fail;
5122
5173
    }
5155
5206
  
5156
5207
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_file_options_t_ignore_space_set",&obj0,&obj1)) SWIG_fail;
5157
5208
  {
5158
 
    arg1 = (struct svn_diff_file_options_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5209
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5159
5210
    if (PyErr_Occurred()) {
5160
5211
      SWIG_fail;
5161
5212
    }
5182
5233
  
5183
5234
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_file_options_t_ignore_space_get",&obj0)) SWIG_fail;
5184
5235
  {
5185
 
    arg1 = (struct svn_diff_file_options_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5236
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5186
5237
    if (PyErr_Occurred()) {
5187
5238
      SWIG_fail;
5188
5239
    }
5204
5255
  
5205
5256
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_file_options_t_ignore_eol_style_set",&obj0,&obj1)) SWIG_fail;
5206
5257
  {
5207
 
    arg1 = (struct svn_diff_file_options_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5258
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5208
5259
    if (PyErr_Occurred()) {
5209
5260
      SWIG_fail;
5210
5261
    }
5231
5282
  
5232
5283
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_file_options_t_ignore_eol_style_get",&obj0)) SWIG_fail;
5233
5284
  {
5234
 
    arg1 = (struct svn_diff_file_options_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5285
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5235
5286
    if (PyErr_Occurred()) {
5236
5287
      SWIG_fail;
5237
5288
    }
5253
5304
  
5254
5305
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_file_options_t_show_c_function_set",&obj0,&obj1)) SWIG_fail;
5255
5306
  {
5256
 
    arg1 = (struct svn_diff_file_options_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5307
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5257
5308
    if (PyErr_Occurred()) {
5258
5309
      SWIG_fail;
5259
5310
    }
5280
5331
  
5281
5332
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_file_options_t_show_c_function_get",&obj0)) SWIG_fail;
5282
5333
  {
5283
 
    arg1 = (struct svn_diff_file_options_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5334
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5284
5335
    if (PyErr_Occurred()) {
5285
5336
      SWIG_fail;
5286
5337
    }
5293
5344
}
5294
5345
 
5295
5346
 
 
5347
SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_context_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5348
  PyObject *resultobj = 0;
 
5349
  struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
 
5350
  int arg2 ;
 
5351
  PyObject * obj0 = 0 ;
 
5352
  PyObject * obj1 = 0 ;
 
5353
  
 
5354
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_file_options_t_context_size_set",&obj0,&obj1)) SWIG_fail;
 
5355
  {
 
5356
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5357
    if (PyErr_Occurred()) {
 
5358
      SWIG_fail;
 
5359
    }
 
5360
  }
 
5361
  {
 
5362
    arg2 = (int)SWIG_As_long (obj1);
 
5363
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
5364
      SWIG_fail;
 
5365
    }
 
5366
  }
 
5367
  if (arg1) (arg1)->context_size = arg2;
 
5368
  resultobj = SWIG_Py_Void();
 
5369
  return resultobj;
 
5370
fail:
 
5371
  return NULL;
 
5372
}
 
5373
 
 
5374
 
 
5375
SWIGINTERN PyObject *_wrap_svn_diff_file_options_t_context_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5376
  PyObject *resultobj = 0;
 
5377
  struct svn_diff_file_options_t *arg1 = (struct svn_diff_file_options_t *) 0 ;
 
5378
  PyObject * obj0 = 0 ;
 
5379
  int result;
 
5380
  
 
5381
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_file_options_t_context_size_get",&obj0)) SWIG_fail;
 
5382
  {
 
5383
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5384
    if (PyErr_Occurred()) {
 
5385
      SWIG_fail;
 
5386
    }
 
5387
  }
 
5388
  result = (int) ((arg1)->context_size);
 
5389
  resultobj = SWIG_From_long((long)(result));
 
5390
  return resultobj;
 
5391
fail:
 
5392
  return NULL;
 
5393
}
 
5394
 
 
5395
 
5296
5396
SWIGINTERN PyObject *_wrap_new_svn_diff_file_options_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297
5397
  PyObject *resultobj = 0;
5298
5398
  struct svn_diff_file_options_t *result = 0 ;
5306
5406
    svn_swig_py_acquire_py_lock();
5307
5407
    
5308
5408
  }
5309
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_diff_file_options_t,
 
5409
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_file_options_t,
5310
5410
    _global_py_pool, args);
5311
5411
  return resultobj;
5312
5412
fail:
5321
5421
  
5322
5422
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_diff_file_options_t",&obj0)) SWIG_fail;
5323
5423
  {
5324
 
    arg1 = (struct svn_diff_file_options_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5424
    arg1 = (struct svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5325
5425
    if (PyErr_Occurred()) {
5326
5426
      SWIG_fail;
5327
5427
    }
5377
5477
    svn_swig_py_acquire_py_lock();
5378
5478
    
5379
5479
  }
5380
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_diff_file_options_t,
 
5480
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_diff_file_options_t,
5381
5481
    _global_py_pool, args);
5382
5482
  {
5383
5483
    Py_XDECREF(_global_py_pool);
5409
5509
  arg3 = _global_pool;
5410
5510
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_diff_file_options_parse",&obj0,&obj1,&obj2)) SWIG_fail;
5411
5511
  {
5412
 
    arg1 = (svn_diff_file_options_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
 
5512
    arg1 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj0);
5413
5513
    if (PyErr_Occurred()) {
5414
5514
      SWIG_fail;
5415
5515
    }
5483
5583
  arg1 = &temp1;
5484
5584
  if (!PyArg_ParseTuple(args,(char *)"ssO|O:svn_diff_file_diff_2",&arg2,&arg3,&obj2,&obj3)) SWIG_fail;
5485
5585
  {
5486
 
    arg4 = (svn_diff_file_options_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj2);
 
5586
    arg4 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj2);
5487
5587
    if (PyErr_Occurred()) {
5488
5588
      SWIG_fail;
5489
5589
    }
5516
5616
    resultobj = Py_None;
5517
5617
  }
5518
5618
  {
5519
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
5619
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5520
5620
        _global_py_pool, args))
5521
5621
    
5522
5622
    ;
5579
5679
    resultobj = Py_None;
5580
5680
  }
5581
5681
  {
5582
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
5682
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5583
5683
        _global_py_pool, args))
5584
5684
    
5585
5685
    ;
5618
5718
  arg1 = &temp1;
5619
5719
  if (!PyArg_ParseTuple(args,(char *)"sssO|O:svn_diff_file_diff3_2",&arg2,&arg3,&arg4,&obj3,&obj4)) SWIG_fail;
5620
5720
  {
5621
 
    arg5 = (svn_diff_file_options_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj3);
 
5721
    arg5 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj3);
5622
5722
    if (PyErr_Occurred()) {
5623
5723
      SWIG_fail;
5624
5724
    }
5651
5751
    resultobj = Py_None;
5652
5752
  }
5653
5753
  {
5654
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
5754
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5655
5755
        _global_py_pool, args))
5656
5756
    
5657
5757
    ;
5715
5815
    resultobj = Py_None;
5716
5816
  }
5717
5817
  {
5718
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
5818
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5719
5819
        _global_py_pool, args))
5720
5820
    
5721
5821
    ;
5755
5855
  arg1 = &temp1;
5756
5856
  if (!PyArg_ParseTuple(args,(char *)"ssssO|O:svn_diff_file_diff4_2",&arg2,&arg3,&arg4,&arg5,&obj4,&obj5)) SWIG_fail;
5757
5857
  {
5758
 
    arg6 = (svn_diff_file_options_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj4);
 
5858
    arg6 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj4);
5759
5859
    if (PyErr_Occurred()) {
5760
5860
      SWIG_fail;
5761
5861
    }
5788
5888
    resultobj = Py_None;
5789
5889
  }
5790
5890
  {
5791
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
5891
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5792
5892
        _global_py_pool, args))
5793
5893
    
5794
5894
    ;
5853
5953
    resultobj = Py_None;
5854
5954
  }
5855
5955
  {
5856
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
5956
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
5857
5957
        _global_py_pool, args))
5858
5958
    
5859
5959
    ;
5870
5970
}
5871
5971
 
5872
5972
 
 
5973
SWIGINTERN PyObject *_wrap_svn_diff_file_output_unified4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5974
  PyObject *resultobj = 0;
 
5975
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
 
5976
  svn_diff_t *arg2 = (svn_diff_t *) 0 ;
 
5977
  char *arg3 = (char *) 0 ;
 
5978
  char *arg4 = (char *) 0 ;
 
5979
  char *arg5 = (char *) 0 ;
 
5980
  char *arg6 = (char *) 0 ;
 
5981
  char *arg7 = (char *) 0 ;
 
5982
  char *arg8 = (char *) 0 ;
 
5983
  svn_boolean_t arg9 ;
 
5984
  int arg10 ;
 
5985
  svn_cancel_func_t arg11 = (svn_cancel_func_t) 0 ;
 
5986
  void *arg12 = (void *) 0 ;
 
5987
  apr_pool_t *arg13 = (apr_pool_t *) 0 ;
 
5988
  apr_pool_t *_global_pool = NULL ;
 
5989
  PyObject *_global_py_pool = NULL ;
 
5990
  PyObject * obj0 = 0 ;
 
5991
  PyObject * obj1 = 0 ;
 
5992
  PyObject * obj8 = 0 ;
 
5993
  PyObject * obj9 = 0 ;
 
5994
  PyObject * obj10 = 0 ;
 
5995
  PyObject * obj11 = 0 ;
 
5996
  svn_error_t *result = 0 ;
 
5997
  
 
5998
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
5999
      &_global_py_pool, &_global_pool))
 
6000
  SWIG_fail;
 
6001
  arg13 = _global_pool;
 
6002
  if (!PyArg_ParseTuple(args,(char *)"OOsszzzzOOO|O:svn_diff_file_output_unified4",&obj0,&obj1,&arg3,&arg4,&arg5,&arg6,&arg7,&arg8,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
 
6003
  {
 
6004
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
 
6005
  }
 
6006
  {
 
6007
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
6008
    if (PyErr_Occurred()) {
 
6009
      SWIG_fail;
 
6010
    }
 
6011
  }
 
6012
  {
 
6013
    arg9 = (svn_boolean_t)SWIG_As_long (obj8);
 
6014
    if (SWIG_arg_fail(svn_argnum_obj8)) {
 
6015
      SWIG_fail;
 
6016
    }
 
6017
  }
 
6018
  {
 
6019
    arg10 = (int)SWIG_As_long (obj9);
 
6020
    if (SWIG_arg_fail(svn_argnum_obj9)) {
 
6021
      SWIG_fail;
 
6022
    }
 
6023
  }
 
6024
  {
 
6025
    arg11 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
6026
    arg12 = obj10;
 
6027
  }
 
6028
  if (obj11) {
 
6029
    /* Verify that the user supplied a valid pool */
 
6030
    if (obj11 != Py_None && obj11 != _global_py_pool) {
 
6031
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
 
6032
      SWIG_arg_fail(svn_argnum_obj11);
 
6033
      SWIG_fail;
 
6034
    }
 
6035
  }
 
6036
  {
 
6037
    svn_swig_py_release_py_lock();
 
6038
    
 
6039
    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);
 
6040
    
 
6041
    svn_swig_py_acquire_py_lock();
 
6042
    
 
6043
  }
 
6044
  {
 
6045
    if (result != NULL) {
 
6046
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
6047
      svn_swig_py_svn_exception(result);
 
6048
      else
 
6049
      svn_error_clear(result);
 
6050
      SWIG_fail;
 
6051
    }
 
6052
    Py_INCREF(Py_None);
 
6053
    resultobj = Py_None;
 
6054
  }
 
6055
  {
 
6056
    Py_XDECREF(_global_py_pool);
 
6057
  }
 
6058
  return resultobj;
 
6059
fail:
 
6060
  {
 
6061
    Py_XDECREF(_global_py_pool);
 
6062
  }
 
6063
  return NULL;
 
6064
}
 
6065
 
 
6066
 
5873
6067
SWIGINTERN PyObject *_wrap_svn_diff_file_output_unified3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5874
6068
  PyObject *resultobj = 0;
5875
6069
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
5899
6093
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
5900
6094
  }
5901
6095
  {
5902
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
6096
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
5903
6097
    if (PyErr_Occurred()) {
5904
6098
      SWIG_fail;
5905
6099
    }
5975
6169
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
5976
6170
  }
5977
6171
  {
5978
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
6172
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
5979
6173
    if (PyErr_Occurred()) {
5980
6174
      SWIG_fail;
5981
6175
    }
6044
6238
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6045
6239
  }
6046
6240
  {
6047
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
6241
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6048
6242
    if (PyErr_Occurred()) {
6049
6243
      SWIG_fail;
6050
6244
    }
6088
6282
}
6089
6283
 
6090
6284
 
 
6285
SWIGINTERN PyObject *_wrap_svn_diff_file_output_merge3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6286
  PyObject *resultobj = 0;
 
6287
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
 
6288
  svn_diff_t *arg2 = (svn_diff_t *) 0 ;
 
6289
  char *arg3 = (char *) 0 ;
 
6290
  char *arg4 = (char *) 0 ;
 
6291
  char *arg5 = (char *) 0 ;
 
6292
  char *arg6 = (char *) 0 ;
 
6293
  char *arg7 = (char *) 0 ;
 
6294
  char *arg8 = (char *) 0 ;
 
6295
  char *arg9 = (char *) 0 ;
 
6296
  svn_diff_conflict_display_style_t arg10 ;
 
6297
  svn_cancel_func_t arg11 = (svn_cancel_func_t) 0 ;
 
6298
  void *arg12 = (void *) 0 ;
 
6299
  apr_pool_t *arg13 = (apr_pool_t *) 0 ;
 
6300
  apr_pool_t *_global_pool = NULL ;
 
6301
  PyObject *_global_py_pool = NULL ;
 
6302
  PyObject * obj0 = 0 ;
 
6303
  PyObject * obj1 = 0 ;
 
6304
  PyObject * obj9 = 0 ;
 
6305
  PyObject * obj10 = 0 ;
 
6306
  PyObject * obj11 = 0 ;
 
6307
  svn_error_t *result = 0 ;
 
6308
  
 
6309
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
6310
      &_global_py_pool, &_global_pool))
 
6311
  SWIG_fail;
 
6312
  arg13 = _global_pool;
 
6313
  if (!PyArg_ParseTuple(args,(char *)"OOssszzzzOO|O:svn_diff_file_output_merge3",&obj0,&obj1,&arg3,&arg4,&arg5,&arg6,&arg7,&arg8,&arg9,&obj9,&obj10,&obj11)) SWIG_fail;
 
6314
  {
 
6315
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
 
6316
  }
 
6317
  {
 
6318
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
6319
    if (PyErr_Occurred()) {
 
6320
      SWIG_fail;
 
6321
    }
 
6322
  }
 
6323
  {
 
6324
    arg10 = (svn_diff_conflict_display_style_t)SWIG_As_long (obj9);
 
6325
    if (SWIG_arg_fail(svn_argnum_obj9)) {
 
6326
      SWIG_fail;
 
6327
    }
 
6328
  }
 
6329
  {
 
6330
    arg11 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
6331
    arg12 = obj10;
 
6332
  }
 
6333
  if (obj11) {
 
6334
    /* Verify that the user supplied a valid pool */
 
6335
    if (obj11 != Py_None && obj11 != _global_py_pool) {
 
6336
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
 
6337
      SWIG_arg_fail(svn_argnum_obj11);
 
6338
      SWIG_fail;
 
6339
    }
 
6340
  }
 
6341
  {
 
6342
    svn_swig_py_release_py_lock();
 
6343
    
 
6344
    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);
 
6345
    
 
6346
    svn_swig_py_acquire_py_lock();
 
6347
    
 
6348
  }
 
6349
  {
 
6350
    if (result != NULL) {
 
6351
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
6352
      svn_swig_py_svn_exception(result);
 
6353
      else
 
6354
      svn_error_clear(result);
 
6355
      SWIG_fail;
 
6356
    }
 
6357
    Py_INCREF(Py_None);
 
6358
    resultobj = Py_None;
 
6359
  }
 
6360
  {
 
6361
    Py_XDECREF(_global_py_pool);
 
6362
  }
 
6363
  return resultobj;
 
6364
fail:
 
6365
  {
 
6366
    Py_XDECREF(_global_py_pool);
 
6367
  }
 
6368
  return NULL;
 
6369
}
 
6370
 
 
6371
 
6091
6372
SWIGINTERN PyObject *_wrap_svn_diff_file_output_merge2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6092
6373
  PyObject *resultobj = 0;
6093
6374
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6118
6399
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6119
6400
  }
6120
6401
  {
6121
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
6402
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6122
6403
    if (PyErr_Occurred()) {
6123
6404
      SWIG_fail;
6124
6405
    }
6200
6481
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6201
6482
  }
6202
6483
  {
6203
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
6484
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6204
6485
    if (PyErr_Occurred()) {
6205
6486
      SWIG_fail;
6206
6487
    }
6256
6537
}
6257
6538
 
6258
6539
 
 
6540
SWIGINTERN PyObject *_wrap_svn_diff_output_binary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6541
  PyObject *resultobj = 0;
 
6542
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
 
6543
  svn_stream_t *arg2 = (svn_stream_t *) 0 ;
 
6544
  svn_stream_t *arg3 = (svn_stream_t *) 0 ;
 
6545
  svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
 
6546
  void *arg5 = (void *) 0 ;
 
6547
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
6548
  apr_pool_t *_global_pool = NULL ;
 
6549
  PyObject *_global_py_pool = NULL ;
 
6550
  PyObject * obj0 = 0 ;
 
6551
  PyObject * obj1 = 0 ;
 
6552
  PyObject * obj2 = 0 ;
 
6553
  PyObject * obj3 = 0 ;
 
6554
  PyObject * obj4 = 0 ;
 
6555
  svn_error_t *result = 0 ;
 
6556
  
 
6557
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
6558
      &_global_py_pool, &_global_pool))
 
6559
  SWIG_fail;
 
6560
  arg6 = _global_pool;
 
6561
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_diff_output_binary",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
6562
  {
 
6563
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
 
6564
  }
 
6565
  {
 
6566
    arg2 = svn_swig_py_make_stream (obj1, _global_pool);
 
6567
  }
 
6568
  {
 
6569
    arg3 = svn_swig_py_make_stream (obj2, _global_pool);
 
6570
  }
 
6571
  {
 
6572
    arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
6573
    arg5 = obj3;
 
6574
  }
 
6575
  if (obj4) {
 
6576
    /* Verify that the user supplied a valid pool */
 
6577
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
6578
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
6579
      SWIG_arg_fail(svn_argnum_obj4);
 
6580
      SWIG_fail;
 
6581
    }
 
6582
  }
 
6583
  {
 
6584
    svn_swig_py_release_py_lock();
 
6585
    
 
6586
    result = (svn_error_t *)svn_diff_output_binary(arg1,arg2,arg3,arg4,arg5,arg6);
 
6587
    
 
6588
    svn_swig_py_acquire_py_lock();
 
6589
    
 
6590
  }
 
6591
  {
 
6592
    if (result != NULL) {
 
6593
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
6594
      svn_swig_py_svn_exception(result);
 
6595
      else
 
6596
      svn_error_clear(result);
 
6597
      SWIG_fail;
 
6598
    }
 
6599
    Py_INCREF(Py_None);
 
6600
    resultobj = Py_None;
 
6601
  }
 
6602
  {
 
6603
    Py_XDECREF(_global_py_pool);
 
6604
  }
 
6605
  return resultobj;
 
6606
fail:
 
6607
  {
 
6608
    Py_XDECREF(_global_py_pool);
 
6609
  }
 
6610
  return NULL;
 
6611
}
 
6612
 
 
6613
 
6259
6614
SWIGINTERN PyObject *_wrap_svn_diff_mem_string_diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6260
6615
  PyObject *resultobj = 0;
6261
6616
  svn_diff_t **arg1 = (svn_diff_t **) 0 ;
6307
6662
    }
6308
6663
  }
6309
6664
  {
6310
 
    arg4 = (svn_diff_file_options_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj2);
 
6665
    arg4 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj2);
6311
6666
    if (PyErr_Occurred()) {
6312
6667
      SWIG_fail;
6313
6668
    }
6340
6695
    resultobj = Py_None;
6341
6696
  }
6342
6697
  {
6343
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
6698
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
6344
6699
        _global_py_pool, args))
6345
6700
    
6346
6701
    ;
6424
6779
    }
6425
6780
  }
6426
6781
  {
6427
 
    arg5 = (svn_diff_file_options_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj3);
 
6782
    arg5 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj3);
6428
6783
    if (PyErr_Occurred()) {
6429
6784
      SWIG_fail;
6430
6785
    }
6457
6812
    resultobj = Py_None;
6458
6813
  }
6459
6814
  {
6460
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
6815
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
6461
6816
        _global_py_pool, args))
6462
6817
    
6463
6818
    ;
6557
6912
    }
6558
6913
  }
6559
6914
  {
6560
 
    arg6 = (svn_diff_file_options_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj4);
 
6915
    arg6 = (svn_diff_file_options_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_diff_file_options_t, svn_argnum_obj4);
6561
6916
    if (PyErr_Occurred()) {
6562
6917
      SWIG_fail;
6563
6918
    }
6590
6945
    resultobj = Py_None;
6591
6946
  }
6592
6947
  {
6593
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_diff_t,
 
6948
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_diff_t,
6594
6949
        _global_py_pool, args))
6595
6950
    
6596
6951
    ;
6607
6962
}
6608
6963
 
6609
6964
 
 
6965
SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_unified3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6966
  PyObject *resultobj = 0;
 
6967
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
 
6968
  svn_diff_t *arg2 = (svn_diff_t *) 0 ;
 
6969
  svn_boolean_t arg3 ;
 
6970
  char *arg4 = (char *) 0 ;
 
6971
  char *arg5 = (char *) 0 ;
 
6972
  char *arg6 = (char *) 0 ;
 
6973
  char *arg7 = (char *) 0 ;
 
6974
  svn_string_t *arg8 = (svn_string_t *) 0 ;
 
6975
  svn_string_t *arg9 = (svn_string_t *) 0 ;
 
6976
  int arg10 ;
 
6977
  svn_cancel_func_t arg11 = (svn_cancel_func_t) 0 ;
 
6978
  void *arg12 = (void *) 0 ;
 
6979
  apr_pool_t *arg13 = (apr_pool_t *) 0 ;
 
6980
  apr_pool_t *_global_pool = NULL ;
 
6981
  PyObject *_global_py_pool = NULL ;
 
6982
  svn_string_t value8 ;
 
6983
  svn_string_t value9 ;
 
6984
  PyObject * obj0 = 0 ;
 
6985
  PyObject * obj1 = 0 ;
 
6986
  PyObject * obj2 = 0 ;
 
6987
  PyObject * obj7 = 0 ;
 
6988
  PyObject * obj8 = 0 ;
 
6989
  PyObject * obj9 = 0 ;
 
6990
  PyObject * obj10 = 0 ;
 
6991
  PyObject * obj11 = 0 ;
 
6992
  svn_error_t *result = 0 ;
 
6993
  
 
6994
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
6995
      &_global_py_pool, &_global_pool))
 
6996
  SWIG_fail;
 
6997
  arg13 = _global_pool;
 
6998
  if (!PyArg_ParseTuple(args,(char *)"OOOszzzOOOO|O:svn_diff_mem_string_output_unified3",&obj0,&obj1,&obj2,&arg4,&arg5,&arg6,&arg7,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
 
6999
  {
 
7000
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
 
7001
  }
 
7002
  {
 
7003
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
7004
    if (PyErr_Occurred()) {
 
7005
      SWIG_fail;
 
7006
    }
 
7007
  }
 
7008
  {
 
7009
    arg3 = (svn_boolean_t)SWIG_As_long (obj2);
 
7010
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
7011
      SWIG_fail;
 
7012
    }
 
7013
  }
 
7014
  {
 
7015
    if (obj7 == Py_None)
 
7016
    arg8 = NULL;
 
7017
    else {
 
7018
      if (!PyString_Check(obj7)) {
 
7019
        PyErr_SetString(PyExc_TypeError, "not a string");
 
7020
        SWIG_fail;
 
7021
      }
 
7022
      value8.data = PyString_AS_STRING(obj7);
 
7023
      value8.len = PyString_GET_SIZE(obj7);
 
7024
      arg8 = &value8;
 
7025
    }
 
7026
  }
 
7027
  {
 
7028
    if (obj8 == Py_None)
 
7029
    arg9 = NULL;
 
7030
    else {
 
7031
      if (!PyString_Check(obj8)) {
 
7032
        PyErr_SetString(PyExc_TypeError, "not a string");
 
7033
        SWIG_fail;
 
7034
      }
 
7035
      value9.data = PyString_AS_STRING(obj8);
 
7036
      value9.len = PyString_GET_SIZE(obj8);
 
7037
      arg9 = &value9;
 
7038
    }
 
7039
  }
 
7040
  {
 
7041
    arg10 = (int)SWIG_As_long (obj9);
 
7042
    if (SWIG_arg_fail(svn_argnum_obj9)) {
 
7043
      SWIG_fail;
 
7044
    }
 
7045
  }
 
7046
  {
 
7047
    arg11 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
7048
    arg12 = obj10;
 
7049
  }
 
7050
  if (obj11) {
 
7051
    /* Verify that the user supplied a valid pool */
 
7052
    if (obj11 != Py_None && obj11 != _global_py_pool) {
 
7053
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
 
7054
      SWIG_arg_fail(svn_argnum_obj11);
 
7055
      SWIG_fail;
 
7056
    }
 
7057
  }
 
7058
  {
 
7059
    svn_swig_py_release_py_lock();
 
7060
    
 
7061
    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);
 
7062
    
 
7063
    svn_swig_py_acquire_py_lock();
 
7064
    
 
7065
  }
 
7066
  {
 
7067
    if (result != NULL) {
 
7068
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
7069
      svn_swig_py_svn_exception(result);
 
7070
      else
 
7071
      svn_error_clear(result);
 
7072
      SWIG_fail;
 
7073
    }
 
7074
    Py_INCREF(Py_None);
 
7075
    resultobj = Py_None;
 
7076
  }
 
7077
  {
 
7078
    Py_XDECREF(_global_py_pool);
 
7079
  }
 
7080
  return resultobj;
 
7081
fail:
 
7082
  {
 
7083
    Py_XDECREF(_global_py_pool);
 
7084
  }
 
7085
  return NULL;
 
7086
}
 
7087
 
 
7088
 
6610
7089
SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_unified2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6611
7090
  PyObject *resultobj = 0;
6612
7091
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6640
7119
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6641
7120
  }
6642
7121
  {
6643
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
7122
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6644
7123
    if (PyErr_Occurred()) {
6645
7124
      SWIG_fail;
6646
7125
    }
6746
7225
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6747
7226
  }
6748
7227
  {
6749
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
7228
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6750
7229
    if (PyErr_Occurred()) {
6751
7230
      SWIG_fail;
6752
7231
    }
6816
7295
}
6817
7296
 
6818
7297
 
 
7298
SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_merge3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7299
  PyObject *resultobj = 0;
 
7300
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
 
7301
  svn_diff_t *arg2 = (svn_diff_t *) 0 ;
 
7302
  svn_string_t *arg3 = (svn_string_t *) 0 ;
 
7303
  svn_string_t *arg4 = (svn_string_t *) 0 ;
 
7304
  svn_string_t *arg5 = (svn_string_t *) 0 ;
 
7305
  char *arg6 = (char *) 0 ;
 
7306
  char *arg7 = (char *) 0 ;
 
7307
  char *arg8 = (char *) 0 ;
 
7308
  char *arg9 = (char *) 0 ;
 
7309
  svn_diff_conflict_display_style_t arg10 ;
 
7310
  svn_cancel_func_t arg11 = (svn_cancel_func_t) 0 ;
 
7311
  void *arg12 = (void *) 0 ;
 
7312
  apr_pool_t *arg13 = (apr_pool_t *) 0 ;
 
7313
  apr_pool_t *_global_pool = NULL ;
 
7314
  PyObject *_global_py_pool = NULL ;
 
7315
  svn_string_t value3 ;
 
7316
  svn_string_t value4 ;
 
7317
  svn_string_t value5 ;
 
7318
  PyObject * obj0 = 0 ;
 
7319
  PyObject * obj1 = 0 ;
 
7320
  PyObject * obj2 = 0 ;
 
7321
  PyObject * obj3 = 0 ;
 
7322
  PyObject * obj4 = 0 ;
 
7323
  PyObject * obj9 = 0 ;
 
7324
  PyObject * obj10 = 0 ;
 
7325
  PyObject * obj11 = 0 ;
 
7326
  svn_error_t *result = 0 ;
 
7327
  
 
7328
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
7329
      &_global_py_pool, &_global_pool))
 
7330
  SWIG_fail;
 
7331
  arg13 = _global_pool;
 
7332
  if (!PyArg_ParseTuple(args,(char *)"OOOOOzzzzOO|O:svn_diff_mem_string_output_merge3",&obj0,&obj1,&obj2,&obj3,&obj4,&arg6,&arg7,&arg8,&arg9,&obj9,&obj10,&obj11)) SWIG_fail;
 
7333
  {
 
7334
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
 
7335
  }
 
7336
  {
 
7337
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
7338
    if (PyErr_Occurred()) {
 
7339
      SWIG_fail;
 
7340
    }
 
7341
  }
 
7342
  {
 
7343
    if (obj2 == Py_None)
 
7344
    arg3 = NULL;
 
7345
    else {
 
7346
      if (!PyString_Check(obj2)) {
 
7347
        PyErr_SetString(PyExc_TypeError, "not a string");
 
7348
        SWIG_fail;
 
7349
      }
 
7350
      value3.data = PyString_AS_STRING(obj2);
 
7351
      value3.len = PyString_GET_SIZE(obj2);
 
7352
      arg3 = &value3;
 
7353
    }
 
7354
  }
 
7355
  {
 
7356
    if (obj3 == Py_None)
 
7357
    arg4 = NULL;
 
7358
    else {
 
7359
      if (!PyString_Check(obj3)) {
 
7360
        PyErr_SetString(PyExc_TypeError, "not a string");
 
7361
        SWIG_fail;
 
7362
      }
 
7363
      value4.data = PyString_AS_STRING(obj3);
 
7364
      value4.len = PyString_GET_SIZE(obj3);
 
7365
      arg4 = &value4;
 
7366
    }
 
7367
  }
 
7368
  {
 
7369
    if (obj4 == Py_None)
 
7370
    arg5 = NULL;
 
7371
    else {
 
7372
      if (!PyString_Check(obj4)) {
 
7373
        PyErr_SetString(PyExc_TypeError, "not a string");
 
7374
        SWIG_fail;
 
7375
      }
 
7376
      value5.data = PyString_AS_STRING(obj4);
 
7377
      value5.len = PyString_GET_SIZE(obj4);
 
7378
      arg5 = &value5;
 
7379
    }
 
7380
  }
 
7381
  {
 
7382
    arg10 = (svn_diff_conflict_display_style_t)SWIG_As_long (obj9);
 
7383
    if (SWIG_arg_fail(svn_argnum_obj9)) {
 
7384
      SWIG_fail;
 
7385
    }
 
7386
  }
 
7387
  {
 
7388
    arg11 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
7389
    arg12 = obj10;
 
7390
  }
 
7391
  if (obj11) {
 
7392
    /* Verify that the user supplied a valid pool */
 
7393
    if (obj11 != Py_None && obj11 != _global_py_pool) {
 
7394
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
 
7395
      SWIG_arg_fail(svn_argnum_obj11);
 
7396
      SWIG_fail;
 
7397
    }
 
7398
  }
 
7399
  {
 
7400
    svn_swig_py_release_py_lock();
 
7401
    
 
7402
    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);
 
7403
    
 
7404
    svn_swig_py_acquire_py_lock();
 
7405
    
 
7406
  }
 
7407
  {
 
7408
    if (result != NULL) {
 
7409
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
7410
      svn_swig_py_svn_exception(result);
 
7411
      else
 
7412
      svn_error_clear(result);
 
7413
      SWIG_fail;
 
7414
    }
 
7415
    Py_INCREF(Py_None);
 
7416
    resultobj = Py_None;
 
7417
  }
 
7418
  {
 
7419
    Py_XDECREF(_global_py_pool);
 
7420
  }
 
7421
  return resultobj;
 
7422
fail:
 
7423
  {
 
7424
    Py_XDECREF(_global_py_pool);
 
7425
  }
 
7426
  return NULL;
 
7427
}
 
7428
 
 
7429
 
6819
7430
SWIGINTERN PyObject *_wrap_svn_diff_mem_string_output_merge2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6820
7431
  PyObject *resultobj = 0;
6821
7432
  svn_stream_t *arg1 = (svn_stream_t *) 0 ;
6852
7463
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6853
7464
  }
6854
7465
  {
6855
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
7466
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6856
7467
    if (PyErr_Occurred()) {
6857
7468
      SWIG_fail;
6858
7469
    }
6979
7590
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
6980
7591
  }
6981
7592
  {
6982
 
    arg2 = (svn_diff_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
 
7593
    arg2 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_diff_t, svn_argnum_obj1);
6983
7594
    if (PyErr_Occurred()) {
6984
7595
      SWIG_fail;
6985
7596
    }
7106
7717
  arg4 = &temp4;
7107
7718
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_diff_hunk_readline_diff_text",&obj0,&obj1,&obj2)) SWIG_fail;
7108
7719
  {
7109
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
7720
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7110
7721
    if (PyErr_Occurred()) {
7111
7722
      SWIG_fail;
7112
7723
    }
7228
7839
  arg4 = &temp4;
7229
7840
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_diff_hunk_readline_original_text",&obj0,&obj1,&obj2)) SWIG_fail;
7230
7841
  {
7231
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
7842
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7232
7843
    if (PyErr_Occurred()) {
7233
7844
      SWIG_fail;
7234
7845
    }
7350
7961
  arg4 = &temp4;
7351
7962
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_diff_hunk_readline_modified_text",&obj0,&obj1,&obj2)) SWIG_fail;
7352
7963
  {
7353
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
7964
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7354
7965
    if (PyErr_Occurred()) {
7355
7966
      SWIG_fail;
7356
7967
    }
7447
8058
  
7448
8059
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_reset_diff_text",&obj0)) SWIG_fail;
7449
8060
  {
7450
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8061
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7451
8062
    if (PyErr_Occurred()) {
7452
8063
      SWIG_fail;
7453
8064
    }
7474
8085
  
7475
8086
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_reset_original_text",&obj0)) SWIG_fail;
7476
8087
  {
7477
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8088
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7478
8089
    if (PyErr_Occurred()) {
7479
8090
      SWIG_fail;
7480
8091
    }
7501
8112
  
7502
8113
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_reset_modified_text",&obj0)) SWIG_fail;
7503
8114
  {
7504
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8115
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7505
8116
    if (PyErr_Occurred()) {
7506
8117
      SWIG_fail;
7507
8118
    }
7529
8140
  
7530
8141
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_get_original_start",&obj0)) SWIG_fail;
7531
8142
  {
7532
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8143
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7533
8144
    if (PyErr_Occurred()) {
7534
8145
      SWIG_fail;
7535
8146
    }
7557
8168
  
7558
8169
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_get_original_length",&obj0)) SWIG_fail;
7559
8170
  {
7560
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8171
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7561
8172
    if (PyErr_Occurred()) {
7562
8173
      SWIG_fail;
7563
8174
    }
7585
8196
  
7586
8197
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_get_modified_start",&obj0)) SWIG_fail;
7587
8198
  {
7588
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8199
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7589
8200
    if (PyErr_Occurred()) {
7590
8201
      SWIG_fail;
7591
8202
    }
7613
8224
  
7614
8225
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_get_modified_length",&obj0)) SWIG_fail;
7615
8226
  {
7616
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8227
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7617
8228
    if (PyErr_Occurred()) {
7618
8229
      SWIG_fail;
7619
8230
    }
7641
8252
  
7642
8253
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_get_leading_context",&obj0)) SWIG_fail;
7643
8254
  {
7644
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8255
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7645
8256
    if (PyErr_Occurred()) {
7646
8257
      SWIG_fail;
7647
8258
    }
7669
8280
  
7670
8281
  if (!PyArg_ParseTuple(args,(char *)"O:svn_diff_hunk_get_trailing_context",&obj0)) SWIG_fail;
7671
8282
  {
7672
 
    arg1 = (svn_diff_hunk_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
 
8283
    arg1 = (svn_diff_hunk_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_hunk_t, svn_argnum_obj0);
7673
8284
    if (PyErr_Occurred()) {
7674
8285
      SWIG_fail;
7675
8286
    }
7697
8308
  
7698
8309
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_prop_patch_t_name_set",&obj0,&arg2)) SWIG_fail;
7699
8310
  {
7700
 
    arg1 = (struct svn_prop_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
 
8311
    arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
7701
8312
    if (PyErr_Occurred()) {
7702
8313
      SWIG_fail;
7703
8314
    }
7725
8336
  
7726
8337
  if (!PyArg_ParseTuple(args,(char *)"O:svn_prop_patch_t_name_get",&obj0)) SWIG_fail;
7727
8338
  {
7728
 
    arg1 = (struct svn_prop_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
 
8339
    arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
7729
8340
    if (PyErr_Occurred()) {
7730
8341
      SWIG_fail;
7731
8342
    }
7747
8358
  
7748
8359
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_prop_patch_t_operation_set",&obj0,&obj1)) SWIG_fail;
7749
8360
  {
7750
 
    arg1 = (struct svn_prop_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
 
8361
    arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
7751
8362
    if (PyErr_Occurred()) {
7752
8363
      SWIG_fail;
7753
8364
    }
7774
8385
  
7775
8386
  if (!PyArg_ParseTuple(args,(char *)"O:svn_prop_patch_t_operation_get",&obj0)) SWIG_fail;
7776
8387
  {
7777
 
    arg1 = (struct svn_prop_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
 
8388
    arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
7778
8389
    if (PyErr_Occurred()) {
7779
8390
      SWIG_fail;
7780
8391
    }
7796
8407
  
7797
8408
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_prop_patch_t_hunks_set",&obj0,&obj1)) SWIG_fail;
7798
8409
  {
7799
 
    arg1 = (struct svn_prop_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
 
8410
    arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
7800
8411
    if (PyErr_Occurred()) {
7801
8412
      SWIG_fail;
7802
8413
    }
7803
8414
  }
7804
8415
  {
7805
 
    arg2 = (apr_array_header_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
 
8416
    arg2 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
7806
8417
    if (PyErr_Occurred()) {
7807
8418
      SWIG_fail;
7808
8419
    }
7823
8434
  
7824
8435
  if (!PyArg_ParseTuple(args,(char *)"O:svn_prop_patch_t_hunks_get",&obj0)) SWIG_fail;
7825
8436
  {
7826
 
    arg1 = (struct svn_prop_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
 
8437
    arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
7827
8438
    if (PyErr_Occurred()) {
7828
8439
      SWIG_fail;
7829
8440
    }
7830
8441
  }
7831
8442
  result = (apr_array_header_t *) ((arg1)->hunks);
7832
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_apr_array_header_t,
7833
 
    _global_py_pool, args);
 
8443
  {
 
8444
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_pointerlist_to_list(result, SWIGTYPE_p_svn_diff_hunk_t,
 
8445
        _global_py_pool))
 
8446
    
 
8447
    ;
 
8448
    if (PyErr_Occurred()) {
 
8449
      SWIG_fail;
 
8450
    }
 
8451
  }
7834
8452
  return resultobj;
7835
8453
fail:
7836
8454
  return NULL;
7850
8468
    svn_swig_py_acquire_py_lock();
7851
8469
    
7852
8470
  }
7853
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_prop_patch_t,
 
8471
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_prop_patch_t,
7854
8472
    _global_py_pool, args);
7855
8473
  return resultobj;
7856
8474
fail:
7865
8483
  
7866
8484
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_prop_patch_t",&obj0)) SWIG_fail;
7867
8485
  {
7868
 
    arg1 = (struct svn_prop_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
 
8486
    arg1 = (struct svn_prop_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_prop_patch_t, svn_argnum_obj0);
7869
8487
    if (PyErr_Occurred()) {
7870
8488
      SWIG_fail;
7871
8489
    }
7900
8518
  
7901
8519
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_patch_t_old_filename_set",&obj0,&arg2)) SWIG_fail;
7902
8520
  {
7903
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8521
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
7904
8522
    if (PyErr_Occurred()) {
7905
8523
      SWIG_fail;
7906
8524
    }
7928
8546
  
7929
8547
  if (!PyArg_ParseTuple(args,(char *)"O:svn_patch_t_old_filename_get",&obj0)) SWIG_fail;
7930
8548
  {
7931
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8549
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
7932
8550
    if (PyErr_Occurred()) {
7933
8551
      SWIG_fail;
7934
8552
    }
7949
8567
  
7950
8568
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_patch_t_new_filename_set",&obj0,&arg2)) SWIG_fail;
7951
8569
  {
7952
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8570
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
7953
8571
    if (PyErr_Occurred()) {
7954
8572
      SWIG_fail;
7955
8573
    }
7977
8595
  
7978
8596
  if (!PyArg_ParseTuple(args,(char *)"O:svn_patch_t_new_filename_get",&obj0)) SWIG_fail;
7979
8597
  {
7980
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8598
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
7981
8599
    if (PyErr_Occurred()) {
7982
8600
      SWIG_fail;
7983
8601
    }
7999
8617
  
8000
8618
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_patch_t_hunks_set",&obj0,&obj1)) SWIG_fail;
8001
8619
  {
8002
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8620
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8003
8621
    if (PyErr_Occurred()) {
8004
8622
      SWIG_fail;
8005
8623
    }
8006
8624
  }
8007
8625
  {
8008
 
    arg2 = (apr_array_header_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
 
8626
    arg2 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
8009
8627
    if (PyErr_Occurred()) {
8010
8628
      SWIG_fail;
8011
8629
    }
8026
8644
  
8027
8645
  if (!PyArg_ParseTuple(args,(char *)"O:svn_patch_t_hunks_get",&obj0)) SWIG_fail;
8028
8646
  {
8029
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8647
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8030
8648
    if (PyErr_Occurred()) {
8031
8649
      SWIG_fail;
8032
8650
    }
8033
8651
  }
8034
8652
  result = (apr_array_header_t *) ((arg1)->hunks);
8035
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_apr_array_header_t,
8036
 
    _global_py_pool, args);
 
8653
  {
 
8654
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_pointerlist_to_list(result, SWIGTYPE_p_svn_diff_hunk_t,
 
8655
        _global_py_pool))
 
8656
    
 
8657
    ;
 
8658
    if (PyErr_Occurred()) {
 
8659
      SWIG_fail;
 
8660
    }
 
8661
  }
8037
8662
  return resultobj;
8038
8663
fail:
8039
8664
  return NULL;
8049
8674
  
8050
8675
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_patch_t_prop_patches_set",&obj0,&obj1)) SWIG_fail;
8051
8676
  {
8052
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8677
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8053
8678
    if (PyErr_Occurred()) {
8054
8679
      SWIG_fail;
8055
8680
    }
8056
8681
  }
8057
8682
  {
8058
 
    arg2 = (apr_hash_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
 
8683
    arg2 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
8059
8684
    if (PyErr_Occurred()) {
8060
8685
      SWIG_fail;
8061
8686
    }
8076
8701
  
8077
8702
  if (!PyArg_ParseTuple(args,(char *)"O:svn_patch_t_prop_patches_get",&obj0)) SWIG_fail;
8078
8703
  {
8079
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8704
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8080
8705
    if (PyErr_Occurred()) {
8081
8706
      SWIG_fail;
8082
8707
    }
8083
8708
  }
8084
8709
  result = (apr_hash_t *) ((arg1)->prop_patches);
8085
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_apr_hash_t,
 
8710
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_apr_hash_t,
8086
8711
    _global_py_pool, args);
8087
8712
  return resultobj;
8088
8713
fail:
8099
8724
  
8100
8725
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_patch_t_operation_set",&obj0,&obj1)) SWIG_fail;
8101
8726
  {
8102
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8727
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8103
8728
    if (PyErr_Occurred()) {
8104
8729
      SWIG_fail;
8105
8730
    }
8126
8751
  
8127
8752
  if (!PyArg_ParseTuple(args,(char *)"O:svn_patch_t_operation_get",&obj0)) SWIG_fail;
8128
8753
  {
8129
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8754
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8130
8755
    if (PyErr_Occurred()) {
8131
8756
      SWIG_fail;
8132
8757
    }
8148
8773
  
8149
8774
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_patch_t_reverse_set",&obj0,&obj1)) SWIG_fail;
8150
8775
  {
8151
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8776
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8152
8777
    if (PyErr_Occurred()) {
8153
8778
      SWIG_fail;
8154
8779
    }
8175
8800
  
8176
8801
  if (!PyArg_ParseTuple(args,(char *)"O:svn_patch_t_reverse_get",&obj0)) SWIG_fail;
8177
8802
  {
8178
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8803
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8179
8804
    if (PyErr_Occurred()) {
8180
8805
      SWIG_fail;
8181
8806
    }
8188
8813
}
8189
8814
 
8190
8815
 
 
8816
SWIGINTERN PyObject *_wrap_svn_patch_t_mergeinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8817
  PyObject *resultobj = 0;
 
8818
  struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
 
8819
  svn_mergeinfo_t arg2 = (svn_mergeinfo_t) 0 ;
 
8820
  apr_pool_t *_global_pool = NULL ;
 
8821
  PyObject *_global_py_pool = NULL ;
 
8822
  PyObject * obj0 = 0 ;
 
8823
  PyObject * obj1 = 0 ;
 
8824
  
 
8825
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_patch_t_mergeinfo_set",&obj0,&obj1)) SWIG_fail;
 
8826
  {
 
8827
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8828
    if (PyErr_Occurred()) {
 
8829
      SWIG_fail;
 
8830
    }
 
8831
  }
 
8832
  {
 
8833
    if (_global_pool == NULL)
 
8834
    {
 
8835
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
8836
          &_global_py_pool, &_global_pool))
 
8837
      SWIG_fail;
 
8838
    }
 
8839
    
 
8840
    arg2 = svn_swig_py_mergeinfo_from_dict(obj1, _global_pool);
 
8841
    if (PyErr_Occurred()) {
 
8842
      SWIG_fail;
 
8843
    }
 
8844
  }
 
8845
  if (arg1) (arg1)->mergeinfo = arg2;
 
8846
  resultobj = SWIG_Py_Void();
 
8847
  return resultobj;
 
8848
fail:
 
8849
  return NULL;
 
8850
}
 
8851
 
 
8852
 
 
8853
SWIGINTERN PyObject *_wrap_svn_patch_t_mergeinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8854
  PyObject *resultobj = 0;
 
8855
  struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
 
8856
  PyObject * obj0 = 0 ;
 
8857
  svn_mergeinfo_t result;
 
8858
  
 
8859
  if (!PyArg_ParseTuple(args,(char *)"O:svn_patch_t_mergeinfo_get",&obj0)) SWIG_fail;
 
8860
  {
 
8861
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8862
    if (PyErr_Occurred()) {
 
8863
      SWIG_fail;
 
8864
    }
 
8865
  }
 
8866
  result = (svn_mergeinfo_t) ((arg1)->mergeinfo);
 
8867
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_apr_hash_t,
 
8868
    _global_py_pool, args);
 
8869
  return resultobj;
 
8870
fail:
 
8871
  return NULL;
 
8872
}
 
8873
 
 
8874
 
 
8875
SWIGINTERN PyObject *_wrap_svn_patch_t_reverse_mergeinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8876
  PyObject *resultobj = 0;
 
8877
  struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
 
8878
  svn_mergeinfo_t arg2 = (svn_mergeinfo_t) 0 ;
 
8879
  PyObject * obj0 = 0 ;
 
8880
  PyObject * obj1 = 0 ;
 
8881
  
 
8882
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_patch_t_reverse_mergeinfo_set",&obj0,&obj1)) SWIG_fail;
 
8883
  {
 
8884
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8885
    if (PyErr_Occurred()) {
 
8886
      SWIG_fail;
 
8887
    }
 
8888
  }
 
8889
  {
 
8890
    arg2 = (svn_mergeinfo_t)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
 
8891
    if (PyErr_Occurred()) {
 
8892
      SWIG_fail;
 
8893
    }
 
8894
  }
 
8895
  if (arg1) (arg1)->reverse_mergeinfo = arg2;
 
8896
  resultobj = SWIG_Py_Void();
 
8897
  return resultobj;
 
8898
fail:
 
8899
  return NULL;
 
8900
}
 
8901
 
 
8902
 
 
8903
SWIGINTERN PyObject *_wrap_svn_patch_t_reverse_mergeinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8904
  PyObject *resultobj = 0;
 
8905
  struct svn_patch_t *arg1 = (struct svn_patch_t *) 0 ;
 
8906
  PyObject * obj0 = 0 ;
 
8907
  svn_mergeinfo_t result;
 
8908
  
 
8909
  if (!PyArg_ParseTuple(args,(char *)"O:svn_patch_t_reverse_mergeinfo_get",&obj0)) SWIG_fail;
 
8910
  {
 
8911
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8912
    if (PyErr_Occurred()) {
 
8913
      SWIG_fail;
 
8914
    }
 
8915
  }
 
8916
  result = (svn_mergeinfo_t) ((arg1)->reverse_mergeinfo);
 
8917
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_apr_hash_t,
 
8918
    _global_py_pool, args);
 
8919
  return resultobj;
 
8920
fail:
 
8921
  return NULL;
 
8922
}
 
8923
 
 
8924
 
8191
8925
SWIGINTERN PyObject *_wrap_new_svn_patch_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8192
8926
  PyObject *resultobj = 0;
8193
8927
  struct svn_patch_t *result = 0 ;
8201
8935
    svn_swig_py_acquire_py_lock();
8202
8936
    
8203
8937
  }
8204
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_patch_t,
 
8938
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_patch_t,
8205
8939
    _global_py_pool, args);
8206
8940
  return resultobj;
8207
8941
fail:
8216
8950
  
8217
8951
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_patch_t",&obj0)) SWIG_fail;
8218
8952
  {
8219
 
    arg1 = (struct svn_patch_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
 
8953
    arg1 = (struct svn_patch_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_t, svn_argnum_obj0);
8220
8954
    if (PyErr_Occurred()) {
8221
8955
      SWIG_fail;
8222
8956
    }
8288
9022
    resultobj = Py_None;
8289
9023
  }
8290
9024
  {
8291
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_patch_file_t,
 
9025
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_patch_file_t,
8292
9026
        _global_py_pool, args))
8293
9027
    
8294
9028
    ;
8334
9068
  arg1 = &temp1;
8335
9069
  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:svn_diff_parse_next_patch",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8336
9070
  {
8337
 
    arg2 = (svn_patch_file_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_file_t, svn_argnum_obj0);
 
9071
    arg2 = (svn_patch_file_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_file_t, svn_argnum_obj0);
8338
9072
    if (PyErr_Occurred()) {
8339
9073
      SWIG_fail;
8340
9074
    }
8387
9121
    resultobj = Py_None;
8388
9122
  }
8389
9123
  {
8390
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_patch_t,
 
9124
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_patch_t,
8391
9125
        _global_py_pool, args))
8392
9126
    
8393
9127
    ;
8426
9160
  arg2 = _global_pool;
8427
9161
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_diff_close_patch_file",&obj0,&obj1)) SWIG_fail;
8428
9162
  {
8429
 
    arg1 = (svn_patch_file_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_patch_file_t, svn_argnum_obj0);
 
9163
    arg1 = (svn_patch_file_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_patch_file_t, svn_argnum_obj0);
8430
9164
    if (PyErr_Occurred()) {
8431
9165
      SWIG_fail;
8432
9166
    }
8509
9243
  
8510
9244
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:svn_diff_fns2_invoke_datasources_open",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
8511
9245
  {
8512
 
    arg1 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
9246
    arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
8513
9247
    if (PyErr_Occurred()) {
8514
9248
      SWIG_fail;
8515
9249
    }
8523
9257
    }
8524
9258
  }
8525
9259
  {
8526
 
    arg3 = (apr_off_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_apr_off_t, svn_argnum_obj2);
8527
 
    if (PyErr_Occurred()) {
8528
 
      SWIG_fail;
8529
 
    }
8530
 
  }
8531
 
  {
8532
 
    arg4 = (apr_off_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_apr_off_t, svn_argnum_obj3);
8533
 
    if (PyErr_Occurred()) {
8534
 
      SWIG_fail;
8535
 
    }
8536
 
  }
8537
 
  {
8538
 
    arg5 = (svn_diff_datasource_e *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_svn_diff_datasource_e, svn_argnum_obj4);
 
9260
    arg3 = (apr_off_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_apr_off_t, svn_argnum_obj2);
 
9261
    if (PyErr_Occurred()) {
 
9262
      SWIG_fail;
 
9263
    }
 
9264
  }
 
9265
  {
 
9266
    arg4 = (apr_off_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_apr_off_t, svn_argnum_obj3);
 
9267
    if (PyErr_Occurred()) {
 
9268
      SWIG_fail;
 
9269
    }
 
9270
  }
 
9271
  {
 
9272
    arg5 = (svn_diff_datasource_e *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_diff_datasource_e, svn_argnum_obj4);
8539
9273
    if (PyErr_Occurred()) {
8540
9274
      SWIG_fail;
8541
9275
    }
8583
9317
  
8584
9318
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_diff_fns2_invoke_datasource_close",&obj0,&obj1,&obj2)) SWIG_fail;
8585
9319
  {
8586
 
    arg1 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
9320
    arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
8587
9321
    if (PyErr_Occurred()) {
8588
9322
      SWIG_fail;
8589
9323
    }
8646
9380
  arg3 = &temp3;
8647
9381
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_diff_fns2_invoke_datasource_get_next_token",&obj0,&obj1,&obj2)) SWIG_fail;
8648
9382
  {
8649
 
    arg1 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
9383
    arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
8650
9384
    if (PyErr_Occurred()) {
8651
9385
      SWIG_fail;
8652
9386
    }
8691
9425
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_apr_uint32_t, new_flags));
8692
9426
  }
8693
9427
  {
8694
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
 
9428
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg3, SWIGTYPE_p_void,
8695
9429
        _global_py_pool, args))
8696
9430
    
8697
9431
    ;
8720
9454
  arg5 = &temp5;
8721
9455
  if (!PyArg_ParseTuple(args,(char *)"OOOO:svn_diff_fns2_invoke_token_compare",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8722
9456
  {
8723
 
    arg1 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
9457
    arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
8724
9458
    if (PyErr_Occurred()) {
8725
9459
      SWIG_fail;
8726
9460
    }
8734
9468
    }
8735
9469
  }
8736
9470
  {
8737
 
    arg3 = (void *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
 
9471
    arg3 = (void *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
8738
9472
    if (PyErr_Occurred()) {
8739
9473
      SWIG_fail;
8740
9474
    }
8741
9475
  }
8742
9476
  {
8743
 
    arg4 = (void *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_void, svn_argnum_obj3);
 
9477
    arg4 = (void *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_void, svn_argnum_obj3);
8744
9478
    if (PyErr_Occurred()) {
8745
9479
      SWIG_fail;
8746
9480
    }
8787
9521
  
8788
9522
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_diff_fns2_invoke_token_discard",&obj0,&obj1,&obj2)) SWIG_fail;
8789
9523
  {
8790
 
    arg1 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
9524
    arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
8791
9525
    if (PyErr_Occurred()) {
8792
9526
      SWIG_fail;
8793
9527
    }
8801
9535
    }
8802
9536
  }
8803
9537
  {
8804
 
    arg3 = (void *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
 
9538
    arg3 = (void *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
8805
9539
    if (PyErr_Occurred()) {
8806
9540
      SWIG_fail;
8807
9541
    }
8830
9564
  
8831
9565
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns2_invoke_token_discard_all",&obj0,&obj1)) SWIG_fail;
8832
9566
  {
8833
 
    arg1 = (svn_diff_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
 
9567
    arg1 = (svn_diff_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns2_t, svn_argnum_obj0);
8834
9568
    if (PyErr_Occurred()) {
8835
9569
      SWIG_fail;
8836
9570
    }
8870
9604
  
8871
9605
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_diff_fns_invoke_datasource_open",&obj0,&obj1,&obj2)) SWIG_fail;
8872
9606
  {
8873
 
    arg1 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
9607
    arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
8874
9608
    if (PyErr_Occurred()) {
8875
9609
      SWIG_fail;
8876
9610
    }
8926
9660
  
8927
9661
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_diff_fns_invoke_datasource_close",&obj0,&obj1,&obj2)) SWIG_fail;
8928
9662
  {
8929
 
    arg1 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
9663
    arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
8930
9664
    if (PyErr_Occurred()) {
8931
9665
      SWIG_fail;
8932
9666
    }
8989
9723
  arg3 = &temp3;
8990
9724
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_diff_fns_invoke_datasource_get_next_token",&obj0,&obj1,&obj2)) SWIG_fail;
8991
9725
  {
8992
 
    arg1 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
9726
    arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
8993
9727
    if (PyErr_Occurred()) {
8994
9728
      SWIG_fail;
8995
9729
    }
9034
9768
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_apr_uint32_t, new_flags));
9035
9769
  }
9036
9770
  {
9037
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
 
9771
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg3, SWIGTYPE_p_void,
9038
9772
        _global_py_pool, args))
9039
9773
    
9040
9774
    ;
9063
9797
  arg5 = &temp5;
9064
9798
  if (!PyArg_ParseTuple(args,(char *)"OOOO:svn_diff_fns_invoke_token_compare",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9065
9799
  {
9066
 
    arg1 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
9800
    arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
9067
9801
    if (PyErr_Occurred()) {
9068
9802
      SWIG_fail;
9069
9803
    }
9077
9811
    }
9078
9812
  }
9079
9813
  {
9080
 
    arg3 = (void *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
 
9814
    arg3 = (void *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
9081
9815
    if (PyErr_Occurred()) {
9082
9816
      SWIG_fail;
9083
9817
    }
9084
9818
  }
9085
9819
  {
9086
 
    arg4 = (void *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_void, svn_argnum_obj3);
 
9820
    arg4 = (void *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_void, svn_argnum_obj3);
9087
9821
    if (PyErr_Occurred()) {
9088
9822
      SWIG_fail;
9089
9823
    }
9130
9864
  
9131
9865
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_diff_fns_invoke_token_discard",&obj0,&obj1,&obj2)) SWIG_fail;
9132
9866
  {
9133
 
    arg1 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
9867
    arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
9134
9868
    if (PyErr_Occurred()) {
9135
9869
      SWIG_fail;
9136
9870
    }
9144
9878
    }
9145
9879
  }
9146
9880
  {
9147
 
    arg3 = (void *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
 
9881
    arg3 = (void *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_void, svn_argnum_obj2);
9148
9882
    if (PyErr_Occurred()) {
9149
9883
      SWIG_fail;
9150
9884
    }
9173
9907
  
9174
9908
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_diff_fns_invoke_token_discard_all",&obj0,&obj1)) SWIG_fail;
9175
9909
  {
9176
 
    arg1 = (svn_diff_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
 
9910
    arg1 = (svn_diff_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_fns_t, svn_argnum_obj0);
9177
9911
    if (PyErr_Occurred()) {
9178
9912
      SWIG_fail;
9179
9913
    }
9223
9957
  
9224
9958
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:svn_diff_output_fns_invoke_output_common",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9225
9959
  {
9226
 
    arg1 = (svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
9960
    arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
9227
9961
    if (PyErr_Occurred()) {
9228
9962
      SWIG_fail;
9229
9963
    }
9289
10023
  
9290
10024
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:svn_diff_output_fns_invoke_output_diff_modified",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9291
10025
  {
9292
 
    arg1 = (svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
10026
    arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
9293
10027
    if (PyErr_Occurred()) {
9294
10028
      SWIG_fail;
9295
10029
    }
9355
10089
  
9356
10090
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:svn_diff_output_fns_invoke_output_diff_latest",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9357
10091
  {
9358
 
    arg1 = (svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
10092
    arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
9359
10093
    if (PyErr_Occurred()) {
9360
10094
      SWIG_fail;
9361
10095
    }
9421
10155
  
9422
10156
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:svn_diff_output_fns_invoke_output_diff_common",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9423
10157
  {
9424
 
    arg1 = (svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
10158
    arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
9425
10159
    if (PyErr_Occurred()) {
9426
10160
      SWIG_fail;
9427
10161
    }
9489
10223
  
9490
10224
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:svn_diff_output_fns_invoke_output_conflict",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
9491
10225
  {
9492
 
    arg1 = (svn_diff_output_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
 
10226
    arg1 = (svn_diff_output_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_diff_output_fns_t, svn_argnum_obj0);
9493
10227
    if (PyErr_Occurred()) {
9494
10228
      SWIG_fail;
9495
10229
    }
9509
10243
  arg7 = (apr_off_t) PyLong_AsLongLong(obj6); 
9510
10244
  arg8 = (apr_off_t) PyLong_AsLongLong(obj7); 
9511
10245
  {
9512
 
    arg9 = (svn_diff_t *)svn_swig_MustGetPtr(obj8, SWIGTYPE_p_svn_diff_t, svn_argnum_obj8);
 
10246
    arg9 = (svn_diff_t *)svn_swig_py_must_get_ptr(obj8, SWIGTYPE_p_svn_diff_t, svn_argnum_obj8);
9513
10247
    if (PyErr_Occurred()) {
9514
10248
      SWIG_fail;
9515
10249
    }
9593
10327
         { (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"},
9594
10328
         { (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)"},
9595
10329
         { (char *)"svn_diff_output_fns_t_swigregister", svn_diff_output_fns_t_swigregister, METH_VARARGS, NULL},
 
10330
         { (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"},
9596
10331
         { (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"},
9597
10332
         { (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)"},
9598
10333
         { (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"},
9600
10335
         { (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"},
9601
10336
         { (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)"},
9602
10337
         { (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"},
 
10338
         { (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)"},
 
10339
         { (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"},
9603
10340
         { (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"},
9604
10341
         { (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)"},
9605
10342
         { (char *)"svn_diff_file_options_t_swigregister", svn_diff_file_options_t_swigregister, METH_VARARGS, NULL},
9620
10357
                "svn_diff_file_diff4(char const * original, char const * modified, char const * latest, char const * ancestor, \n"
9621
10358
                "    apr_pool_t pool) -> svn_error_t\n"
9622
10359
                ""},
 
10360
         { (char *)"svn_diff_file_output_unified4", _wrap_svn_diff_file_output_unified4, METH_VARARGS, (char *)"\n"
 
10361
                "svn_diff_file_output_unified4(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, \n"
 
10362
                "    char const * original_header, char const * modified_header, \n"
 
10363
                "    char const * header_encoding, char const * relative_to_dir, svn_boolean_t show_c_function, \n"
 
10364
                "    int context_size, svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t\n"
 
10365
                ""},
9623
10366
         { (char *)"svn_diff_file_output_unified3", _wrap_svn_diff_file_output_unified3, METH_VARARGS, (char *)"\n"
9624
10367
                "svn_diff_file_output_unified3(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, \n"
9625
10368
                "    char const * original_header, char const * modified_header, \n"
9636
10379
                "    char const * original_header, char const * modified_header, \n"
9637
10380
                "    apr_pool_t pool) -> svn_error_t\n"
9638
10381
                ""},
 
10382
         { (char *)"svn_diff_file_output_merge3", _wrap_svn_diff_file_output_merge3, METH_VARARGS, (char *)"\n"
 
10383
                "svn_diff_file_output_merge3(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, \n"
 
10384
                "    char const * latest_path, char const * conflict_original, \n"
 
10385
                "    char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, \n"
 
10386
                "    svn_diff_conflict_display_style_t conflict_style, \n"
 
10387
                "    svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t\n"
 
10388
                ""},
9639
10389
         { (char *)"svn_diff_file_output_merge2", _wrap_svn_diff_file_output_merge2, METH_VARARGS, (char *)"\n"
9640
10390
                "svn_diff_file_output_merge2(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, \n"
9641
10391
                "    char const * latest_path, char const * conflict_original, \n"
9650
10400
                "    svn_boolean_t display_original_in_conflict, svn_boolean_t display_resolved_conflicts, \n"
9651
10401
                "    apr_pool_t pool) -> svn_error_t\n"
9652
10402
                ""},
 
10403
         { (char *)"svn_diff_output_binary", _wrap_svn_diff_output_binary, METH_VARARGS, (char *)"\n"
 
10404
                "svn_diff_output_binary(svn_stream_t * output_stream, svn_stream_t * original, svn_stream_t * latest, svn_cancel_func_t cancel_func, \n"
 
10405
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
10406
                ""},
9653
10407
         { (char *)"svn_diff_mem_string_diff", _wrap_svn_diff_mem_string_diff, METH_VARARGS, (char *)"\n"
9654
10408
                "svn_diff_mem_string_diff(svn_string_t const * original, svn_string_t const * modified, svn_diff_file_options_t options, \n"
9655
10409
                "    apr_pool_t pool) -> svn_error_t\n"
9662
10416
                "svn_diff_mem_string_diff4(svn_string_t const * original, svn_string_t const * modified, svn_string_t const * latest, \n"
9663
10417
                "    svn_string_t const * ancestor, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t\n"
9664
10418
                ""},
 
10419
         { (char *)"svn_diff_mem_string_output_unified3", _wrap_svn_diff_mem_string_output_unified3, METH_VARARGS, (char *)"\n"
 
10420
                "svn_diff_mem_string_output_unified3(svn_stream_t * output_stream, svn_diff_t * diff, svn_boolean_t with_diff_header, \n"
 
10421
                "    char const * hunk_delimiter, char const * original_header, char const * modified_header, \n"
 
10422
                "    char const * header_encoding, svn_string_t const * original, \n"
 
10423
                "    svn_string_t const * modified, int context_size, svn_cancel_func_t cancel_func, \n"
 
10424
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
10425
                ""},
9665
10426
         { (char *)"svn_diff_mem_string_output_unified2", _wrap_svn_diff_mem_string_output_unified2, METH_VARARGS, (char *)"\n"
9666
10427
                "svn_diff_mem_string_output_unified2(svn_stream_t * output_stream, svn_diff_t * diff, svn_boolean_t with_diff_header, \n"
9667
10428
                "    char const * hunk_delimiter, char const * original_header, char const * modified_header, \n"
9673
10434
                "    char const * header_encoding, svn_string_t const * original, \n"
9674
10435
                "    svn_string_t const * modified, apr_pool_t pool) -> svn_error_t\n"
9675
10436
                ""},
 
10437
         { (char *)"svn_diff_mem_string_output_merge3", _wrap_svn_diff_mem_string_output_merge3, METH_VARARGS, (char *)"\n"
 
10438
                "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, \n"
 
10439
                "    svn_string_t const * latest, char const * conflict_original, \n"
 
10440
                "    char const * conflict_modified, char const * conflict_latest, \n"
 
10441
                "    char const * conflict_separator, svn_diff_conflict_display_style_t style, \n"
 
10442
                "    svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t\n"
 
10443
                ""},
9676
10444
         { (char *)"svn_diff_mem_string_output_merge2", _wrap_svn_diff_mem_string_output_merge2, METH_VARARGS, (char *)"\n"
9677
10445
                "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, \n"
9678
10446
                "    svn_string_t const * latest, char const * conflict_original, \n"
9720
10488
         { (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"},
9721
10489
         { (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)"},
9722
10490
         { (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"},
 
10491
         { (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)"},
 
10492
         { (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"},
 
10493
         { (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)"},
 
10494
         { (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"},
9723
10495
         { (char *)"new_svn_patch_t", _wrap_new_svn_patch_t, METH_VARARGS, (char *)"new_svn_patch_t() -> svn_patch_t"},
9724
10496
         { (char *)"delete_svn_patch_t", _wrap_delete_svn_patch_t, METH_VARARGS, (char *)"delete_svn_patch_t(svn_patch_t self)"},
9725
10497
         { (char *)"svn_patch_t_swigregister", svn_patch_t_swigregister, METH_VARARGS, NULL},
9779
10551
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
9780
10552
 
9781
10553
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};
9782
 
static swig_type_info _swigt__p_apr_hash_t = {"_p_apr_hash_t", "apr_hash_t *", 0, 0, (void*)0, 0};
 
10554
static swig_type_info _swigt__p_apr_hash_t = {"_p_apr_hash_t", "svn_mergeinfo_t|apr_hash_t *", 0, 0, (void*)0, 0};
9783
10555
static swig_type_info _swigt__p_apr_int32_t = {"_p_apr_int32_t", "apr_int32_t *|time_t *", 0, 0, (void*)0, 0};
9784
10556
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};
9785
10557
static swig_type_info _swigt__p_apr_off_t = {"_p_apr_off_t", "apr_off_t *", 0, 0, (void*)0, 0};
9788
10560
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
9789
10561
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 *|struct svn_error_t *(*)(apr_getopt_t *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
9790
10562
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", "struct svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)|svn_error_t *(*)(apr_uint32_t *,void **,void *,svn_diff_datasource_e)", 0, 0, (void*)0, 0};
 
10563
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|struct svn_error_t *(*)(void *)", 0, 0, (void*)0, 0};
9791
10564
static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "void (*)(void *)", 0, 0, (void*)0, 0};
9792
10565
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", "struct svn_error_t *(*)(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, 0, (void*)0, 0};
9793
10566
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", "struct 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 *)|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};
9832
10605
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};
9833
10606
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};
9834
10607
static swig_type_info _swigt__p_svn_error_t = {"_p_svn_error_t", "struct svn_error_t *|svn_error_t *", 0, 0, (void*)0, 0};
 
10608
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};
9835
10609
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};
9836
10610
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};
9837
10611
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};
9878
10652
  &_swigt__p_char,
9879
10653
  &_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
9880
10654
  &_swigt__p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t,
 
10655
  &_swigt__p_f_p_void__p_svn_error_t,
9881
10656
  &_swigt__p_f_p_void__void,
9882
10657
  &_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,
9883
10658
  &_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,
9922
10697
  &_swigt__p_svn_dirent_t,
9923
10698
  &_swigt__p_svn_errno_t,
9924
10699
  &_swigt__p_svn_error_t,
 
10700
  &_swigt__p_svn_fs_lock_target_t,
9925
10701
  &_swigt__p_svn_io_dirent2_t,
9926
10702
  &_swigt__p_svn_io_dirent_t,
9927
10703
  &_swigt__p_svn_io_file_del_t,
9968
10744
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
9969
10745
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}};
9970
10746
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}};
 
10747
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}};
9971
10748
static swig_cast_info _swigc__p_f_p_void__void[] = {  {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
9972
10749
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}};
9973
10750
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}};
10012
10789
static swig_cast_info _swigc__p_svn_dirent_t[] = {  {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
10013
10790
static swig_cast_info _swigc__p_svn_errno_t[] = {  {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
10014
10791
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
10792
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}};
10015
10793
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
10016
10794
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
10017
10795
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}};
10058
10836
  _swigc__p_char,
10059
10837
  _swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
10060
10838
  _swigc__p_f_p_apr_uint32_t_p_p_void_p_void_svn_diff_datasource_e__p_svn_error_t,
 
10839
  _swigc__p_f_p_void__p_svn_error_t,
10061
10840
  _swigc__p_f_p_void__void,
10062
10841
  _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,
10063
10842
  _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,
10102
10881
  _swigc__p_svn_dirent_t,
10103
10882
  _swigc__p_svn_errno_t,
10104
10883
  _swigc__p_svn_error_t,
 
10884
  _swigc__p_svn_fs_lock_target_t,
10105
10885
  _swigc__p_svn_io_dirent2_t,
10106
10886
  _swigc__p_svn_io_dirent_t,
10107
10887
  _swigc__p_svn_io_file_del_t,
10149
10929
#endif
10150
10930
/* -----------------------------------------------------------------------------
10151
10931
 * Type initialization:
10152
 
 * This problem is tough by the requirement that no dynamic 
10153
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
10932
 * This problem is tough by the requirement that no dynamic
 
10933
 * memory is used. Also, since swig_type_info structures store pointers to
10154
10934
 * swig_cast_info structures and swig_cast_info structures store pointers back
10155
 
 * to swig_type_info structures, we need some lookup code at initialization. 
10156
 
 * The idea is that swig generates all the structures that are needed. 
10157
 
 * The runtime then collects these partially filled structures. 
10158
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
10935
 * to swig_type_info structures, we need some lookup code at initialization.
 
10936
 * The idea is that swig generates all the structures that are needed.
 
10937
 * The runtime then collects these partially filled structures.
 
10938
 * The SWIG_InitializeModule function takes these initial arrays out of
10159
10939
 * swig_module, and does all the lookup, filling in the swig_module.types
10160
10940
 * array with the correct data and linking the correct swig_cast_info
10161
10941
 * structures together.
10162
10942
 *
10163
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
10943
 * The generated swig_type_info structures are assigned staticly to an initial
10164
10944
 * array. We just loop through that array, and handle each type individually.
10165
10945
 * First we lookup if this type has been already loaded, and if so, use the
10166
10946
 * loaded structure instead of the generated one. Then we have to fill in the
10170
10950
 * a column is one of the swig_cast_info structures for that type.
10171
10951
 * The cast_initial array is actually an array of arrays, because each row has
10172
10952
 * a variable number of columns. So to actually build the cast linked list,
10173
 
 * we find the array of casts associated with the type, and loop through it 
 
10953
 * we find the array of casts associated with the type, and loop through it
10174
10954
 * adding the casts to the list. The one last trick we need to do is making
10175
10955
 * sure the type pointer in the swig_cast_info struct is correct.
10176
10956
 *
10177
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
10957
 * First off, we lookup the cast->type name to see if it is already loaded.
10178
10958
 * There are three cases to handle:
10179
10959
 *  1) If the cast->type has already been loaded AND the type we are adding
10180
10960
 *     casting info to has not been loaded (it is in this module), THEN we
10181
10961
 *     replace the cast->type pointer with the type pointer that has already
10182
10962
 *     been loaded.
10183
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
10963
 *  2) If BOTH types (the one we are adding casting info to, and the
10184
10964
 *     cast->type) are loaded, THEN the cast info has already been loaded by
10185
10965
 *     the previous module so we just ignore it.
10186
10966
 *  3) Finally, if cast->type has not already been loaded, then we add that
10243
11023
    module_head->next = &swig_module;
10244
11024
  }
10245
11025
  
10246
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
11026
  /* When multiple interpreters are used, a module could have already been initialized in
10247
11027
       a different interpreter, but not yet have a pointer in this interpreter.
10248
11028
       In this case, we do not want to continue adding types... everything should be
10249
11029
       set up already */