← Back to branch summary

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

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/python/svn_delta.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
http://bugs.debian.org/791844
* 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:
subversion/bindings/swig/python/svn_delta.c
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)
2997
2971
#define SWIGTYPE_p_svn_config_t swig_types[54]
2998
2972
#define SWIGTYPE_p_svn_delta_editor_t swig_types[55]
2999
2973
#define SWIGTYPE_p_svn_depth_t swig_types[56]
3000
 
#define SWIGTYPE_p_svn_dirent_t swig_types[57]
3001
 
#define SWIGTYPE_p_svn_errno_t swig_types[58]
3002
 
#define SWIGTYPE_p_svn_error_t swig_types[59]
3003
 
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[60]
3004
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[61]
3005
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[62]
3006
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[63]
3007
 
#define SWIGTYPE_p_svn_lock_t swig_types[64]
3008
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[65]
3009
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[66]
3010
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[67]
3011
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[68]
3012
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[69]
3013
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[70]
3014
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[71]
3015
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[72]
3016
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[73]
3017
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[74]
3018
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[75]
3019
 
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[76]
3020
 
#define SWIGTYPE_p_svn_prop_kind swig_types[77]
3021
 
#define SWIGTYPE_p_svn_stream_mark_t swig_types[78]
3022
 
#define SWIGTYPE_p_svn_stream_t swig_types[79]
3023
 
#define SWIGTYPE_p_svn_string_t swig_types[80]
3024
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[81]
3025
 
#define SWIGTYPE_p_svn_tristate_t swig_types[82]
3026
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[83]
3027
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[84]
3028
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[85]
3029
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[86]
3030
 
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[87]
3031
 
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[88]
3032
 
#define SWIGTYPE_p_svn_version_extended_t swig_types[89]
3033
 
#define SWIGTYPE_p_svn_version_t swig_types[90]
3034
 
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[91]
3035
 
#define SWIGTYPE_p_unsigned_char swig_types[92]
3036
 
#define SWIGTYPE_p_unsigned_long swig_types[93]
3037
 
#define SWIGTYPE_p_void swig_types[94]
3038
 
static swig_type_info *swig_types[96];
3039
 
static swig_module_info swig_module = {swig_types, 95, 0, 0, 0, 0};
 
2974
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[57]
 
2975
#define SWIGTYPE_p_svn_dirent_t swig_types[58]
 
2976
#define SWIGTYPE_p_svn_errno_t swig_types[59]
 
2977
#define SWIGTYPE_p_svn_error_t swig_types[60]
 
2978
#define SWIGTYPE_p_svn_fs_lock_target_t swig_types[61]
 
2979
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[62]
 
2980
#define SWIGTYPE_p_svn_io_dirent_t swig_types[63]
 
2981
#define SWIGTYPE_p_svn_io_file_del_t swig_types[64]
 
2982
#define SWIGTYPE_p_svn_location_segment_t swig_types[65]
 
2983
#define SWIGTYPE_p_svn_lock_t swig_types[66]
 
2984
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[67]
 
2985
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[68]
 
2986
#define SWIGTYPE_p_svn_log_entry_t swig_types[69]
 
2987
#define SWIGTYPE_p_svn_merge_range_t swig_types[70]
 
2988
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[71]
 
2989
#define SWIGTYPE_p_svn_node_kind_t swig_types[72]
 
2990
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[73]
 
2991
#define SWIGTYPE_p_svn_opt_revision_t swig_types[74]
 
2992
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[75]
 
2993
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[76]
 
2994
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[77]
 
2995
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[78]
 
2996
#define SWIGTYPE_p_svn_prop_kind swig_types[79]
 
2997
#define SWIGTYPE_p_svn_stream_mark_t swig_types[80]
 
2998
#define SWIGTYPE_p_svn_stream_t swig_types[81]
 
2999
#define SWIGTYPE_p_svn_string_t swig_types[82]
 
3000
#define SWIGTYPE_p_svn_stringbuf_t swig_types[83]
 
3001
#define SWIGTYPE_p_svn_tristate_t swig_types[84]
 
3002
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[85]
 
3003
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[86]
 
3004
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[87]
 
3005
#define SWIGTYPE_p_svn_version_checklist_t swig_types[88]
 
3006
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[89]
 
3007
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[90]
 
3008
#define SWIGTYPE_p_svn_version_extended_t swig_types[91]
 
3009
#define SWIGTYPE_p_svn_version_t swig_types[92]
 
3010
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[93]
 
3011
#define SWIGTYPE_p_unsigned_char swig_types[94]
 
3012
#define SWIGTYPE_p_unsigned_long swig_types[95]
 
3013
#define SWIGTYPE_p_void swig_types[96]
 
3014
static swig_type_info *swig_types[98];
 
3015
static swig_module_info swig_module = {swig_types, 97, 0, 0, 0, 0};
3040
3016
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3041
3017
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3042
3018
 
3060
3036
#endif
3061
3037
#define SWIG_name    "_delta"
3062
3038
 
3063
 
#define SWIGVERSION 0x020009 
 
3039
#define SWIGVERSION 0x020012 
3064
3040
#define SWIG_VERSION SWIGVERSION
3065
3041
 
3066
3042
 
3286
3262
      return SWIG_OK;
3287
3263
    } else {
3288
3264
      PyErr_Clear();
 
3265
#if PY_VERSION_HEX >= 0x03000000
 
3266
      {
 
3267
        long v = PyLong_AsLong(obj);
 
3268
        if (!PyErr_Occurred()) {
 
3269
          if (v < 0) {
 
3270
            return SWIG_OverflowError;
 
3271
          }
 
3272
        } else {
 
3273
          PyErr_Clear();
 
3274
        }
 
3275
      }
 
3276
#endif
3289
3277
    }
3290
3278
  }
3291
3279
#ifdef SWIG_PYTHON_CAST_MODE
3335
3323
    PyLong_FromUnsignedLong(value) : PyLong_FromLong((long)(value)); 
3336
3324
}
3337
3325
 
3338
 
SWIGINTERN void svn_txdelta_window_t__ops_get(struct svn_txdelta_window_t *self,int *num_ops,svn_txdelta_op_t **ops){
 
3326
SWIGINTERN void svn_txdelta_window_t__ops_get(struct svn_txdelta_window_t *self,int *num_ops,svn_txdelta_op_t const **ops){
3339
3327
  *num_ops = self->num_ops;
3340
3328
  *ops = self->ops;
3341
3329
}
3585
3573
  }
3586
3574
  resultobj = SWIG_Py_Void();
3587
3575
  {
3588
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
 
3576
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
3589
3577
        _global_py_pool, args))
3590
3578
    
3591
3579
    ;
3592
3580
  }
3593
3581
  {
3594
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
3582
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
3595
3583
        _global_py_pool, args))
3596
3584
    
3597
3585
    ;
3621
3609
    svn_swig_py_acquire_py_lock();
3622
3610
    
3623
3611
  }
3624
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_version_t,
 
3612
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_version_t,
3625
3613
    _global_py_pool, args);
3626
3614
  return resultobj;
3627
3615
fail:
3638
3626
  
3639
3627
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_op_t_action_code_set",&obj0,&obj1)) SWIG_fail;
3640
3628
  {
3641
 
    arg1 = (struct svn_txdelta_op_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
 
3629
    arg1 = (struct svn_txdelta_op_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
3642
3630
    if (PyErr_Occurred()) {
3643
3631
      SWIG_fail;
3644
3632
    }
3665
3653
  
3666
3654
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_op_t_action_code_get",&obj0)) SWIG_fail;
3667
3655
  {
3668
 
    arg1 = (struct svn_txdelta_op_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
 
3656
    arg1 = (struct svn_txdelta_op_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
3669
3657
    if (PyErr_Occurred()) {
3670
3658
      SWIG_fail;
3671
3659
    }
3687
3675
  
3688
3676
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_op_t_offset_set",&obj0,&obj1)) SWIG_fail;
3689
3677
  {
3690
 
    arg1 = (struct svn_txdelta_op_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
 
3678
    arg1 = (struct svn_txdelta_op_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
3691
3679
    if (PyErr_Occurred()) {
3692
3680
      SWIG_fail;
3693
3681
    }
3714
3702
  
3715
3703
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_op_t_offset_get",&obj0)) SWIG_fail;
3716
3704
  {
3717
 
    arg1 = (struct svn_txdelta_op_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
 
3705
    arg1 = (struct svn_txdelta_op_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
3718
3706
    if (PyErr_Occurred()) {
3719
3707
      SWIG_fail;
3720
3708
    }
3736
3724
  
3737
3725
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_op_t_length_set",&obj0,&obj1)) SWIG_fail;
3738
3726
  {
3739
 
    arg1 = (struct svn_txdelta_op_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
 
3727
    arg1 = (struct svn_txdelta_op_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
3740
3728
    if (PyErr_Occurred()) {
3741
3729
      SWIG_fail;
3742
3730
    }
3763
3751
  
3764
3752
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_op_t_length_get",&obj0)) SWIG_fail;
3765
3753
  {
3766
 
    arg1 = (struct svn_txdelta_op_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
 
3754
    arg1 = (struct svn_txdelta_op_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
3767
3755
    if (PyErr_Occurred()) {
3768
3756
      SWIG_fail;
3769
3757
    }
3789
3777
    svn_swig_py_acquire_py_lock();
3790
3778
    
3791
3779
  }
3792
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_txdelta_op_t,
 
3780
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_txdelta_op_t,
3793
3781
    _global_py_pool, args);
3794
3782
  return resultobj;
3795
3783
fail:
3804
3792
  
3805
3793
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_txdelta_op_t",&obj0)) SWIG_fail;
3806
3794
  {
3807
 
    arg1 = (struct svn_txdelta_op_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
 
3795
    arg1 = (struct svn_txdelta_op_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj0);
3808
3796
    if (PyErr_Occurred()) {
3809
3797
      SWIG_fail;
3810
3798
    }
3840
3828
  
3841
3829
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_window_t_sview_offset_set",&obj0,&obj1)) SWIG_fail;
3842
3830
  {
3843
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
3831
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3844
3832
    if (PyErr_Occurred()) {
3845
3833
      SWIG_fail;
3846
3834
    }
3862
3850
  
3863
3851
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t_sview_offset_get",&obj0)) SWIG_fail;
3864
3852
  {
3865
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
3853
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3866
3854
    if (PyErr_Occurred()) {
3867
3855
      SWIG_fail;
3868
3856
    }
3884
3872
  
3885
3873
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_window_t_sview_len_set",&obj0,&obj1)) SWIG_fail;
3886
3874
  {
3887
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
3875
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3888
3876
    if (PyErr_Occurred()) {
3889
3877
      SWIG_fail;
3890
3878
    }
3911
3899
  
3912
3900
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t_sview_len_get",&obj0)) SWIG_fail;
3913
3901
  {
3914
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
3902
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3915
3903
    if (PyErr_Occurred()) {
3916
3904
      SWIG_fail;
3917
3905
    }
3933
3921
  
3934
3922
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_window_t_tview_len_set",&obj0,&obj1)) SWIG_fail;
3935
3923
  {
3936
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
3924
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3937
3925
    if (PyErr_Occurred()) {
3938
3926
      SWIG_fail;
3939
3927
    }
3960
3948
  
3961
3949
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t_tview_len_get",&obj0)) SWIG_fail;
3962
3950
  {
3963
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
3951
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3964
3952
    if (PyErr_Occurred()) {
3965
3953
      SWIG_fail;
3966
3954
    }
3982
3970
  
3983
3971
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_window_t_num_ops_set",&obj0,&obj1)) SWIG_fail;
3984
3972
  {
3985
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
3973
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3986
3974
    if (PyErr_Occurred()) {
3987
3975
      SWIG_fail;
3988
3976
    }
4009
3997
  
4010
3998
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t_num_ops_get",&obj0)) SWIG_fail;
4011
3999
  {
4012
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4000
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4013
4001
    if (PyErr_Occurred()) {
4014
4002
      SWIG_fail;
4015
4003
    }
4031
4019
  
4032
4020
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_window_t_src_ops_set",&obj0,&obj1)) SWIG_fail;
4033
4021
  {
4034
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4022
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4035
4023
    if (PyErr_Occurred()) {
4036
4024
      SWIG_fail;
4037
4025
    }
4058
4046
  
4059
4047
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t_src_ops_get",&obj0)) SWIG_fail;
4060
4048
  {
4061
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4049
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4062
4050
    if (PyErr_Occurred()) {
4063
4051
      SWIG_fail;
4064
4052
    }
4079
4067
  
4080
4068
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t_new_data_get",&obj0)) SWIG_fail;
4081
4069
  {
4082
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4070
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4083
4071
    if (PyErr_Occurred()) {
4084
4072
      SWIG_fail;
4085
4073
    }
4108
4096
  arg3 = &temp3;
4109
4097
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t__ops_get",&obj0)) SWIG_fail;
4110
4098
  {
4111
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4099
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4112
4100
    if (PyErr_Occurred()) {
4113
4101
      SWIG_fail;
4114
4102
    }
4116
4104
  {
4117
4105
    svn_swig_py_release_py_lock();
4118
4106
    
4119
 
    svn_txdelta_window_t__ops_get(arg1,arg2,arg3);
 
4107
    svn_txdelta_window_t__ops_get(arg1,arg2,(struct svn_txdelta_op_t const **)arg3);
4120
4108
    
4121
4109
    svn_swig_py_acquire_py_lock();
4122
4110
    
4157
4145
    svn_swig_py_acquire_py_lock();
4158
4146
    
4159
4147
  }
4160
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_txdelta_window_t,
 
4148
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_txdelta_window_t,
4161
4149
    _global_py_pool, args);
4162
4150
  return resultobj;
4163
4151
fail:
4172
4160
  
4173
4161
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_txdelta_window_t",&obj0)) SWIG_fail;
4174
4162
  {
4175
 
    arg1 = (struct svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4163
    arg1 = (struct svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4176
4164
    if (PyErr_Occurred()) {
4177
4165
      SWIG_fail;
4178
4166
    }
4215
4203
  arg2 = _global_pool;
4216
4204
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_txdelta_window_dup",&obj0,&obj1)) SWIG_fail;
4217
4205
  {
4218
 
    arg1 = (svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4206
    arg1 = (svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4219
4207
    if (PyErr_Occurred()) {
4220
4208
      SWIG_fail;
4221
4209
    }
4236
4224
    svn_swig_py_acquire_py_lock();
4237
4225
    
4238
4226
  }
4239
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_txdelta_window_t,
 
4227
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_txdelta_window_t,
4240
4228
    _global_py_pool, args);
4241
4229
  {
4242
4230
    Py_XDECREF(_global_py_pool);
4268
4256
  arg3 = _global_pool;
4269
4257
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_txdelta_compose_windows",&obj0,&obj1,&obj2)) SWIG_fail;
4270
4258
  {
4271
 
    arg1 = (svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4259
    arg1 = (svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4272
4260
    if (PyErr_Occurred()) {
4273
4261
      SWIG_fail;
4274
4262
    }
4275
4263
  }
4276
4264
  {
4277
 
    arg2 = (svn_txdelta_window_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj1);
 
4265
    arg2 = (svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj1);
4278
4266
    if (PyErr_Occurred()) {
4279
4267
      SWIG_fail;
4280
4268
    }
4295
4283
    svn_swig_py_acquire_py_lock();
4296
4284
    
4297
4285
  }
4298
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_txdelta_window_t,
 
4286
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_txdelta_window_t,
4299
4287
    _global_py_pool, args);
4300
4288
  {
4301
4289
    Py_XDECREF(_global_py_pool);
4322
4310
  arg4 = &temp4;
4323
4311
  if (!PyArg_ParseTuple(args,(char *)"Oss:svn_txdelta_apply_instructions",&obj0,&arg2,&arg3)) SWIG_fail;
4324
4312
  {
4325
 
    arg1 = (svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
4313
    arg1 = (svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
4326
4314
    if (PyErr_Occurred()) {
4327
4315
      SWIG_fail;
4328
4316
    }
4391
4379
  }
4392
4380
  {
4393
4381
    svn_txdelta_window_handler_t * tmp =
4394
 
    svn_swig_MustGetPtr(obj2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj2);
 
4382
    svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj2);
4395
4383
    if (tmp == NULL || PyErr_Occurred()) {
4396
4384
      SWIG_fail;
4397
4385
    }
4412
4400
    }
4413
4401
  }
4414
4402
  {
4415
 
    arg7 = svn_swig_py_cancel_func;
4416
 
    arg8 = obj5; /* our function is the baton. */
 
4403
    arg7 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
4404
    arg8 = obj5;
4417
4405
  }
4418
4406
  if (obj6) {
4419
4407
    /* Verify that the user supplied a valid pool */
4506
4494
  }
4507
4495
  {
4508
4496
    svn_txdelta_next_window_fn_t * tmp =
4509
 
    svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj1);
 
4497
    svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj1);
4510
4498
    if (tmp == NULL || PyErr_Occurred()) {
4511
4499
      SWIG_fail;
4512
4500
    }
4514
4502
  }
4515
4503
  {
4516
4504
    svn_txdelta_md5_digest_fn_t * tmp =
4517
 
    svn_swig_MustGetPtr(obj2, SWIGTYPE_p_p_f_p_void__p_unsigned_char, svn_argnum_obj2);
 
4505
    svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_p_f_p_void__p_unsigned_char, svn_argnum_obj2);
4518
4506
    if (tmp == NULL || PyErr_Occurred()) {
4519
4507
      SWIG_fail;
4520
4508
    }
4536
4524
    svn_swig_py_acquire_py_lock();
4537
4525
    
4538
4526
  }
4539
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_txdelta_stream_t,
 
4527
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_txdelta_stream_t,
4540
4528
    _global_py_pool, args);
4541
4529
  {
4542
4530
    Py_XDECREF(_global_py_pool);
4569
4557
  arg1 = &temp1;
4570
4558
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_txdelta_next_window",&obj0,&obj1)) SWIG_fail;
4571
4559
  {
4572
 
    arg2 = (svn_txdelta_stream_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_stream_t, svn_argnum_obj0);
 
4560
    arg2 = (svn_txdelta_stream_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_stream_t, svn_argnum_obj0);
4573
4561
    if (PyErr_Occurred()) {
4574
4562
      SWIG_fail;
4575
4563
    }
4602
4590
    resultobj = Py_None;
4603
4591
  }
4604
4592
  {
4605
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_window_t,
 
4593
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_txdelta_window_t,
4606
4594
        _global_py_pool, args))
4607
4595
    
4608
4596
    ;
4627
4615
  
4628
4616
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_md5_digest",&obj0)) SWIG_fail;
4629
4617
  {
4630
 
    arg1 = (svn_txdelta_stream_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_stream_t, svn_argnum_obj0);
 
4618
    arg1 = (svn_txdelta_stream_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_stream_t, svn_argnum_obj0);
4631
4619
    if (PyErr_Occurred()) {
4632
4620
      SWIG_fail;
4633
4621
    }
4640
4628
    svn_swig_py_acquire_py_lock();
4641
4629
    
4642
4630
  }
4643
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_unsigned_char,
 
4631
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_unsigned_char,
4644
4632
    _global_py_pool, args);
4645
4633
  return resultobj;
4646
4634
fail:
4699
4687
  }
4700
4688
  resultobj = SWIG_Py_Void();
4701
4689
  {
4702
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t,
 
4690
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t,
4703
4691
        _global_py_pool, args))
4704
4692
    
4705
4693
    ;
4759
4747
  }
4760
4748
  resultobj = SWIG_Py_Void();
4761
4749
  {
4762
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t,
 
4750
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t,
4763
4751
        _global_py_pool, args))
4764
4752
    
4765
4753
    ;
4797
4785
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_txdelta_target_push",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4798
4786
  {
4799
4787
    svn_txdelta_window_handler_t * tmp =
4800
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj0);
 
4788
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj0);
4801
4789
    if (tmp == NULL || PyErr_Occurred()) {
4802
4790
      SWIG_fail;
4803
4791
    }
4830
4818
    svn_swig_py_acquire_py_lock();
4831
4819
    
4832
4820
  }
4833
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_stream_t,
 
4821
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_stream_t,
4834
4822
    _global_py_pool, args);
4835
4823
  {
4836
4824
    Py_XDECREF(_global_py_pool);
4879
4867
  }
4880
4868
  {
4881
4869
    svn_txdelta_window_handler_t * tmp =
4882
 
    svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj1);
 
4870
    svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj1);
4883
4871
    if (tmp == NULL || PyErr_Occurred()) {
4884
4872
      SWIG_fail;
4885
4873
    }
4959
4947
  }
4960
4948
  {
4961
4949
    svn_txdelta_window_handler_t * tmp =
4962
 
    svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj1);
 
4950
    svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj1);
4963
4951
    if (tmp == NULL || PyErr_Occurred()) {
4964
4952
      SWIG_fail;
4965
4953
    }
5035
5023
  arg4 = _global_pool;
5036
5024
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_txdelta_send_txstream",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5037
5025
  {
5038
 
    arg1 = (svn_txdelta_stream_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_stream_t, svn_argnum_obj0);
 
5026
    arg1 = (svn_txdelta_stream_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_stream_t, svn_argnum_obj0);
5039
5027
    if (PyErr_Occurred()) {
5040
5028
      SWIG_fail;
5041
5029
    }
5042
5030
  }
5043
5031
  {
5044
5032
    svn_txdelta_window_handler_t * tmp =
5045
 
    svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj1);
 
5033
    svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj1);
5046
5034
    if (tmp == NULL || PyErr_Occurred()) {
5047
5035
      SWIG_fail;
5048
5036
    }
5117
5105
  arg5 = _global_pool;
5118
5106
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_txdelta_send_contents",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5119
5107
  {
5120
 
    arg1 = (unsigned char *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_unsigned_char, svn_argnum_obj0);
 
5108
    arg1 = (unsigned char *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_unsigned_char, svn_argnum_obj0);
5121
5109
    if (PyErr_Occurred()) {
5122
5110
      SWIG_fail;
5123
5111
    }
5130
5118
  }
5131
5119
  {
5132
5120
    svn_txdelta_window_handler_t * tmp =
5133
 
    svn_swig_MustGetPtr(obj2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj2);
 
5121
    svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj2);
5134
5122
    if (tmp == NULL || PyErr_Occurred()) {
5135
5123
      SWIG_fail;
5136
5124
    }
5241
5229
  }
5242
5230
  resultobj = SWIG_Py_Void();
5243
5231
  {
5244
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
5232
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
5245
5233
        _global_py_pool, args))
5246
5234
    
5247
5235
    ;
5248
5236
  }
5249
5237
  {
5250
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
 
5238
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg7, SWIGTYPE_p_void,
5251
5239
        _global_py_pool, args))
5252
5240
    
5253
5241
    ;
5329
5317
  }
5330
5318
  resultobj = SWIG_Py_Void();
5331
5319
  {
5332
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
5320
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
5333
5321
        _global_py_pool, args))
5334
5322
    
5335
5323
    ;
5336
5324
  }
5337
5325
  {
5338
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
5326
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
5339
5327
        _global_py_pool, args))
5340
5328
    
5341
5329
    ;
5409
5397
  }
5410
5398
  resultobj = SWIG_Py_Void();
5411
5399
  {
5412
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
5400
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
5413
5401
        _global_py_pool, args))
5414
5402
    
5415
5403
    ;
5416
5404
  }
5417
5405
  {
5418
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
5406
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
5419
5407
        _global_py_pool, args))
5420
5408
    
5421
5409
    ;
5481
5469
  }
5482
5470
  resultobj = SWIG_Py_Void();
5483
5471
  {
5484
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg3, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
5472
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg3, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
5485
5473
        _global_py_pool, args))
5486
5474
    
5487
5475
    ;
5488
5476
  }
5489
5477
  {
5490
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_void,
 
5478
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg4, SWIGTYPE_p_void,
5491
5479
        _global_py_pool, args))
5492
5480
    
5493
5481
    ;
5525
5513
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_txdelta_parse_svndiff",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5526
5514
  {
5527
5515
    svn_txdelta_window_handler_t * tmp =
5528
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj0);
 
5516
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj0);
5529
5517
    if (tmp == NULL || PyErr_Occurred()) {
5530
5518
      SWIG_fail;
5531
5519
    }
5561
5549
    svn_swig_py_acquire_py_lock();
5562
5550
    
5563
5551
  }
5564
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_stream_t,
 
5552
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_stream_t,
5565
5553
    _global_py_pool, args);
5566
5554
  {
5567
5555
    Py_XDECREF(_global_py_pool);
5632
5620
    resultobj = Py_None;
5633
5621
  }
5634
5622
  {
5635
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_window_t,
 
5623
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_txdelta_window_t,
5636
5624
        _global_py_pool, args))
5637
5625
    
5638
5626
    ;
5724
5712
  
5725
5713
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_set_target_revision_set",&obj0,&obj1)) SWIG_fail;
5726
5714
  {
5727
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5715
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5728
5716
    if (PyErr_Occurred()) {
5729
5717
      SWIG_fail;
5730
5718
    }
5751
5739
  
5752
5740
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_set_target_revision_get",&obj0)) SWIG_fail;
5753
5741
  {
5754
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5742
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5755
5743
    if (PyErr_Occurred()) {
5756
5744
      SWIG_fail;
5757
5745
    }
5773
5761
  
5774
5762
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_open_root_set",&obj0,&obj1)) SWIG_fail;
5775
5763
  {
5776
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5764
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5777
5765
    if (PyErr_Occurred()) {
5778
5766
      SWIG_fail;
5779
5767
    }
5800
5788
  
5801
5789
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_open_root_get",&obj0)) SWIG_fail;
5802
5790
  {
5803
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5791
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5804
5792
    if (PyErr_Occurred()) {
5805
5793
      SWIG_fail;
5806
5794
    }
5822
5810
  
5823
5811
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_delete_entry_set",&obj0,&obj1)) SWIG_fail;
5824
5812
  {
5825
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5813
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5826
5814
    if (PyErr_Occurred()) {
5827
5815
      SWIG_fail;
5828
5816
    }
5849
5837
  
5850
5838
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_delete_entry_get",&obj0)) SWIG_fail;
5851
5839
  {
5852
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5840
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5853
5841
    if (PyErr_Occurred()) {
5854
5842
      SWIG_fail;
5855
5843
    }
5871
5859
  
5872
5860
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_add_directory_set",&obj0,&obj1)) SWIG_fail;
5873
5861
  {
5874
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5862
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5875
5863
    if (PyErr_Occurred()) {
5876
5864
      SWIG_fail;
5877
5865
    }
5898
5886
  
5899
5887
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_add_directory_get",&obj0)) SWIG_fail;
5900
5888
  {
5901
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5889
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5902
5890
    if (PyErr_Occurred()) {
5903
5891
      SWIG_fail;
5904
5892
    }
5920
5908
  
5921
5909
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_open_directory_set",&obj0,&obj1)) SWIG_fail;
5922
5910
  {
5923
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5911
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5924
5912
    if (PyErr_Occurred()) {
5925
5913
      SWIG_fail;
5926
5914
    }
5947
5935
  
5948
5936
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_open_directory_get",&obj0)) SWIG_fail;
5949
5937
  {
5950
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5938
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5951
5939
    if (PyErr_Occurred()) {
5952
5940
      SWIG_fail;
5953
5941
    }
5969
5957
  
5970
5958
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_change_dir_prop_set",&obj0,&obj1)) SWIG_fail;
5971
5959
  {
5972
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5960
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
5973
5961
    if (PyErr_Occurred()) {
5974
5962
      SWIG_fail;
5975
5963
    }
5996
5984
  
5997
5985
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_change_dir_prop_get",&obj0)) SWIG_fail;
5998
5986
  {
5999
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
5987
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6000
5988
    if (PyErr_Occurred()) {
6001
5989
      SWIG_fail;
6002
5990
    }
6018
6006
  
6019
6007
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_close_directory_set",&obj0,&obj1)) SWIG_fail;
6020
6008
  {
6021
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6009
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6022
6010
    if (PyErr_Occurred()) {
6023
6011
      SWIG_fail;
6024
6012
    }
6045
6033
  
6046
6034
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_close_directory_get",&obj0)) SWIG_fail;
6047
6035
  {
6048
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6036
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6049
6037
    if (PyErr_Occurred()) {
6050
6038
      SWIG_fail;
6051
6039
    }
6067
6055
  
6068
6056
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_absent_directory_set",&obj0,&obj1)) SWIG_fail;
6069
6057
  {
6070
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6058
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6071
6059
    if (PyErr_Occurred()) {
6072
6060
      SWIG_fail;
6073
6061
    }
6094
6082
  
6095
6083
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_absent_directory_get",&obj0)) SWIG_fail;
6096
6084
  {
6097
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6085
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6098
6086
    if (PyErr_Occurred()) {
6099
6087
      SWIG_fail;
6100
6088
    }
6116
6104
  
6117
6105
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_add_file_set",&obj0,&obj1)) SWIG_fail;
6118
6106
  {
6119
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6107
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6120
6108
    if (PyErr_Occurred()) {
6121
6109
      SWIG_fail;
6122
6110
    }
6143
6131
  
6144
6132
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_add_file_get",&obj0)) SWIG_fail;
6145
6133
  {
6146
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6134
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6147
6135
    if (PyErr_Occurred()) {
6148
6136
      SWIG_fail;
6149
6137
    }
6165
6153
  
6166
6154
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_open_file_set",&obj0,&obj1)) SWIG_fail;
6167
6155
  {
6168
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6156
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6169
6157
    if (PyErr_Occurred()) {
6170
6158
      SWIG_fail;
6171
6159
    }
6192
6180
  
6193
6181
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_open_file_get",&obj0)) SWIG_fail;
6194
6182
  {
6195
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6183
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6196
6184
    if (PyErr_Occurred()) {
6197
6185
      SWIG_fail;
6198
6186
    }
6214
6202
  
6215
6203
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_apply_textdelta_set",&obj0,&obj1)) SWIG_fail;
6216
6204
  {
6217
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6205
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6218
6206
    if (PyErr_Occurred()) {
6219
6207
      SWIG_fail;
6220
6208
    }
6241
6229
  
6242
6230
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_apply_textdelta_get",&obj0)) SWIG_fail;
6243
6231
  {
6244
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6232
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6245
6233
    if (PyErr_Occurred()) {
6246
6234
      SWIG_fail;
6247
6235
    }
6263
6251
  
6264
6252
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_change_file_prop_set",&obj0,&obj1)) SWIG_fail;
6265
6253
  {
6266
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6254
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6267
6255
    if (PyErr_Occurred()) {
6268
6256
      SWIG_fail;
6269
6257
    }
6290
6278
  
6291
6279
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_change_file_prop_get",&obj0)) SWIG_fail;
6292
6280
  {
6293
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6281
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6294
6282
    if (PyErr_Occurred()) {
6295
6283
      SWIG_fail;
6296
6284
    }
6312
6300
  
6313
6301
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_close_file_set",&obj0,&obj1)) SWIG_fail;
6314
6302
  {
6315
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6303
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6316
6304
    if (PyErr_Occurred()) {
6317
6305
      SWIG_fail;
6318
6306
    }
6339
6327
  
6340
6328
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_close_file_get",&obj0)) SWIG_fail;
6341
6329
  {
6342
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6330
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6343
6331
    if (PyErr_Occurred()) {
6344
6332
      SWIG_fail;
6345
6333
    }
6361
6349
  
6362
6350
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_absent_file_set",&obj0,&obj1)) SWIG_fail;
6363
6351
  {
6364
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6352
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6365
6353
    if (PyErr_Occurred()) {
6366
6354
      SWIG_fail;
6367
6355
    }
6388
6376
  
6389
6377
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_absent_file_get",&obj0)) SWIG_fail;
6390
6378
  {
6391
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6379
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6392
6380
    if (PyErr_Occurred()) {
6393
6381
      SWIG_fail;
6394
6382
    }
6410
6398
  
6411
6399
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_close_edit_set",&obj0,&obj1)) SWIG_fail;
6412
6400
  {
6413
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6401
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6414
6402
    if (PyErr_Occurred()) {
6415
6403
      SWIG_fail;
6416
6404
    }
6437
6425
  
6438
6426
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_close_edit_get",&obj0)) SWIG_fail;
6439
6427
  {
6440
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6428
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6441
6429
    if (PyErr_Occurred()) {
6442
6430
      SWIG_fail;
6443
6431
    }
6459
6447
  
6460
6448
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_editor_t_abort_edit_set",&obj0,&obj1)) SWIG_fail;
6461
6449
  {
6462
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6450
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6463
6451
    if (PyErr_Occurred()) {
6464
6452
      SWIG_fail;
6465
6453
    }
6486
6474
  
6487
6475
  if (!PyArg_ParseTuple(args,(char *)"O:svn_delta_editor_t_abort_edit_get",&obj0)) SWIG_fail;
6488
6476
  {
6489
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6477
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6490
6478
    if (PyErr_Occurred()) {
6491
6479
      SWIG_fail;
6492
6480
    }
6512
6500
    svn_swig_py_acquire_py_lock();
6513
6501
    
6514
6502
  }
6515
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_delta_editor_t,
 
6503
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_delta_editor_t,
6516
6504
    _global_py_pool, args);
6517
6505
  return resultobj;
6518
6506
fail:
6527
6515
  
6528
6516
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_delta_editor_t",&obj0)) SWIG_fail;
6529
6517
  {
6530
 
    arg1 = (struct svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6518
    arg1 = (struct svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6531
6519
    if (PyErr_Occurred()) {
6532
6520
      SWIG_fail;
6533
6521
    }
6583
6571
    svn_swig_py_acquire_py_lock();
6584
6572
    
6585
6573
  }
6586
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_delta_editor_t,
 
6574
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_delta_editor_t,
6587
6575
    _global_py_pool, args);
6588
6576
  {
6589
6577
    Py_XDECREF(_global_py_pool);
6607
6595
  
6608
6596
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_delta_noop_window_handler",&obj0,&obj1)) SWIG_fail;
6609
6597
  {
6610
 
    arg1 = (svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
 
6598
    arg1 = (svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
6611
6599
    if (PyErr_Occurred()) {
6612
6600
      SWIG_fail;
6613
6601
    }
6672
6660
  arg6 = &temp6;
6673
6661
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_delta_get_cancellation_editor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6674
6662
  {
6675
 
    arg1 = svn_swig_py_cancel_func;
6676
 
    arg2 = obj0; /* our function is the baton. */
 
6663
    arg1 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
6664
    arg2 = obj0;
6677
6665
  }
6678
6666
  {
6679
 
    arg3 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj1);
 
6667
    arg3 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj1);
6680
6668
    if (PyErr_Occurred()) {
6681
6669
      SWIG_fail;
6682
6670
    }
6717
6705
    resultobj = Py_None;
6718
6706
  }
6719
6707
  {
6720
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg5, SWIGTYPE_p_svn_delta_editor_t,
 
6708
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg5, SWIGTYPE_p_svn_delta_editor_t,
6721
6709
        _global_py_pool, args))
6722
6710
    
6723
6711
    ;
6724
6712
  }
6725
6713
  {
6726
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg6, SWIGTYPE_p_void,
 
6714
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg6, SWIGTYPE_p_void,
6727
6715
        _global_py_pool, args))
6728
6716
    
6729
6717
    ;
6768
6756
  arg2 = &temp2;
6769
6757
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_delta_depth_filter_editor",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
6770
6758
  {
6771
 
    arg3 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6759
    arg3 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6772
6760
    if (PyErr_Occurred()) {
6773
6761
      SWIG_fail;
6774
6762
    }
6821
6809
    resultobj = Py_None;
6822
6810
  }
6823
6811
  {
6824
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
 
6812
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
6825
6813
        _global_py_pool, args))
6826
6814
    
6827
6815
    ;
6828
6816
  }
6829
6817
  {
6830
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
6818
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
6831
6819
        _global_py_pool, args))
6832
6820
    
6833
6821
    ;
6869
6857
  arg7 = _global_pool;
6870
6858
  if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:svn_delta_path_driver2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6871
6859
  {
6872
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6860
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6873
6861
    if (PyErr_Occurred()) {
6874
6862
      SWIG_fail;
6875
6863
    }
6898
6886
    }
6899
6887
  }
6900
6888
  {
6901
 
    arg5 = svn_swig_py_delta_path_driver_cb_func;
 
6889
    arg5 = (svn_delta_path_driver_cb_func_t) svn_swig_py_delta_path_driver_cb_func;
6902
6890
    arg6 = obj4;
6903
6891
  }
6904
6892
  if (obj5) {
6965
6953
  arg7 = _global_pool;
6966
6954
  if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:svn_delta_path_driver",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6967
6955
  {
6968
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
6956
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
6969
6957
    if (PyErr_Occurred()) {
6970
6958
      SWIG_fail;
6971
6959
    }
6994
6982
    SWIG_fail;
6995
6983
  }
6996
6984
  {
6997
 
    arg5 = svn_swig_py_delta_path_driver_cb_func;
 
6985
    arg5 = (svn_delta_path_driver_cb_func_t) svn_swig_py_delta_path_driver_cb_func;
6998
6986
    arg6 = obj4;
6999
6987
  }
7000
6988
  if (obj5) {
7068
7056
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_compat_wrap_file_rev_handler",&obj0,&obj1,&obj2)) SWIG_fail;
7069
7057
  {
7070
7058
    svn_file_rev_handler_old_t * tmp =
7071
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
7059
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
7072
7060
    if (tmp == NULL || PyErr_Occurred()) {
7073
7061
      SWIG_fail;
7074
7062
    }
7100
7088
  }
7101
7089
  resultobj = SWIG_Py_Void();
7102
7090
  {
7103
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg1, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
 
7091
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg1, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
7104
7092
        _global_py_pool, args))
7105
7093
    
7106
7094
    ;
7153
7141
  arg4 = _global_pool;
7154
7142
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_delta_editor_invoke_set_target_revision",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7155
7143
  {
7156
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7144
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7157
7145
    if (PyErr_Occurred()) {
7158
7146
      SWIG_fail;
7159
7147
    }
7234
7222
  arg5 = &temp5;
7235
7223
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_delta_editor_invoke_open_root",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7236
7224
  {
7237
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7225
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7238
7226
    if (PyErr_Occurred()) {
7239
7227
      SWIG_fail;
7240
7228
    }
7281
7269
    resultobj = Py_None;
7282
7270
  }
7283
7271
  {
7284
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg5, SWIGTYPE_p_void,
 
7272
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg5, SWIGTYPE_p_void,
7285
7273
        _global_py_pool, args))
7286
7274
    
7287
7275
    ;
7319
7307
  arg5 = _global_pool;
7320
7308
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_delta_editor_invoke_delete_entry",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
7321
7309
  {
7322
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7310
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7323
7311
    if (PyErr_Occurred()) {
7324
7312
      SWIG_fail;
7325
7313
    }
7402
7390
  arg7 = &temp7;
7403
7391
  if (!PyArg_ParseTuple(args,(char *)"OsOzO|O:svn_delta_editor_invoke_add_directory",&obj0,&arg2,&obj2,&arg4,&obj4,&obj5)) SWIG_fail;
7404
7392
  {
7405
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7393
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7406
7394
    if (PyErr_Occurred()) {
7407
7395
      SWIG_fail;
7408
7396
    }
7449
7437
    resultobj = Py_None;
7450
7438
  }
7451
7439
  {
7452
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
 
7440
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg7, SWIGTYPE_p_void,
7453
7441
        _global_py_pool, args))
7454
7442
    
7455
7443
    ;
7490
7478
  arg6 = &temp6;
7491
7479
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_delta_editor_invoke_open_directory",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
7492
7480
  {
7493
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7481
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7494
7482
    if (PyErr_Occurred()) {
7495
7483
      SWIG_fail;
7496
7484
    }
7537
7525
    resultobj = Py_None;
7538
7526
  }
7539
7527
  {
7540
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg6, SWIGTYPE_p_void,
 
7528
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg6, SWIGTYPE_p_void,
7541
7529
        _global_py_pool, args))
7542
7530
    
7543
7531
    ;
7576
7564
  arg5 = _global_pool;
7577
7565
  if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_delta_editor_invoke_change_dir_prop",&obj0,&obj1,&arg3,&obj3,&obj4)) SWIG_fail;
7578
7566
  {
7579
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7567
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7580
7568
    if (PyErr_Occurred()) {
7581
7569
      SWIG_fail;
7582
7570
    }
7659
7647
  arg3 = _global_pool;
7660
7648
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_delta_editor_invoke_close_directory",&obj0,&obj1,&obj2)) SWIG_fail;
7661
7649
  {
7662
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7650
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7663
7651
    if (PyErr_Occurred()) {
7664
7652
      SWIG_fail;
7665
7653
    }
7730
7718
  arg4 = _global_pool;
7731
7719
  if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_delta_editor_invoke_absent_directory",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
7732
7720
  {
7733
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7721
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7734
7722
    if (PyErr_Occurred()) {
7735
7723
      SWIG_fail;
7736
7724
    }
7807
7795
  arg7 = &temp7;
7808
7796
  if (!PyArg_ParseTuple(args,(char *)"OsOzO|O:svn_delta_editor_invoke_add_file",&obj0,&arg2,&obj2,&arg4,&obj4,&obj5)) SWIG_fail;
7809
7797
  {
7810
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7798
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7811
7799
    if (PyErr_Occurred()) {
7812
7800
      SWIG_fail;
7813
7801
    }
7854
7842
    resultobj = Py_None;
7855
7843
  }
7856
7844
  {
7857
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
 
7845
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg7, SWIGTYPE_p_void,
7858
7846
        _global_py_pool, args))
7859
7847
    
7860
7848
    ;
7895
7883
  arg6 = &temp6;
7896
7884
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_delta_editor_invoke_open_file",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
7897
7885
  {
7898
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7886
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7899
7887
    if (PyErr_Occurred()) {
7900
7888
      SWIG_fail;
7901
7889
    }
7942
7930
    resultobj = Py_None;
7943
7931
  }
7944
7932
  {
7945
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg6, SWIGTYPE_p_void,
 
7933
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg6, SWIGTYPE_p_void,
7946
7934
        _global_py_pool, args))
7947
7935
    
7948
7936
    ;
7992
7980
  arg6 = &temp6;
7993
7981
  if (!PyArg_ParseTuple(args,(char *)"OOz|O:svn_delta_editor_invoke_apply_textdelta",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
7994
7982
  {
7995
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
7983
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
7996
7984
    if (PyErr_Occurred()) {
7997
7985
      SWIG_fail;
7998
7986
    }
8033
8021
    resultobj = Py_None;
8034
8022
  }
8035
8023
  {
8036
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg5, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
8024
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg5, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
8037
8025
        _global_py_pool, args))
8038
8026
    
8039
8027
    ;
8040
8028
  }
8041
8029
  {
8042
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg6, SWIGTYPE_p_void,
 
8030
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg6, SWIGTYPE_p_void,
8043
8031
        _global_py_pool, args))
8044
8032
    
8045
8033
    ;
8078
8066
  arg5 = _global_pool;
8079
8067
  if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_delta_editor_invoke_change_file_prop",&obj0,&obj1,&arg3,&obj3,&obj4)) SWIG_fail;
8080
8068
  {
8081
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
8069
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
8082
8070
    if (PyErr_Occurred()) {
8083
8071
      SWIG_fail;
8084
8072
    }
8162
8150
  arg4 = _global_pool;
8163
8151
  if (!PyArg_ParseTuple(args,(char *)"OOz|O:svn_delta_editor_invoke_close_file",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
8164
8152
  {
8165
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
8153
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
8166
8154
    if (PyErr_Occurred()) {
8167
8155
      SWIG_fail;
8168
8156
    }
8233
8221
  arg4 = _global_pool;
8234
8222
  if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_delta_editor_invoke_absent_file",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
8235
8223
  {
8236
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
8224
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
8237
8225
    if (PyErr_Occurred()) {
8238
8226
      SWIG_fail;
8239
8227
    }
8303
8291
  arg3 = _global_pool;
8304
8292
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_delta_editor_invoke_close_edit",&obj0,&obj1,&obj2)) SWIG_fail;
8305
8293
  {
8306
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
8294
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
8307
8295
    if (PyErr_Occurred()) {
8308
8296
      SWIG_fail;
8309
8297
    }
8373
8361
  arg3 = _global_pool;
8374
8362
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_delta_editor_invoke_abort_edit",&obj0,&obj1,&obj2)) SWIG_fail;
8375
8363
  {
8376
 
    arg1 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
 
8364
    arg1 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj0);
8377
8365
    if (PyErr_Occurred()) {
8378
8366
      SWIG_fail;
8379
8367
    }
8438
8426
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_txdelta_invoke_window_handler",&obj0,&obj1,&obj2)) SWIG_fail;
8439
8427
  {
8440
8428
    svn_txdelta_window_handler_t * tmp =
8441
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj0);
 
8429
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, svn_argnum_obj0);
8442
8430
    if (tmp == NULL || PyErr_Occurred()) {
8443
8431
      SWIG_fail;
8444
8432
    }
8445
8433
    arg1 = *tmp;
8446
8434
  }
8447
8435
  {
8448
 
    arg2 = (svn_txdelta_window_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj1);
 
8436
    arg2 = (svn_txdelta_window_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj1);
8449
8437
    if (PyErr_Occurred()) {
8450
8438
      SWIG_fail;
8451
8439
    }
8505
8493
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_txdelta_invoke_next_window_fn",&obj0,&obj1,&obj2)) SWIG_fail;
8506
8494
  {
8507
8495
    svn_txdelta_next_window_fn_t * tmp =
8508
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
8496
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
8509
8497
    if (tmp == NULL || PyErr_Occurred()) {
8510
8498
      SWIG_fail;
8511
8499
    }
8547
8535
    resultobj = Py_None;
8548
8536
  }
8549
8537
  {
8550
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_txdelta_window_t,
 
8538
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_svn_txdelta_window_t,
8551
8539
        _global_py_pool, args))
8552
8540
    
8553
8541
    ;
8575
8563
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_invoke_md5_digest_fn",&obj0,&obj1)) SWIG_fail;
8576
8564
  {
8577
8565
    svn_txdelta_md5_digest_fn_t * tmp =
8578
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void__p_unsigned_char, svn_argnum_obj0);
 
8566
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void__p_unsigned_char, svn_argnum_obj0);
8579
8567
    if (tmp == NULL || PyErr_Occurred()) {
8580
8568
      SWIG_fail;
8581
8569
    }
8597
8585
    svn_swig_py_acquire_py_lock();
8598
8586
    
8599
8587
  }
8600
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_unsigned_char,
 
8588
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_unsigned_char,
8601
8589
    _global_py_pool, args);
8602
8590
  return resultobj;
8603
8591
fail:
8630
8618
  if (!PyArg_ParseTuple(args,(char *)"OOOs|O:svn_delta_invoke_path_driver_cb_func",&obj0,&obj1,&obj2,&arg5,&obj4)) SWIG_fail;
8631
8619
  {
8632
8620
    svn_delta_path_driver_cb_func_t * tmp =
8633
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
8621
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
8634
8622
    if (tmp == NULL || PyErr_Occurred()) {
8635
8623
      SWIG_fail;
8636
8624
    }
8680
8668
    resultobj = Py_None;
8681
8669
  }
8682
8670
  {
8683
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
8671
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
8684
8672
        _global_py_pool, args))
8685
8673
    
8686
8674
    ;
8739
8727
  if (!PyArg_ParseTuple(args,(char *)"OOsOOOO|O:svn_file_invoke_rev_handler",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
8740
8728
  {
8741
8729
    svn_file_rev_handler_t * tmp =
8742
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
8730
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
8743
8731
    if (tmp == NULL || PyErr_Occurred()) {
8744
8732
      SWIG_fail;
8745
8733
    }
8760
8748
    }
8761
8749
  }
8762
8750
  {
8763
 
    arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_apr_hash_t, svn_argnum_obj4);
 
8751
    arg5 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_apr_hash_t, svn_argnum_obj4);
8764
8752
    if (PyErr_Occurred()) {
8765
8753
      SWIG_fail;
8766
8754
    }
8772
8760
    }
8773
8761
  }
8774
8762
  {
8775
 
    arg9 = (apr_array_header_t *)svn_swig_MustGetPtr(obj6, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj6);
 
8763
    arg9 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj6, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj6);
8776
8764
    if (PyErr_Occurred()) {
8777
8765
      SWIG_fail;
8778
8766
    }
8805
8793
    resultobj = Py_None;
8806
8794
  }
8807
8795
  {
8808
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg7, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
8796
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg7, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
8809
8797
        _global_py_pool, args))
8810
8798
    
8811
8799
    ;
8812
8800
  }
8813
8801
  {
8814
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg8, SWIGTYPE_p_void,
 
8802
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg8, SWIGTYPE_p_void,
8815
8803
        _global_py_pool, args))
8816
8804
    
8817
8805
    ;
8868
8856
  if (!PyArg_ParseTuple(args,(char *)"OOsOOO|O:svn_file_invoke_rev_handler_old",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
8869
8857
  {
8870
8858
    svn_file_rev_handler_old_t * tmp =
8871
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
8859
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
8872
8860
    if (tmp == NULL || PyErr_Occurred()) {
8873
8861
      SWIG_fail;
8874
8862
    }
8889
8877
    }
8890
8878
  }
8891
8879
  {
8892
 
    arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_apr_hash_t, svn_argnum_obj4);
 
8880
    arg5 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_apr_hash_t, svn_argnum_obj4);
8893
8881
    if (PyErr_Occurred()) {
8894
8882
      SWIG_fail;
8895
8883
    }
8896
8884
  }
8897
8885
  {
8898
 
    arg8 = (apr_array_header_t *)svn_swig_MustGetPtr(obj5, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj5);
 
8886
    arg8 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj5, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj5);
8899
8887
    if (PyErr_Occurred()) {
8900
8888
      SWIG_fail;
8901
8889
    }
8928
8916
    resultobj = Py_None;
8929
8917
  }
8930
8918
  {
8931
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
8919
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
8932
8920
        _global_py_pool, args))
8933
8921
    
8934
8922
    ;
8935
8923
  }
8936
8924
  {
8937
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
 
8925
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg7, SWIGTYPE_p_void,
8938
8926
        _global_py_pool, args))
8939
8927
    
8940
8928
    ;
9244
9232
static swig_type_info _swigt__p_svn_config_t = {"_p_svn_config_t", "struct svn_config_t *|svn_config_t *", 0, 0, (void*)0, 0};
9245
9233
static swig_type_info _swigt__p_svn_delta_editor_t = {"_p_svn_delta_editor_t", "struct svn_delta_editor_t *|svn_delta_editor_t *", 0, 0, (void*)0, 0};
9246
9234
static swig_type_info _swigt__p_svn_depth_t = {"_p_svn_depth_t", "enum svn_depth_t *|svn_depth_t *", 0, 0, (void*)0, 0};
 
9235
static swig_type_info _swigt__p_svn_diff_hunk_t = {"_p_svn_diff_hunk_t", "svn_diff_hunk_t *", 0, 0, (void*)0, 0};
9247
9236
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};
9248
9237
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};
9249
9238
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};
 
9239
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};
9250
9240
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};
9251
9241
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};
9252
9242
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};
9341
9331
  &_swigt__p_svn_config_t,
9342
9332
  &_swigt__p_svn_delta_editor_t,
9343
9333
  &_swigt__p_svn_depth_t,
 
9334
  &_swigt__p_svn_diff_hunk_t,
9344
9335
  &_swigt__p_svn_dirent_t,
9345
9336
  &_swigt__p_svn_errno_t,
9346
9337
  &_swigt__p_svn_error_t,
 
9338
  &_swigt__p_svn_fs_lock_target_t,
9347
9339
  &_swigt__p_svn_io_dirent2_t,
9348
9340
  &_swigt__p_svn_io_dirent_t,
9349
9341
  &_swigt__p_svn_io_file_del_t,
9438
9430
static swig_cast_info _swigc__p_svn_config_t[] = {  {&_swigt__p_svn_config_t, 0, 0, 0},{0, 0, 0, 0}};
9439
9431
static swig_cast_info _swigc__p_svn_delta_editor_t[] = {  {&_swigt__p_svn_delta_editor_t, 0, 0, 0},{0, 0, 0, 0}};
9440
9432
static swig_cast_info _swigc__p_svn_depth_t[] = {  {&_swigt__p_svn_depth_t, 0, 0, 0},{0, 0, 0, 0}};
 
9433
static swig_cast_info _swigc__p_svn_diff_hunk_t[] = {  {&_swigt__p_svn_diff_hunk_t, 0, 0, 0},{0, 0, 0, 0}};
9441
9434
static swig_cast_info _swigc__p_svn_dirent_t[] = {  {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
9442
9435
static swig_cast_info _swigc__p_svn_errno_t[] = {  {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
9443
9436
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
9437
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}};
9444
9438
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
9445
9439
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
9446
9440
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}};
9535
9529
  _swigc__p_svn_config_t,
9536
9530
  _swigc__p_svn_delta_editor_t,
9537
9531
  _swigc__p_svn_depth_t,
 
9532
  _swigc__p_svn_diff_hunk_t,
9538
9533
  _swigc__p_svn_dirent_t,
9539
9534
  _swigc__p_svn_errno_t,
9540
9535
  _swigc__p_svn_error_t,
 
9536
  _swigc__p_svn_fs_lock_target_t,
9541
9537
  _swigc__p_svn_io_dirent2_t,
9542
9538
  _swigc__p_svn_io_dirent_t,
9543
9539
  _swigc__p_svn_io_file_del_t,
9586
9582
#endif
9587
9583
/* -----------------------------------------------------------------------------
9588
9584
 * Type initialization:
9589
 
 * This problem is tough by the requirement that no dynamic 
9590
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
9585
 * This problem is tough by the requirement that no dynamic
 
9586
 * memory is used. Also, since swig_type_info structures store pointers to
9591
9587
 * swig_cast_info structures and swig_cast_info structures store pointers back
9592
 
 * to swig_type_info structures, we need some lookup code at initialization. 
9593
 
 * The idea is that swig generates all the structures that are needed. 
9594
 
 * The runtime then collects these partially filled structures. 
9595
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
9588
 * to swig_type_info structures, we need some lookup code at initialization.
 
9589
 * The idea is that swig generates all the structures that are needed.
 
9590
 * The runtime then collects these partially filled structures.
 
9591
 * The SWIG_InitializeModule function takes these initial arrays out of
9596
9592
 * swig_module, and does all the lookup, filling in the swig_module.types
9597
9593
 * array with the correct data and linking the correct swig_cast_info
9598
9594
 * structures together.
9599
9595
 *
9600
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
9596
 * The generated swig_type_info structures are assigned staticly to an initial
9601
9597
 * array. We just loop through that array, and handle each type individually.
9602
9598
 * First we lookup if this type has been already loaded, and if so, use the
9603
9599
 * loaded structure instead of the generated one. Then we have to fill in the
9607
9603
 * a column is one of the swig_cast_info structures for that type.
9608
9604
 * The cast_initial array is actually an array of arrays, because each row has
9609
9605
 * a variable number of columns. So to actually build the cast linked list,
9610
 
 * we find the array of casts associated with the type, and loop through it 
 
9606
 * we find the array of casts associated with the type, and loop through it
9611
9607
 * adding the casts to the list. The one last trick we need to do is making
9612
9608
 * sure the type pointer in the swig_cast_info struct is correct.
9613
9609
 *
9614
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
9610
 * First off, we lookup the cast->type name to see if it is already loaded.
9615
9611
 * There are three cases to handle:
9616
9612
 *  1) If the cast->type has already been loaded AND the type we are adding
9617
9613
 *     casting info to has not been loaded (it is in this module), THEN we
9618
9614
 *     replace the cast->type pointer with the type pointer that has already
9619
9615
 *     been loaded.
9620
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
9616
 *  2) If BOTH types (the one we are adding casting info to, and the
9621
9617
 *     cast->type) are loaded, THEN the cast info has already been loaded by
9622
9618
 *     the previous module so we just ignore it.
9623
9619
 *  3) Finally, if cast->type has not already been loaded, then we add that
9680
9676
    module_head->next = &swig_module;
9681
9677
  }
9682
9678
  
9683
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
9679
  /* When multiple interpreters are used, a module could have already been initialized in
9684
9680
       a different interpreter, but not yet have a pointer in this interpreter.
9685
9681
       In this case, we do not want to continue adding types... everything should be
9686
9682
       set up already */