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

« back to all changes in this revision

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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 2.0.9
4
 
 * 
5
 
 * This file is not intended to be easily readable and contains a number of 
 
3
 * Version 2.0.12
 
4
 *
 
5
 * This file is not intended to be easily readable and contains a number of
6
6
 * coding conventions designed to improve portability and efficiency. Do not make
7
 
 * changes to this file unless you know what you are doing--modify the SWIG 
8
 
 * interface file instead. 
 
7
 * changes to this file unless you know what you are doing--modify the SWIG
 
8
 * interface file instead.
9
9
 * ----------------------------------------------------------------------------- */
10
10
 
11
11
#define SWIGPYTHON
43
43
#ifndef SWIGUNUSED
44
44
# if defined(__GNUC__)
45
45
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
46
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
46
#     define SWIGUNUSED __attribute__ ((__unused__))
47
47
#   else
48
48
#     define SWIGUNUSED
49
49
#   endif
50
50
# elif defined(__ICC)
51
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
 
51
#   define SWIGUNUSED __attribute__ ((__unused__))
52
52
# else
53
 
#   define SWIGUNUSED 
 
53
#   define SWIGUNUSED
54
54
# endif
55
55
#endif
56
56
 
57
57
#ifndef SWIG_MSC_UNSUPPRESS_4505
58
58
# if defined(_MSC_VER)
59
59
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
60
 
# endif 
 
60
# endif
61
61
#endif
62
62
 
63
63
#ifndef SWIGUNUSEDPARM
64
64
# ifdef __cplusplus
65
65
#   define SWIGUNUSEDPARM(p)
66
66
# else
67
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
67
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
68
68
# endif
69
69
#endif
70
70
 
107
107
#   define SWIGSTDCALL __stdcall
108
108
# else
109
109
#   define SWIGSTDCALL
110
 
# endif 
 
110
# endif
111
111
#endif
112
112
 
113
113
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
122
122
 
123
123
 
124
124
 
125
 
/* Python.h has to appear first */
126
 
#include <Python.h>
 
125
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
 
126
/* Use debug wrappers with the Python release dll */
 
127
# undef _DEBUG
 
128
# include <Python.h>
 
129
# define _DEBUG
 
130
#else
 
131
# include <Python.h>
 
132
#endif
127
133
 
128
134
/* -----------------------------------------------------------------------------
129
135
 * swigrun.swg
149
155
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
150
156
  creating a static or dynamic library from the SWIG runtime code.
151
157
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
152
 
  
 
158
 
153
159
  But only do this if strictly necessary, ie, if you have problems
154
160
  with your compiler or suchlike.
155
161
*/
175
181
#define SWIG_POINTER_OWN           0x1
176
182
 
177
183
 
178
 
/* 
 
184
/*
179
185
   Flags/methods for returning states.
180
 
   
181
 
   The SWIG conversion methods, as ConvertPtr, return an integer 
 
186
 
 
187
   The SWIG conversion methods, as ConvertPtr, return an integer
182
188
   that tells if the conversion was successful or not. And if not,
183
189
   an error code can be returned (see swigerrors.swg for the codes).
184
 
   
 
190
 
185
191
   Use the following macros/flags to set or process the returning
186
192
   states.
187
 
   
 
193
 
188
194
   In old versions of SWIG, code such as the following was usually written:
189
195
 
190
196
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
217
223
    } else {
218
224
      // fail code
219
225
    }
220
 
    
 
226
 
221
227
   I.e., now SWIG_ConvertPtr can return new objects and you can
222
228
   identify the case and take care of the deallocation. Of course that
223
229
   also requires SWIG_ConvertPtr to return new result values, such as
224
230
 
225
 
      int SWIG_ConvertPtr(obj, ptr,...) {         
226
 
        if (<obj is ok>) {                             
227
 
          if (<need new object>) {                     
228
 
            *ptr = <ptr to new allocated object>; 
229
 
            return SWIG_NEWOBJ;                
230
 
          } else {                                     
231
 
            *ptr = <ptr to old object>;        
232
 
            return SWIG_OLDOBJ;                
233
 
          }                                    
234
 
        } else {                                       
235
 
          return SWIG_BADOBJ;                  
236
 
        }                                              
 
231
      int SWIG_ConvertPtr(obj, ptr,...) {
 
232
        if (<obj is ok>) {
 
233
          if (<need new object>) {
 
234
            *ptr = <ptr to new allocated object>;
 
235
            return SWIG_NEWOBJ;
 
236
          } else {
 
237
            *ptr = <ptr to old object>;
 
238
            return SWIG_OLDOBJ;
 
239
          }
 
240
        } else {
 
241
          return SWIG_BADOBJ;
 
242
        }
237
243
      }
238
244
 
239
245
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
247
253
       int fooi(int);
248
254
 
249
255
   and you call
250
 
 
 
256
 
251
257
      food(1)   // cast rank '1'  (1 -> 1.0)
252
258
      fooi(1)   // cast rank '0'
253
259
 
254
260
   just use the SWIG_AddCast()/SWIG_CheckState()
255
261
*/
256
262
 
257
 
#define SWIG_OK                    (0) 
 
263
#define SWIG_OK                    (0)
258
264
#define SWIG_ERROR                 (-1)
259
265
#define SWIG_IsOK(r)               (r >= 0)
260
 
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
 
266
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
261
267
 
262
268
/* The CastRankLimit says how many bits are used for the cast rank */
263
269
#define SWIG_CASTRANKLIMIT         (1 << 8)
288
294
#  endif
289
295
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
290
296
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
291
 
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
 
297
SWIGINTERNINLINE int SWIG_AddCast(int r) {
292
298
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
293
299
}
294
 
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
295
 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
 
300
SWIGINTERNINLINE int SWIG_CheckState(int r) {
 
301
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
296
302
}
297
303
#else /* no cast-rank mode */
298
 
#  define SWIG_AddCast
 
304
#  define SWIG_AddCast(r) (r)
299
305
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
300
306
#endif
301
307
 
339
345
  void                    *clientdata;          /* Language specific module data */
340
346
} swig_module_info;
341
347
 
342
 
/* 
 
348
/*
343
349
  Compare two type names skipping the space characters, therefore
344
350
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
345
351
 
359
365
 
360
366
/*
361
367
  Check type equivalence in a name list like <name1>|<name2>|...
 
368
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 
369
*/
 
370
SWIGRUNTIME int
 
371
SWIG_TypeCmp(const char *nb, const char *tb) {
 
372
  int equiv = 1;
 
373
  const char* te = tb + strlen(tb);
 
374
  const char* ne = nb;
 
375
  while (equiv != 0 && *ne) {
 
376
    for (nb = ne; *ne; ++ne) {
 
377
      if (*ne == '|') break;
 
378
    }
 
379
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
 
380
    if (*ne) ++ne;
 
381
  }
 
382
  return equiv;
 
383
}
 
384
 
 
385
/*
 
386
  Check type equivalence in a name list like <name1>|<name2>|...
362
387
  Return 0 if not equal, 1 if equal
363
388
*/
364
389
SWIGRUNTIME int
365
390
SWIG_TypeEquiv(const char *nb, const char *tb) {
366
 
  int equiv = 0;
367
 
  const char* te = tb + strlen(tb);
368
 
  const char* ne = nb;
369
 
  while (!equiv && *ne) {
370
 
    for (nb = ne; *ne; ++ne) {
371
 
      if (*ne == '|') break;
372
 
    }
373
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
374
 
    if (*ne) ++ne;
375
 
  }
376
 
  return equiv;
377
 
}
378
 
 
379
 
/*
380
 
  Check type equivalence in a name list like <name1>|<name2>|...
381
 
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
382
 
*/
383
 
SWIGRUNTIME int
384
 
SWIG_TypeCompare(const char *nb, const char *tb) {
385
 
  int equiv = 0;
386
 
  const char* te = tb + strlen(tb);
387
 
  const char* ne = nb;
388
 
  while (!equiv && *ne) {
389
 
    for (nb = ne; *ne; ++ne) {
390
 
      if (*ne == '|') break;
391
 
    }
392
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
393
 
    if (*ne) ++ne;
394
 
  }
395
 
  return equiv;
396
 
}
397
 
 
 
391
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 
392
}
398
393
 
399
394
/*
400
395
  Check the typename
423
418
  return 0;
424
419
}
425
420
 
426
 
/* 
 
421
/*
427
422
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
428
423
*/
429
424
SWIGRUNTIME swig_cast_info *
458
453
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
459
454
}
460
455
 
461
 
/* 
 
456
/*
462
457
   Dynamic pointer casting. Down an inheritance hierarchy
463
458
*/
464
459
SWIGRUNTIME swig_type_info *
502
497
    return type->name;
503
498
}
504
499
 
505
 
/* 
 
500
/*
506
501
   Set the clientdata field for a type
507
502
*/
508
503
SWIGRUNTIME void
510
505
  swig_cast_info *cast = ti->cast;
511
506
  /* if (ti->clientdata == clientdata) return; */
512
507
  ti->clientdata = clientdata;
513
 
  
 
508
 
514
509
  while (cast) {
515
510
    if (!cast->converter) {
516
511
      swig_type_info *tc = cast->type;
517
512
      if (!tc->clientdata) {
518
513
        SWIG_TypeClientData(tc, clientdata);
519
514
      }
520
 
    }    
 
515
    }
521
516
    cast = cast->next;
522
517
  }
523
518
}
526
521
  SWIG_TypeClientData(ti, clientdata);
527
522
  ti->owndata = 1;
528
523
}
529
 
  
 
524
 
530
525
/*
531
526
  Search for a swig_type_info structure only by mangled name
532
527
  Search is a O(log #types)
533
 
  
534
 
  We start searching at module start, and finish searching when start == end.  
 
528
 
 
529
  We start searching at module start, and finish searching when start == end.
535
530
  Note: if start == end at the beginning of the function, we go all the way around
536
531
  the circular list.
537
532
*/
538
533
SWIGRUNTIME swig_type_info *
539
 
SWIG_MangledTypeQueryModule(swig_module_info *start, 
540
 
                            swig_module_info *end, 
 
534
SWIG_MangledTypeQueryModule(swig_module_info *start,
 
535
                            swig_module_info *end,
541
536
                            const char *name) {
542
537
  swig_module_info *iter = start;
543
538
  do {
546
541
      register size_t r = iter->size - 1;
547
542
      do {
548
543
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
549
 
        register size_t i = (l + r) >> 1; 
 
544
        register size_t i = (l + r) >> 1;
550
545
        const char *iname = iter->types[i]->name;
551
546
        if (iname) {
552
547
          register int compare = strcmp(name, iname);
553
 
          if (compare == 0) {       
 
548
          if (compare == 0) {
554
549
            return iter->types[i];
555
550
          } else if (compare < 0) {
556
551
            if (i) {
575
570
  Search for a swig_type_info structure for either a mangled name or a human readable name.
576
571
  It first searches the mangled names of the types, which is a O(log #types)
577
572
  If a type is not found it then searches the human readable names, which is O(#types).
578
 
  
579
 
  We start searching at module start, and finish searching when start == end.  
 
573
 
 
574
  We start searching at module start, and finish searching when start == end.
580
575
  Note: if start == end at the beginning of the function, we go all the way around
581
576
  the circular list.
582
577
*/
583
578
SWIGRUNTIME swig_type_info *
584
 
SWIG_TypeQueryModule(swig_module_info *start, 
585
 
                     swig_module_info *end, 
 
579
SWIG_TypeQueryModule(swig_module_info *start,
 
580
                     swig_module_info *end,
586
581
                     const char *name) {
587
582
  /* STEP 1: Search the name field using binary search */
588
583
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
601
596
      iter = iter->next;
602
597
    } while (iter != end);
603
598
  }
604
 
  
 
599
 
605
600
  /* neither found a match */
606
601
  return 0;
607
602
}
608
603
 
609
 
/* 
 
604
/*
610
605
   Pack binary data into a string
611
606
*/
612
607
SWIGRUNTIME char *
622
617
  return c;
623
618
}
624
619
 
625
 
/* 
 
620
/*
626
621
   Unpack binary data from a string
627
622
*/
628
623
SWIGRUNTIME const char *
636
631
      uu = ((d - '0') << 4);
637
632
    else if ((d >= 'a') && (d <= 'f'))
638
633
      uu = ((d - ('a'-10)) << 4);
639
 
    else 
 
634
    else
640
635
      return (char *) 0;
641
636
    d = *(c++);
642
637
    if ((d >= '0') && (d <= '9'))
643
638
      uu |= (d - '0');
644
639
    else if ((d >= 'a') && (d <= 'f'))
645
640
      uu |= (d - ('a'-10));
646
 
    else 
 
641
    else
647
642
      return (char *) 0;
648
643
    *u = uu;
649
644
  }
650
645
  return c;
651
646
}
652
647
 
653
 
/* 
 
648
/*
654
649
   Pack 'void *' into a string buffer.
655
650
*/
656
651
SWIGRUNTIME char *
710
705
#endif
711
706
 
712
707
/*  Errors in SWIG */
713
 
#define  SWIG_UnknownError         -1 
714
 
#define  SWIG_IOError              -2 
715
 
#define  SWIG_RuntimeError         -3 
716
 
#define  SWIG_IndexError           -4 
717
 
#define  SWIG_TypeError            -5 
718
 
#define  SWIG_DivisionByZero       -6 
719
 
#define  SWIG_OverflowError        -7 
720
 
#define  SWIG_SyntaxError          -8 
721
 
#define  SWIG_ValueError           -9 
 
708
#define  SWIG_UnknownError         -1
 
709
#define  SWIG_IOError              -2
 
710
#define  SWIG_RuntimeError         -3
 
711
#define  SWIG_IndexError           -4
 
712
#define  SWIG_TypeError            -5
 
713
#define  SWIG_DivisionByZero       -6
 
714
#define  SWIG_OverflowError        -7
 
715
#define  SWIG_SyntaxError          -8
 
716
#define  SWIG_ValueError           -9
722
717
#define  SWIG_SystemError          -10
723
718
#define  SWIG_AttributeError       -11
724
 
#define  SWIG_MemoryError          -12 
 
719
#define  SWIG_MemoryError          -12
725
720
#define  SWIG_NullReferenceError   -13
726
721
 
727
722
 
1582
1577
}
1583
1578
 
1584
1579
SWIGRUNTIME int
1585
 
SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1586
 
{
1587
 
  char *str;
1588
 
#ifdef METH_NOARGS
1589
 
  PyObject *repr = SwigPyObject_repr(v);
1590
 
#else
1591
 
  PyObject *repr = SwigPyObject_repr(v, NULL);
1592
 
#endif
1593
 
  if (repr) {
1594
 
    str = SWIG_Python_str_AsChar(repr); 
1595
 
    fputs(str, fp);
1596
 
    SWIG_Python_str_DelForPy3(str);
1597
 
    Py_DECREF(repr);
1598
 
    return 0; 
1599
 
  } else {
1600
 
    return 1; 
1601
 
  }
1602
 
}
1603
 
 
1604
 
SWIGRUNTIME PyObject *
1605
 
SwigPyObject_str(SwigPyObject *v)
1606
 
{
1607
 
  char result[SWIG_BUFFER_SIZE];
1608
 
  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1609
 
    SWIG_Python_str_FromChar(result) : 0;
1610
 
}
1611
 
 
1612
 
SWIGRUNTIME int
1613
1580
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1614
1581
{
1615
1582
  void *i = v->ptr;
1801
1768
static PyMethodDef
1802
1769
swigobject_methods[] = {
1803
1770
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1804
 
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
 
1771
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
1805
1772
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1806
1773
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
1807
1774
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1894
1861
      sizeof(SwigPyObject),                 /* tp_basicsize */
1895
1862
      0,                                    /* tp_itemsize */
1896
1863
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
1897
 
      (printfunc)SwigPyObject_print,        /* tp_print */
 
1864
      0,                                    /* tp_print */
1898
1865
#if PY_VERSION_HEX < 0x02020000
1899
1866
      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
1900
1867
#else
1912
1879
      0,                                    /* tp_as_mapping */
1913
1880
      (hashfunc)0,                          /* tp_hash */
1914
1881
      (ternaryfunc)0,                       /* tp_call */
1915
 
      (reprfunc)SwigPyObject_str,           /* tp_str */
 
1882
      0,                                    /* tp_str */
1916
1883
      PyObject_GenericGetAttr,              /* tp_getattro */
1917
1884
      0,                                    /* tp_setattro */
1918
1885
      0,                                    /* tp_as_buffer */
2289
2256
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2290
2257
  int res;
2291
2258
  SwigPyObject *sobj;
 
2259
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2292
2260
 
2293
2261
  if (!obj)
2294
2262
    return SWIG_ERROR;
2295
 
  if (obj == Py_None) {
 
2263
  if (obj == Py_None && !implicit_conv) {
2296
2264
    if (ptr)
2297
2265
      *ptr = 0;
2298
2266
    return SWIG_OK;
2341
2309
    }
2342
2310
    res = SWIG_OK;
2343
2311
  } else {
2344
 
    if (flags & SWIG_POINTER_IMPLICIT_CONV) {
 
2312
    if (implicit_conv) {
2345
2313
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2346
2314
      if (data && !data->implicitconv) {
2347
2315
        PyObject *klass = data->klass;
2376
2344
        }
2377
2345
      }
2378
2346
    }
 
2347
    if (!SWIG_IsOK(res) && obj == Py_None) {
 
2348
      if (ptr)
 
2349
        *ptr = 0;
 
2350
      if (PyErr_Occurred())
 
2351
        PyErr_Clear();
 
2352
      res = SWIG_OK;
 
2353
    }
2379
2354
  }
2380
2355
  return res;
2381
2356
}
2875
2850
  PyObject *descr;
2876
2851
  PyObject *encoded_name;
2877
2852
  descrsetfunc f;
2878
 
  int res;
 
2853
  int res = -1;
2879
2854
 
2880
2855
# ifdef Py_USING_UNICODE
2881
2856
  if (PyString_Check(name)) {
2898
2873
      goto done;
2899
2874
  }
2900
2875
 
2901
 
  res = -1;
2902
2876
  descr = _PyType_Lookup(tp, name);
2903
2877
  f = NULL;
2904
2878
  if (descr != NULL)
2960
2934
#define SWIGTYPE_p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t swig_types[17]
2961
2935
#define SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[18]
2962
2936
#define SWIGTYPE_p_f_p_void_p_q_const__char__p_svn_error_t swig_types[19]
2963
 
#define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t swig_types[20]
2964
 
#define SWIGTYPE_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 swig_types[21]
2965
 
#define SWIGTYPE_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 swig_types[22]
2966
 
#define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[23]
2967
 
#define SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void swig_types[24]
2968
 
#define SWIGTYPE_p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t swig_types[25]
2969
 
#define SWIGTYPE_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[26]
2970
 
#define SWIGTYPE_p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t swig_types[27]
2971
 
#define SWIGTYPE_p_int swig_types[28]
2972
 
#define SWIGTYPE_p_long swig_types[29]
2973
 
#define SWIGTYPE_p_p_apr_array_header_t swig_types[30]
2974
 
#define SWIGTYPE_p_p_apr_hash_t swig_types[31]
2975
 
#define SWIGTYPE_p_p_char swig_types[32]
2976
 
#define SWIGTYPE_p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[33]
2977
 
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[34]
2978
 
#define SWIGTYPE_p_p_f_p_void__p_svn_error_t swig_types[35]
2979
 
#define SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[36]
2980
 
#define SWIGTYPE_p_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[37]
2981
 
#define 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 swig_types[38]
2982
 
#define 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 swig_types[39]
2983
 
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[40]
2984
 
#define SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void swig_types[41]
2985
 
#define SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[42]
2986
 
#define SWIGTYPE_p_p_svn_authz_t swig_types[43]
2987
 
#define SWIGTYPE_p_p_svn_delta_editor_t swig_types[44]
2988
 
#define SWIGTYPE_p_p_svn_dirent_t swig_types[45]
2989
 
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[46]
2990
 
#define SWIGTYPE_p_p_svn_lock_t swig_types[47]
2991
 
#define SWIGTYPE_p_p_svn_repos_parse_fns2_t swig_types[48]
2992
 
#define SWIGTYPE_p_p_svn_repos_parse_fns3_t swig_types[49]
2993
 
#define SWIGTYPE_p_p_svn_repos_parse_fns_t swig_types[50]
2994
 
#define SWIGTYPE_p_p_svn_repos_t swig_types[51]
2995
 
#define SWIGTYPE_p_p_svn_stream_t swig_types[52]
2996
 
#define SWIGTYPE_p_p_svn_string_t swig_types[53]
2997
 
#define SWIGTYPE_p_p_void swig_types[54]
2998
 
#define SWIGTYPE_p_svn_auth_baton_t swig_types[55]
2999
 
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[56]
3000
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[57]
3001
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[58]
3002
 
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[59]
3003
 
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[60]
3004
 
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[61]
3005
 
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[62]
3006
 
#define SWIGTYPE_p_svn_auth_provider_t swig_types[63]
3007
 
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[64]
3008
 
#define SWIGTYPE_p_svn_authz_t swig_types[65]
3009
 
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[66]
3010
 
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[67]
3011
 
#define SWIGTYPE_p_svn_checksum_t swig_types[68]
3012
 
#define SWIGTYPE_p_svn_commit_info_t swig_types[69]
3013
 
#define SWIGTYPE_p_svn_config_t swig_types[70]
3014
 
#define SWIGTYPE_p_svn_delta_editor_t swig_types[71]
3015
 
#define SWIGTYPE_p_svn_depth_t swig_types[72]
3016
 
#define SWIGTYPE_p_svn_dirent_t swig_types[73]
3017
 
#define SWIGTYPE_p_svn_errno_t swig_types[74]
3018
 
#define SWIGTYPE_p_svn_error_t swig_types[75]
3019
 
#define SWIGTYPE_p_svn_fs_access_t swig_types[76]
3020
 
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[77]
3021
 
#define SWIGTYPE_p_svn_fs_history_t swig_types[78]
3022
 
#define SWIGTYPE_p_svn_fs_id_t swig_types[79]
3023
 
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[80]
3024
 
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[81]
3025
 
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[82]
3026
 
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[83]
3027
 
#define SWIGTYPE_p_svn_fs_root_t swig_types[84]
3028
 
#define SWIGTYPE_p_svn_fs_t swig_types[85]
3029
 
#define SWIGTYPE_p_svn_fs_txn_t swig_types[86]
3030
 
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[87]
3031
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[88]
3032
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[89]
3033
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[90]
3034
 
#define SWIGTYPE_p_svn_lock_t swig_types[91]
3035
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[92]
3036
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[93]
3037
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[94]
3038
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[95]
3039
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[96]
3040
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[97]
3041
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[98]
3042
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[99]
3043
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[100]
3044
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[101]
3045
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[102]
3046
 
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[103]
3047
 
#define SWIGTYPE_p_svn_prop_kind swig_types[104]
3048
 
#define SWIGTYPE_p_svn_repos_authz_access_t swig_types[105]
3049
 
#define SWIGTYPE_p_svn_repos_node_t swig_types[106]
3050
 
#define SWIGTYPE_p_svn_repos_notify_action_t swig_types[107]
3051
 
#define SWIGTYPE_p_svn_repos_notify_t swig_types[108]
3052
 
#define SWIGTYPE_p_svn_repos_notify_warning_t swig_types[109]
3053
 
#define SWIGTYPE_p_svn_repos_parse_fns2_t swig_types[110]
3054
 
#define SWIGTYPE_p_svn_repos_parse_fns3_t swig_types[111]
3055
 
#define SWIGTYPE_p_svn_repos_parse_fns_t swig_types[112]
3056
 
#define SWIGTYPE_p_svn_repos_revision_access_level_t swig_types[113]
3057
 
#define SWIGTYPE_p_svn_repos_t swig_types[114]
3058
 
#define SWIGTYPE_p_svn_stream_mark_t swig_types[115]
3059
 
#define SWIGTYPE_p_svn_stream_t swig_types[116]
3060
 
#define SWIGTYPE_p_svn_string_t swig_types[117]
3061
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[118]
3062
 
#define SWIGTYPE_p_svn_tristate_t swig_types[119]
3063
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[120]
3064
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[121]
3065
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[122]
3066
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[123]
3067
 
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[124]
3068
 
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[125]
3069
 
#define SWIGTYPE_p_svn_version_extended_t swig_types[126]
3070
 
#define SWIGTYPE_p_svn_version_t swig_types[127]
3071
 
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[128]
3072
 
#define SWIGTYPE_p_unsigned_long swig_types[129]
3073
 
#define SWIGTYPE_p_void swig_types[130]
3074
 
static swig_type_info *swig_types[132];
3075
 
static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
 
2937
#define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t swig_types[20]
 
2938
#define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t swig_types[21]
 
2939
#define SWIGTYPE_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 swig_types[22]
 
2940
#define SWIGTYPE_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 swig_types[23]
 
2941
#define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[24]
 
2942
#define SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void swig_types[25]
 
2943
#define SWIGTYPE_p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t swig_types[26]
 
2944
#define SWIGTYPE_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t swig_types[27]
 
2945
#define SWIGTYPE_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[28]
 
2946
#define SWIGTYPE_p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t swig_types[29]
 
2947
#define SWIGTYPE_p_int swig_types[30]
 
2948
#define SWIGTYPE_p_long swig_types[31]
 
2949
#define SWIGTYPE_p_p_apr_array_header_t swig_types[32]
 
2950
#define SWIGTYPE_p_p_apr_hash_t swig_types[33]
 
2951
#define SWIGTYPE_p_p_char swig_types[34]
 
2952
#define SWIGTYPE_p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[35]
 
2953
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[36]
 
2954
#define SWIGTYPE_p_p_f_p_void__p_svn_error_t swig_types[37]
 
2955
#define SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[38]
 
2956
#define SWIGTYPE_p_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[39]
 
2957
#define 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 swig_types[40]
 
2958
#define 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 swig_types[41]
 
2959
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[42]
 
2960
#define SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void swig_types[43]
 
2961
#define SWIGTYPE_p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t swig_types[44]
 
2962
#define SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[45]
 
2963
#define SWIGTYPE_p_p_svn_authz_t swig_types[46]
 
2964
#define SWIGTYPE_p_p_svn_delta_editor_t swig_types[47]
 
2965
#define SWIGTYPE_p_p_svn_dirent_t swig_types[48]
 
2966
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[49]
 
2967
#define SWIGTYPE_p_p_svn_lock_t swig_types[50]
 
2968
#define SWIGTYPE_p_p_svn_repos_parse_fns2_t swig_types[51]
 
2969
#define SWIGTYPE_p_p_svn_repos_parse_fns3_t swig_types[52]
 
2970
#define SWIGTYPE_p_p_svn_repos_parse_fns_t swig_types[53]
 
2971
#define SWIGTYPE_p_p_svn_repos_t swig_types[54]
 
2972
#define SWIGTYPE_p_p_svn_stream_t swig_types[55]
 
2973
#define SWIGTYPE_p_p_svn_string_t swig_types[56]
 
2974
#define SWIGTYPE_p_p_svn_version_t swig_types[57]
 
2975
#define SWIGTYPE_p_p_void swig_types[58]
 
2976
#define SWIGTYPE_p_svn_auth_baton_t swig_types[59]
 
2977
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[60]
 
2978
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[61]
 
2979
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[62]
 
2980
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[63]
 
2981
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[64]
 
2982
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[65]
 
2983
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[66]
 
2984
#define SWIGTYPE_p_svn_auth_provider_t swig_types[67]
 
2985
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[68]
 
2986
#define SWIGTYPE_p_svn_authz_t swig_types[69]
 
2987
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[70]
 
2988
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[71]
 
2989
#define SWIGTYPE_p_svn_checksum_t swig_types[72]
 
2990
#define SWIGTYPE_p_svn_commit_info_t swig_types[73]
 
2991
#define SWIGTYPE_p_svn_config_t swig_types[74]
 
2992
#define SWIGTYPE_p_svn_delta_editor_t swig_types[75]
 
2993
#define SWIGTYPE_p_svn_depth_t swig_types[76]
 
2994
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[77]
 
2995
#define SWIGTYPE_p_svn_dirent_t swig_types[78]
 
2996
#define SWIGTYPE_p_svn_errno_t swig_types[79]
 
2997
#define SWIGTYPE_p_svn_error_t swig_types[80]
 
2998
#define SWIGTYPE_p_svn_fs_access_t swig_types[81]
 
2999
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[82]
 
3000
#define SWIGTYPE_p_svn_fs_fsfs_info_t swig_types[83]
 
3001
#define SWIGTYPE_p_svn_fs_fsx_info_t swig_types[84]
 
3002
#define SWIGTYPE_p_svn_fs_history_t swig_types[85]
 
3003
#define SWIGTYPE_p_svn_fs_id_t swig_types[86]
 
3004
#define SWIGTYPE_p_svn_fs_info_placeholder_t swig_types[87]
 
3005
#define SWIGTYPE_p_svn_fs_lock_target_t swig_types[88]
 
3006
#define SWIGTYPE_p_svn_fs_node_relation_t swig_types[89]
 
3007
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[90]
 
3008
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[91]
 
3009
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[92]
 
3010
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[93]
 
3011
#define SWIGTYPE_p_svn_fs_root_t swig_types[94]
 
3012
#define SWIGTYPE_p_svn_fs_t swig_types[95]
 
3013
#define SWIGTYPE_p_svn_fs_txn_t swig_types[96]
 
3014
#define SWIGTYPE_p_svn_fs_upgrade_notify_action_t swig_types[97]
 
3015
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[98]
 
3016
#define SWIGTYPE_p_svn_io_dirent_t swig_types[99]
 
3017
#define SWIGTYPE_p_svn_io_file_del_t swig_types[100]
 
3018
#define SWIGTYPE_p_svn_location_segment_t swig_types[101]
 
3019
#define SWIGTYPE_p_svn_lock_t swig_types[102]
 
3020
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[103]
 
3021
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[104]
 
3022
#define SWIGTYPE_p_svn_log_entry_t swig_types[105]
 
3023
#define SWIGTYPE_p_svn_merge_range_t swig_types[106]
 
3024
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[107]
 
3025
#define SWIGTYPE_p_svn_node_kind_t swig_types[108]
 
3026
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[109]
 
3027
#define SWIGTYPE_p_svn_opt_revision_t swig_types[110]
 
3028
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[111]
 
3029
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[112]
 
3030
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[113]
 
3031
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[114]
 
3032
#define SWIGTYPE_p_svn_prop_kind swig_types[115]
 
3033
#define SWIGTYPE_p_svn_repos_authz_access_t swig_types[116]
 
3034
#define SWIGTYPE_p_svn_repos_node_t swig_types[117]
 
3035
#define SWIGTYPE_p_svn_repos_notify_action_t swig_types[118]
 
3036
#define SWIGTYPE_p_svn_repos_notify_t swig_types[119]
 
3037
#define SWIGTYPE_p_svn_repos_notify_warning_t swig_types[120]
 
3038
#define SWIGTYPE_p_svn_repos_parse_fns2_t swig_types[121]
 
3039
#define SWIGTYPE_p_svn_repos_parse_fns3_t swig_types[122]
 
3040
#define SWIGTYPE_p_svn_repos_parse_fns_t swig_types[123]
 
3041
#define SWIGTYPE_p_svn_repos_revision_access_level_t swig_types[124]
 
3042
#define SWIGTYPE_p_svn_repos_t swig_types[125]
 
3043
#define SWIGTYPE_p_svn_stream_mark_t swig_types[126]
 
3044
#define SWIGTYPE_p_svn_stream_t swig_types[127]
 
3045
#define SWIGTYPE_p_svn_string_t swig_types[128]
 
3046
#define SWIGTYPE_p_svn_stringbuf_t swig_types[129]
 
3047
#define SWIGTYPE_p_svn_tristate_t swig_types[130]
 
3048
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[131]
 
3049
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[132]
 
3050
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[133]
 
3051
#define SWIGTYPE_p_svn_version_checklist_t swig_types[134]
 
3052
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[135]
 
3053
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[136]
 
3054
#define SWIGTYPE_p_svn_version_extended_t swig_types[137]
 
3055
#define SWIGTYPE_p_svn_version_t swig_types[138]
 
3056
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[139]
 
3057
#define SWIGTYPE_p_unsigned_long swig_types[140]
 
3058
#define SWIGTYPE_p_void swig_types[141]
 
3059
static swig_type_info *swig_types[143];
 
3060
static swig_module_info swig_module = {swig_types, 142, 0, 0, 0, 0};
3076
3061
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3077
3062
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3078
3063
 
3096
3081
#endif
3097
3082
#define SWIG_name    "_repos"
3098
3083
 
3099
 
#define SWIGVERSION 0x020009 
 
3084
#define SWIGVERSION 0x020012 
3100
3085
#define SWIG_VERSION SWIGVERSION
3101
3086
 
3102
3087
 
3445
3430
      return SWIG_OK;
3446
3431
    } else {
3447
3432
      PyErr_Clear();
 
3433
#if PY_VERSION_HEX >= 0x03000000
 
3434
      {
 
3435
        long v = PyLong_AsLong(obj);
 
3436
        if (!PyErr_Occurred()) {
 
3437
          if (v < 0) {
 
3438
            return SWIG_OverflowError;
 
3439
          }
 
3440
        } else {
 
3441
          PyErr_Clear();
 
3442
        }
 
3443
      }
 
3444
#endif
3448
3445
    }
3449
3446
  }
3450
3447
#ifdef SWIG_PYTHON_CAST_MODE
3672
3669
  return _obj(required, allowed, root, path, baton, pool);
3673
3670
}
3674
3671
 
3675
 
static svn_error_t * svn_repos_invoke_file_rev_handler(
3676
 
  svn_repos_file_rev_handler_t _obj, void *baton, const char *path, svn_revnum_t rev, apr_hash_t *rev_props, svn_txdelta_window_handler_t *delta_handler, void **delta_baton, apr_array_header_t *prop_diffs, apr_pool_t *pool) {
3677
 
  return _obj(baton, path, rev, rev_props, delta_handler, delta_baton, prop_diffs, pool);
3678
 
}
3679
 
 
3680
3672
static void svn_repos_invoke_notify_func(
3681
3673
  svn_repos_notify_func_t _obj, void *baton, const svn_repos_notify_t *notify, apr_pool_t *scratch_pool) {
3682
3674
  _obj(baton, notify, scratch_pool);
3692
3684
  return _obj(baton, path, revision, pool);
3693
3685
}
3694
3686
 
 
3687
static svn_error_t * svn_repos_invoke_file_rev_handler(
 
3688
  svn_repos_file_rev_handler_t _obj, void *baton, const char *path, svn_revnum_t rev, apr_hash_t *rev_props, svn_txdelta_window_handler_t *delta_handler, void **delta_baton, apr_array_header_t *prop_diffs, apr_pool_t *pool) {
 
3689
  return _obj(baton, path, rev, rev_props, delta_handler, delta_baton, prop_diffs, pool);
 
3690
}
 
3691
 
 
3692
static svn_error_t * svn_repos_invoke_verify_callback(
 
3693
  svn_repos_verify_callback_t _obj, void *baton, svn_revnum_t revision, svn_error_t *verify_err, apr_pool_t *scratch_pool) {
 
3694
  return _obj(baton, revision, verify_err, scratch_pool);
 
3695
}
 
3696
 
3695
3697
 
3696
3698
#ifdef __cplusplus
3697
3699
extern "C" {
3698
3700
#endif
 
3701
SWIGINTERN PyObject *_wrap_svn_swig_py_make_parse_fns3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3702
  PyObject *resultobj = 0;
 
3703
  svn_repos_parse_fns3_t **arg1 = (svn_repos_parse_fns3_t **) 0 ;
 
3704
  void **arg2 = (void **) 0 ;
 
3705
  PyObject *arg3 = (PyObject *) 0 ;
 
3706
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
3707
  apr_pool_t *_global_pool = NULL ;
 
3708
  PyObject *_global_py_pool = NULL ;
 
3709
  svn_repos_parse_fns3_t *temp1 ;
 
3710
  void *temp2 ;
 
3711
  PyObject * obj0 = 0 ;
 
3712
  PyObject * obj1 = 0 ;
 
3713
  
 
3714
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
3715
      &_global_py_pool, &_global_pool))
 
3716
  SWIG_fail;
 
3717
  arg4 = _global_pool;
 
3718
  arg1 = &temp1;
 
3719
  arg2 = &temp2;
 
3720
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_swig_py_make_parse_fns3",&obj0,&obj1)) SWIG_fail;
 
3721
  arg3 = obj0;
 
3722
  if (obj1) {
 
3723
    /* Verify that the user supplied a valid pool */
 
3724
    if (obj1 != Py_None && obj1 != _global_py_pool) {
 
3725
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
 
3726
      SWIG_arg_fail(svn_argnum_obj1);
 
3727
      SWIG_fail;
 
3728
    }
 
3729
  }
 
3730
  {
 
3731
    svn_swig_py_release_py_lock();
 
3732
    
 
3733
    svn_swig_py_make_parse_fns3((struct svn_repos_parse_fns3_t const **)arg1,arg2,arg3,arg4);
 
3734
    
 
3735
    svn_swig_py_acquire_py_lock();
 
3736
    
 
3737
  }
 
3738
  resultobj = SWIG_Py_Void();
 
3739
  {
 
3740
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_repos_parse_fns3_t,
 
3741
        _global_py_pool, args))
 
3742
    
 
3743
    ;
 
3744
  }
 
3745
  {
 
3746
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
 
3747
        _global_py_pool, args))
 
3748
    
 
3749
    ;
 
3750
  }
 
3751
  {
 
3752
    Py_XDECREF(_global_py_pool);
 
3753
  }
 
3754
  return resultobj;
 
3755
fail:
 
3756
  {
 
3757
    Py_XDECREF(_global_py_pool);
 
3758
  }
 
3759
  return NULL;
 
3760
}
 
3761
 
 
3762
 
3699
3763
SWIGINTERN PyObject *_wrap_svn_repos_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3700
3764
  PyObject *resultobj = 0;
3701
3765
  svn_version_t *result = 0 ;
3709
3773
    svn_swig_py_acquire_py_lock();
3710
3774
    
3711
3775
  }
3712
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_version_t,
 
3776
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_version_t,
3713
3777
    _global_py_pool, args);
3714
3778
  return resultobj;
3715
3779
fail:
3726
3790
  
3727
3791
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_action_set",&obj0,&obj1)) SWIG_fail;
3728
3792
  {
3729
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3793
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3730
3794
    if (PyErr_Occurred()) {
3731
3795
      SWIG_fail;
3732
3796
    }
3753
3817
  
3754
3818
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_action_get",&obj0)) SWIG_fail;
3755
3819
  {
3756
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3820
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3757
3821
    if (PyErr_Occurred()) {
3758
3822
      SWIG_fail;
3759
3823
    }
3775
3839
  
3776
3840
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_revision_set",&obj0,&obj1)) SWIG_fail;
3777
3841
  {
3778
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3842
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3779
3843
    if (PyErr_Occurred()) {
3780
3844
      SWIG_fail;
3781
3845
    }
3802
3866
  
3803
3867
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_revision_get",&obj0)) SWIG_fail;
3804
3868
  {
3805
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3869
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3806
3870
    if (PyErr_Occurred()) {
3807
3871
      SWIG_fail;
3808
3872
    }
3823
3887
  
3824
3888
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_repos_notify_t_warning_str_set",&obj0,&arg2)) SWIG_fail;
3825
3889
  {
3826
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3890
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3827
3891
    if (PyErr_Occurred()) {
3828
3892
      SWIG_fail;
3829
3893
    }
3851
3915
  
3852
3916
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_warning_str_get",&obj0)) SWIG_fail;
3853
3917
  {
3854
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3918
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3855
3919
    if (PyErr_Occurred()) {
3856
3920
      SWIG_fail;
3857
3921
    }
3873
3937
  
3874
3938
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_warning_set",&obj0,&obj1)) SWIG_fail;
3875
3939
  {
3876
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3940
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3877
3941
    if (PyErr_Occurred()) {
3878
3942
      SWIG_fail;
3879
3943
    }
3900
3964
  
3901
3965
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_warning_get",&obj0)) SWIG_fail;
3902
3966
  {
3903
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3967
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3904
3968
    if (PyErr_Occurred()) {
3905
3969
      SWIG_fail;
3906
3970
    }
3922
3986
  
3923
3987
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_shard_set",&obj0,&obj1)) SWIG_fail;
3924
3988
  {
3925
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
3989
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3926
3990
    if (PyErr_Occurred()) {
3927
3991
      SWIG_fail;
3928
3992
    }
3944
4008
  
3945
4009
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_shard_get",&obj0)) SWIG_fail;
3946
4010
  {
3947
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4011
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3948
4012
    if (PyErr_Occurred()) {
3949
4013
      SWIG_fail;
3950
4014
    }
3966
4030
  
3967
4031
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_new_revision_set",&obj0,&obj1)) SWIG_fail;
3968
4032
  {
3969
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4033
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3970
4034
    if (PyErr_Occurred()) {
3971
4035
      SWIG_fail;
3972
4036
    }
3993
4057
  
3994
4058
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_new_revision_get",&obj0)) SWIG_fail;
3995
4059
  {
3996
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4060
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
3997
4061
    if (PyErr_Occurred()) {
3998
4062
      SWIG_fail;
3999
4063
    }
4015
4079
  
4016
4080
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_old_revision_set",&obj0,&obj1)) SWIG_fail;
4017
4081
  {
4018
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4082
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
4019
4083
    if (PyErr_Occurred()) {
4020
4084
      SWIG_fail;
4021
4085
    }
4042
4106
  
4043
4107
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_old_revision_get",&obj0)) SWIG_fail;
4044
4108
  {
4045
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4109
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
4046
4110
    if (PyErr_Occurred()) {
4047
4111
      SWIG_fail;
4048
4112
    }
4064
4128
  
4065
4129
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_node_action_set",&obj0,&obj1)) SWIG_fail;
4066
4130
  {
4067
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4131
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
4068
4132
    if (PyErr_Occurred()) {
4069
4133
      SWIG_fail;
4070
4134
    }
4091
4155
  
4092
4156
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_node_action_get",&obj0)) SWIG_fail;
4093
4157
  {
4094
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4158
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
4095
4159
    if (PyErr_Occurred()) {
4096
4160
      SWIG_fail;
4097
4161
    }
4112
4176
  
4113
4177
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_repos_notify_t_path_set",&obj0,&arg2)) SWIG_fail;
4114
4178
  {
4115
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4179
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
4116
4180
    if (PyErr_Occurred()) {
4117
4181
      SWIG_fail;
4118
4182
    }
4140
4204
  
4141
4205
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_path_get",&obj0)) SWIG_fail;
4142
4206
  {
4143
 
    arg1 = (struct svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4207
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
4144
4208
    if (PyErr_Occurred()) {
4145
4209
      SWIG_fail;
4146
4210
    }
4153
4217
}
4154
4218
 
4155
4219
 
 
4220
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_start_revision_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4221
  PyObject *resultobj = 0;
 
4222
  struct svn_repos_notify_t *arg1 = (struct svn_repos_notify_t *) 0 ;
 
4223
  svn_revnum_t arg2 ;
 
4224
  PyObject * obj0 = 0 ;
 
4225
  PyObject * obj1 = 0 ;
 
4226
  
 
4227
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_start_revision_set",&obj0,&obj1)) SWIG_fail;
 
4228
  {
 
4229
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4230
    if (PyErr_Occurred()) {
 
4231
      SWIG_fail;
 
4232
    }
 
4233
  }
 
4234
  {
 
4235
    arg2 = (svn_revnum_t)SWIG_As_long (obj1);
 
4236
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
4237
      SWIG_fail;
 
4238
    }
 
4239
  }
 
4240
  if (arg1) (arg1)->start_revision = arg2;
 
4241
  resultobj = SWIG_Py_Void();
 
4242
  return resultobj;
 
4243
fail:
 
4244
  return NULL;
 
4245
}
 
4246
 
 
4247
 
 
4248
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_start_revision_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4249
  PyObject *resultobj = 0;
 
4250
  struct svn_repos_notify_t *arg1 = (struct svn_repos_notify_t *) 0 ;
 
4251
  PyObject * obj0 = 0 ;
 
4252
  svn_revnum_t result;
 
4253
  
 
4254
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_start_revision_get",&obj0)) SWIG_fail;
 
4255
  {
 
4256
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4257
    if (PyErr_Occurred()) {
 
4258
      SWIG_fail;
 
4259
    }
 
4260
  }
 
4261
  result = (svn_revnum_t) ((arg1)->start_revision);
 
4262
  resultobj = SWIG_From_long((long)(result));
 
4263
  return resultobj;
 
4264
fail:
 
4265
  return NULL;
 
4266
}
 
4267
 
 
4268
 
 
4269
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_end_revision_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4270
  PyObject *resultobj = 0;
 
4271
  struct svn_repos_notify_t *arg1 = (struct svn_repos_notify_t *) 0 ;
 
4272
  svn_revnum_t arg2 ;
 
4273
  PyObject * obj0 = 0 ;
 
4274
  PyObject * obj1 = 0 ;
 
4275
  
 
4276
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_end_revision_set",&obj0,&obj1)) SWIG_fail;
 
4277
  {
 
4278
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4279
    if (PyErr_Occurred()) {
 
4280
      SWIG_fail;
 
4281
    }
 
4282
  }
 
4283
  {
 
4284
    arg2 = (svn_revnum_t)SWIG_As_long (obj1);
 
4285
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
4286
      SWIG_fail;
 
4287
    }
 
4288
  }
 
4289
  if (arg1) (arg1)->end_revision = arg2;
 
4290
  resultobj = SWIG_Py_Void();
 
4291
  return resultobj;
 
4292
fail:
 
4293
  return NULL;
 
4294
}
 
4295
 
 
4296
 
 
4297
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_end_revision_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4298
  PyObject *resultobj = 0;
 
4299
  struct svn_repos_notify_t *arg1 = (struct svn_repos_notify_t *) 0 ;
 
4300
  PyObject * obj0 = 0 ;
 
4301
  svn_revnum_t result;
 
4302
  
 
4303
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_end_revision_get",&obj0)) SWIG_fail;
 
4304
  {
 
4305
    arg1 = (struct svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
 
4306
    if (PyErr_Occurred()) {
 
4307
      SWIG_fail;
 
4308
    }
 
4309
  }
 
4310
  result = (svn_revnum_t) ((arg1)->end_revision);
 
4311
  resultobj = SWIG_From_long((long)(result));
 
4312
  return resultobj;
 
4313
fail:
 
4314
  return NULL;
 
4315
}
 
4316
 
 
4317
 
4156
4318
SWIGINTERN PyObject *svn_repos_notify_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4157
4319
  PyObject *obj;
4158
4320
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4197
4359
    svn_swig_py_acquire_py_lock();
4198
4360
    
4199
4361
  }
4200
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_notify_t,
 
4362
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_repos_notify_t,
4201
4363
    _global_py_pool, args);
4202
4364
  {
4203
4365
    Py_XDECREF(_global_py_pool);
4254
4416
}
4255
4417
 
4256
4418
 
 
4419
SWIGINTERN PyObject *_wrap_svn_repos_open3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4420
  PyObject *resultobj = 0;
 
4421
  svn_repos_t **arg1 = (svn_repos_t **) 0 ;
 
4422
  char *arg2 = (char *) 0 ;
 
4423
  apr_hash_t *arg3 = (apr_hash_t *) 0 ;
 
4424
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
4425
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
4426
  apr_pool_t *_global_pool = NULL ;
 
4427
  PyObject *_global_py_pool = NULL ;
 
4428
  svn_repos_t *temp1 ;
 
4429
  PyObject * obj1 = 0 ;
 
4430
  PyObject * obj2 = 0 ;
 
4431
  PyObject * obj3 = 0 ;
 
4432
  svn_error_t *result = 0 ;
 
4433
  
 
4434
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
4435
      &_global_py_pool, &_global_pool))
 
4436
  SWIG_fail;
 
4437
  arg4 = _global_pool;
 
4438
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
4439
      &_global_py_pool, &_global_pool))
 
4440
  SWIG_fail;
 
4441
  arg5 = _global_pool;
 
4442
  arg1 = &temp1;
 
4443
  if (!PyArg_ParseTuple(args,(char *)"sO|OO:svn_repos_open3",&arg2,&obj1,&obj2,&obj3)) SWIG_fail;
 
4444
  {
 
4445
    /* PYTHON-FIXME: Handle None -> NULL. */
 
4446
    arg3 = svn_swig_py_stringhash_from_dict(obj1, _global_pool);
 
4447
  }
 
4448
  if (obj2) {
 
4449
    /* Verify that the user supplied a valid pool */
 
4450
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
4451
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
4452
      SWIG_arg_fail(svn_argnum_obj2);
 
4453
      SWIG_fail;
 
4454
    }
 
4455
  }
 
4456
  if (obj3) {
 
4457
    /* Verify that the user supplied a valid pool */
 
4458
    if (obj3 != Py_None && obj3 != _global_py_pool) {
 
4459
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
 
4460
      SWIG_arg_fail(svn_argnum_obj3);
 
4461
      SWIG_fail;
 
4462
    }
 
4463
  }
 
4464
  {
 
4465
    svn_swig_py_release_py_lock();
 
4466
    
 
4467
    result = (svn_error_t *)svn_repos_open3(arg1,(char const *)arg2,arg3,arg4,arg5);
 
4468
    
 
4469
    svn_swig_py_acquire_py_lock();
 
4470
    
 
4471
  }
 
4472
  {
 
4473
    if (result != NULL) {
 
4474
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
4475
      svn_swig_py_svn_exception(result);
 
4476
      else
 
4477
      svn_error_clear(result);
 
4478
      SWIG_fail;
 
4479
    }
 
4480
    Py_INCREF(Py_None);
 
4481
    resultobj = Py_None;
 
4482
  }
 
4483
  {
 
4484
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_repos_t,
 
4485
        _global_py_pool, args))
 
4486
    
 
4487
    ;
 
4488
  }
 
4489
  {
 
4490
    Py_XDECREF(_global_py_pool);
 
4491
  }
 
4492
  {
 
4493
    Py_XDECREF(_global_py_pool);
 
4494
  }
 
4495
  return resultobj;
 
4496
fail:
 
4497
  {
 
4498
    Py_XDECREF(_global_py_pool);
 
4499
  }
 
4500
  {
 
4501
    Py_XDECREF(_global_py_pool);
 
4502
  }
 
4503
  return NULL;
 
4504
}
 
4505
 
 
4506
 
4257
4507
SWIGINTERN PyObject *_wrap_svn_repos_open2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4258
4508
  PyObject *resultobj = 0;
4259
4509
  svn_repos_t **arg1 = (svn_repos_t **) 0 ;
4305
4555
    resultobj = Py_None;
4306
4556
  }
4307
4557
  {
4308
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_t,
 
4558
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_repos_t,
4309
4559
        _global_py_pool, args))
4310
4560
    
4311
4561
    ;
4367
4617
    resultobj = Py_None;
4368
4618
  }
4369
4619
  {
4370
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_t,
 
4620
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_repos_t,
4371
4621
        _global_py_pool, args))
4372
4622
    
4373
4623
    ;
4452
4702
    resultobj = Py_None;
4453
4703
  }
4454
4704
  {
4455
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_t,
 
4705
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_repos_t,
4456
4706
        _global_py_pool, args))
4457
4707
    
4458
4708
    ;
4497
4747
  }
4498
4748
  {
4499
4749
    svn_repos_notify_func_t * tmp =
4500
 
    svn_swig_MustGetPtr(obj2, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj2);
 
4750
    svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj2);
4501
4751
    if (tmp == NULL || PyErr_Occurred()) {
4502
4752
      SWIG_fail;
4503
4753
    }
4703
4953
  arg2 = &temp2;
4704
4954
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_has_capability",&obj0,&arg3,&obj2)) SWIG_fail;
4705
4955
  {
4706
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
4956
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
4707
4957
    if (PyErr_Occurred()) {
4708
4958
      SWIG_fail;
4709
4959
    }
4753
5003
}
4754
5004
 
4755
5005
 
 
5006
SWIGINTERN PyObject *_wrap_svn_repos_capabilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5007
  PyObject *resultobj = 0;
 
5008
  apr_hash_t **arg1 = (apr_hash_t **) 0 ;
 
5009
  svn_repos_t *arg2 = (svn_repos_t *) 0 ;
 
5010
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
5011
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
5012
  apr_pool_t *_global_pool = NULL ;
 
5013
  PyObject *_global_py_pool = NULL ;
 
5014
  apr_hash_t *temp1 ;
 
5015
  PyObject * obj0 = 0 ;
 
5016
  PyObject * obj1 = 0 ;
 
5017
  PyObject * obj2 = 0 ;
 
5018
  svn_error_t *result = 0 ;
 
5019
  
 
5020
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
5021
      &_global_py_pool, &_global_pool))
 
5022
  SWIG_fail;
 
5023
  arg3 = _global_pool;
 
5024
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
5025
      &_global_py_pool, &_global_pool))
 
5026
  SWIG_fail;
 
5027
  arg4 = _global_pool;
 
5028
  arg1 = &temp1;
 
5029
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_repos_capabilities",&obj0,&obj1,&obj2)) SWIG_fail;
 
5030
  {
 
5031
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
5032
    if (PyErr_Occurred()) {
 
5033
      SWIG_fail;
 
5034
    }
 
5035
  }
 
5036
  if (obj1) {
 
5037
    /* Verify that the user supplied a valid pool */
 
5038
    if (obj1 != Py_None && obj1 != _global_py_pool) {
 
5039
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
 
5040
      SWIG_arg_fail(svn_argnum_obj1);
 
5041
      SWIG_fail;
 
5042
    }
 
5043
  }
 
5044
  if (obj2) {
 
5045
    /* Verify that the user supplied a valid pool */
 
5046
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
5047
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
5048
      SWIG_arg_fail(svn_argnum_obj2);
 
5049
      SWIG_fail;
 
5050
    }
 
5051
  }
 
5052
  {
 
5053
    svn_swig_py_release_py_lock();
 
5054
    
 
5055
    result = (svn_error_t *)svn_repos_capabilities(arg1,arg2,arg3,arg4);
 
5056
    
 
5057
    svn_swig_py_acquire_py_lock();
 
5058
    
 
5059
  }
 
5060
  {
 
5061
    if (result != NULL) {
 
5062
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
5063
      svn_swig_py_svn_exception(result);
 
5064
      else
 
5065
      svn_error_clear(result);
 
5066
      SWIG_fail;
 
5067
    }
 
5068
    Py_INCREF(Py_None);
 
5069
    resultobj = Py_None;
 
5070
  }
 
5071
  {
 
5072
    /* FIXME: Missing argout typemap: svn_repos_capabilities arg 1 (apr_hash_t **) */
 
5073
    
 
5074
    
 
5075
    
 
5076
    
 
5077
    SWIG_exception(SWIG_ValueError, "svn_repos_capabilities is not implemented yet");
 
5078
    
 
5079
  }
 
5080
  {
 
5081
    Py_XDECREF(_global_py_pool);
 
5082
  }
 
5083
  {
 
5084
    Py_XDECREF(_global_py_pool);
 
5085
  }
 
5086
  return resultobj;
 
5087
fail:
 
5088
  {
 
5089
    Py_XDECREF(_global_py_pool);
 
5090
  }
 
5091
  {
 
5092
    Py_XDECREF(_global_py_pool);
 
5093
  }
 
5094
  return NULL;
 
5095
}
 
5096
 
 
5097
 
 
5098
SWIGINTERN PyObject *_wrap_svn_repos_remember_client_capabilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5099
  PyObject *resultobj = 0;
 
5100
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
5101
  apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
 
5102
  PyObject * obj0 = 0 ;
 
5103
  PyObject * obj1 = 0 ;
 
5104
  svn_error_t *result = 0 ;
 
5105
  
 
5106
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_remember_client_capabilities",&obj0,&obj1)) SWIG_fail;
 
5107
  {
 
5108
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
5109
    if (PyErr_Occurred()) {
 
5110
      SWIG_fail;
 
5111
    }
 
5112
  }
 
5113
  {
 
5114
    arg2 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
 
5115
    if (PyErr_Occurred()) {
 
5116
      SWIG_fail;
 
5117
    }
 
5118
  }
 
5119
  {
 
5120
    svn_swig_py_release_py_lock();
 
5121
    
 
5122
    result = (svn_error_t *)svn_repos_remember_client_capabilities(arg1,(apr_array_header_t const *)arg2);
 
5123
    
 
5124
    svn_swig_py_acquire_py_lock();
 
5125
    
 
5126
  }
 
5127
  {
 
5128
    if (result != NULL) {
 
5129
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
5130
      svn_swig_py_svn_exception(result);
 
5131
      else
 
5132
      svn_error_clear(result);
 
5133
      SWIG_fail;
 
5134
    }
 
5135
    Py_INCREF(Py_None);
 
5136
    resultobj = Py_None;
 
5137
  }
 
5138
  return resultobj;
 
5139
fail:
 
5140
  return NULL;
 
5141
}
 
5142
 
 
5143
 
4756
5144
SWIGINTERN PyObject *_wrap_svn_repos_fs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4757
5145
  PyObject *resultobj = 0;
4758
5146
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
4761
5149
  
4762
5150
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_fs",&obj0)) SWIG_fail;
4763
5151
  {
4764
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
5152
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
4765
5153
    if (PyErr_Occurred()) {
4766
5154
      SWIG_fail;
4767
5155
    }
4774
5162
    svn_swig_py_acquire_py_lock();
4775
5163
    
4776
5164
  }
4777
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_t,
 
5165
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_t,
4778
5166
    _global_py_pool, args);
4779
5167
  return resultobj;
4780
5168
fail:
4782
5170
}
4783
5171
 
4784
5172
 
 
5173
SWIGINTERN PyObject *_wrap_svn_repos_fs_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5174
  PyObject *resultobj = 0;
 
5175
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
5176
  apr_pool_t *arg2 = (apr_pool_t *) 0 ;
 
5177
  apr_pool_t *_global_pool = NULL ;
 
5178
  PyObject *_global_py_pool = NULL ;
 
5179
  PyObject * obj0 = 0 ;
 
5180
  PyObject * obj1 = 0 ;
 
5181
  char *result = 0 ;
 
5182
  
 
5183
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
5184
      &_global_py_pool, &_global_pool))
 
5185
  SWIG_fail;
 
5186
  arg2 = _global_pool;
 
5187
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_fs_type",&obj0,&obj1)) SWIG_fail;
 
5188
  {
 
5189
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
5190
    if (PyErr_Occurred()) {
 
5191
      SWIG_fail;
 
5192
    }
 
5193
  }
 
5194
  if (obj1) {
 
5195
    /* Verify that the user supplied a valid pool */
 
5196
    if (obj1 != Py_None && obj1 != _global_py_pool) {
 
5197
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
 
5198
      SWIG_arg_fail(svn_argnum_obj1);
 
5199
      SWIG_fail;
 
5200
    }
 
5201
  }
 
5202
  {
 
5203
    svn_swig_py_release_py_lock();
 
5204
    
 
5205
    result = (char *)svn_repos_fs_type(arg1,arg2);
 
5206
    
 
5207
    svn_swig_py_acquire_py_lock();
 
5208
    
 
5209
  }
 
5210
  resultobj = SWIG_FromCharPtr((const char *)result);
 
5211
  {
 
5212
    Py_XDECREF(_global_py_pool);
 
5213
  }
 
5214
  return resultobj;
 
5215
fail:
 
5216
  {
 
5217
    Py_XDECREF(_global_py_pool);
 
5218
  }
 
5219
  return NULL;
 
5220
}
 
5221
 
 
5222
 
 
5223
SWIGINTERN PyObject *_wrap_svn_repos_hotcopy3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5224
  PyObject *resultobj = 0;
 
5225
  char *arg1 = (char *) 0 ;
 
5226
  char *arg2 = (char *) 0 ;
 
5227
  svn_boolean_t arg3 ;
 
5228
  svn_boolean_t arg4 ;
 
5229
  svn_repos_notify_func_t arg5 = (svn_repos_notify_func_t) 0 ;
 
5230
  void *arg6 = (void *) 0 ;
 
5231
  svn_cancel_func_t arg7 = (svn_cancel_func_t) 0 ;
 
5232
  void *arg8 = (void *) 0 ;
 
5233
  apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
5234
  apr_pool_t *_global_pool = NULL ;
 
5235
  PyObject *_global_py_pool = NULL ;
 
5236
  PyObject * obj2 = 0 ;
 
5237
  PyObject * obj3 = 0 ;
 
5238
  PyObject * obj4 = 0 ;
 
5239
  PyObject * obj5 = 0 ;
 
5240
  PyObject * obj6 = 0 ;
 
5241
  PyObject * obj7 = 0 ;
 
5242
  svn_error_t *result = 0 ;
 
5243
  
 
5244
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
5245
      &_global_py_pool, &_global_pool))
 
5246
  SWIG_fail;
 
5247
  arg9 = _global_pool;
 
5248
  if (!PyArg_ParseTuple(args,(char *)"ssOOOOO|O:svn_repos_hotcopy3",&arg1,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
5249
  {
 
5250
    arg3 = (svn_boolean_t)SWIG_As_long (obj2);
 
5251
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
5252
      SWIG_fail;
 
5253
    }
 
5254
  }
 
5255
  {
 
5256
    arg4 = (svn_boolean_t)SWIG_As_long (obj3);
 
5257
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
5258
      SWIG_fail;
 
5259
    }
 
5260
  }
 
5261
  {
 
5262
    svn_repos_notify_func_t * tmp =
 
5263
    svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj4);
 
5264
    if (tmp == NULL || PyErr_Occurred()) {
 
5265
      SWIG_fail;
 
5266
    }
 
5267
    arg5 = *tmp;
 
5268
  }
 
5269
  {
 
5270
    if (obj5 == Py_None) {
 
5271
      arg6 = NULL;
 
5272
    } else if (SWIG_ConvertPtr(obj5, (void **) &arg6, 0, 0) == -1) {
 
5273
      arg6 = (void *) obj5;
 
5274
      PyErr_Clear();
 
5275
    }
 
5276
  }
 
5277
  {
 
5278
    arg7 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
5279
    arg8 = obj6;
 
5280
  }
 
5281
  if (obj7) {
 
5282
    /* Verify that the user supplied a valid pool */
 
5283
    if (obj7 != Py_None && obj7 != _global_py_pool) {
 
5284
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
 
5285
      SWIG_arg_fail(svn_argnum_obj7);
 
5286
      SWIG_fail;
 
5287
    }
 
5288
  }
 
5289
  {
 
5290
    svn_swig_py_release_py_lock();
 
5291
    
 
5292
    result = (svn_error_t *)svn_repos_hotcopy3((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
5293
    
 
5294
    svn_swig_py_acquire_py_lock();
 
5295
    
 
5296
  }
 
5297
  {
 
5298
    if (result != NULL) {
 
5299
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
5300
      svn_swig_py_svn_exception(result);
 
5301
      else
 
5302
      svn_error_clear(result);
 
5303
      SWIG_fail;
 
5304
    }
 
5305
    Py_INCREF(Py_None);
 
5306
    resultobj = Py_None;
 
5307
  }
 
5308
  {
 
5309
    Py_XDECREF(_global_py_pool);
 
5310
  }
 
5311
  return resultobj;
 
5312
fail:
 
5313
  {
 
5314
    Py_XDECREF(_global_py_pool);
 
5315
  }
 
5316
  return NULL;
 
5317
}
 
5318
 
 
5319
 
4785
5320
SWIGINTERN PyObject *_wrap_svn_repos_hotcopy2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4786
5321
  PyObject *resultobj = 0;
4787
5322
  char *arg1 = (char *) 0 ;
4817
5352
    }
4818
5353
  }
4819
5354
  {
4820
 
    arg5 = svn_swig_py_cancel_func;
4821
 
    arg6 = obj4; /* our function is the baton. */
 
5355
    arg5 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
5356
    arg6 = obj4;
4822
5357
  }
4823
5358
  if (obj5) {
4824
5359
    /* Verify that the user supplied a valid pool */
4944
5479
  arg6 = _global_pool;
4945
5480
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_fs_pack2",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4946
5481
  {
4947
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
5482
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
4948
5483
    if (PyErr_Occurred()) {
4949
5484
      SWIG_fail;
4950
5485
    }
4951
5486
  }
4952
5487
  {
4953
5488
    svn_repos_notify_func_t * tmp =
4954
 
    svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj1);
 
5489
    svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj1);
4955
5490
    if (tmp == NULL || PyErr_Occurred()) {
4956
5491
      SWIG_fail;
4957
5492
    }
4966
5501
    }
4967
5502
  }
4968
5503
  {
4969
 
    arg4 = svn_swig_py_cancel_func;
4970
 
    arg5 = obj3; /* our function is the baton. */
 
5504
    arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
5505
    arg5 = obj3;
4971
5506
  }
4972
5507
  if (obj4) {
4973
5508
    /* Verify that the user supplied a valid pool */
5031
5566
  arg6 = _global_pool;
5032
5567
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_fs_pack",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5033
5568
  {
5034
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
5569
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5035
5570
    if (PyErr_Occurred()) {
5036
5571
      SWIG_fail;
5037
5572
    }
5038
5573
  }
5039
5574
  {
5040
5575
    svn_fs_pack_notify_t * tmp =
5041
 
    svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj1);
 
5576
    svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj1);
5042
5577
    if (tmp == NULL || PyErr_Occurred()) {
5043
5578
      SWIG_fail;
5044
5579
    }
5053
5588
    }
5054
5589
  }
5055
5590
  {
5056
 
    arg4 = svn_swig_py_cancel_func;
5057
 
    arg5 = obj3; /* our function is the baton. */
 
5591
    arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
5592
    arg5 = obj3;
5058
5593
  }
5059
5594
  if (obj4) {
5060
5595
    /* Verify that the user supplied a valid pool */
5126
5661
  }
5127
5662
  {
5128
5663
    svn_repos_notify_func_t * tmp =
5129
 
    svn_swig_MustGetPtr(obj2, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj2);
 
5664
    svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj2);
5130
5665
    if (tmp == NULL || PyErr_Occurred()) {
5131
5666
      SWIG_fail;
5132
5667
    }
5141
5676
    }
5142
5677
  }
5143
5678
  {
5144
 
    arg5 = svn_swig_py_cancel_func;
5145
 
    arg6 = obj4; /* our function is the baton. */
 
5679
    arg5 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
5680
    arg6 = obj4;
5146
5681
  }
5147
5682
  if (obj5) {
5148
5683
    /* Verify that the user supplied a valid pool */
5227
5762
    }
5228
5763
  }
5229
5764
  {
5230
 
    arg5 = svn_swig_py_cancel_func;
5231
 
    arg6 = obj4; /* our function is the baton. */
 
5765
    arg5 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
5766
    arg6 = obj4;
5232
5767
  }
5233
5768
  if (obj5) {
5234
5769
    /* Verify that the user supplied a valid pool */
5554
6089
  arg2 = _global_pool;
5555
6090
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_path",&obj0,&obj1)) SWIG_fail;
5556
6091
  {
5557
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6092
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5558
6093
    if (PyErr_Occurred()) {
5559
6094
      SWIG_fail;
5560
6095
    }
5604
6139
  arg2 = _global_pool;
5605
6140
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_db_env",&obj0,&obj1)) SWIG_fail;
5606
6141
  {
5607
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6142
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5608
6143
    if (PyErr_Occurred()) {
5609
6144
      SWIG_fail;
5610
6145
    }
5654
6189
  arg2 = _global_pool;
5655
6190
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_conf_dir",&obj0,&obj1)) SWIG_fail;
5656
6191
  {
5657
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6192
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5658
6193
    if (PyErr_Occurred()) {
5659
6194
      SWIG_fail;
5660
6195
    }
5704
6239
  arg2 = _global_pool;
5705
6240
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_svnserve_conf",&obj0,&obj1)) SWIG_fail;
5706
6241
  {
5707
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6242
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5708
6243
    if (PyErr_Occurred()) {
5709
6244
      SWIG_fail;
5710
6245
    }
5754
6289
  arg2 = _global_pool;
5755
6290
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_lock_dir",&obj0,&obj1)) SWIG_fail;
5756
6291
  {
5757
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6292
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5758
6293
    if (PyErr_Occurred()) {
5759
6294
      SWIG_fail;
5760
6295
    }
5804
6339
  arg2 = _global_pool;
5805
6340
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_db_lockfile",&obj0,&obj1)) SWIG_fail;
5806
6341
  {
5807
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6342
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5808
6343
    if (PyErr_Occurred()) {
5809
6344
      SWIG_fail;
5810
6345
    }
5854
6389
  arg2 = _global_pool;
5855
6390
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_db_logs_lockfile",&obj0,&obj1)) SWIG_fail;
5856
6391
  {
5857
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6392
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5858
6393
    if (PyErr_Occurred()) {
5859
6394
      SWIG_fail;
5860
6395
    }
5904
6439
  arg2 = _global_pool;
5905
6440
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_hook_dir",&obj0,&obj1)) SWIG_fail;
5906
6441
  {
5907
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6442
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5908
6443
    if (PyErr_Occurred()) {
5909
6444
      SWIG_fail;
5910
6445
    }
5954
6489
  arg2 = _global_pool;
5955
6490
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_start_commit_hook",&obj0,&obj1)) SWIG_fail;
5956
6491
  {
5957
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6492
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
5958
6493
    if (PyErr_Occurred()) {
5959
6494
      SWIG_fail;
5960
6495
    }
6004
6539
  arg2 = _global_pool;
6005
6540
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_pre_commit_hook",&obj0,&obj1)) SWIG_fail;
6006
6541
  {
6007
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6542
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6008
6543
    if (PyErr_Occurred()) {
6009
6544
      SWIG_fail;
6010
6545
    }
6054
6589
  arg2 = _global_pool;
6055
6590
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_post_commit_hook",&obj0,&obj1)) SWIG_fail;
6056
6591
  {
6057
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6592
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6058
6593
    if (PyErr_Occurred()) {
6059
6594
      SWIG_fail;
6060
6595
    }
6104
6639
  arg2 = _global_pool;
6105
6640
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_pre_revprop_change_hook",&obj0,&obj1)) SWIG_fail;
6106
6641
  {
6107
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6642
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6108
6643
    if (PyErr_Occurred()) {
6109
6644
      SWIG_fail;
6110
6645
    }
6154
6689
  arg2 = _global_pool;
6155
6690
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_post_revprop_change_hook",&obj0,&obj1)) SWIG_fail;
6156
6691
  {
6157
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6692
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6158
6693
    if (PyErr_Occurred()) {
6159
6694
      SWIG_fail;
6160
6695
    }
6204
6739
  arg2 = _global_pool;
6205
6740
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_pre_lock_hook",&obj0,&obj1)) SWIG_fail;
6206
6741
  {
6207
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6742
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6208
6743
    if (PyErr_Occurred()) {
6209
6744
      SWIG_fail;
6210
6745
    }
6254
6789
  arg2 = _global_pool;
6255
6790
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_post_lock_hook",&obj0,&obj1)) SWIG_fail;
6256
6791
  {
6257
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6792
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6258
6793
    if (PyErr_Occurred()) {
6259
6794
      SWIG_fail;
6260
6795
    }
6304
6839
  arg2 = _global_pool;
6305
6840
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_pre_unlock_hook",&obj0,&obj1)) SWIG_fail;
6306
6841
  {
6307
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6842
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6308
6843
    if (PyErr_Occurred()) {
6309
6844
      SWIG_fail;
6310
6845
    }
6354
6889
  arg2 = _global_pool;
6355
6890
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_post_unlock_hook",&obj0,&obj1)) SWIG_fail;
6356
6891
  {
6357
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6892
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6358
6893
    if (PyErr_Occurred()) {
6359
6894
      SWIG_fail;
6360
6895
    }
6405
6940
  arg3 = _global_pool;
6406
6941
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_hooks_setenv",&obj0,&arg2,&obj2)) SWIG_fail;
6407
6942
  {
6408
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
6943
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
6409
6944
    if (PyErr_Occurred()) {
6410
6945
      SWIG_fail;
6411
6946
    }
6496
7031
    }
6497
7032
  }
6498
7033
  {
6499
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_t, svn_argnum_obj1);
 
7034
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_t, svn_argnum_obj1);
6500
7035
    if (PyErr_Occurred()) {
6501
7036
      SWIG_fail;
6502
7037
    }
6526
7061
    }
6527
7062
  }
6528
7063
  {
6529
 
    arg11 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj9, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj9);
 
7064
    arg11 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj9, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj9);
6530
7065
    if (PyErr_Occurred()) {
6531
7066
      SWIG_fail;
6532
7067
    }
6541
7076
  }
6542
7077
  {
6543
7078
    /* FIXME: Handle the NULL case. */
6544
 
    arg13 = svn_swig_py_repos_authz_func;
 
7079
    arg13 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
6545
7080
    arg14 = obj11;
6546
7081
  }
6547
7082
  {
6578
7113
    resultobj = Py_None;
6579
7114
  }
6580
7115
  {
6581
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_void,
 
7116
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_void,
6582
7117
        _global_py_pool, args))
6583
7118
    
6584
7119
    ;
6640
7175
    }
6641
7176
  }
6642
7177
  {
6643
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_t, svn_argnum_obj1);
 
7178
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_t, svn_argnum_obj1);
6644
7179
    if (PyErr_Occurred()) {
6645
7180
      SWIG_fail;
6646
7181
    }
6670
7205
    }
6671
7206
  }
6672
7207
  {
6673
 
    arg11 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj9, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj9);
 
7208
    arg11 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj9, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj9);
6674
7209
    if (PyErr_Occurred()) {
6675
7210
      SWIG_fail;
6676
7211
    }
6685
7220
  }
6686
7221
  {
6687
7222
    /* FIXME: Handle the NULL case. */
6688
 
    arg13 = svn_swig_py_repos_authz_func;
 
7223
    arg13 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
6689
7224
    arg14 = obj11;
6690
7225
  }
6691
7226
  if (obj12) {
6716
7251
    resultobj = Py_None;
6717
7252
  }
6718
7253
  {
6719
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_void,
 
7254
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_void,
6720
7255
        _global_py_pool, args))
6721
7256
    
6722
7257
    ;
6777
7312
    }
6778
7313
  }
6779
7314
  {
6780
 
    arg4 = (svn_repos_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_repos_t, svn_argnum_obj2);
 
7315
    arg4 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_repos_t, svn_argnum_obj2);
6781
7316
    if (PyErr_Occurred()) {
6782
7317
      SWIG_fail;
6783
7318
    }
6801
7336
    }
6802
7337
  }
6803
7338
  {
6804
 
    arg11 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj9, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj9);
 
7339
    arg11 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj9, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj9);
6805
7340
    if (PyErr_Occurred()) {
6806
7341
      SWIG_fail;
6807
7342
    }
6816
7351
  }
6817
7352
  {
6818
7353
    /* FIXME: Handle the NULL case. */
6819
 
    arg13 = svn_swig_py_repos_authz_func;
 
7354
    arg13 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
6820
7355
    arg14 = obj11;
6821
7356
  }
6822
7357
  if (obj12) {
6847
7382
    resultobj = Py_None;
6848
7383
  }
6849
7384
  {
6850
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_void,
 
7385
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_void,
6851
7386
        _global_py_pool, args))
6852
7387
    
6853
7388
    ;
7584
8119
  arg14 = _global_pool;
7585
8120
  if (!PyArg_ParseTuple(args,(char *)"OszOzOOOOOOO|O:svn_repos_dir_delta2",&obj0,&arg2,&arg3,&obj3,&arg5,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
7586
8121
  {
7587
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7588
 
    if (PyErr_Occurred()) {
7589
 
      SWIG_fail;
7590
 
    }
7591
 
  }
7592
 
  {
7593
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj3);
7594
 
    if (PyErr_Occurred()) {
7595
 
      SWIG_fail;
7596
 
    }
7597
 
  }
7598
 
  {
7599
 
    arg6 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj5, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj5);
 
8122
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8123
    if (PyErr_Occurred()) {
 
8124
      SWIG_fail;
 
8125
    }
 
8126
  }
 
8127
  {
 
8128
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj3);
 
8129
    if (PyErr_Occurred()) {
 
8130
      SWIG_fail;
 
8131
    }
 
8132
  }
 
8133
  {
 
8134
    arg6 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj5, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj5);
7600
8135
    if (PyErr_Occurred()) {
7601
8136
      SWIG_fail;
7602
8137
    }
7611
8146
  }
7612
8147
  {
7613
8148
    /* FIXME: Handle the NULL case. */
7614
 
    arg8 = svn_swig_py_repos_authz_func;
 
8149
    arg8 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
7615
8150
    arg9 = obj7;
7616
8151
  }
7617
8152
  {
7713
8248
  arg14 = _global_pool;
7714
8249
  if (!PyArg_ParseTuple(args,(char *)"OszOzOOOOOOO|O:svn_repos_dir_delta",&obj0,&arg2,&arg3,&obj3,&arg5,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
7715
8250
  {
7716
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7717
 
    if (PyErr_Occurred()) {
7718
 
      SWIG_fail;
7719
 
    }
7720
 
  }
7721
 
  {
7722
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj3);
7723
 
    if (PyErr_Occurred()) {
7724
 
      SWIG_fail;
7725
 
    }
7726
 
  }
7727
 
  {
7728
 
    arg6 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj5, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj5);
 
8251
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8252
    if (PyErr_Occurred()) {
 
8253
      SWIG_fail;
 
8254
    }
 
8255
  }
 
8256
  {
 
8257
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj3);
 
8258
    if (PyErr_Occurred()) {
 
8259
      SWIG_fail;
 
8260
    }
 
8261
  }
 
8262
  {
 
8263
    arg6 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj5, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj5);
7729
8264
    if (PyErr_Occurred()) {
7730
8265
      SWIG_fail;
7731
8266
    }
7740
8275
  }
7741
8276
  {
7742
8277
    /* FIXME: Handle the NULL case. */
7743
 
    arg8 = svn_swig_py_repos_authz_func;
 
8278
    arg8 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
7744
8279
    arg9 = obj7;
7745
8280
  }
7746
8281
  {
7834
8369
  arg9 = _global_pool;
7835
8370
  if (!PyArg_ParseTuple(args,(char *)"OsOOOOO|O:svn_repos_replay2",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
7836
8371
  {
7837
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8372
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7838
8373
    if (PyErr_Occurred()) {
7839
8374
      SWIG_fail;
7840
8375
    }
7852
8387
    }
7853
8388
  }
7854
8389
  {
7855
 
    arg5 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj4);
 
8390
    arg5 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj4);
7856
8391
    if (PyErr_Occurred()) {
7857
8392
      SWIG_fail;
7858
8393
    }
7867
8402
  }
7868
8403
  {
7869
8404
    /* FIXME: Handle the NULL case. */
7870
 
    arg7 = svn_swig_py_repos_authz_func;
 
8405
    arg7 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
7871
8406
    arg8 = obj6;
7872
8407
  }
7873
8408
  if (obj7) {
7929
8464
  arg4 = _global_pool;
7930
8465
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_replay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7931
8466
  {
7932
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8467
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7933
8468
    if (PyErr_Occurred()) {
7934
8469
      SWIG_fail;
7935
8470
    }
7936
8471
  }
7937
8472
  {
7938
 
    arg2 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj1);
 
8473
    arg2 = (svn_delta_editor_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj1);
7939
8474
    if (PyErr_Occurred()) {
7940
8475
      SWIG_fail;
7941
8476
    }
8022
8557
  arg2 = &temp2;
8023
8558
  if (!PyArg_ParseTuple(args,(char *)"OOssOOOO|O:svn_repos_get_commit_editor5",&obj0,&obj1,&arg5,&arg6,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
8024
8559
  {
8025
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
8560
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
8026
8561
    if (PyErr_Occurred()) {
8027
8562
      SWIG_fail;
8028
8563
    }
8029
8564
  }
8030
8565
  {
8031
 
    arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
 
8566
    arg4 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
8032
8567
    if (PyErr_Occurred()) {
8033
8568
      SWIG_fail;
8034
8569
    }
8052
8587
  }
8053
8588
  {
8054
8589
    svn_repos_authz_callback_t * tmp =
8055
 
    svn_swig_MustGetPtr(obj6, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj6);
 
8590
    svn_swig_py_must_get_ptr(obj6, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj6);
8056
8591
    if (tmp == NULL || PyErr_Occurred()) {
8057
8592
      SWIG_fail;
8058
8593
    }
8094
8629
    resultobj = Py_None;
8095
8630
  }
8096
8631
  {
8097
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
 
8632
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
8098
8633
        _global_py_pool, args))
8099
8634
    
8100
8635
    ;
8101
8636
  }
8102
8637
  {
8103
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
8638
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
8104
8639
        _global_py_pool, args))
8105
8640
    
8106
8641
    ;
8152
8687
  arg2 = &temp2;
8153
8688
  if (!PyArg_ParseTuple(args,(char *)"OOsszzOOO|O:svn_repos_get_commit_editor4",&obj0,&obj1,&arg5,&arg6,&arg7,&arg8,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
8154
8689
  {
8155
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
8690
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
8156
8691
    if (PyErr_Occurred()) {
8157
8692
      SWIG_fail;
8158
8693
    }
8159
8694
  }
8160
8695
  {
8161
 
    arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
 
8696
    arg4 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
8162
8697
    if (PyErr_Occurred()) {
8163
8698
      SWIG_fail;
8164
8699
    }
8169
8704
  }
8170
8705
  {
8171
8706
    svn_repos_authz_callback_t * tmp =
8172
 
    svn_swig_MustGetPtr(obj7, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj7);
 
8707
    svn_swig_py_must_get_ptr(obj7, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj7);
8173
8708
    if (tmp == NULL || PyErr_Occurred()) {
8174
8709
      SWIG_fail;
8175
8710
    }
8211
8746
    resultobj = Py_None;
8212
8747
  }
8213
8748
  {
8214
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
 
8749
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
8215
8750
        _global_py_pool, args))
8216
8751
    
8217
8752
    ;
8218
8753
  }
8219
8754
  {
8220
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
8755
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
8221
8756
        _global_py_pool, args))
8222
8757
    
8223
8758
    ;
8269
8804
  arg2 = &temp2;
8270
8805
  if (!PyArg_ParseTuple(args,(char *)"OOsszzOOO|O:svn_repos_get_commit_editor3",&obj0,&obj1,&arg5,&arg6,&arg7,&arg8,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
8271
8806
  {
8272
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
8807
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
8273
8808
    if (PyErr_Occurred()) {
8274
8809
      SWIG_fail;
8275
8810
    }
8276
8811
  }
8277
8812
  {
8278
 
    arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
 
8813
    arg4 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
8279
8814
    if (PyErr_Occurred()) {
8280
8815
      SWIG_fail;
8281
8816
    }
8286
8821
  }
8287
8822
  {
8288
8823
    svn_repos_authz_callback_t * tmp =
8289
 
    svn_swig_MustGetPtr(obj7, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj7);
 
8824
    svn_swig_py_must_get_ptr(obj7, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj7);
8290
8825
    if (tmp == NULL || PyErr_Occurred()) {
8291
8826
      SWIG_fail;
8292
8827
    }
8328
8863
    resultobj = Py_None;
8329
8864
  }
8330
8865
  {
8331
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
 
8866
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
8332
8867
        _global_py_pool, args))
8333
8868
    
8334
8869
    ;
8335
8870
  }
8336
8871
  {
8337
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
8872
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
8338
8873
        _global_py_pool, args))
8339
8874
    
8340
8875
    ;
8382
8917
  arg2 = &temp2;
8383
8918
  if (!PyArg_ParseTuple(args,(char *)"OOsszzO|O:svn_repos_get_commit_editor2",&obj0,&obj1,&arg5,&arg6,&arg7,&arg8,&obj6,&obj7)) SWIG_fail;
8384
8919
  {
8385
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
8920
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
8386
8921
    if (PyErr_Occurred()) {
8387
8922
      SWIG_fail;
8388
8923
    }
8389
8924
  }
8390
8925
  {
8391
 
    arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
 
8926
    arg4 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
8392
8927
    if (PyErr_Occurred()) {
8393
8928
      SWIG_fail;
8394
8929
    }
8425
8960
    resultobj = Py_None;
8426
8961
  }
8427
8962
  {
8428
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
 
8963
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
8429
8964
        _global_py_pool, args))
8430
8965
    
8431
8966
    ;
8432
8967
  }
8433
8968
  {
8434
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
8969
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
8435
8970
        _global_py_pool, args))
8436
8971
    
8437
8972
    ;
8477
9012
  arg2 = &temp2;
8478
9013
  if (!PyArg_ParseTuple(args,(char *)"OsszzO|O:svn_repos_get_commit_editor",&obj0,&arg4,&arg5,&arg6,&arg7,&obj5,&obj6)) SWIG_fail;
8479
9014
  {
8480
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
9015
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
8481
9016
    if (PyErr_Occurred()) {
8482
9017
      SWIG_fail;
8483
9018
    }
8514
9049
    resultobj = Py_None;
8515
9050
  }
8516
9051
  {
8517
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
 
9052
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
8518
9053
        _global_py_pool, args))
8519
9054
    
8520
9055
    ;
8521
9056
  }
8522
9057
  {
8523
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
9058
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
8524
9059
        _global_py_pool, args))
8525
9060
    
8526
9061
    ;
8559
9094
  arg1 = &temp1;
8560
9095
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_repos_dated_revision",&obj0,&obj1,&obj2)) SWIG_fail;
8561
9096
  {
8562
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
9097
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
8563
9098
    if (PyErr_Occurred()) {
8564
9099
      SWIG_fail;
8565
9100
    }
8637
9172
  arg3 = &temp3;
8638
9173
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_get_committed_info",&obj0,&arg5,&obj2)) SWIG_fail;
8639
9174
  {
8640
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9175
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8641
9176
    if (PyErr_Occurred()) {
8642
9177
      SWIG_fail;
8643
9178
    }
8733
9268
  arg1 = &temp1;
8734
9269
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_stat",&obj0,&arg3,&obj2)) SWIG_fail;
8735
9270
  {
8736
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9271
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8737
9272
    if (PyErr_Occurred()) {
8738
9273
      SWIG_fail;
8739
9274
    }
8766
9301
    resultobj = Py_None;
8767
9302
  }
8768
9303
  {
8769
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_dirent_t,
 
9304
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_dirent_t,
8770
9305
        _global_py_pool, args))
8771
9306
    
8772
9307
    ;
8808
9343
  arg5 = &temp5;
8809
9344
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_repos_deleted_rev",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
8810
9345
  {
8811
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
9346
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
8812
9347
    if (PyErr_Occurred()) {
8813
9348
      SWIG_fail;
8814
9349
    }
8899
9434
  arg10 = _global_pool;
8900
9435
  if (!PyArg_ParseTuple(args,(char *)"OsOOOOO|O:svn_repos_history2",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
8901
9436
  {
8902
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
9437
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
8903
9438
    if (PyErr_Occurred()) {
8904
9439
      SWIG_fail;
8905
9440
    }
8906
9441
  }
8907
9442
  {
8908
 
    arg3 = svn_swig_py_repos_history_func;
 
9443
    arg3 = (svn_repos_history_func_t) svn_swig_py_repos_history_func;
8909
9444
    arg4 = obj2;
8910
9445
  }
8911
9446
  {
8912
9447
    /* FIXME: Handle the NULL case. */
8913
 
    arg5 = svn_swig_py_repos_authz_func;
 
9448
    arg5 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
8914
9449
    arg6 = obj3;
8915
9450
  }
8916
9451
  {
8996
9531
  arg8 = _global_pool;
8997
9532
  if (!PyArg_ParseTuple(args,(char *)"OsOOOO|O:svn_repos_history",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
8998
9533
  {
8999
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
9534
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
9000
9535
    if (PyErr_Occurred()) {
9001
9536
      SWIG_fail;
9002
9537
    }
9003
9538
  }
9004
9539
  {
9005
 
    arg3 = svn_swig_py_repos_history_func;
 
9540
    arg3 = (svn_repos_history_func_t) svn_swig_py_repos_history_func;
9006
9541
    arg4 = obj2;
9007
9542
  }
9008
9543
  {
9089
9624
  arg2 = &temp2;
9090
9625
  if (!PyArg_ParseTuple(args,(char *)"OsOOO|O:svn_repos_trace_node_locations",&obj0,&arg3,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
9091
9626
  {
9092
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
9627
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
9093
9628
    if (PyErr_Occurred()) {
9094
9629
      SWIG_fail;
9095
9630
    }
9111
9646
  }
9112
9647
  {
9113
9648
    /* FIXME: Handle the NULL case. */
9114
 
    arg6 = svn_swig_py_repos_authz_func;
 
9649
    arg6 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
9115
9650
    arg7 = obj4;
9116
9651
  }
9117
9652
  if (obj5) {
9185
9720
  arg10 = _global_pool;
9186
9721
  if (!PyArg_ParseTuple(args,(char *)"OsOOOOO|O:svn_repos_node_location_segments",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9187
9722
  {
9188
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
9723
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
9189
9724
    if (PyErr_Occurred()) {
9190
9725
      SWIG_fail;
9191
9726
    }
9209
9744
    }
9210
9745
  }
9211
9746
  {
9212
 
    arg6 = svn_swig_py_location_segment_receiver_func;
 
9747
    arg6 = (svn_location_segment_receiver_t) svn_swig_py_location_segment_receiver_func;
9213
9748
    arg7 = obj5;
9214
9749
  }
9215
9750
  {
9216
9751
    /* FIXME: Handle the NULL case. */
9217
 
    arg8 = svn_swig_py_repos_authz_func;
 
9752
    arg8 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
9218
9753
    arg9 = obj6;
9219
9754
  }
9220
9755
  if (obj7) {
9294
9829
  arg14 = _global_pool;
9295
9830
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO|O:svn_repos_get_logs4",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
9296
9831
  {
9297
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
9832
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
9298
9833
    if (PyErr_Occurred()) {
9299
9834
      SWIG_fail;
9300
9835
    }
9355
9890
  }
9356
9891
  {
9357
9892
    /* FIXME: Handle the NULL case. */
9358
 
    arg10 = svn_swig_py_repos_authz_func;
 
9893
    arg10 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
9359
9894
    arg11 = obj9;
9360
9895
  }
9361
9896
  {
9362
 
    arg12 = svn_swig_py_log_entry_receiver;
 
9897
    arg12 = (svn_log_entry_receiver_t) svn_swig_py_log_entry_receiver;
9363
9898
    arg13 = obj10;
9364
9899
  }
9365
9900
  if (obj11) {
9435
9970
  arg12 = _global_pool;
9436
9971
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|O:svn_repos_get_logs3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
9437
9972
  {
9438
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
9973
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
9439
9974
    if (PyErr_Occurred()) {
9440
9975
      SWIG_fail;
9441
9976
    }
9481
10016
  }
9482
10017
  {
9483
10018
    /* FIXME: Handle the NULL case. */
9484
 
    arg8 = svn_swig_py_repos_authz_func;
 
10019
    arg8 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
9485
10020
    arg9 = obj7;
9486
10021
  }
9487
10022
  {
9488
 
    arg10 = svn_swig_py_log_receiver;
 
10023
    arg10 = (svn_log_message_receiver_t) svn_swig_py_log_receiver;
9489
10024
    arg11 = obj8;
9490
10025
  }
9491
10026
  if (obj9) {
9559
10094
  arg11 = _global_pool;
9560
10095
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO|O:svn_repos_get_logs2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
9561
10096
  {
9562
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10097
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
9563
10098
    if (PyErr_Occurred()) {
9564
10099
      SWIG_fail;
9565
10100
    }
9599
10134
  }
9600
10135
  {
9601
10136
    /* FIXME: Handle the NULL case. */
9602
 
    arg7 = svn_swig_py_repos_authz_func;
 
10137
    arg7 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
9603
10138
    arg8 = obj6;
9604
10139
  }
9605
10140
  {
9606
 
    arg9 = svn_swig_py_log_receiver;
 
10141
    arg9 = (svn_log_message_receiver_t) svn_swig_py_log_receiver;
9607
10142
    arg10 = obj7;
9608
10143
  }
9609
10144
  if (obj8) {
9674
10209
  arg9 = _global_pool;
9675
10210
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO|O:svn_repos_get_logs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9676
10211
  {
9677
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10212
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
9678
10213
    if (PyErr_Occurred()) {
9679
10214
      SWIG_fail;
9680
10215
    }
9713
10248
    }
9714
10249
  }
9715
10250
  {
9716
 
    arg7 = svn_swig_py_log_receiver;
 
10251
    arg7 = (svn_log_message_receiver_t) svn_swig_py_log_receiver;
9717
10252
    arg8 = obj6;
9718
10253
  }
9719
10254
  if (obj7) {
9785
10320
  arg1 = &temp1;
9786
10321
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO|O:svn_repos_fs_get_mergeinfo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
9787
10322
  {
9788
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10323
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
9789
10324
    if (PyErr_Occurred()) {
9790
10325
      SWIG_fail;
9791
10326
    }
9819
10354
  }
9820
10355
  {
9821
10356
    /* FIXME: Handle the NULL case. */
9822
 
    arg7 = svn_swig_py_repos_authz_func;
 
10357
    arg7 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
9823
10358
    arg8 = obj5;
9824
10359
  }
9825
10360
  if (obj6) {
9903
10438
  arg10 = _global_pool;
9904
10439
  if (!PyArg_ParseTuple(args,(char *)"OsOOOOOO|O:svn_repos_get_file_revs2",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
9905
10440
  {
9906
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10441
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
9907
10442
    if (PyErr_Occurred()) {
9908
10443
      SWIG_fail;
9909
10444
    }
9928
10463
  }
9929
10464
  {
9930
10465
    /* FIXME: Handle the NULL case. */
9931
 
    arg6 = svn_swig_py_repos_authz_func;
 
10466
    arg6 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
9932
10467
    arg7 = obj5;
9933
10468
  }
9934
10469
  {
9935
10470
    svn_file_rev_handler_t * tmp =
9936
 
    svn_swig_MustGetPtr(obj6, 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_obj6);
 
10471
    svn_swig_py_must_get_ptr(obj6, 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_obj6);
9937
10472
    if (tmp == NULL || PyErr_Occurred()) {
9938
10473
      SWIG_fail;
9939
10474
    }
10014
10549
  arg9 = _global_pool;
10015
10550
  if (!PyArg_ParseTuple(args,(char *)"OsOOOOO|O:svn_repos_get_file_revs",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
10016
10551
  {
10017
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10552
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10018
10553
    if (PyErr_Occurred()) {
10019
10554
      SWIG_fail;
10020
10555
    }
10033
10568
  }
10034
10569
  {
10035
10570
    /* FIXME: Handle the NULL case. */
10036
 
    arg5 = svn_swig_py_repos_authz_func;
 
10571
    arg5 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
10037
10572
    arg6 = obj4;
10038
10573
  }
10039
10574
  {
10040
10575
    svn_repos_file_rev_handler_t * tmp =
10041
 
    svn_swig_MustGetPtr(obj5, 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_obj5);
 
10576
    svn_swig_py_must_get_ptr(obj5, 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_obj5);
10042
10577
    if (tmp == NULL || PyErr_Occurred()) {
10043
10578
      SWIG_fail;
10044
10579
    }
10116
10651
  arg3 = &temp3;
10117
10652
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_repos_fs_commit_txn",&obj0,&obj1,&obj2)) SWIG_fail;
10118
10653
  {
10119
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10654
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10120
10655
    if (PyErr_Occurred()) {
10121
10656
      SWIG_fail;
10122
10657
    }
10123
10658
  }
10124
10659
  {
10125
 
    arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
 
10660
    arg4 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
10126
10661
    if (PyErr_Occurred()) {
10127
10662
      SWIG_fail;
10128
10663
    }
10208
10743
  arg1 = &temp1;
10209
10744
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_fs_begin_txn_for_commit2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10210
10745
  {
10211
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10746
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10212
10747
    if (PyErr_Occurred()) {
10213
10748
      SWIG_fail;
10214
10749
    }
10260
10795
    resultobj = Py_None;
10261
10796
  }
10262
10797
  {
10263
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
 
10798
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
10264
10799
        _global_py_pool, args))
10265
10800
    
10266
10801
    ;
10300
10835
  arg1 = &temp1;
10301
10836
  if (!PyArg_ParseTuple(args,(char *)"OOsz|O:svn_repos_fs_begin_txn_for_commit",&obj0,&obj1,&arg4,&arg5,&obj4)) SWIG_fail;
10302
10837
  {
10303
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10838
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10304
10839
    if (PyErr_Occurred()) {
10305
10840
      SWIG_fail;
10306
10841
    }
10339
10874
    resultobj = Py_None;
10340
10875
  }
10341
10876
  {
10342
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
 
10877
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
10343
10878
        _global_py_pool, args))
10344
10879
    
10345
10880
    ;
10378
10913
  arg1 = &temp1;
10379
10914
  if (!PyArg_ParseTuple(args,(char *)"OOs|O:svn_repos_fs_begin_txn_for_update",&obj0,&obj1,&arg4,&obj3)) SWIG_fail;
10380
10915
  {
10381
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
10916
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10382
10917
    if (PyErr_Occurred()) {
10383
10918
      SWIG_fail;
10384
10919
    }
10417
10952
    resultobj = Py_None;
10418
10953
  }
10419
10954
  {
10420
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
 
10955
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
10421
10956
        _global_py_pool, args))
10422
10957
    
10423
10958
    ;
10434
10969
}
10435
10970
 
10436
10971
 
 
10972
SWIGINTERN PyObject *_wrap_svn_repos_fs_lock_many(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10973
  PyObject *resultobj = 0;
 
10974
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
10975
  apr_hash_t *arg2 = (apr_hash_t *) 0 ;
 
10976
  char *arg3 = (char *) 0 ;
 
10977
  svn_boolean_t arg4 ;
 
10978
  apr_time_t arg5 ;
 
10979
  svn_boolean_t arg6 ;
 
10980
  svn_fs_lock_callback_t arg7 = (svn_fs_lock_callback_t) 0 ;
 
10981
  void *arg8 = (void *) 0 ;
 
10982
  apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
10983
  apr_pool_t *arg10 = (apr_pool_t *) 0 ;
 
10984
  apr_pool_t *_global_pool = NULL ;
 
10985
  PyObject *_global_py_pool = NULL ;
 
10986
  PyObject * obj0 = 0 ;
 
10987
  PyObject * obj1 = 0 ;
 
10988
  PyObject * obj3 = 0 ;
 
10989
  PyObject * obj4 = 0 ;
 
10990
  PyObject * obj5 = 0 ;
 
10991
  PyObject * obj6 = 0 ;
 
10992
  PyObject * obj7 = 0 ;
 
10993
  PyObject * obj8 = 0 ;
 
10994
  svn_error_t *result = 0 ;
 
10995
  
 
10996
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
10997
      &_global_py_pool, &_global_pool))
 
10998
  SWIG_fail;
 
10999
  arg9 = _global_pool;
 
11000
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
11001
      &_global_py_pool, &_global_pool))
 
11002
  SWIG_fail;
 
11003
  arg10 = _global_pool;
 
11004
  if (!PyArg_ParseTuple(args,(char *)"OOzOOOO|OO:svn_repos_fs_lock_many",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
11005
  {
 
11006
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11007
    if (PyErr_Occurred()) {
 
11008
      SWIG_fail;
 
11009
    }
 
11010
  }
 
11011
  {
 
11012
    if (_global_pool == NULL)
 
11013
    {
 
11014
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
11015
          &_global_py_pool, &_global_pool))
 
11016
      SWIG_fail;
 
11017
    }
 
11018
    arg2 = svn_swig_py_struct_ptr_hash_from_dict(obj1,
 
11019
      SWIGTYPE_p_svn_fs_lock_target_t, _global_pool);
 
11020
    if (PyErr_Occurred()) {
 
11021
      SWIG_fail;
 
11022
    }
 
11023
  }
 
11024
  {
 
11025
    arg4 = (svn_boolean_t)SWIG_As_long (obj3);
 
11026
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
11027
      SWIG_fail;
 
11028
    }
 
11029
  }
 
11030
  arg5 = (apr_time_t) PyLong_AsLongLong(obj4); 
 
11031
  {
 
11032
    arg6 = (svn_boolean_t)SWIG_As_long (obj5);
 
11033
    if (SWIG_arg_fail(svn_argnum_obj5)) {
 
11034
      SWIG_fail;
 
11035
    }
 
11036
  }
 
11037
  {
 
11038
    arg7 = (svn_fs_lock_callback_t) svn_swig_py_fs_lock_callback;
 
11039
    arg8 = obj6;
 
11040
  }
 
11041
  if (obj7) {
 
11042
    /* Verify that the user supplied a valid pool */
 
11043
    if (obj7 != Py_None && obj7 != _global_py_pool) {
 
11044
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
 
11045
      SWIG_arg_fail(svn_argnum_obj7);
 
11046
      SWIG_fail;
 
11047
    }
 
11048
  }
 
11049
  if (obj8) {
 
11050
    /* Verify that the user supplied a valid pool */
 
11051
    if (obj8 != Py_None && obj8 != _global_py_pool) {
 
11052
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
 
11053
      SWIG_arg_fail(svn_argnum_obj8);
 
11054
      SWIG_fail;
 
11055
    }
 
11056
  }
 
11057
  {
 
11058
    svn_swig_py_release_py_lock();
 
11059
    
 
11060
    result = (svn_error_t *)svn_repos_fs_lock_many(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
 
11061
    
 
11062
    svn_swig_py_acquire_py_lock();
 
11063
    
 
11064
  }
 
11065
  {
 
11066
    if (result != NULL) {
 
11067
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
11068
      svn_swig_py_svn_exception(result);
 
11069
      else
 
11070
      svn_error_clear(result);
 
11071
      SWIG_fail;
 
11072
    }
 
11073
    Py_INCREF(Py_None);
 
11074
    resultobj = Py_None;
 
11075
  }
 
11076
  {
 
11077
    Py_XDECREF(_global_py_pool);
 
11078
  }
 
11079
  {
 
11080
    Py_XDECREF(_global_py_pool);
 
11081
  }
 
11082
  return resultobj;
 
11083
fail:
 
11084
  {
 
11085
    Py_XDECREF(_global_py_pool);
 
11086
  }
 
11087
  {
 
11088
    Py_XDECREF(_global_py_pool);
 
11089
  }
 
11090
  return NULL;
 
11091
}
 
11092
 
 
11093
 
10437
11094
SWIGINTERN PyObject *_wrap_svn_repos_fs_lock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10438
11095
  PyObject *resultobj = 0;
10439
11096
  svn_lock_t **arg1 = (svn_lock_t **) 0 ;
10464
11121
  arg1 = &temp1;
10465
11122
  if (!PyArg_ParseTuple(args,(char *)"OszzOOOO|O:svn_repos_fs_lock",&obj0,&arg3,&arg4,&arg5,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
10466
11123
  {
10467
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11124
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10468
11125
    if (PyErr_Occurred()) {
10469
11126
      SWIG_fail;
10470
11127
    }
10516
11173
    resultobj = Py_None;
10517
11174
  }
10518
11175
  {
10519
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_lock_t,
 
11176
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_lock_t,
10520
11177
        _global_py_pool, args))
10521
11178
    
10522
11179
    ;
10533
11190
}
10534
11191
 
10535
11192
 
 
11193
SWIGINTERN PyObject *_wrap_svn_repos_fs_unlock_many(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
11194
  PyObject *resultobj = 0;
 
11195
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
11196
  apr_hash_t *arg2 = (apr_hash_t *) 0 ;
 
11197
  svn_boolean_t arg3 ;
 
11198
  svn_fs_lock_callback_t arg4 = (svn_fs_lock_callback_t) 0 ;
 
11199
  void *arg5 = (void *) 0 ;
 
11200
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
11201
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
 
11202
  apr_pool_t *_global_pool = NULL ;
 
11203
  PyObject *_global_py_pool = NULL ;
 
11204
  PyObject * obj0 = 0 ;
 
11205
  PyObject * obj1 = 0 ;
 
11206
  PyObject * obj2 = 0 ;
 
11207
  PyObject * obj3 = 0 ;
 
11208
  PyObject * obj4 = 0 ;
 
11209
  PyObject * obj5 = 0 ;
 
11210
  svn_error_t *result = 0 ;
 
11211
  
 
11212
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
11213
      &_global_py_pool, &_global_pool))
 
11214
  SWIG_fail;
 
11215
  arg6 = _global_pool;
 
11216
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
11217
      &_global_py_pool, &_global_pool))
 
11218
  SWIG_fail;
 
11219
  arg7 = _global_pool;
 
11220
  if (!PyArg_ParseTuple(args,(char *)"OOOO|OO:svn_repos_fs_unlock_many",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
11221
  {
 
11222
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11223
    if (PyErr_Occurred()) {
 
11224
      SWIG_fail;
 
11225
    }
 
11226
  }
 
11227
  {
 
11228
    arg2 = svn_swig_py_stringhash_from_dict(obj1, _global_pool);
 
11229
  }
 
11230
  {
 
11231
    arg3 = (svn_boolean_t)SWIG_As_long (obj2);
 
11232
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
11233
      SWIG_fail;
 
11234
    }
 
11235
  }
 
11236
  {
 
11237
    arg4 = (svn_fs_lock_callback_t) svn_swig_py_fs_lock_callback;
 
11238
    arg5 = obj3;
 
11239
  }
 
11240
  if (obj4) {
 
11241
    /* Verify that the user supplied a valid pool */
 
11242
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
11243
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
11244
      SWIG_arg_fail(svn_argnum_obj4);
 
11245
      SWIG_fail;
 
11246
    }
 
11247
  }
 
11248
  if (obj5) {
 
11249
    /* Verify that the user supplied a valid pool */
 
11250
    if (obj5 != Py_None && obj5 != _global_py_pool) {
 
11251
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
 
11252
      SWIG_arg_fail(svn_argnum_obj5);
 
11253
      SWIG_fail;
 
11254
    }
 
11255
  }
 
11256
  {
 
11257
    svn_swig_py_release_py_lock();
 
11258
    
 
11259
    result = (svn_error_t *)svn_repos_fs_unlock_many(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
 
11260
    
 
11261
    svn_swig_py_acquire_py_lock();
 
11262
    
 
11263
  }
 
11264
  {
 
11265
    if (result != NULL) {
 
11266
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
11267
      svn_swig_py_svn_exception(result);
 
11268
      else
 
11269
      svn_error_clear(result);
 
11270
      SWIG_fail;
 
11271
    }
 
11272
    Py_INCREF(Py_None);
 
11273
    resultobj = Py_None;
 
11274
  }
 
11275
  {
 
11276
    Py_XDECREF(_global_py_pool);
 
11277
  }
 
11278
  {
 
11279
    Py_XDECREF(_global_py_pool);
 
11280
  }
 
11281
  return resultobj;
 
11282
fail:
 
11283
  {
 
11284
    Py_XDECREF(_global_py_pool);
 
11285
  }
 
11286
  {
 
11287
    Py_XDECREF(_global_py_pool);
 
11288
  }
 
11289
  return NULL;
 
11290
}
 
11291
 
 
11292
 
10536
11293
SWIGINTERN PyObject *_wrap_svn_repos_fs_unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10537
11294
  PyObject *resultobj = 0;
10538
11295
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
10553
11310
  arg5 = _global_pool;
10554
11311
  if (!PyArg_ParseTuple(args,(char *)"OszO|O:svn_repos_fs_unlock",&obj0,&arg2,&arg3,&obj3,&obj4)) SWIG_fail;
10555
11312
  {
10556
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11313
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10557
11314
    if (PyErr_Occurred()) {
10558
11315
      SWIG_fail;
10559
11316
    }
10628
11385
  arg1 = &temp1;
10629
11386
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_repos_fs_get_locks2",&obj0,&arg3,&obj2,&obj3,&obj4)) SWIG_fail;
10630
11387
  {
10631
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11388
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10632
11389
    if (PyErr_Occurred()) {
10633
11390
      SWIG_fail;
10634
11391
    }
10641
11398
  }
10642
11399
  {
10643
11400
    /* FIXME: Handle the NULL case. */
10644
 
    arg5 = svn_swig_py_repos_authz_func;
 
11401
    arg5 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
10645
11402
    arg6 = obj3;
10646
11403
  }
10647
11404
  if (obj4) {
10715
11472
  arg1 = &temp1;
10716
11473
  if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_repos_fs_get_locks",&obj0,&arg3,&obj2,&obj3)) SWIG_fail;
10717
11474
  {
10718
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11475
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10719
11476
    if (PyErr_Occurred()) {
10720
11477
      SWIG_fail;
10721
11478
    }
10722
11479
  }
10723
11480
  {
10724
11481
    /* FIXME: Handle the NULL case. */
10725
 
    arg4 = svn_swig_py_repos_authz_func;
 
11482
    arg4 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
10726
11483
    arg5 = obj2;
10727
11484
  }
10728
11485
  if (obj3) {
10805
11562
  arg11 = _global_pool;
10806
11563
  if (!PyArg_ParseTuple(args,(char *)"OOssOOOOO|O:svn_repos_fs_change_rev_prop4",&obj0,&obj1,&arg3,&arg4,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
10807
11564
  {
10808
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11565
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10809
11566
    if (PyErr_Occurred()) {
10810
11567
      SWIG_fail;
10811
11568
    }
10817
11574
    }
10818
11575
  }
10819
11576
  {
10820
 
    arg5 = (svn_string_t **)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_p_svn_string_t, svn_argnum_obj4);
 
11577
    arg5 = (svn_string_t **)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_p_svn_string_t, svn_argnum_obj4);
10821
11578
    if (PyErr_Occurred()) {
10822
11579
      SWIG_fail;
10823
11580
    }
10849
11606
  }
10850
11607
  {
10851
11608
    /* FIXME: Handle the NULL case. */
10852
 
    arg9 = svn_swig_py_repos_authz_func;
 
11609
    arg9 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
10853
11610
    arg10 = obj8;
10854
11611
  }
10855
11612
  if (obj9) {
10934
11691
  arg10 = _global_pool;
10935
11692
  if (!PyArg_ParseTuple(args,(char *)"OOssOOOO|O:svn_repos_fs_change_rev_prop3",&obj0,&obj1,&arg3,&arg4,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
10936
11693
  {
10937
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11694
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
10938
11695
    if (PyErr_Occurred()) {
10939
11696
      SWIG_fail;
10940
11697
    }
10972
11729
  }
10973
11730
  {
10974
11731
    /* FIXME: Handle the NULL case. */
10975
 
    arg8 = svn_swig_py_repos_authz_func;
 
11732
    arg8 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
10976
11733
    arg9 = obj7;
10977
11734
  }
10978
11735
  if (obj8) {
11040
11797
  arg8 = _global_pool;
11041
11798
  if (!PyArg_ParseTuple(args,(char *)"OOssOO|O:svn_repos_fs_change_rev_prop2",&obj0,&obj1,&arg3,&arg4,&obj4,&obj5,&obj6)) SWIG_fail;
11042
11799
  {
11043
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11800
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
11044
11801
    if (PyErr_Occurred()) {
11045
11802
      SWIG_fail;
11046
11803
    }
11066
11823
  }
11067
11824
  {
11068
11825
    /* FIXME: Handle the NULL case. */
11069
 
    arg6 = svn_swig_py_repos_authz_func;
 
11826
    arg6 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
11070
11827
    arg7 = obj5;
11071
11828
  }
11072
11829
  if (obj6) {
11131
11888
  arg6 = _global_pool;
11132
11889
  if (!PyArg_ParseTuple(args,(char *)"OOssO|O:svn_repos_fs_change_rev_prop",&obj0,&obj1,&arg3,&arg4,&obj4,&obj5)) SWIG_fail;
11133
11890
  {
11134
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11891
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
11135
11892
    if (PyErr_Occurred()) {
11136
11893
      SWIG_fail;
11137
11894
    }
11219
11976
  arg1 = &temp1;
11220
11977
  if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_repos_fs_revision_prop",&obj0,&obj1,&arg4,&obj3,&obj4)) SWIG_fail;
11221
11978
  {
11222
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
11979
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
11223
11980
    if (PyErr_Occurred()) {
11224
11981
      SWIG_fail;
11225
11982
    }
11232
11989
  }
11233
11990
  {
11234
11991
    /* FIXME: Handle the NULL case. */
11235
 
    arg5 = svn_swig_py_repos_authz_func;
 
11992
    arg5 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
11236
11993
    arg6 = obj3;
11237
11994
  }
11238
11995
  if (obj4) {
11311
12068
  arg1 = &temp1;
11312
12069
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_fs_revision_proplist",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11313
12070
  {
11314
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
12071
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
11315
12072
    if (PyErr_Occurred()) {
11316
12073
      SWIG_fail;
11317
12074
    }
11324
12081
  }
11325
12082
  {
11326
12083
    /* FIXME: Handle the NULL case. */
11327
 
    arg4 = svn_swig_py_repos_authz_func;
 
12084
    arg4 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
11328
12085
    arg5 = obj2;
11329
12086
  }
11330
12087
  if (obj3) {
11390
12147
  arg5 = _global_pool;
11391
12148
  if (!PyArg_ParseTuple(args,(char *)"OssO|O:svn_repos_fs_change_node_prop",&obj0,&arg2,&arg3,&obj3,&obj4)) SWIG_fail;
11392
12149
  {
11393
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
12150
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
11394
12151
    if (PyErr_Occurred()) {
11395
12152
      SWIG_fail;
11396
12153
    }
11447
12204
}
11448
12205
 
11449
12206
 
 
12207
SWIGINTERN PyObject *_wrap_svn_repos_fs_get_inherited_props(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12208
  PyObject *resultobj = 0;
 
12209
  apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
 
12210
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
12211
  char *arg3 = (char *) 0 ;
 
12212
  char *arg4 = (char *) 0 ;
 
12213
  svn_repos_authz_func_t arg5 = (svn_repos_authz_func_t) 0 ;
 
12214
  void *arg6 = (void *) 0 ;
 
12215
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
 
12216
  apr_pool_t *arg8 = (apr_pool_t *) 0 ;
 
12217
  apr_pool_t *_global_pool = NULL ;
 
12218
  PyObject *_global_py_pool = NULL ;
 
12219
  apr_array_header_t *temp1 ;
 
12220
  PyObject * obj0 = 0 ;
 
12221
  PyObject * obj3 = 0 ;
 
12222
  PyObject * obj4 = 0 ;
 
12223
  PyObject * obj5 = 0 ;
 
12224
  svn_error_t *result = 0 ;
 
12225
  
 
12226
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
12227
      &_global_py_pool, &_global_pool))
 
12228
  SWIG_fail;
 
12229
  arg7 = _global_pool;
 
12230
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
12231
      &_global_py_pool, &_global_pool))
 
12232
  SWIG_fail;
 
12233
  arg8 = _global_pool;
 
12234
  arg1 = &temp1;
 
12235
  if (!PyArg_ParseTuple(args,(char *)"OssO|OO:svn_repos_fs_get_inherited_props",&obj0,&arg3,&arg4,&obj3,&obj4,&obj5)) SWIG_fail;
 
12236
  {
 
12237
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
12238
    if (PyErr_Occurred()) {
 
12239
      SWIG_fail;
 
12240
    }
 
12241
  }
 
12242
  {
 
12243
    /* FIXME: Handle the NULL case. */
 
12244
    arg5 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
 
12245
    arg6 = obj3;
 
12246
  }
 
12247
  if (obj4) {
 
12248
    /* Verify that the user supplied a valid pool */
 
12249
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
12250
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
12251
      SWIG_arg_fail(svn_argnum_obj4);
 
12252
      SWIG_fail;
 
12253
    }
 
12254
  }
 
12255
  if (obj5) {
 
12256
    /* Verify that the user supplied a valid pool */
 
12257
    if (obj5 != Py_None && obj5 != _global_py_pool) {
 
12258
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
 
12259
      SWIG_arg_fail(svn_argnum_obj5);
 
12260
      SWIG_fail;
 
12261
    }
 
12262
  }
 
12263
  {
 
12264
    svn_swig_py_release_py_lock();
 
12265
    
 
12266
    result = (svn_error_t *)svn_repos_fs_get_inherited_props(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7,arg8);
 
12267
    
 
12268
    svn_swig_py_acquire_py_lock();
 
12269
    
 
12270
  }
 
12271
  {
 
12272
    if (result != NULL) {
 
12273
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
12274
      svn_swig_py_svn_exception(result);
 
12275
      else
 
12276
      svn_error_clear(result);
 
12277
      SWIG_fail;
 
12278
    }
 
12279
    Py_INCREF(Py_None);
 
12280
    resultobj = Py_None;
 
12281
  }
 
12282
  {
 
12283
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_propinheriteditemarray_to_dict(*arg1));
 
12284
  }
 
12285
  {
 
12286
    Py_XDECREF(_global_py_pool);
 
12287
  }
 
12288
  {
 
12289
    Py_XDECREF(_global_py_pool);
 
12290
  }
 
12291
  return resultobj;
 
12292
fail:
 
12293
  {
 
12294
    Py_XDECREF(_global_py_pool);
 
12295
  }
 
12296
  {
 
12297
    Py_XDECREF(_global_py_pool);
 
12298
  }
 
12299
  return NULL;
 
12300
}
 
12301
 
 
12302
 
11450
12303
SWIGINTERN PyObject *_wrap_svn_repos_fs_change_txn_prop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11451
12304
  PyObject *resultobj = 0;
11452
12305
  svn_fs_txn_t *arg1 = (svn_fs_txn_t *) 0 ;
11467
12320
  arg4 = _global_pool;
11468
12321
  if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_repos_fs_change_txn_prop",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
11469
12322
  {
11470
 
    arg1 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
12323
    arg1 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
11471
12324
    if (PyErr_Occurred()) {
11472
12325
      SWIG_fail;
11473
12326
    }
11542
12395
  arg3 = _global_pool;
11543
12396
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_repos_fs_change_txn_props",&obj0,&obj1,&obj2)) SWIG_fail;
11544
12397
  {
11545
 
    arg1 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
12398
    arg1 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
11546
12399
    if (PyErr_Occurred()) {
11547
12400
      SWIG_fail;
11548
12401
    }
11549
12402
  }
11550
12403
  {
11551
 
    arg2 = (apr_array_header_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
 
12404
    arg2 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
11552
12405
    if (PyErr_Occurred()) {
11553
12406
      SWIG_fail;
11554
12407
    }
11601
12454
  
11602
12455
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_kind_set",&obj0,&obj1)) SWIG_fail;
11603
12456
  {
11604
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12457
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11605
12458
    if (PyErr_Occurred()) {
11606
12459
      SWIG_fail;
11607
12460
    }
11628
12481
  
11629
12482
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_kind_get",&obj0)) SWIG_fail;
11630
12483
  {
11631
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12484
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11632
12485
    if (PyErr_Occurred()) {
11633
12486
      SWIG_fail;
11634
12487
    }
11649
12502
  
11650
12503
  if (!PyArg_ParseTuple(args,(char *)"Oc:svn_repos_node_t_action_set",&obj0,&arg2)) SWIG_fail;
11651
12504
  {
11652
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12505
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11653
12506
    if (PyErr_Occurred()) {
11654
12507
      SWIG_fail;
11655
12508
    }
11670
12523
  
11671
12524
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_action_get",&obj0)) SWIG_fail;
11672
12525
  {
11673
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12526
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11674
12527
    if (PyErr_Occurred()) {
11675
12528
      SWIG_fail;
11676
12529
    }
11692
12545
  
11693
12546
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_text_mod_set",&obj0,&obj1)) SWIG_fail;
11694
12547
  {
11695
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12548
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11696
12549
    if (PyErr_Occurred()) {
11697
12550
      SWIG_fail;
11698
12551
    }
11719
12572
  
11720
12573
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_text_mod_get",&obj0)) SWIG_fail;
11721
12574
  {
11722
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12575
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11723
12576
    if (PyErr_Occurred()) {
11724
12577
      SWIG_fail;
11725
12578
    }
11741
12594
  
11742
12595
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_prop_mod_set",&obj0,&obj1)) SWIG_fail;
11743
12596
  {
11744
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12597
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11745
12598
    if (PyErr_Occurred()) {
11746
12599
      SWIG_fail;
11747
12600
    }
11768
12621
  
11769
12622
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_prop_mod_get",&obj0)) SWIG_fail;
11770
12623
  {
11771
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12624
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11772
12625
    if (PyErr_Occurred()) {
11773
12626
      SWIG_fail;
11774
12627
    }
11789
12642
  
11790
12643
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_repos_node_t_name_set",&obj0,&arg2)) SWIG_fail;
11791
12644
  {
11792
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12645
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11793
12646
    if (PyErr_Occurred()) {
11794
12647
      SWIG_fail;
11795
12648
    }
11817
12670
  
11818
12671
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_name_get",&obj0)) SWIG_fail;
11819
12672
  {
11820
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12673
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11821
12674
    if (PyErr_Occurred()) {
11822
12675
      SWIG_fail;
11823
12676
    }
11839
12692
  
11840
12693
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_copyfrom_rev_set",&obj0,&obj1)) SWIG_fail;
11841
12694
  {
11842
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12695
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11843
12696
    if (PyErr_Occurred()) {
11844
12697
      SWIG_fail;
11845
12698
    }
11866
12719
  
11867
12720
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_copyfrom_rev_get",&obj0)) SWIG_fail;
11868
12721
  {
11869
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12722
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11870
12723
    if (PyErr_Occurred()) {
11871
12724
      SWIG_fail;
11872
12725
    }
11887
12740
  
11888
12741
  if (!PyArg_ParseTuple(args,(char *)"Oz:svn_repos_node_t_copyfrom_path_set",&obj0,&arg2)) SWIG_fail;
11889
12742
  {
11890
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12743
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11891
12744
    if (PyErr_Occurred()) {
11892
12745
      SWIG_fail;
11893
12746
    }
11915
12768
  
11916
12769
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_copyfrom_path_get",&obj0)) SWIG_fail;
11917
12770
  {
11918
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12771
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11919
12772
    if (PyErr_Occurred()) {
11920
12773
      SWIG_fail;
11921
12774
    }
11937
12790
  
11938
12791
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_sibling_set",&obj0,&obj1)) SWIG_fail;
11939
12792
  {
11940
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12793
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11941
12794
    if (PyErr_Occurred()) {
11942
12795
      SWIG_fail;
11943
12796
    }
11944
12797
  }
11945
12798
  {
11946
 
    arg2 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
 
12799
    arg2 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
11947
12800
    if (PyErr_Occurred()) {
11948
12801
      SWIG_fail;
11949
12802
    }
11964
12817
  
11965
12818
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_sibling_get",&obj0)) SWIG_fail;
11966
12819
  {
11967
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12820
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11968
12821
    if (PyErr_Occurred()) {
11969
12822
      SWIG_fail;
11970
12823
    }
11971
12824
  }
11972
12825
  result = (struct svn_repos_node_t *) ((arg1)->sibling);
11973
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
 
12826
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
11974
12827
    _global_py_pool, args);
11975
12828
  return resultobj;
11976
12829
fail:
11987
12840
  
11988
12841
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_child_set",&obj0,&obj1)) SWIG_fail;
11989
12842
  {
11990
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12843
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
11991
12844
    if (PyErr_Occurred()) {
11992
12845
      SWIG_fail;
11993
12846
    }
11994
12847
  }
11995
12848
  {
11996
 
    arg2 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
 
12849
    arg2 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
11997
12850
    if (PyErr_Occurred()) {
11998
12851
      SWIG_fail;
11999
12852
    }
12014
12867
  
12015
12868
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_child_get",&obj0)) SWIG_fail;
12016
12869
  {
12017
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12870
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
12018
12871
    if (PyErr_Occurred()) {
12019
12872
      SWIG_fail;
12020
12873
    }
12021
12874
  }
12022
12875
  result = (struct svn_repos_node_t *) ((arg1)->child);
12023
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
 
12876
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
12024
12877
    _global_py_pool, args);
12025
12878
  return resultobj;
12026
12879
fail:
12037
12890
  
12038
12891
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_parent_set",&obj0,&obj1)) SWIG_fail;
12039
12892
  {
12040
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12893
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
12041
12894
    if (PyErr_Occurred()) {
12042
12895
      SWIG_fail;
12043
12896
    }
12044
12897
  }
12045
12898
  {
12046
 
    arg2 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
 
12899
    arg2 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
12047
12900
    if (PyErr_Occurred()) {
12048
12901
      SWIG_fail;
12049
12902
    }
12064
12917
  
12065
12918
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_parent_get",&obj0)) SWIG_fail;
12066
12919
  {
12067
 
    arg1 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
 
12920
    arg1 = (struct svn_repos_node_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
12068
12921
    if (PyErr_Occurred()) {
12069
12922
      SWIG_fail;
12070
12923
    }
12071
12924
  }
12072
12925
  result = (struct svn_repos_node_t *) ((arg1)->parent);
12073
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
 
12926
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
12074
12927
    _global_py_pool, args);
12075
12928
  return resultobj;
12076
12929
fail:
12117
12970
  arg2 = &temp2;
12118
12971
  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:svn_repos_node_editor",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12119
12972
  {
12120
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
12121
 
    if (PyErr_Occurred()) {
12122
 
      SWIG_fail;
12123
 
    }
12124
 
  }
12125
 
  {
12126
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
12127
 
    if (PyErr_Occurred()) {
12128
 
      SWIG_fail;
12129
 
    }
12130
 
  }
12131
 
  {
12132
 
    arg5 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
12973
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
12974
    if (PyErr_Occurred()) {
 
12975
      SWIG_fail;
 
12976
    }
 
12977
  }
 
12978
  {
 
12979
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
 
12980
    if (PyErr_Occurred()) {
 
12981
      SWIG_fail;
 
12982
    }
 
12983
  }
 
12984
  {
 
12985
    arg5 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
12133
12986
    if (PyErr_Occurred()) {
12134
12987
      SWIG_fail;
12135
12988
    }
12170
13023
    resultobj = Py_None;
12171
13024
  }
12172
13025
  {
12173
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
 
13026
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
12174
13027
        _global_py_pool, args))
12175
13028
    
12176
13029
    ;
12177
13030
  }
12178
13031
  {
12179
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
13032
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
12180
13033
        _global_py_pool, args))
12181
13034
    
12182
13035
    ;
12222
13075
    svn_swig_py_acquire_py_lock();
12223
13076
    
12224
13077
  }
12225
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
 
13078
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
12226
13079
    _global_py_pool, args);
12227
13080
  return resultobj;
12228
13081
fail:
12230
13083
}
12231
13084
 
12232
13085
 
 
13086
SWIGINTERN PyObject *_wrap_svn_repos_info_format(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13087
  PyObject *resultobj = 0;
 
13088
  int *arg1 = (int *) 0 ;
 
13089
  svn_version_t **arg2 = (svn_version_t **) 0 ;
 
13090
  svn_repos_t *arg3 = (svn_repos_t *) 0 ;
 
13091
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
13092
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
13093
  apr_pool_t *_global_pool = NULL ;
 
13094
  PyObject *_global_py_pool = NULL ;
 
13095
  int temp1 ;
 
13096
  int res1 = SWIG_TMPOBJ ;
 
13097
  svn_version_t *temp2 ;
 
13098
  PyObject * obj0 = 0 ;
 
13099
  PyObject * obj1 = 0 ;
 
13100
  PyObject * obj2 = 0 ;
 
13101
  svn_error_t *result = 0 ;
 
13102
  
 
13103
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13104
      &_global_py_pool, &_global_pool))
 
13105
  SWIG_fail;
 
13106
  arg4 = _global_pool;
 
13107
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13108
      &_global_py_pool, &_global_pool))
 
13109
  SWIG_fail;
 
13110
  arg5 = _global_pool;
 
13111
  arg1 = &temp1;
 
13112
  arg2 = &temp2;
 
13113
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_repos_info_format",&obj0,&obj1,&obj2)) SWIG_fail;
 
13114
  {
 
13115
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
13116
    if (PyErr_Occurred()) {
 
13117
      SWIG_fail;
 
13118
    }
 
13119
  }
 
13120
  if (obj1) {
 
13121
    /* Verify that the user supplied a valid pool */
 
13122
    if (obj1 != Py_None && obj1 != _global_py_pool) {
 
13123
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
 
13124
      SWIG_arg_fail(svn_argnum_obj1);
 
13125
      SWIG_fail;
 
13126
    }
 
13127
  }
 
13128
  if (obj2) {
 
13129
    /* Verify that the user supplied a valid pool */
 
13130
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
13131
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
13132
      SWIG_arg_fail(svn_argnum_obj2);
 
13133
      SWIG_fail;
 
13134
    }
 
13135
  }
 
13136
  {
 
13137
    svn_swig_py_release_py_lock();
 
13138
    
 
13139
    result = (svn_error_t *)svn_repos_info_format(arg1,arg2,arg3,arg4,arg5);
 
13140
    
 
13141
    svn_swig_py_acquire_py_lock();
 
13142
    
 
13143
  }
 
13144
  {
 
13145
    if (result != NULL) {
 
13146
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
13147
      svn_swig_py_svn_exception(result);
 
13148
      else
 
13149
      svn_error_clear(result);
 
13150
      SWIG_fail;
 
13151
    }
 
13152
    Py_INCREF(Py_None);
 
13153
    resultobj = Py_None;
 
13154
  }
 
13155
  if (SWIG_IsTmpObj(res1)) {
 
13156
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
 
13157
  } else {
 
13158
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
13159
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
 
13160
  }
 
13161
  {
 
13162
    /* FIXME: Missing argout typemap: svn_repos_info_format arg 2 (svn_version_t **) */
 
13163
    
 
13164
    
 
13165
    
 
13166
    
 
13167
    SWIG_exception(SWIG_ValueError, "svn_repos_info_format is not implemented yet");
 
13168
    
 
13169
  }
 
13170
  {
 
13171
    Py_XDECREF(_global_py_pool);
 
13172
  }
 
13173
  {
 
13174
    Py_XDECREF(_global_py_pool);
 
13175
  }
 
13176
  return resultobj;
 
13177
fail:
 
13178
  {
 
13179
    Py_XDECREF(_global_py_pool);
 
13180
  }
 
13181
  {
 
13182
    Py_XDECREF(_global_py_pool);
 
13183
  }
 
13184
  return NULL;
 
13185
}
 
13186
 
 
13187
 
 
13188
SWIGINTERN PyObject *_wrap_svn_repos_verify_fs3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13189
  PyObject *resultobj = 0;
 
13190
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
13191
  svn_revnum_t arg2 ;
 
13192
  svn_revnum_t arg3 ;
 
13193
  svn_boolean_t arg4 ;
 
13194
  svn_boolean_t arg5 ;
 
13195
  svn_repos_notify_func_t arg6 = (svn_repos_notify_func_t) 0 ;
 
13196
  void *arg7 = (void *) 0 ;
 
13197
  svn_repos_verify_callback_t arg8 = (svn_repos_verify_callback_t) 0 ;
 
13198
  void *arg9 = (void *) 0 ;
 
13199
  svn_cancel_func_t arg10 = (svn_cancel_func_t) 0 ;
 
13200
  void *arg11 = (void *) 0 ;
 
13201
  apr_pool_t *arg12 = (apr_pool_t *) 0 ;
 
13202
  apr_pool_t *_global_pool = NULL ;
 
13203
  PyObject *_global_py_pool = NULL ;
 
13204
  PyObject * obj0 = 0 ;
 
13205
  PyObject * obj1 = 0 ;
 
13206
  PyObject * obj2 = 0 ;
 
13207
  PyObject * obj3 = 0 ;
 
13208
  PyObject * obj4 = 0 ;
 
13209
  PyObject * obj5 = 0 ;
 
13210
  PyObject * obj6 = 0 ;
 
13211
  PyObject * obj7 = 0 ;
 
13212
  PyObject * obj8 = 0 ;
 
13213
  PyObject * obj9 = 0 ;
 
13214
  PyObject * obj10 = 0 ;
 
13215
  PyObject * obj11 = 0 ;
 
13216
  svn_error_t *result = 0 ;
 
13217
  
 
13218
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13219
      &_global_py_pool, &_global_pool))
 
13220
  SWIG_fail;
 
13221
  arg12 = _global_pool;
 
13222
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO|O:svn_repos_verify_fs3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
 
13223
  {
 
13224
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
13225
    if (PyErr_Occurred()) {
 
13226
      SWIG_fail;
 
13227
    }
 
13228
  }
 
13229
  {
 
13230
    arg2 = (svn_revnum_t)SWIG_As_long (obj1);
 
13231
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
13232
      SWIG_fail;
 
13233
    }
 
13234
  }
 
13235
  {
 
13236
    arg3 = (svn_revnum_t)SWIG_As_long (obj2);
 
13237
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
13238
      SWIG_fail;
 
13239
    }
 
13240
  }
 
13241
  {
 
13242
    arg4 = (svn_boolean_t)SWIG_As_long (obj3);
 
13243
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
13244
      SWIG_fail;
 
13245
    }
 
13246
  }
 
13247
  {
 
13248
    arg5 = (svn_boolean_t)SWIG_As_long (obj4);
 
13249
    if (SWIG_arg_fail(svn_argnum_obj4)) {
 
13250
      SWIG_fail;
 
13251
    }
 
13252
  }
 
13253
  {
 
13254
    svn_repos_notify_func_t * tmp =
 
13255
    svn_swig_py_must_get_ptr(obj5, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj5);
 
13256
    if (tmp == NULL || PyErr_Occurred()) {
 
13257
      SWIG_fail;
 
13258
    }
 
13259
    arg6 = *tmp;
 
13260
  }
 
13261
  {
 
13262
    if (obj6 == Py_None) {
 
13263
      arg7 = NULL;
 
13264
    } else if (SWIG_ConvertPtr(obj6, (void **) &arg7, 0, 0) == -1) {
 
13265
      arg7 = (void *) obj6;
 
13266
      PyErr_Clear();
 
13267
    }
 
13268
  }
 
13269
  {
 
13270
    svn_repos_verify_callback_t * tmp =
 
13271
    svn_swig_py_must_get_ptr(obj7, SWIGTYPE_p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj7);
 
13272
    if (tmp == NULL || PyErr_Occurred()) {
 
13273
      SWIG_fail;
 
13274
    }
 
13275
    arg8 = *tmp;
 
13276
  }
 
13277
  {
 
13278
    if (obj8 == Py_None) {
 
13279
      arg9 = NULL;
 
13280
    } else if (SWIG_ConvertPtr(obj8, (void **) &arg9, 0, 0) == -1) {
 
13281
      arg9 = (void *) obj8;
 
13282
      PyErr_Clear();
 
13283
    }
 
13284
  }
 
13285
  {
 
13286
    svn_cancel_func_t * tmp =
 
13287
    svn_swig_py_must_get_ptr(obj9, SWIGTYPE_p_p_f_p_void__p_svn_error_t, svn_argnum_obj9);
 
13288
    if (tmp == NULL || PyErr_Occurred()) {
 
13289
      SWIG_fail;
 
13290
    }
 
13291
    arg10 = *tmp;
 
13292
  }
 
13293
  {
 
13294
    if (obj10 == Py_None) {
 
13295
      arg11 = NULL;
 
13296
    } else if (SWIG_ConvertPtr(obj10, (void **) &arg11, 0, 0) == -1) {
 
13297
      arg11 = (void *) obj10;
 
13298
      PyErr_Clear();
 
13299
    }
 
13300
  }
 
13301
  if (obj11) {
 
13302
    /* Verify that the user supplied a valid pool */
 
13303
    if (obj11 != Py_None && obj11 != _global_py_pool) {
 
13304
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
 
13305
      SWIG_arg_fail(svn_argnum_obj11);
 
13306
      SWIG_fail;
 
13307
    }
 
13308
  }
 
13309
  {
 
13310
    svn_swig_py_release_py_lock();
 
13311
    
 
13312
    result = (svn_error_t *)svn_repos_verify_fs3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
 
13313
    
 
13314
    svn_swig_py_acquire_py_lock();
 
13315
    
 
13316
  }
 
13317
  {
 
13318
    if (result != NULL) {
 
13319
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
13320
      svn_swig_py_svn_exception(result);
 
13321
      else
 
13322
      svn_error_clear(result);
 
13323
      SWIG_fail;
 
13324
    }
 
13325
    Py_INCREF(Py_None);
 
13326
    resultobj = Py_None;
 
13327
  }
 
13328
  {
 
13329
    Py_XDECREF(_global_py_pool);
 
13330
  }
 
13331
  return resultobj;
 
13332
fail:
 
13333
  {
 
13334
    Py_XDECREF(_global_py_pool);
 
13335
  }
 
13336
  return NULL;
 
13337
}
 
13338
 
 
13339
 
12233
13340
SWIGINTERN PyObject *_wrap_svn_repos_verify_fs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12234
13341
  PyObject *resultobj = 0;
12235
13342
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
12258
13365
  arg8 = _global_pool;
12259
13366
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO|O:svn_repos_verify_fs2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
12260
13367
  {
12261
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
13368
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
12262
13369
    if (PyErr_Occurred()) {
12263
13370
      SWIG_fail;
12264
13371
    }
12277
13384
  }
12278
13385
  {
12279
13386
    svn_repos_notify_func_t * tmp =
12280
 
    svn_swig_MustGetPtr(obj3, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj3);
 
13387
    svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj3);
12281
13388
    if (tmp == NULL || PyErr_Occurred()) {
12282
13389
      SWIG_fail;
12283
13390
    }
12293
13400
  }
12294
13401
  {
12295
13402
    svn_cancel_func_t * tmp =
12296
 
    svn_swig_MustGetPtr(obj5, SWIGTYPE_p_p_f_p_void__p_svn_error_t, svn_argnum_obj5);
 
13403
    svn_swig_py_must_get_ptr(obj5, SWIGTYPE_p_p_f_p_void__p_svn_error_t, svn_argnum_obj5);
12297
13404
    if (tmp == NULL || PyErr_Occurred()) {
12298
13405
      SWIG_fail;
12299
13406
    }
12371
13478
  arg7 = _global_pool;
12372
13479
  if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:svn_repos_verify_fs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12373
13480
  {
12374
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
13481
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
12375
13482
    if (PyErr_Occurred()) {
12376
13483
      SWIG_fail;
12377
13484
    }
12392
13499
    }
12393
13500
  }
12394
13501
  {
12395
 
    arg5 = svn_swig_py_cancel_func;
12396
 
    arg6 = obj4; /* our function is the baton. */
 
13502
    arg5 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
13503
    arg6 = obj4;
12397
13504
  }
12398
13505
  if (obj5) {
12399
13506
    /* Verify that the user supplied a valid pool */
12467
13574
  arg11 = _global_pool;
12468
13575
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|O:svn_repos_dump_fs3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
12469
13576
  {
12470
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
13577
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
12471
13578
    if (PyErr_Occurred()) {
12472
13579
      SWIG_fail;
12473
13580
    }
12501
13608
  }
12502
13609
  {
12503
13610
    svn_repos_notify_func_t * tmp =
12504
 
    svn_swig_MustGetPtr(obj6, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj6);
 
13611
    svn_swig_py_must_get_ptr(obj6, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj6);
12505
13612
    if (tmp == NULL || PyErr_Occurred()) {
12506
13613
      SWIG_fail;
12507
13614
    }
12516
13623
    }
12517
13624
  }
12518
13625
  {
12519
 
    arg9 = svn_swig_py_cancel_func;
12520
 
    arg10 = obj8; /* our function is the baton. */
 
13626
    arg9 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
13627
    arg10 = obj8;
12521
13628
  }
12522
13629
  if (obj9) {
12523
13630
    /* Verify that the user supplied a valid pool */
12589
13696
  arg10 = _global_pool;
12590
13697
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO|O:svn_repos_dump_fs2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
12591
13698
  {
12592
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
13699
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
12593
13700
    if (PyErr_Occurred()) {
12594
13701
      SWIG_fail;
12595
13702
    }
12625
13732
    }
12626
13733
  }
12627
13734
  {
12628
 
    arg8 = svn_swig_py_cancel_func;
12629
 
    arg9 = obj7; /* our function is the baton. */
 
13735
    arg8 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
13736
    arg9 = obj7;
12630
13737
  }
12631
13738
  if (obj8) {
12632
13739
    /* Verify that the user supplied a valid pool */
12696
13803
  arg9 = _global_pool;
12697
13804
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO|O:svn_repos_dump_fs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
12698
13805
  {
12699
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
13806
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
12700
13807
    if (PyErr_Occurred()) {
12701
13808
      SWIG_fail;
12702
13809
    }
12726
13833
    }
12727
13834
  }
12728
13835
  {
12729
 
    arg7 = svn_swig_py_cancel_func;
12730
 
    arg8 = obj6; /* our function is the baton. */
 
13836
    arg7 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
13837
    arg8 = obj6;
12731
13838
  }
12732
13839
  if (obj7) {
12733
13840
    /* Verify that the user supplied a valid pool */
12768
13875
}
12769
13876
 
12770
13877
 
 
13878
SWIGINTERN PyObject *_wrap_svn_repos_load_fs5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13879
  PyObject *resultobj = 0;
 
13880
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
13881
  svn_stream_t *arg2 = (svn_stream_t *) 0 ;
 
13882
  svn_revnum_t arg3 ;
 
13883
  svn_revnum_t arg4 ;
 
13884
  enum svn_repos_load_uuid arg5 ;
 
13885
  char *arg6 = (char *) 0 ;
 
13886
  svn_boolean_t arg7 ;
 
13887
  svn_boolean_t arg8 ;
 
13888
  svn_boolean_t arg9 ;
 
13889
  svn_boolean_t arg10 ;
 
13890
  svn_repos_notify_func_t arg11 = (svn_repos_notify_func_t) 0 ;
 
13891
  void *arg12 = (void *) 0 ;
 
13892
  svn_cancel_func_t arg13 = (svn_cancel_func_t) 0 ;
 
13893
  void *arg14 = (void *) 0 ;
 
13894
  apr_pool_t *arg15 = (apr_pool_t *) 0 ;
 
13895
  apr_pool_t *_global_pool = NULL ;
 
13896
  PyObject *_global_py_pool = NULL ;
 
13897
  PyObject * obj0 = 0 ;
 
13898
  PyObject * obj1 = 0 ;
 
13899
  PyObject * obj2 = 0 ;
 
13900
  PyObject * obj3 = 0 ;
 
13901
  PyObject * obj4 = 0 ;
 
13902
  PyObject * obj6 = 0 ;
 
13903
  PyObject * obj7 = 0 ;
 
13904
  PyObject * obj8 = 0 ;
 
13905
  PyObject * obj9 = 0 ;
 
13906
  PyObject * obj10 = 0 ;
 
13907
  PyObject * obj11 = 0 ;
 
13908
  PyObject * obj12 = 0 ;
 
13909
  PyObject * obj13 = 0 ;
 
13910
  svn_error_t *result = 0 ;
 
13911
  
 
13912
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13913
      &_global_py_pool, &_global_pool))
 
13914
  SWIG_fail;
 
13915
  arg15 = _global_pool;
 
13916
  if (!PyArg_ParseTuple(args,(char *)"OOOOOzOOOOOOO|O:svn_repos_load_fs5",&obj0,&obj1,&obj2,&obj3,&obj4,&arg6,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
 
13917
  {
 
13918
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
13919
    if (PyErr_Occurred()) {
 
13920
      SWIG_fail;
 
13921
    }
 
13922
  }
 
13923
  {
 
13924
    arg2 = svn_swig_py_make_stream (obj1, _global_pool);
 
13925
  }
 
13926
  {
 
13927
    arg3 = (svn_revnum_t)SWIG_As_long (obj2);
 
13928
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
13929
      SWIG_fail;
 
13930
    }
 
13931
  }
 
13932
  {
 
13933
    arg4 = (svn_revnum_t)SWIG_As_long (obj3);
 
13934
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
13935
      SWIG_fail;
 
13936
    }
 
13937
  }
 
13938
  {
 
13939
    arg5 = (enum svn_repos_load_uuid)SWIG_As_long (obj4);
 
13940
    if (SWIG_arg_fail(svn_argnum_obj4)) {
 
13941
      SWIG_fail;
 
13942
    }
 
13943
  }
 
13944
  {
 
13945
    arg7 = (svn_boolean_t)SWIG_As_long (obj6);
 
13946
    if (SWIG_arg_fail(svn_argnum_obj6)) {
 
13947
      SWIG_fail;
 
13948
    }
 
13949
  }
 
13950
  {
 
13951
    arg8 = (svn_boolean_t)SWIG_As_long (obj7);
 
13952
    if (SWIG_arg_fail(svn_argnum_obj7)) {
 
13953
      SWIG_fail;
 
13954
    }
 
13955
  }
 
13956
  {
 
13957
    arg9 = (svn_boolean_t)SWIG_As_long (obj8);
 
13958
    if (SWIG_arg_fail(svn_argnum_obj8)) {
 
13959
      SWIG_fail;
 
13960
    }
 
13961
  }
 
13962
  {
 
13963
    arg10 = (svn_boolean_t)SWIG_As_long (obj9);
 
13964
    if (SWIG_arg_fail(svn_argnum_obj9)) {
 
13965
      SWIG_fail;
 
13966
    }
 
13967
  }
 
13968
  {
 
13969
    svn_repos_notify_func_t * tmp =
 
13970
    svn_swig_py_must_get_ptr(obj10, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj10);
 
13971
    if (tmp == NULL || PyErr_Occurred()) {
 
13972
      SWIG_fail;
 
13973
    }
 
13974
    arg11 = *tmp;
 
13975
  }
 
13976
  {
 
13977
    if (obj11 == Py_None) {
 
13978
      arg12 = NULL;
 
13979
    } else if (SWIG_ConvertPtr(obj11, (void **) &arg12, 0, 0) == -1) {
 
13980
      arg12 = (void *) obj11;
 
13981
      PyErr_Clear();
 
13982
    }
 
13983
  }
 
13984
  {
 
13985
    arg13 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
13986
    arg14 = obj12;
 
13987
  }
 
13988
  if (obj13) {
 
13989
    /* Verify that the user supplied a valid pool */
 
13990
    if (obj13 != Py_None && obj13 != _global_py_pool) {
 
13991
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj13);
 
13992
      SWIG_arg_fail(svn_argnum_obj13);
 
13993
      SWIG_fail;
 
13994
    }
 
13995
  }
 
13996
  {
 
13997
    svn_swig_py_release_py_lock();
 
13998
    
 
13999
    result = (svn_error_t *)svn_repos_load_fs5(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
 
14000
    
 
14001
    svn_swig_py_acquire_py_lock();
 
14002
    
 
14003
  }
 
14004
  {
 
14005
    if (result != NULL) {
 
14006
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
14007
      svn_swig_py_svn_exception(result);
 
14008
      else
 
14009
      svn_error_clear(result);
 
14010
      SWIG_fail;
 
14011
    }
 
14012
    Py_INCREF(Py_None);
 
14013
    resultobj = Py_None;
 
14014
  }
 
14015
  {
 
14016
    Py_XDECREF(_global_py_pool);
 
14017
  }
 
14018
  return resultobj;
 
14019
fail:
 
14020
  {
 
14021
    Py_XDECREF(_global_py_pool);
 
14022
  }
 
14023
  return NULL;
 
14024
}
 
14025
 
 
14026
 
12771
14027
SWIGINTERN PyObject *_wrap_svn_repos_load_fs4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12772
14028
  PyObject *resultobj = 0;
12773
14029
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
12806
14062
  arg14 = _global_pool;
12807
14063
  if (!PyArg_ParseTuple(args,(char *)"OOOOOzOOOOOO|O:svn_repos_load_fs4",&obj0,&obj1,&obj2,&obj3,&obj4,&arg6,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
12808
14064
  {
12809
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
14065
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
12810
14066
    if (PyErr_Occurred()) {
12811
14067
      SWIG_fail;
12812
14068
    }
12852
14108
  }
12853
14109
  {
12854
14110
    svn_repos_notify_func_t * tmp =
12855
 
    svn_swig_MustGetPtr(obj9, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj9);
 
14111
    svn_swig_py_must_get_ptr(obj9, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj9);
12856
14112
    if (tmp == NULL || PyErr_Occurred()) {
12857
14113
      SWIG_fail;
12858
14114
    }
12867
14123
    }
12868
14124
  }
12869
14125
  {
12870
 
    arg12 = svn_swig_py_cancel_func;
12871
 
    arg13 = obj11; /* our function is the baton. */
 
14126
    arg12 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
14127
    arg13 = obj11;
12872
14128
  }
12873
14129
  if (obj12) {
12874
14130
    /* Verify that the user supplied a valid pool */
12943
14199
  arg12 = _global_pool;
12944
14200
  if (!PyArg_ParseTuple(args,(char *)"OOOzOOOOOO|O:svn_repos_load_fs3",&obj0,&obj1,&obj2,&arg4,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
12945
14201
  {
12946
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
14202
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
12947
14203
    if (PyErr_Occurred()) {
12948
14204
      SWIG_fail;
12949
14205
    }
12977
14233
  }
12978
14234
  {
12979
14235
    svn_repos_notify_func_t * tmp =
12980
 
    svn_swig_MustGetPtr(obj7, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj7);
 
14236
    svn_swig_py_must_get_ptr(obj7, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj7);
12981
14237
    if (tmp == NULL || PyErr_Occurred()) {
12982
14238
      SWIG_fail;
12983
14239
    }
12992
14248
    }
12993
14249
  }
12994
14250
  {
12995
 
    arg10 = svn_swig_py_cancel_func;
12996
 
    arg11 = obj9; /* our function is the baton. */
 
14251
    arg10 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
14252
    arg11 = obj9;
12997
14253
  }
12998
14254
  if (obj10) {
12999
14255
    /* Verify that the user supplied a valid pool */
13064
14320
  arg10 = _global_pool;
13065
14321
  if (!PyArg_ParseTuple(args,(char *)"OOOOzOOO|O:svn_repos_load_fs2",&obj0,&obj1,&obj2,&obj3,&arg5,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
13066
14322
  {
13067
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
14323
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
13068
14324
    if (PyErr_Occurred()) {
13069
14325
      SWIG_fail;
13070
14326
    }
13094
14350
    }
13095
14351
  }
13096
14352
  {
13097
 
    arg8 = svn_swig_py_cancel_func;
13098
 
    arg9 = obj7; /* our function is the baton. */
 
14353
    arg8 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
14354
    arg9 = obj7;
13099
14355
  }
13100
14356
  if (obj8) {
13101
14357
    /* Verify that the user supplied a valid pool */
13162
14418
  arg8 = _global_pool;
13163
14419
  if (!PyArg_ParseTuple(args,(char *)"OOOOzO|O:svn_repos_load_fs",&obj0,&obj1,&obj2,&obj3,&arg5,&obj5,&obj6)) SWIG_fail;
13164
14420
  {
13165
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
14421
    arg1 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
13166
14422
    if (PyErr_Occurred()) {
13167
14423
      SWIG_fail;
13168
14424
    }
13180
14436
    }
13181
14437
  }
13182
14438
  {
13183
 
    arg6 = svn_swig_py_cancel_func;
13184
 
    arg7 = obj5; /* our function is the baton. */
 
14439
    arg6 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
14440
    arg7 = obj5;
13185
14441
  }
13186
14442
  if (obj6) {
13187
14443
    /* Verify that the user supplied a valid pool */
13231
14487
  
13232
14488
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_magic_header_record_set",&obj0,&obj1)) SWIG_fail;
13233
14489
  {
13234
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14490
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13235
14491
    if (PyErr_Occurred()) {
13236
14492
      SWIG_fail;
13237
14493
    }
13258
14514
  
13259
14515
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_magic_header_record_get",&obj0)) SWIG_fail;
13260
14516
  {
13261
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14517
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13262
14518
    if (PyErr_Occurred()) {
13263
14519
      SWIG_fail;
13264
14520
    }
13280
14536
  
13281
14537
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_uuid_record_set",&obj0,&obj1)) SWIG_fail;
13282
14538
  {
13283
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14539
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13284
14540
    if (PyErr_Occurred()) {
13285
14541
      SWIG_fail;
13286
14542
    }
13307
14563
  
13308
14564
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_uuid_record_get",&obj0)) SWIG_fail;
13309
14565
  {
13310
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14566
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13311
14567
    if (PyErr_Occurred()) {
13312
14568
      SWIG_fail;
13313
14569
    }
13329
14585
  
13330
14586
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_new_revision_record_set",&obj0,&obj1)) SWIG_fail;
13331
14587
  {
13332
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14588
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13333
14589
    if (PyErr_Occurred()) {
13334
14590
      SWIG_fail;
13335
14591
    }
13356
14612
  
13357
14613
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_new_revision_record_get",&obj0)) SWIG_fail;
13358
14614
  {
13359
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14615
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13360
14616
    if (PyErr_Occurred()) {
13361
14617
      SWIG_fail;
13362
14618
    }
13378
14634
  
13379
14635
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_new_node_record_set",&obj0,&obj1)) SWIG_fail;
13380
14636
  {
13381
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14637
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13382
14638
    if (PyErr_Occurred()) {
13383
14639
      SWIG_fail;
13384
14640
    }
13405
14661
  
13406
14662
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_new_node_record_get",&obj0)) SWIG_fail;
13407
14663
  {
13408
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14664
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13409
14665
    if (PyErr_Occurred()) {
13410
14666
      SWIG_fail;
13411
14667
    }
13427
14683
  
13428
14684
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_set_revision_property_set",&obj0,&obj1)) SWIG_fail;
13429
14685
  {
13430
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14686
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13431
14687
    if (PyErr_Occurred()) {
13432
14688
      SWIG_fail;
13433
14689
    }
13454
14710
  
13455
14711
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_set_revision_property_get",&obj0)) SWIG_fail;
13456
14712
  {
13457
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14713
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13458
14714
    if (PyErr_Occurred()) {
13459
14715
      SWIG_fail;
13460
14716
    }
13476
14732
  
13477
14733
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_set_node_property_set",&obj0,&obj1)) SWIG_fail;
13478
14734
  {
13479
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14735
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13480
14736
    if (PyErr_Occurred()) {
13481
14737
      SWIG_fail;
13482
14738
    }
13503
14759
  
13504
14760
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_set_node_property_get",&obj0)) SWIG_fail;
13505
14761
  {
13506
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14762
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13507
14763
    if (PyErr_Occurred()) {
13508
14764
      SWIG_fail;
13509
14765
    }
13525
14781
  
13526
14782
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_delete_node_property_set",&obj0,&obj1)) SWIG_fail;
13527
14783
  {
13528
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14784
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13529
14785
    if (PyErr_Occurred()) {
13530
14786
      SWIG_fail;
13531
14787
    }
13552
14808
  
13553
14809
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_delete_node_property_get",&obj0)) SWIG_fail;
13554
14810
  {
13555
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14811
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13556
14812
    if (PyErr_Occurred()) {
13557
14813
      SWIG_fail;
13558
14814
    }
13574
14830
  
13575
14831
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_remove_node_props_set",&obj0,&obj1)) SWIG_fail;
13576
14832
  {
13577
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14833
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13578
14834
    if (PyErr_Occurred()) {
13579
14835
      SWIG_fail;
13580
14836
    }
13601
14857
  
13602
14858
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_remove_node_props_get",&obj0)) SWIG_fail;
13603
14859
  {
13604
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14860
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13605
14861
    if (PyErr_Occurred()) {
13606
14862
      SWIG_fail;
13607
14863
    }
13623
14879
  
13624
14880
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_set_fulltext_set",&obj0,&obj1)) SWIG_fail;
13625
14881
  {
13626
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14882
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13627
14883
    if (PyErr_Occurred()) {
13628
14884
      SWIG_fail;
13629
14885
    }
13650
14906
  
13651
14907
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_set_fulltext_get",&obj0)) SWIG_fail;
13652
14908
  {
13653
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14909
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13654
14910
    if (PyErr_Occurred()) {
13655
14911
      SWIG_fail;
13656
14912
    }
13672
14928
  
13673
14929
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_apply_textdelta_set",&obj0,&obj1)) SWIG_fail;
13674
14930
  {
13675
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14931
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13676
14932
    if (PyErr_Occurred()) {
13677
14933
      SWIG_fail;
13678
14934
    }
13699
14955
  
13700
14956
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_apply_textdelta_get",&obj0)) SWIG_fail;
13701
14957
  {
13702
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14958
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13703
14959
    if (PyErr_Occurred()) {
13704
14960
      SWIG_fail;
13705
14961
    }
13721
14977
  
13722
14978
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_close_node_set",&obj0,&obj1)) SWIG_fail;
13723
14979
  {
13724
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
14980
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13725
14981
    if (PyErr_Occurred()) {
13726
14982
      SWIG_fail;
13727
14983
    }
13748
15004
  
13749
15005
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_close_node_get",&obj0)) SWIG_fail;
13750
15006
  {
13751
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
15007
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13752
15008
    if (PyErr_Occurred()) {
13753
15009
      SWIG_fail;
13754
15010
    }
13770
15026
  
13771
15027
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_t_close_revision_set",&obj0,&obj1)) SWIG_fail;
13772
15028
  {
13773
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
15029
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13774
15030
    if (PyErr_Occurred()) {
13775
15031
      SWIG_fail;
13776
15032
    }
13797
15053
  
13798
15054
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns3_t_close_revision_get",&obj0)) SWIG_fail;
13799
15055
  {
13800
 
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
15056
    arg1 = (struct svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
13801
15057
    if (PyErr_Occurred()) {
13802
15058
      SWIG_fail;
13803
15059
    }
13845
15101
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
13846
15102
  }
13847
15103
  {
13848
 
    arg2 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj1);
 
15104
    arg2 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj1);
13849
15105
    if (PyErr_Occurred()) {
13850
15106
      SWIG_fail;
13851
15107
    }
13865
15121
    }
13866
15122
  }
13867
15123
  {
13868
 
    arg5 = svn_swig_py_cancel_func;
13869
 
    arg6 = obj4; /* our function is the baton. */
 
15124
    arg5 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
15125
    arg6 = obj4;
13870
15126
  }
13871
15127
  if (obj5) {
13872
15128
    /* Verify that the user supplied a valid pool */
13907
15163
}
13908
15164
 
13909
15165
 
 
15166
SWIGINTERN PyObject *_wrap_svn_repos_get_fs_build_parser5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15167
  PyObject *resultobj = 0;
 
15168
  svn_repos_parse_fns3_t **arg1 = (svn_repos_parse_fns3_t **) 0 ;
 
15169
  void **arg2 = (void **) 0 ;
 
15170
  svn_repos_t *arg3 = (svn_repos_t *) 0 ;
 
15171
  svn_revnum_t arg4 ;
 
15172
  svn_revnum_t arg5 ;
 
15173
  svn_boolean_t arg6 ;
 
15174
  svn_boolean_t arg7 ;
 
15175
  enum svn_repos_load_uuid arg8 ;
 
15176
  char *arg9 = (char *) 0 ;
 
15177
  svn_boolean_t arg10 ;
 
15178
  svn_boolean_t arg11 ;
 
15179
  svn_boolean_t arg12 ;
 
15180
  svn_repos_notify_func_t arg13 = (svn_repos_notify_func_t) 0 ;
 
15181
  void *arg14 = (void *) 0 ;
 
15182
  apr_pool_t *arg15 = (apr_pool_t *) 0 ;
 
15183
  apr_pool_t *_global_pool = NULL ;
 
15184
  PyObject *_global_py_pool = NULL ;
 
15185
  svn_repos_parse_fns3_t *temp1 ;
 
15186
  void *temp2 ;
 
15187
  PyObject * obj0 = 0 ;
 
15188
  PyObject * obj1 = 0 ;
 
15189
  PyObject * obj2 = 0 ;
 
15190
  PyObject * obj3 = 0 ;
 
15191
  PyObject * obj4 = 0 ;
 
15192
  PyObject * obj5 = 0 ;
 
15193
  PyObject * obj7 = 0 ;
 
15194
  PyObject * obj8 = 0 ;
 
15195
  PyObject * obj9 = 0 ;
 
15196
  PyObject * obj10 = 0 ;
 
15197
  PyObject * obj11 = 0 ;
 
15198
  PyObject * obj12 = 0 ;
 
15199
  svn_error_t *result = 0 ;
 
15200
  
 
15201
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
15202
      &_global_py_pool, &_global_pool))
 
15203
  SWIG_fail;
 
15204
  arg15 = _global_pool;
 
15205
  arg1 = &temp1;
 
15206
  arg2 = &temp2;
 
15207
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOzOOOOO|O:svn_repos_get_fs_build_parser5",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&arg9,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
 
15208
  {
 
15209
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
15210
    if (PyErr_Occurred()) {
 
15211
      SWIG_fail;
 
15212
    }
 
15213
  }
 
15214
  {
 
15215
    arg4 = (svn_revnum_t)SWIG_As_long (obj1);
 
15216
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
15217
      SWIG_fail;
 
15218
    }
 
15219
  }
 
15220
  {
 
15221
    arg5 = (svn_revnum_t)SWIG_As_long (obj2);
 
15222
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
15223
      SWIG_fail;
 
15224
    }
 
15225
  }
 
15226
  {
 
15227
    arg6 = (svn_boolean_t)SWIG_As_long (obj3);
 
15228
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
15229
      SWIG_fail;
 
15230
    }
 
15231
  }
 
15232
  {
 
15233
    arg7 = (svn_boolean_t)SWIG_As_long (obj4);
 
15234
    if (SWIG_arg_fail(svn_argnum_obj4)) {
 
15235
      SWIG_fail;
 
15236
    }
 
15237
  }
 
15238
  {
 
15239
    arg8 = (enum svn_repos_load_uuid)SWIG_As_long (obj5);
 
15240
    if (SWIG_arg_fail(svn_argnum_obj5)) {
 
15241
      SWIG_fail;
 
15242
    }
 
15243
  }
 
15244
  {
 
15245
    arg10 = (svn_boolean_t)SWIG_As_long (obj7);
 
15246
    if (SWIG_arg_fail(svn_argnum_obj7)) {
 
15247
      SWIG_fail;
 
15248
    }
 
15249
  }
 
15250
  {
 
15251
    arg11 = (svn_boolean_t)SWIG_As_long (obj8);
 
15252
    if (SWIG_arg_fail(svn_argnum_obj8)) {
 
15253
      SWIG_fail;
 
15254
    }
 
15255
  }
 
15256
  {
 
15257
    arg12 = (svn_boolean_t)SWIG_As_long (obj9);
 
15258
    if (SWIG_arg_fail(svn_argnum_obj9)) {
 
15259
      SWIG_fail;
 
15260
    }
 
15261
  }
 
15262
  {
 
15263
    svn_repos_notify_func_t * tmp =
 
15264
    svn_swig_py_must_get_ptr(obj10, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj10);
 
15265
    if (tmp == NULL || PyErr_Occurred()) {
 
15266
      SWIG_fail;
 
15267
    }
 
15268
    arg13 = *tmp;
 
15269
  }
 
15270
  {
 
15271
    if (obj11 == Py_None) {
 
15272
      arg14 = NULL;
 
15273
    } else if (SWIG_ConvertPtr(obj11, (void **) &arg14, 0, 0) == -1) {
 
15274
      arg14 = (void *) obj11;
 
15275
      PyErr_Clear();
 
15276
    }
 
15277
  }
 
15278
  if (obj12) {
 
15279
    /* Verify that the user supplied a valid pool */
 
15280
    if (obj12 != Py_None && obj12 != _global_py_pool) {
 
15281
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj12);
 
15282
      SWIG_arg_fail(svn_argnum_obj12);
 
15283
      SWIG_fail;
 
15284
    }
 
15285
  }
 
15286
  {
 
15287
    svn_swig_py_release_py_lock();
 
15288
    
 
15289
    result = (svn_error_t *)svn_repos_get_fs_build_parser5((struct svn_repos_parse_fns3_t const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(char const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15);
 
15290
    
 
15291
    svn_swig_py_acquire_py_lock();
 
15292
    
 
15293
  }
 
15294
  {
 
15295
    if (result != NULL) {
 
15296
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
15297
      svn_swig_py_svn_exception(result);
 
15298
      else
 
15299
      svn_error_clear(result);
 
15300
      SWIG_fail;
 
15301
    }
 
15302
    Py_INCREF(Py_None);
 
15303
    resultobj = Py_None;
 
15304
  }
 
15305
  {
 
15306
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_repos_parse_fns3_t,
 
15307
        _global_py_pool, args))
 
15308
    
 
15309
    ;
 
15310
  }
 
15311
  {
 
15312
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
 
15313
        _global_py_pool, args))
 
15314
    
 
15315
    ;
 
15316
  }
 
15317
  {
 
15318
    Py_XDECREF(_global_py_pool);
 
15319
  }
 
15320
  return resultobj;
 
15321
fail:
 
15322
  {
 
15323
    Py_XDECREF(_global_py_pool);
 
15324
  }
 
15325
  return NULL;
 
15326
}
 
15327
 
 
15328
 
13910
15329
SWIGINTERN PyObject *_wrap_svn_repos_get_fs_build_parser4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13911
15330
  PyObject *resultobj = 0;
13912
15331
  svn_repos_parse_fns3_t **arg1 = (svn_repos_parse_fns3_t **) 0 ;
13944
15363
  arg2 = &temp2;
13945
15364
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOzOO|O:svn_repos_get_fs_build_parser4",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&arg9,&obj7,&obj8,&obj9)) SWIG_fail;
13946
15365
  {
13947
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
15366
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
13948
15367
    if (PyErr_Occurred()) {
13949
15368
      SWIG_fail;
13950
15369
    }
13981
15400
  }
13982
15401
  {
13983
15402
    svn_repos_notify_func_t * tmp =
13984
 
    svn_swig_MustGetPtr(obj7, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj7);
 
15403
    svn_swig_py_must_get_ptr(obj7, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj7);
13985
15404
    if (tmp == NULL || PyErr_Occurred()) {
13986
15405
      SWIG_fail;
13987
15406
    }
14023
15442
    resultobj = Py_None;
14024
15443
  }
14025
15444
  {
14026
 
    /* FIXME: Missing argout typemap: svn_repos_get_fs_build_parser4 arg 1 (svn_repos_parse_fns3_t const **) */
14027
 
    
14028
 
    
14029
 
    
14030
 
    
14031
 
    SWIG_exception(SWIG_ValueError, "svn_repos_get_fs_build_parser4 is not implemented yet");
14032
 
    
 
15445
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_repos_parse_fns3_t,
 
15446
        _global_py_pool, args))
 
15447
    
 
15448
    ;
14033
15449
  }
14034
15450
  {
14035
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
15451
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
14036
15452
        _global_py_pool, args))
14037
15453
    
14038
15454
    ;
14058
15474
  
14059
15475
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_new_revision_record_set",&obj0,&obj1)) SWIG_fail;
14060
15476
  {
14061
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15477
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14062
15478
    if (PyErr_Occurred()) {
14063
15479
      SWIG_fail;
14064
15480
    }
14085
15501
  
14086
15502
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_new_revision_record_get",&obj0)) SWIG_fail;
14087
15503
  {
14088
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15504
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14089
15505
    if (PyErr_Occurred()) {
14090
15506
      SWIG_fail;
14091
15507
    }
14107
15523
  
14108
15524
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_uuid_record_set",&obj0,&obj1)) SWIG_fail;
14109
15525
  {
14110
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15526
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14111
15527
    if (PyErr_Occurred()) {
14112
15528
      SWIG_fail;
14113
15529
    }
14134
15550
  
14135
15551
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_uuid_record_get",&obj0)) SWIG_fail;
14136
15552
  {
14137
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15553
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14138
15554
    if (PyErr_Occurred()) {
14139
15555
      SWIG_fail;
14140
15556
    }
14156
15572
  
14157
15573
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_new_node_record_set",&obj0,&obj1)) SWIG_fail;
14158
15574
  {
14159
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15575
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14160
15576
    if (PyErr_Occurred()) {
14161
15577
      SWIG_fail;
14162
15578
    }
14183
15599
  
14184
15600
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_new_node_record_get",&obj0)) SWIG_fail;
14185
15601
  {
14186
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15602
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14187
15603
    if (PyErr_Occurred()) {
14188
15604
      SWIG_fail;
14189
15605
    }
14205
15621
  
14206
15622
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_set_revision_property_set",&obj0,&obj1)) SWIG_fail;
14207
15623
  {
14208
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15624
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14209
15625
    if (PyErr_Occurred()) {
14210
15626
      SWIG_fail;
14211
15627
    }
14232
15648
  
14233
15649
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_set_revision_property_get",&obj0)) SWIG_fail;
14234
15650
  {
14235
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15651
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14236
15652
    if (PyErr_Occurred()) {
14237
15653
      SWIG_fail;
14238
15654
    }
14254
15670
  
14255
15671
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_set_node_property_set",&obj0,&obj1)) SWIG_fail;
14256
15672
  {
14257
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15673
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14258
15674
    if (PyErr_Occurred()) {
14259
15675
      SWIG_fail;
14260
15676
    }
14281
15697
  
14282
15698
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_set_node_property_get",&obj0)) SWIG_fail;
14283
15699
  {
14284
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15700
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14285
15701
    if (PyErr_Occurred()) {
14286
15702
      SWIG_fail;
14287
15703
    }
14303
15719
  
14304
15720
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_delete_node_property_set",&obj0,&obj1)) SWIG_fail;
14305
15721
  {
14306
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15722
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14307
15723
    if (PyErr_Occurred()) {
14308
15724
      SWIG_fail;
14309
15725
    }
14330
15746
  
14331
15747
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_delete_node_property_get",&obj0)) SWIG_fail;
14332
15748
  {
14333
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15749
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14334
15750
    if (PyErr_Occurred()) {
14335
15751
      SWIG_fail;
14336
15752
    }
14352
15768
  
14353
15769
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_remove_node_props_set",&obj0,&obj1)) SWIG_fail;
14354
15770
  {
14355
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15771
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14356
15772
    if (PyErr_Occurred()) {
14357
15773
      SWIG_fail;
14358
15774
    }
14379
15795
  
14380
15796
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_remove_node_props_get",&obj0)) SWIG_fail;
14381
15797
  {
14382
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15798
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14383
15799
    if (PyErr_Occurred()) {
14384
15800
      SWIG_fail;
14385
15801
    }
14401
15817
  
14402
15818
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_set_fulltext_set",&obj0,&obj1)) SWIG_fail;
14403
15819
  {
14404
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15820
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14405
15821
    if (PyErr_Occurred()) {
14406
15822
      SWIG_fail;
14407
15823
    }
14428
15844
  
14429
15845
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_set_fulltext_get",&obj0)) SWIG_fail;
14430
15846
  {
14431
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15847
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14432
15848
    if (PyErr_Occurred()) {
14433
15849
      SWIG_fail;
14434
15850
    }
14450
15866
  
14451
15867
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_apply_textdelta_set",&obj0,&obj1)) SWIG_fail;
14452
15868
  {
14453
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15869
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14454
15870
    if (PyErr_Occurred()) {
14455
15871
      SWIG_fail;
14456
15872
    }
14477
15893
  
14478
15894
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_apply_textdelta_get",&obj0)) SWIG_fail;
14479
15895
  {
14480
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15896
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14481
15897
    if (PyErr_Occurred()) {
14482
15898
      SWIG_fail;
14483
15899
    }
14499
15915
  
14500
15916
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_close_node_set",&obj0,&obj1)) SWIG_fail;
14501
15917
  {
14502
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15918
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14503
15919
    if (PyErr_Occurred()) {
14504
15920
      SWIG_fail;
14505
15921
    }
14526
15942
  
14527
15943
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_close_node_get",&obj0)) SWIG_fail;
14528
15944
  {
14529
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15945
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14530
15946
    if (PyErr_Occurred()) {
14531
15947
      SWIG_fail;
14532
15948
    }
14548
15964
  
14549
15965
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_close_revision_set",&obj0,&obj1)) SWIG_fail;
14550
15966
  {
14551
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15967
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14552
15968
    if (PyErr_Occurred()) {
14553
15969
      SWIG_fail;
14554
15970
    }
14575
15991
  
14576
15992
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_close_revision_get",&obj0)) SWIG_fail;
14577
15993
  {
14578
 
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
15994
    arg1 = (struct svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
14579
15995
    if (PyErr_Occurred()) {
14580
15996
      SWIG_fail;
14581
15997
    }
14604
16020
  
14605
16021
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_new_revision_record_set",&obj0,&obj1)) SWIG_fail;
14606
16022
  {
14607
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16023
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14608
16024
    if (PyErr_Occurred()) {
14609
16025
      SWIG_fail;
14610
16026
    }
14631
16047
  
14632
16048
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_new_revision_record_get",&obj0)) SWIG_fail;
14633
16049
  {
14634
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16050
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14635
16051
    if (PyErr_Occurred()) {
14636
16052
      SWIG_fail;
14637
16053
    }
14653
16069
  
14654
16070
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_uuid_record_set",&obj0,&obj1)) SWIG_fail;
14655
16071
  {
14656
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16072
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14657
16073
    if (PyErr_Occurred()) {
14658
16074
      SWIG_fail;
14659
16075
    }
14680
16096
  
14681
16097
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_uuid_record_get",&obj0)) SWIG_fail;
14682
16098
  {
14683
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16099
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14684
16100
    if (PyErr_Occurred()) {
14685
16101
      SWIG_fail;
14686
16102
    }
14702
16118
  
14703
16119
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_new_node_record_set",&obj0,&obj1)) SWIG_fail;
14704
16120
  {
14705
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16121
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14706
16122
    if (PyErr_Occurred()) {
14707
16123
      SWIG_fail;
14708
16124
    }
14729
16145
  
14730
16146
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_new_node_record_get",&obj0)) SWIG_fail;
14731
16147
  {
14732
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16148
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14733
16149
    if (PyErr_Occurred()) {
14734
16150
      SWIG_fail;
14735
16151
    }
14751
16167
  
14752
16168
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_set_revision_property_set",&obj0,&obj1)) SWIG_fail;
14753
16169
  {
14754
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16170
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14755
16171
    if (PyErr_Occurred()) {
14756
16172
      SWIG_fail;
14757
16173
    }
14778
16194
  
14779
16195
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_set_revision_property_get",&obj0)) SWIG_fail;
14780
16196
  {
14781
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16197
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14782
16198
    if (PyErr_Occurred()) {
14783
16199
      SWIG_fail;
14784
16200
    }
14800
16216
  
14801
16217
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_set_node_property_set",&obj0,&obj1)) SWIG_fail;
14802
16218
  {
14803
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16219
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14804
16220
    if (PyErr_Occurred()) {
14805
16221
      SWIG_fail;
14806
16222
    }
14827
16243
  
14828
16244
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_set_node_property_get",&obj0)) SWIG_fail;
14829
16245
  {
14830
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16246
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14831
16247
    if (PyErr_Occurred()) {
14832
16248
      SWIG_fail;
14833
16249
    }
14849
16265
  
14850
16266
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_remove_node_props_set",&obj0,&obj1)) SWIG_fail;
14851
16267
  {
14852
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16268
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14853
16269
    if (PyErr_Occurred()) {
14854
16270
      SWIG_fail;
14855
16271
    }
14876
16292
  
14877
16293
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_remove_node_props_get",&obj0)) SWIG_fail;
14878
16294
  {
14879
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16295
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14880
16296
    if (PyErr_Occurred()) {
14881
16297
      SWIG_fail;
14882
16298
    }
14898
16314
  
14899
16315
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_set_fulltext_set",&obj0,&obj1)) SWIG_fail;
14900
16316
  {
14901
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16317
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14902
16318
    if (PyErr_Occurred()) {
14903
16319
      SWIG_fail;
14904
16320
    }
14925
16341
  
14926
16342
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_set_fulltext_get",&obj0)) SWIG_fail;
14927
16343
  {
14928
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16344
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14929
16345
    if (PyErr_Occurred()) {
14930
16346
      SWIG_fail;
14931
16347
    }
14947
16363
  
14948
16364
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_close_node_set",&obj0,&obj1)) SWIG_fail;
14949
16365
  {
14950
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16366
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14951
16367
    if (PyErr_Occurred()) {
14952
16368
      SWIG_fail;
14953
16369
    }
14974
16390
  
14975
16391
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_close_node_get",&obj0)) SWIG_fail;
14976
16392
  {
14977
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16393
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
14978
16394
    if (PyErr_Occurred()) {
14979
16395
      SWIG_fail;
14980
16396
    }
14996
16412
  
14997
16413
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_close_revision_set",&obj0,&obj1)) SWIG_fail;
14998
16414
  {
14999
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16415
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
15000
16416
    if (PyErr_Occurred()) {
15001
16417
      SWIG_fail;
15002
16418
    }
15023
16439
  
15024
16440
  if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_close_revision_get",&obj0)) SWIG_fail;
15025
16441
  {
15026
 
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
 
16442
    arg1 = (struct svn_repos_parse_fns_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
15027
16443
    if (PyErr_Occurred()) {
15028
16444
      SWIG_fail;
15029
16445
    }
15069
16485
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
15070
16486
  }
15071
16487
  {
15072
 
    arg2 = (svn_repos_parser_fns2_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj1);
 
16488
    arg2 = (svn_repos_parser_fns2_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj1);
15073
16489
    if (PyErr_Occurred()) {
15074
16490
      SWIG_fail;
15075
16491
    }
15083
16499
    }
15084
16500
  }
15085
16501
  {
15086
 
    arg4 = svn_swig_py_cancel_func;
15087
 
    arg5 = obj3; /* our function is the baton. */
 
16502
    arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
16503
    arg5 = obj3;
15088
16504
  }
15089
16505
  if (obj4) {
15090
16506
    /* Verify that the user supplied a valid pool */
15151
16567
    arg1 = svn_swig_py_make_stream (obj0, _global_pool);
15152
16568
  }
15153
16569
  {
15154
 
    arg2 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj1);
 
16570
    arg2 = (svn_repos_parser_fns_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj1);
15155
16571
    if (PyErr_Occurred()) {
15156
16572
      SWIG_fail;
15157
16573
    }
15165
16581
    }
15166
16582
  }
15167
16583
  {
15168
 
    arg4 = svn_swig_py_cancel_func;
15169
 
    arg5 = obj3; /* our function is the baton. */
 
16584
    arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
16585
    arg5 = obj3;
15170
16586
  }
15171
16587
  if (obj4) {
15172
16588
    /* Verify that the user supplied a valid pool */
15240
16656
  arg2 = &temp2;
15241
16657
  if (!PyArg_ParseTuple(args,(char *)"OOOOzOO|O:svn_repos_get_fs_build_parser3",&obj0,&obj1,&obj2,&obj3,&arg7,&obj5,&obj6,&obj7)) SWIG_fail;
15242
16658
  {
15243
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
16659
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
15244
16660
    if (PyErr_Occurred()) {
15245
16661
      SWIG_fail;
15246
16662
    }
15265
16681
  }
15266
16682
  {
15267
16683
    svn_repos_notify_func_t * tmp =
15268
 
    svn_swig_MustGetPtr(obj5, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj5);
 
16684
    svn_swig_py_must_get_ptr(obj5, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj5);
15269
16685
    if (tmp == NULL || PyErr_Occurred()) {
15270
16686
      SWIG_fail;
15271
16687
    }
15307
16723
    resultobj = Py_None;
15308
16724
  }
15309
16725
  {
15310
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns2_t,
15311
 
        _global_py_pool, args))
15312
 
    
15313
 
    ;
 
16726
    /* FIXME: Missing argout typemap: svn_repos_get_fs_build_parser3 arg 1 (svn_repos_parse_fns2_t const **) */
 
16727
    
 
16728
    
 
16729
    
 
16730
    
 
16731
    SWIG_exception(SWIG_ValueError, "svn_repos_get_fs_build_parser3 is not implemented yet");
 
16732
    
15314
16733
  }
15315
16734
  {
15316
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
16735
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
15317
16736
        _global_py_pool, args))
15318
16737
    
15319
16738
    ;
15359
16778
  arg2 = &temp2;
15360
16779
  if (!PyArg_ParseTuple(args,(char *)"OOOOz|O:svn_repos_get_fs_build_parser2",&obj0,&obj1,&obj2,&obj3,&arg7,&obj5)) SWIG_fail;
15361
16780
  {
15362
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
16781
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
15363
16782
    if (PyErr_Occurred()) {
15364
16783
      SWIG_fail;
15365
16784
    }
15407
16826
    resultobj = Py_None;
15408
16827
  }
15409
16828
  {
15410
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns2_t,
15411
 
        _global_py_pool, args))
15412
 
    
15413
 
    ;
 
16829
    /* FIXME: Missing argout typemap: svn_repos_get_fs_build_parser2 arg 1 (svn_repos_parse_fns2_t const **) */
 
16830
    
 
16831
    
 
16832
    
 
16833
    
 
16834
    SWIG_exception(SWIG_ValueError, "svn_repos_get_fs_build_parser2 is not implemented yet");
 
16835
    
15414
16836
  }
15415
16837
  {
15416
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
16838
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
15417
16839
        _global_py_pool, args))
15418
16840
    
15419
16841
    ;
15459
16881
  arg2 = &temp2;
15460
16882
  if (!PyArg_ParseTuple(args,(char *)"OOOOz|O:svn_repos_get_fs_build_parser",&obj0,&obj1,&obj2,&obj3,&arg7,&obj5)) SWIG_fail;
15461
16883
  {
15462
 
    arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
 
16884
    arg3 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
15463
16885
    if (PyErr_Occurred()) {
15464
16886
      SWIG_fail;
15465
16887
    }
15507
16929
    resultobj = Py_None;
15508
16930
  }
15509
16931
  {
15510
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns_t,
 
16932
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_repos_parse_fns_t,
15511
16933
        _global_py_pool, args))
15512
16934
    
15513
16935
    ;
15514
16936
  }
15515
16937
  {
15516
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
16938
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
15517
16939
        _global_py_pool, args))
15518
16940
    
15519
16941
    ;
15584
17006
    resultobj = Py_None;
15585
17007
  }
15586
17008
  {
15587
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_authz_t,
 
17009
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_authz_t,
15588
17010
        _global_py_pool, args))
15589
17011
    
15590
17012
    ;
15654
17076
    resultobj = Py_None;
15655
17077
  }
15656
17078
  {
15657
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_authz_t,
 
17079
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_authz_t,
15658
17080
        _global_py_pool, args))
15659
17081
    
15660
17082
    ;
15725
17147
    resultobj = Py_None;
15726
17148
  }
15727
17149
  {
15728
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_authz_t,
 
17150
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_authz_t,
15729
17151
        _global_py_pool, args))
15730
17152
    
15731
17153
    ;
15767
17189
  arg6 = &temp6;
15768
17190
  if (!PyArg_ParseTuple(args,(char *)"OsszO|O:svn_repos_authz_check_access",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) SWIG_fail;
15769
17191
  {
15770
 
    arg1 = (svn_authz_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_authz_t, svn_argnum_obj0);
 
17192
    arg1 = (svn_authz_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_authz_t, svn_argnum_obj0);
15771
17193
    if (PyErr_Occurred()) {
15772
17194
      SWIG_fail;
15773
17195
    }
15846
17268
  arg6 = _global_pool;
15847
17269
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_check_revision_access",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15848
17270
  {
15849
 
    arg1 = (svn_repos_revision_access_level_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_revision_access_level_t, svn_argnum_obj0);
 
17271
    arg1 = (svn_repos_revision_access_level_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_revision_access_level_t, svn_argnum_obj0);
15850
17272
    if (PyErr_Occurred()) {
15851
17273
      SWIG_fail;
15852
17274
    }
15853
17275
  }
15854
17276
  {
15855
 
    arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_t, svn_argnum_obj1);
 
17277
    arg2 = (svn_repos_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_repos_t, svn_argnum_obj1);
15856
17278
    if (PyErr_Occurred()) {
15857
17279
      SWIG_fail;
15858
17280
    }
15865
17287
  }
15866
17288
  {
15867
17289
    /* FIXME: Handle the NULL case. */
15868
 
    arg4 = svn_swig_py_repos_authz_func;
 
17290
    arg4 = (svn_repos_authz_func_t) svn_swig_py_repos_authz_func;
15869
17291
    arg5 = obj3;
15870
17292
  }
15871
17293
  if (obj4) {
15907
17329
}
15908
17330
 
15909
17331
 
15910
 
SWIGINTERN PyObject *_wrap_svn_repos_fs_get_inherited_props(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15911
 
  PyObject *resultobj = 0;
15912
 
  apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
15913
 
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
15914
 
  char *arg3 = (char *) 0 ;
15915
 
  char *arg4 = (char *) 0 ;
15916
 
  svn_repos_authz_func_t arg5 = (svn_repos_authz_func_t) 0 ;
15917
 
  void *arg6 = (void *) 0 ;
15918
 
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
15919
 
  apr_pool_t *arg8 = (apr_pool_t *) 0 ;
15920
 
  apr_pool_t *_global_pool = NULL ;
15921
 
  PyObject *_global_py_pool = NULL ;
15922
 
  apr_array_header_t *temp1 ;
15923
 
  PyObject * obj0 = 0 ;
15924
 
  PyObject * obj3 = 0 ;
15925
 
  PyObject * obj4 = 0 ;
15926
 
  PyObject * obj5 = 0 ;
15927
 
  svn_error_t *result = 0 ;
15928
 
  
15929
 
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
15930
 
      &_global_py_pool, &_global_pool))
15931
 
  SWIG_fail;
15932
 
  arg7 = _global_pool;
15933
 
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
15934
 
      &_global_py_pool, &_global_pool))
15935
 
  SWIG_fail;
15936
 
  arg8 = _global_pool;
15937
 
  arg1 = &temp1;
15938
 
  if (!PyArg_ParseTuple(args,(char *)"OssO|OO:svn_repos_fs_get_inherited_props",&obj0,&arg3,&arg4,&obj3,&obj4,&obj5)) SWIG_fail;
15939
 
  {
15940
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
15941
 
    if (PyErr_Occurred()) {
15942
 
      SWIG_fail;
15943
 
    }
15944
 
  }
15945
 
  {
15946
 
    /* FIXME: Handle the NULL case. */
15947
 
    arg5 = svn_swig_py_repos_authz_func;
15948
 
    arg6 = obj3;
15949
 
  }
15950
 
  if (obj4) {
15951
 
    /* Verify that the user supplied a valid pool */
15952
 
    if (obj4 != Py_None && obj4 != _global_py_pool) {
15953
 
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
15954
 
      SWIG_arg_fail(svn_argnum_obj4);
15955
 
      SWIG_fail;
15956
 
    }
15957
 
  }
15958
 
  if (obj5) {
15959
 
    /* Verify that the user supplied a valid pool */
15960
 
    if (obj5 != Py_None && obj5 != _global_py_pool) {
15961
 
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
15962
 
      SWIG_arg_fail(svn_argnum_obj5);
15963
 
      SWIG_fail;
15964
 
    }
15965
 
  }
15966
 
  {
15967
 
    svn_swig_py_release_py_lock();
15968
 
    
15969
 
    result = (svn_error_t *)svn_repos_fs_get_inherited_props(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7,arg8);
15970
 
    
15971
 
    svn_swig_py_acquire_py_lock();
15972
 
    
15973
 
  }
15974
 
  {
15975
 
    if (result != NULL) {
15976
 
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
15977
 
      svn_swig_py_svn_exception(result);
15978
 
      else
15979
 
      svn_error_clear(result);
15980
 
      SWIG_fail;
15981
 
    }
15982
 
    Py_INCREF(Py_None);
15983
 
    resultobj = Py_None;
15984
 
  }
15985
 
  {
15986
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_propinheriteditemarray_to_dict(*arg1));
15987
 
  }
15988
 
  {
15989
 
    Py_XDECREF(_global_py_pool);
15990
 
  }
15991
 
  {
15992
 
    Py_XDECREF(_global_py_pool);
15993
 
  }
15994
 
  return resultobj;
15995
 
fail:
15996
 
  {
15997
 
    Py_XDECREF(_global_py_pool);
15998
 
  }
15999
 
  {
16000
 
    Py_XDECREF(_global_py_pool);
16001
 
  }
16002
 
  return NULL;
16003
 
}
16004
 
 
16005
 
 
16006
 
SWIGINTERN PyObject *_wrap_svn_repos_remember_client_capabilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16007
 
  PyObject *resultobj = 0;
16008
 
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
16009
 
  apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
16010
 
  PyObject * obj0 = 0 ;
16011
 
  PyObject * obj1 = 0 ;
16012
 
  svn_error_t *result = 0 ;
16013
 
  
16014
 
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_remember_client_capabilities",&obj0,&obj1)) SWIG_fail;
16015
 
  {
16016
 
    arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
16017
 
    if (PyErr_Occurred()) {
16018
 
      SWIG_fail;
16019
 
    }
16020
 
  }
16021
 
  {
16022
 
    arg2 = (apr_array_header_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
16023
 
    if (PyErr_Occurred()) {
16024
 
      SWIG_fail;
16025
 
    }
16026
 
  }
16027
 
  {
16028
 
    svn_swig_py_release_py_lock();
16029
 
    
16030
 
    result = (svn_error_t *)svn_repos_remember_client_capabilities(arg1,(apr_array_header_t const *)arg2);
16031
 
    
16032
 
    svn_swig_py_acquire_py_lock();
16033
 
    
16034
 
  }
16035
 
  {
16036
 
    if (result != NULL) {
16037
 
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
16038
 
      svn_swig_py_svn_exception(result);
16039
 
      else
16040
 
      svn_error_clear(result);
16041
 
      SWIG_fail;
16042
 
    }
16043
 
    Py_INCREF(Py_None);
16044
 
    resultobj = Py_None;
16045
 
  }
16046
 
  return resultobj;
16047
 
fail:
16048
 
  return NULL;
16049
 
}
16050
 
 
16051
 
 
16052
17332
SWIGINTERN PyObject *svn_repos_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16053
17333
  PyObject *obj;
16054
17334
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
16083
17363
  arg4 = _global_pool;
16084
17364
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_parse_fns3_invoke_magic_header_record",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16085
17365
  {
16086
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17366
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16087
17367
    if (PyErr_Occurred()) {
16088
17368
      SWIG_fail;
16089
17369
    }
16160
17440
  arg4 = _global_pool;
16161
17441
  if (!PyArg_ParseTuple(args,(char *)"OzO|O:svn_repos_parse_fns3_invoke_uuid_record",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
16162
17442
  {
16163
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17443
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16164
17444
    if (PyErr_Occurred()) {
16165
17445
      SWIG_fail;
16166
17446
    }
16235
17515
  arg2 = &temp2;
16236
17516
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_parse_fns3_invoke_new_revision_record",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16237
17517
  {
16238
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17518
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16239
17519
    if (PyErr_Occurred()) {
16240
17520
      SWIG_fail;
16241
17521
    }
16242
17522
  }
16243
17523
  {
16244
 
    arg3 = (apr_hash_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
 
17524
    arg3 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
16245
17525
    if (PyErr_Occurred()) {
16246
17526
      SWIG_fail;
16247
17527
    }
16282
17562
    resultobj = Py_None;
16283
17563
  }
16284
17564
  {
16285
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
17565
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
16286
17566
        _global_py_pool, args))
16287
17567
    
16288
17568
    ;
16322
17602
  arg2 = &temp2;
16323
17603
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_parse_fns3_invoke_new_node_record",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16324
17604
  {
16325
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17605
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16326
17606
    if (PyErr_Occurred()) {
16327
17607
      SWIG_fail;
16328
17608
    }
16329
17609
  }
16330
17610
  {
16331
 
    arg3 = (apr_hash_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
 
17611
    arg3 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
16332
17612
    if (PyErr_Occurred()) {
16333
17613
      SWIG_fail;
16334
17614
    }
16369
17649
    resultobj = Py_None;
16370
17650
  }
16371
17651
  {
16372
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
17652
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
16373
17653
        _global_py_pool, args))
16374
17654
    
16375
17655
    ;
16400
17680
  
16401
17681
  if (!PyArg_ParseTuple(args,(char *)"OOsO:svn_repos_parse_fns3_invoke_set_revision_property",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
16402
17682
  {
16403
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17683
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16404
17684
    if (PyErr_Occurred()) {
16405
17685
      SWIG_fail;
16406
17686
    }
16465
17745
  
16466
17746
  if (!PyArg_ParseTuple(args,(char *)"OOsO:svn_repos_parse_fns3_invoke_set_node_property",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
16467
17747
  {
16468
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17748
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16469
17749
    if (PyErr_Occurred()) {
16470
17750
      SWIG_fail;
16471
17751
    }
16527
17807
  
16528
17808
  if (!PyArg_ParseTuple(args,(char *)"OOs:svn_repos_parse_fns3_invoke_delete_node_property",&obj0,&obj1,&arg3)) SWIG_fail;
16529
17809
  {
16530
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17810
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16531
17811
    if (PyErr_Occurred()) {
16532
17812
      SWIG_fail;
16533
17813
    }
16575
17855
  
16576
17856
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_invoke_remove_node_props",&obj0,&obj1)) SWIG_fail;
16577
17857
  {
16578
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17858
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16579
17859
    if (PyErr_Occurred()) {
16580
17860
      SWIG_fail;
16581
17861
    }
16626
17906
  arg2 = &temp2;
16627
17907
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_invoke_set_fulltext",&obj0,&obj1)) SWIG_fail;
16628
17908
  {
16629
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17909
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16630
17910
    if (PyErr_Occurred()) {
16631
17911
      SWIG_fail;
16632
17912
    }
16659
17939
    resultobj = Py_None;
16660
17940
  }
16661
17941
  {
16662
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_stream_t,
 
17942
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_svn_stream_t,
16663
17943
        _global_py_pool, args))
16664
17944
    
16665
17945
    ;
16696
17976
  arg3 = &temp3;
16697
17977
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_invoke_apply_textdelta",&obj0,&obj1)) SWIG_fail;
16698
17978
  {
16699
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
17979
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16700
17980
    if (PyErr_Occurred()) {
16701
17981
      SWIG_fail;
16702
17982
    }
16729
18009
    resultobj = Py_None;
16730
18010
  }
16731
18011
  {
16732
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
18012
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
16733
18013
        _global_py_pool, args))
16734
18014
    
16735
18015
    ;
16736
18016
  }
16737
18017
  {
16738
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
 
18018
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg3, SWIGTYPE_p_void,
16739
18019
        _global_py_pool, args))
16740
18020
    
16741
18021
    ;
16756
18036
  
16757
18037
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_invoke_close_node",&obj0,&obj1)) SWIG_fail;
16758
18038
  {
16759
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
18039
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16760
18040
    if (PyErr_Occurred()) {
16761
18041
      SWIG_fail;
16762
18042
    }
16804
18084
  
16805
18085
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns3_invoke_close_revision",&obj0,&obj1)) SWIG_fail;
16806
18086
  {
16807
 
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
 
18087
    arg1 = (svn_repos_parse_fns3_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns3_t, svn_argnum_obj0);
16808
18088
    if (PyErr_Occurred()) {
16809
18089
      SWIG_fail;
16810
18090
    }
16865
18145
  arg2 = &temp2;
16866
18146
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_parse_fns2_invoke_new_revision_record",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16867
18147
  {
16868
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18148
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
16869
18149
    if (PyErr_Occurred()) {
16870
18150
      SWIG_fail;
16871
18151
    }
16872
18152
  }
16873
18153
  {
16874
 
    arg3 = (apr_hash_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
 
18154
    arg3 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
16875
18155
    if (PyErr_Occurred()) {
16876
18156
      SWIG_fail;
16877
18157
    }
16912
18192
    resultobj = Py_None;
16913
18193
  }
16914
18194
  {
16915
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
18195
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
16916
18196
        _global_py_pool, args))
16917
18197
    
16918
18198
    ;
16948
18228
  arg4 = _global_pool;
16949
18229
  if (!PyArg_ParseTuple(args,(char *)"OzO|O:svn_repos_parse_fns2_invoke_uuid_record",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
16950
18230
  {
16951
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18231
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
16952
18232
    if (PyErr_Occurred()) {
16953
18233
      SWIG_fail;
16954
18234
    }
17023
18303
  arg2 = &temp2;
17024
18304
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_parse_fns2_invoke_new_node_record",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17025
18305
  {
17026
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18306
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17027
18307
    if (PyErr_Occurred()) {
17028
18308
      SWIG_fail;
17029
18309
    }
17030
18310
  }
17031
18311
  {
17032
 
    arg3 = (apr_hash_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
 
18312
    arg3 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
17033
18313
    if (PyErr_Occurred()) {
17034
18314
      SWIG_fail;
17035
18315
    }
17070
18350
    resultobj = Py_None;
17071
18351
  }
17072
18352
  {
17073
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
18353
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
17074
18354
        _global_py_pool, args))
17075
18355
    
17076
18356
    ;
17101
18381
  
17102
18382
  if (!PyArg_ParseTuple(args,(char *)"OOsO:svn_repos_parse_fns2_invoke_set_revision_property",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
17103
18383
  {
17104
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18384
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17105
18385
    if (PyErr_Occurred()) {
17106
18386
      SWIG_fail;
17107
18387
    }
17166
18446
  
17167
18447
  if (!PyArg_ParseTuple(args,(char *)"OOsO:svn_repos_parse_fns2_invoke_set_node_property",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
17168
18448
  {
17169
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18449
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17170
18450
    if (PyErr_Occurred()) {
17171
18451
      SWIG_fail;
17172
18452
    }
17228
18508
  
17229
18509
  if (!PyArg_ParseTuple(args,(char *)"OOs:svn_repos_parse_fns2_invoke_delete_node_property",&obj0,&obj1,&arg3)) SWIG_fail;
17230
18510
  {
17231
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18511
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17232
18512
    if (PyErr_Occurred()) {
17233
18513
      SWIG_fail;
17234
18514
    }
17276
18556
  
17277
18557
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_remove_node_props",&obj0,&obj1)) SWIG_fail;
17278
18558
  {
17279
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18559
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17280
18560
    if (PyErr_Occurred()) {
17281
18561
      SWIG_fail;
17282
18562
    }
17327
18607
  arg2 = &temp2;
17328
18608
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_set_fulltext",&obj0,&obj1)) SWIG_fail;
17329
18609
  {
17330
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18610
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17331
18611
    if (PyErr_Occurred()) {
17332
18612
      SWIG_fail;
17333
18613
    }
17360
18640
    resultobj = Py_None;
17361
18641
  }
17362
18642
  {
17363
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_stream_t,
 
18643
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_svn_stream_t,
17364
18644
        _global_py_pool, args))
17365
18645
    
17366
18646
    ;
17397
18677
  arg3 = &temp3;
17398
18678
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_apply_textdelta",&obj0,&obj1)) SWIG_fail;
17399
18679
  {
17400
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18680
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17401
18681
    if (PyErr_Occurred()) {
17402
18682
      SWIG_fail;
17403
18683
    }
17430
18710
    resultobj = Py_None;
17431
18711
  }
17432
18712
  {
17433
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
18713
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
17434
18714
        _global_py_pool, args))
17435
18715
    
17436
18716
    ;
17437
18717
  }
17438
18718
  {
17439
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
 
18719
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg3, SWIGTYPE_p_void,
17440
18720
        _global_py_pool, args))
17441
18721
    
17442
18722
    ;
17457
18737
  
17458
18738
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_close_node",&obj0,&obj1)) SWIG_fail;
17459
18739
  {
17460
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18740
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17461
18741
    if (PyErr_Occurred()) {
17462
18742
      SWIG_fail;
17463
18743
    }
17505
18785
  
17506
18786
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_close_revision",&obj0,&obj1)) SWIG_fail;
17507
18787
  {
17508
 
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
 
18788
    arg1 = (svn_repos_parse_fns2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
17509
18789
    if (PyErr_Occurred()) {
17510
18790
      SWIG_fail;
17511
18791
    }
17569
18849
  if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_repos_invoke_authz_func",&obj0,&obj1,&arg4,&obj3,&obj4)) SWIG_fail;
17570
18850
  {
17571
18851
    svn_repos_authz_func_t * tmp =
17572
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
18852
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
17573
18853
    if (tmp == NULL || PyErr_Occurred()) {
17574
18854
      SWIG_fail;
17575
18855
    }
17576
18856
    arg1 = *tmp;
17577
18857
  }
17578
18858
  {
17579
 
    arg3 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
 
18859
    arg3 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
17580
18860
    if (PyErr_Occurred()) {
17581
18861
      SWIG_fail;
17582
18862
    }
17662
18942
  if (!PyArg_ParseTuple(args,(char *)"OOOsO|O:svn_repos_invoke_authz_callback",&obj0,&obj1,&obj2,&arg5,&obj4,&obj5)) SWIG_fail;
17663
18943
  {
17664
18944
    svn_repos_authz_callback_t * tmp =
17665
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
18945
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
17666
18946
    if (tmp == NULL || PyErr_Occurred()) {
17667
18947
      SWIG_fail;
17668
18948
    }
17675
18955
    }
17676
18956
  }
17677
18957
  {
17678
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
18958
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
17679
18959
    if (PyErr_Occurred()) {
17680
18960
      SWIG_fail;
17681
18961
    }
17733
19013
}
17734
19014
 
17735
19015
 
17736
 
SWIGINTERN PyObject *_wrap_svn_repos_invoke_file_rev_handler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17737
 
  PyObject *resultobj = 0;
17738
 
  svn_repos_file_rev_handler_t arg1 = (svn_repos_file_rev_handler_t) 0 ;
17739
 
  void *arg2 = (void *) 0 ;
17740
 
  char *arg3 = (char *) 0 ;
17741
 
  svn_revnum_t arg4 ;
17742
 
  apr_hash_t *arg5 = (apr_hash_t *) 0 ;
17743
 
  svn_txdelta_window_handler_t *arg6 = (svn_txdelta_window_handler_t *) 0 ;
17744
 
  void **arg7 = (void **) 0 ;
17745
 
  apr_array_header_t *arg8 = (apr_array_header_t *) 0 ;
17746
 
  apr_pool_t *arg9 = (apr_pool_t *) 0 ;
17747
 
  apr_pool_t *_global_pool = NULL ;
17748
 
  PyObject *_global_py_pool = NULL ;
17749
 
  void *temp7 ;
17750
 
  PyObject * obj0 = 0 ;
17751
 
  PyObject * obj1 = 0 ;
17752
 
  PyObject * obj3 = 0 ;
17753
 
  PyObject * obj4 = 0 ;
17754
 
  PyObject * obj5 = 0 ;
17755
 
  PyObject * obj6 = 0 ;
17756
 
  svn_error_t *result = 0 ;
17757
 
  
17758
 
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
17759
 
      &_global_py_pool, &_global_pool))
17760
 
  SWIG_fail;
17761
 
  arg9 = _global_pool;
17762
 
  {
17763
 
    if (_global_pool == NULL)
17764
 
    {
17765
 
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
17766
 
          &_global_py_pool, &_global_pool))
17767
 
      SWIG_fail;
17768
 
    }
17769
 
    arg6 = (svn_txdelta_window_handler_t *) apr_pcalloc(_global_pool, sizeof(svn_txdelta_window_handler_t));
17770
 
    if (arg6 == NULL) SWIG_fail;
17771
 
  }
17772
 
  arg7 = &temp7;
17773
 
  if (!PyArg_ParseTuple(args,(char *)"OOsOOO|O:svn_repos_invoke_file_rev_handler",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
17774
 
  {
17775
 
    svn_repos_file_rev_handler_t * tmp =
17776
 
    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);
17777
 
    if (tmp == NULL || PyErr_Occurred()) {
17778
 
      SWIG_fail;
17779
 
    }
17780
 
    arg1 = *tmp;
17781
 
  }
17782
 
  {
17783
 
    if (obj1 == Py_None) {
17784
 
      arg2 = NULL;
17785
 
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
17786
 
      arg2 = (void *) obj1;
17787
 
      PyErr_Clear();
17788
 
    }
17789
 
  }
17790
 
  {
17791
 
    arg4 = (svn_revnum_t)SWIG_As_long (obj3);
17792
 
    if (SWIG_arg_fail(svn_argnum_obj3)) {
17793
 
      SWIG_fail;
17794
 
    }
17795
 
  }
17796
 
  {
17797
 
    arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_apr_hash_t, svn_argnum_obj4);
17798
 
    if (PyErr_Occurred()) {
17799
 
      SWIG_fail;
17800
 
    }
17801
 
  }
17802
 
  {
17803
 
    arg8 = (apr_array_header_t *)svn_swig_MustGetPtr(obj5, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj5);
17804
 
    if (PyErr_Occurred()) {
17805
 
      SWIG_fail;
17806
 
    }
17807
 
  }
17808
 
  if (obj6) {
17809
 
    /* Verify that the user supplied a valid pool */
17810
 
    if (obj6 != Py_None && obj6 != _global_py_pool) {
17811
 
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
17812
 
      SWIG_arg_fail(svn_argnum_obj6);
17813
 
      SWIG_fail;
17814
 
    }
17815
 
  }
17816
 
  {
17817
 
    svn_swig_py_release_py_lock();
17818
 
    
17819
 
    result = (svn_error_t *)svn_repos_invoke_file_rev_handler(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9);
17820
 
    
17821
 
    svn_swig_py_acquire_py_lock();
17822
 
    
17823
 
  }
17824
 
  {
17825
 
    if (result != NULL) {
17826
 
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
17827
 
      svn_swig_py_svn_exception(result);
17828
 
      else
17829
 
      svn_error_clear(result);
17830
 
      SWIG_fail;
17831
 
    }
17832
 
    Py_INCREF(Py_None);
17833
 
    resultobj = Py_None;
17834
 
  }
17835
 
  {
17836
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
17837
 
        _global_py_pool, args))
17838
 
    
17839
 
    ;
17840
 
  }
17841
 
  {
17842
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
17843
 
        _global_py_pool, args))
17844
 
    
17845
 
    ;
17846
 
  }
17847
 
  {
17848
 
    Py_XDECREF(_global_py_pool);
17849
 
  }
17850
 
  return resultobj;
17851
 
fail:
17852
 
  {
17853
 
    Py_XDECREF(_global_py_pool);
17854
 
  }
17855
 
  return NULL;
17856
 
}
17857
 
 
17858
 
 
17859
19016
SWIGINTERN PyObject *_wrap_svn_repos_invoke_notify_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17860
19017
  PyObject *resultobj = 0;
17861
19018
  svn_repos_notify_func_t arg1 = (svn_repos_notify_func_t) 0 ;
17876
19033
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_invoke_notify_func",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17877
19034
  {
17878
19035
    svn_repos_notify_func_t * tmp =
17879
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj0);
 
19036
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj0);
17880
19037
    if (tmp == NULL || PyErr_Occurred()) {
17881
19038
      SWIG_fail;
17882
19039
    }
17891
19048
    }
17892
19049
  }
17893
19050
  {
17894
 
    arg3 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj2);
 
19051
    arg3 = (svn_repos_notify_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj2);
17895
19052
    if (PyErr_Occurred()) {
17896
19053
      SWIG_fail;
17897
19054
    }
17944
19101
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_repos_invoke_freeze_func",&obj0,&obj1,&obj2)) SWIG_fail;
17945
19102
  {
17946
19103
    svn_repos_freeze_func_t * tmp =
17947
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
19104
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
17948
19105
    if (tmp == NULL || PyErr_Occurred()) {
17949
19106
      SWIG_fail;
17950
19107
    }
18019
19176
  if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_repos_invoke_history_func",&obj0,&obj1,&arg3,&obj3,&obj4)) SWIG_fail;
18020
19177
  {
18021
19178
    svn_repos_history_func_t * tmp =
18022
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
19179
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
18023
19180
    if (tmp == NULL || PyErr_Occurred()) {
18024
19181
      SWIG_fail;
18025
19182
    }
18078
19235
}
18079
19236
 
18080
19237
 
 
19238
SWIGINTERN PyObject *_wrap_svn_repos_invoke_file_rev_handler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19239
  PyObject *resultobj = 0;
 
19240
  svn_repos_file_rev_handler_t arg1 = (svn_repos_file_rev_handler_t) 0 ;
 
19241
  void *arg2 = (void *) 0 ;
 
19242
  char *arg3 = (char *) 0 ;
 
19243
  svn_revnum_t arg4 ;
 
19244
  apr_hash_t *arg5 = (apr_hash_t *) 0 ;
 
19245
  svn_txdelta_window_handler_t *arg6 = (svn_txdelta_window_handler_t *) 0 ;
 
19246
  void **arg7 = (void **) 0 ;
 
19247
  apr_array_header_t *arg8 = (apr_array_header_t *) 0 ;
 
19248
  apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
19249
  apr_pool_t *_global_pool = NULL ;
 
19250
  PyObject *_global_py_pool = NULL ;
 
19251
  void *temp7 ;
 
19252
  PyObject * obj0 = 0 ;
 
19253
  PyObject * obj1 = 0 ;
 
19254
  PyObject * obj3 = 0 ;
 
19255
  PyObject * obj4 = 0 ;
 
19256
  PyObject * obj5 = 0 ;
 
19257
  PyObject * obj6 = 0 ;
 
19258
  svn_error_t *result = 0 ;
 
19259
  
 
19260
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
19261
      &_global_py_pool, &_global_pool))
 
19262
  SWIG_fail;
 
19263
  arg9 = _global_pool;
 
19264
  {
 
19265
    if (_global_pool == NULL)
 
19266
    {
 
19267
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
19268
          &_global_py_pool, &_global_pool))
 
19269
      SWIG_fail;
 
19270
    }
 
19271
    arg6 = (svn_txdelta_window_handler_t *) apr_pcalloc(_global_pool, sizeof(svn_txdelta_window_handler_t));
 
19272
    if (arg6 == NULL) SWIG_fail;
 
19273
  }
 
19274
  arg7 = &temp7;
 
19275
  if (!PyArg_ParseTuple(args,(char *)"OOsOOO|O:svn_repos_invoke_file_rev_handler",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
19276
  {
 
19277
    svn_repos_file_rev_handler_t * tmp =
 
19278
    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);
 
19279
    if (tmp == NULL || PyErr_Occurred()) {
 
19280
      SWIG_fail;
 
19281
    }
 
19282
    arg1 = *tmp;
 
19283
  }
 
19284
  {
 
19285
    if (obj1 == Py_None) {
 
19286
      arg2 = NULL;
 
19287
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
 
19288
      arg2 = (void *) obj1;
 
19289
      PyErr_Clear();
 
19290
    }
 
19291
  }
 
19292
  {
 
19293
    arg4 = (svn_revnum_t)SWIG_As_long (obj3);
 
19294
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
19295
      SWIG_fail;
 
19296
    }
 
19297
  }
 
19298
  {
 
19299
    arg5 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_apr_hash_t, svn_argnum_obj4);
 
19300
    if (PyErr_Occurred()) {
 
19301
      SWIG_fail;
 
19302
    }
 
19303
  }
 
19304
  {
 
19305
    arg8 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj5, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj5);
 
19306
    if (PyErr_Occurred()) {
 
19307
      SWIG_fail;
 
19308
    }
 
19309
  }
 
19310
  if (obj6) {
 
19311
    /* Verify that the user supplied a valid pool */
 
19312
    if (obj6 != Py_None && obj6 != _global_py_pool) {
 
19313
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
 
19314
      SWIG_arg_fail(svn_argnum_obj6);
 
19315
      SWIG_fail;
 
19316
    }
 
19317
  }
 
19318
  {
 
19319
    svn_swig_py_release_py_lock();
 
19320
    
 
19321
    result = (svn_error_t *)svn_repos_invoke_file_rev_handler(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
19322
    
 
19323
    svn_swig_py_acquire_py_lock();
 
19324
    
 
19325
  }
 
19326
  {
 
19327
    if (result != NULL) {
 
19328
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
19329
      svn_swig_py_svn_exception(result);
 
19330
      else
 
19331
      svn_error_clear(result);
 
19332
      SWIG_fail;
 
19333
    }
 
19334
    Py_INCREF(Py_None);
 
19335
    resultobj = Py_None;
 
19336
  }
 
19337
  {
 
19338
    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,
 
19339
        _global_py_pool, args))
 
19340
    
 
19341
    ;
 
19342
  }
 
19343
  {
 
19344
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg7, SWIGTYPE_p_void,
 
19345
        _global_py_pool, args))
 
19346
    
 
19347
    ;
 
19348
  }
 
19349
  {
 
19350
    Py_XDECREF(_global_py_pool);
 
19351
  }
 
19352
  return resultobj;
 
19353
fail:
 
19354
  {
 
19355
    Py_XDECREF(_global_py_pool);
 
19356
  }
 
19357
  return NULL;
 
19358
}
 
19359
 
 
19360
 
 
19361
SWIGINTERN PyObject *_wrap_svn_repos_invoke_verify_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19362
  PyObject *resultobj = 0;
 
19363
  svn_repos_verify_callback_t arg1 = (svn_repos_verify_callback_t) 0 ;
 
19364
  void *arg2 = (void *) 0 ;
 
19365
  svn_revnum_t arg3 ;
 
19366
  svn_error_t *arg4 = (svn_error_t *) 0 ;
 
19367
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
19368
  apr_pool_t *_global_pool = NULL ;
 
19369
  PyObject *_global_py_pool = NULL ;
 
19370
  PyObject * obj0 = 0 ;
 
19371
  PyObject * obj1 = 0 ;
 
19372
  PyObject * obj2 = 0 ;
 
19373
  PyObject * obj3 = 0 ;
 
19374
  PyObject * obj4 = 0 ;
 
19375
  svn_error_t *result = 0 ;
 
19376
  
 
19377
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
19378
      &_global_py_pool, &_global_pool))
 
19379
  SWIG_fail;
 
19380
  arg5 = _global_pool;
 
19381
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_invoke_verify_callback",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
19382
  {
 
19383
    svn_repos_verify_callback_t * tmp =
 
19384
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
19385
    if (tmp == NULL || PyErr_Occurred()) {
 
19386
      SWIG_fail;
 
19387
    }
 
19388
    arg1 = *tmp;
 
19389
  }
 
19390
  {
 
19391
    if (obj1 == Py_None) {
 
19392
      arg2 = NULL;
 
19393
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
 
19394
      arg2 = (void *) obj1;
 
19395
      PyErr_Clear();
 
19396
    }
 
19397
  }
 
19398
  {
 
19399
    arg3 = (svn_revnum_t)SWIG_As_long (obj2);
 
19400
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
19401
      SWIG_fail;
 
19402
    }
 
19403
  }
 
19404
  {
 
19405
    arg4 = (svn_error_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_error_t, svn_argnum_obj3);
 
19406
    if (PyErr_Occurred()) {
 
19407
      SWIG_fail;
 
19408
    }
 
19409
  }
 
19410
  if (obj4) {
 
19411
    /* Verify that the user supplied a valid pool */
 
19412
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
19413
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
19414
      SWIG_arg_fail(svn_argnum_obj4);
 
19415
      SWIG_fail;
 
19416
    }
 
19417
  }
 
19418
  {
 
19419
    svn_swig_py_release_py_lock();
 
19420
    
 
19421
    result = (svn_error_t *)svn_repos_invoke_verify_callback(arg1,arg2,arg3,arg4,arg5);
 
19422
    
 
19423
    svn_swig_py_acquire_py_lock();
 
19424
    
 
19425
  }
 
19426
  {
 
19427
    if (result != NULL) {
 
19428
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
19429
      svn_swig_py_svn_exception(result);
 
19430
      else
 
19431
      svn_error_clear(result);
 
19432
      SWIG_fail;
 
19433
    }
 
19434
    Py_INCREF(Py_None);
 
19435
    resultobj = Py_None;
 
19436
  }
 
19437
  {
 
19438
    Py_XDECREF(_global_py_pool);
 
19439
  }
 
19440
  return resultobj;
 
19441
fail:
 
19442
  {
 
19443
    Py_XDECREF(_global_py_pool);
 
19444
  }
 
19445
  return NULL;
 
19446
}
 
19447
 
 
19448
 
18081
19449
SWIGINTERN PyObject *svn_repos_authz_func_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18082
19450
  PyObject *obj;
18083
19451
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
18092
19460
  return SWIG_Py_Void();
18093
19461
}
18094
19462
 
18095
 
SWIGINTERN PyObject *svn_repos_file_rev_handler_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18096
 
  PyObject *obj;
18097
 
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
18098
 
  SWIG_TypeNewClientData(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, SWIG_NewClientData(obj));
18099
 
  return SWIG_Py_Void();
18100
 
}
18101
 
 
18102
19463
SWIGINTERN PyObject *svn_repos_notify_func_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18103
19464
  PyObject *obj;
18104
19465
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
18120
19481
  return SWIG_Py_Void();
18121
19482
}
18122
19483
 
 
19484
SWIGINTERN PyObject *svn_repos_file_rev_handler_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19485
  PyObject *obj;
 
19486
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
19487
  SWIG_TypeNewClientData(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, SWIG_NewClientData(obj));
 
19488
  return SWIG_Py_Void();
 
19489
}
 
19490
 
 
19491
SWIGINTERN PyObject *svn_repos_verify_callback_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19492
  PyObject *obj;
 
19493
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
19494
  SWIG_TypeNewClientData(SWIGTYPE_p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, SWIG_NewClientData(obj));
 
19495
  return SWIG_Py_Void();
 
19496
}
 
19497
 
18123
19498
static PyMethodDef SwigMethods[] = {
18124
19499
         { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
 
19500
         { (char *)"svn_swig_py_make_parse_fns3", _wrap_svn_swig_py_make_parse_fns3, METH_VARARGS, (char *)"svn_swig_py_make_parse_fns3(PyObject * py_parse_fns3, apr_pool_t pool)"},
18125
19501
         { (char *)"svn_repos_version", _wrap_svn_repos_version, METH_VARARGS, (char *)"svn_repos_version() -> svn_version_t const *"},
18126
19502
         { (char *)"svn_repos_notify_t_action_set", _wrap_svn_repos_notify_t_action_set, METH_VARARGS, (char *)"svn_repos_notify_t_action_set(svn_repos_notify_t self, svn_repos_notify_action_t action)"},
18127
19503
         { (char *)"svn_repos_notify_t_action_get", _wrap_svn_repos_notify_t_action_get, METH_VARARGS, (char *)"svn_repos_notify_t_action_get(svn_repos_notify_t self) -> svn_repos_notify_action_t"},
18141
19517
         { (char *)"svn_repos_notify_t_node_action_get", _wrap_svn_repos_notify_t_node_action_get, METH_VARARGS, (char *)"svn_repos_notify_t_node_action_get(svn_repos_notify_t self) -> enum svn_node_action"},
18142
19518
         { (char *)"svn_repos_notify_t_path_set", _wrap_svn_repos_notify_t_path_set, METH_VARARGS, (char *)"svn_repos_notify_t_path_set(svn_repos_notify_t self, char const * path)"},
18143
19519
         { (char *)"svn_repos_notify_t_path_get", _wrap_svn_repos_notify_t_path_get, METH_VARARGS, (char *)"svn_repos_notify_t_path_get(svn_repos_notify_t self) -> char const *"},
 
19520
         { (char *)"svn_repos_notify_t_start_revision_set", _wrap_svn_repos_notify_t_start_revision_set, METH_VARARGS, (char *)"svn_repos_notify_t_start_revision_set(svn_repos_notify_t self, svn_revnum_t start_revision)"},
 
19521
         { (char *)"svn_repos_notify_t_start_revision_get", _wrap_svn_repos_notify_t_start_revision_get, METH_VARARGS, (char *)"svn_repos_notify_t_start_revision_get(svn_repos_notify_t self) -> svn_revnum_t"},
 
19522
         { (char *)"svn_repos_notify_t_end_revision_set", _wrap_svn_repos_notify_t_end_revision_set, METH_VARARGS, (char *)"svn_repos_notify_t_end_revision_set(svn_repos_notify_t self, svn_revnum_t end_revision)"},
 
19523
         { (char *)"svn_repos_notify_t_end_revision_get", _wrap_svn_repos_notify_t_end_revision_get, METH_VARARGS, (char *)"svn_repos_notify_t_end_revision_get(svn_repos_notify_t self) -> svn_revnum_t"},
18144
19524
         { (char *)"svn_repos_notify_t_swigregister", svn_repos_notify_t_swigregister, METH_VARARGS, NULL},
18145
19525
         { (char *)"svn_repos_notify_create", _wrap_svn_repos_notify_create, METH_VARARGS, (char *)"svn_repos_notify_create(svn_repos_notify_action_t action, apr_pool_t result_pool) -> svn_repos_notify_t"},
18146
19526
         { (char *)"svn_repos_find_root_path", _wrap_svn_repos_find_root_path, METH_VARARGS, (char *)"svn_repos_find_root_path(char const * path, apr_pool_t pool) -> char const *"},
 
19527
         { (char *)"svn_repos_open3", _wrap_svn_repos_open3, METH_VARARGS, (char *)"svn_repos_open3(char const * path, apr_hash_t fs_config, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
18147
19528
         { (char *)"svn_repos_open2", _wrap_svn_repos_open2, METH_VARARGS, (char *)"svn_repos_open2(char const * path, apr_hash_t fs_config, apr_pool_t pool) -> svn_error_t"},
18148
19529
         { (char *)"svn_repos_open", _wrap_svn_repos_open, METH_VARARGS, (char *)"svn_repos_open(char const * path, apr_pool_t pool) -> svn_error_t"},
18149
19530
         { (char *)"svn_repos_create", _wrap_svn_repos_create, METH_VARARGS, (char *)"\n"
18160
19541
                ""},
18161
19542
         { (char *)"svn_repos_delete", _wrap_svn_repos_delete, METH_VARARGS, (char *)"svn_repos_delete(char const * path, apr_pool_t pool) -> svn_error_t"},
18162
19543
         { (char *)"svn_repos_has_capability", _wrap_svn_repos_has_capability, METH_VARARGS, (char *)"svn_repos_has_capability(svn_repos_t * repos, char const * capability, apr_pool_t pool) -> svn_error_t"},
 
19544
         { (char *)"svn_repos_capabilities", _wrap_svn_repos_capabilities, METH_VARARGS, (char *)"svn_repos_capabilities(svn_repos_t * repos, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
 
19545
         { (char *)"svn_repos_remember_client_capabilities", _wrap_svn_repos_remember_client_capabilities, METH_VARARGS, (char *)"svn_repos_remember_client_capabilities(svn_repos_t * repos, apr_array_header_t capabilities) -> svn_error_t"},
18163
19546
         { (char *)"svn_repos_fs", _wrap_svn_repos_fs, METH_VARARGS, (char *)"svn_repos_fs(svn_repos_t * repos) -> svn_fs_t *"},
 
19547
         { (char *)"svn_repos_fs_type", _wrap_svn_repos_fs_type, METH_VARARGS, (char *)"svn_repos_fs_type(svn_repos_t * repos, apr_pool_t result_pool) -> char const *"},
 
19548
         { (char *)"svn_repos_hotcopy3", _wrap_svn_repos_hotcopy3, METH_VARARGS, (char *)"\n"
 
19549
                "svn_repos_hotcopy3(char const * src_path, char const * dst_path, svn_boolean_t clean_logs, svn_boolean_t incremental, \n"
 
19550
                "    svn_repos_notify_func_t notify_func, void * notify_baton, \n"
 
19551
                "    svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t\n"
 
19552
                ""},
18164
19553
         { (char *)"svn_repos_hotcopy2", _wrap_svn_repos_hotcopy2, METH_VARARGS, (char *)"\n"
18165
19554
                "svn_repos_hotcopy2(char const * src_path, char const * dst_path, svn_boolean_t clean_logs, svn_boolean_t incremental, \n"
18166
19555
                "    svn_cancel_func_t cancel_func, apr_pool_t pool) -> svn_error_t\n"
18275
19664
                ""},
18276
19665
         { (char *)"svn_repos_replay", _wrap_svn_repos_replay, METH_VARARGS, (char *)"svn_repos_replay(svn_fs_root_t * root, svn_delta_editor_t editor, void * edit_baton, apr_pool_t pool) -> svn_error_t"},
18277
19666
         { (char *)"svn_repos_get_commit_editor5", _wrap_svn_repos_get_commit_editor5, METH_VARARGS, (char *)"\n"
18278
 
                "svn_repos_get_commit_editor5(svn_repos_t * repos, svn_fs_txn_t * txn, char const * repos_url, char const * base_path, \n"
18279
 
                "    apr_hash_t revprop_table, svn_commit_callback2_t commit_callback, svn_repos_authz_callback_t authz_callback, \n"
18280
 
                "    void * authz_baton, apr_pool_t pool) -> svn_error_t\n"
 
19667
                "svn_repos_get_commit_editor5(svn_repos_t * repos, svn_fs_txn_t * txn, char const * repos_url_decoded, char const * base_path, \n"
 
19668
                "    apr_hash_t revprop_table, svn_commit_callback2_t commit_callback, \n"
 
19669
                "    svn_repos_authz_callback_t authz_callback, void * authz_baton, apr_pool_t pool) -> svn_error_t\n"
18281
19670
                ""},
18282
19671
         { (char *)"svn_repos_get_commit_editor4", _wrap_svn_repos_get_commit_editor4, METH_VARARGS, (char *)"\n"
18283
19672
                "svn_repos_get_commit_editor4(svn_repos_t * repos, svn_fs_txn_t * txn, char const * repos_url, char const * base_path, \n"
18367
19756
                "    apr_pool_t pool) -> svn_error_t\n"
18368
19757
                ""},
18369
19758
         { (char *)"svn_repos_fs_begin_txn_for_update", _wrap_svn_repos_fs_begin_txn_for_update, METH_VARARGS, (char *)"svn_repos_fs_begin_txn_for_update(svn_repos_t * repos, svn_revnum_t rev, char const * author, apr_pool_t pool) -> svn_error_t"},
 
19759
         { (char *)"svn_repos_fs_lock_many", _wrap_svn_repos_fs_lock_many, METH_VARARGS, (char *)"\n"
 
19760
                "svn_repos_fs_lock_many(svn_repos_t * repos, apr_hash_t lock_targets, char const * comment, svn_boolean_t is_dav_comment, \n"
 
19761
                "    apr_time_t expiration_date, svn_boolean_t steal_lock, svn_fs_lock_callback_t lock_callback, \n"
 
19762
                "    apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t\n"
 
19763
                ""},
18370
19764
         { (char *)"svn_repos_fs_lock", _wrap_svn_repos_fs_lock, METH_VARARGS, (char *)"\n"
18371
19765
                "svn_repos_fs_lock(svn_repos_t * repos, char const * path, char const * token, char const * comment, \n"
18372
19766
                "    svn_boolean_t is_dav_comment, apr_time_t expiration_date, svn_revnum_t current_rev, \n"
18373
19767
                "    svn_boolean_t steal_lock, apr_pool_t pool) -> svn_error_t\n"
18374
19768
                ""},
 
19769
         { (char *)"svn_repos_fs_unlock_many", _wrap_svn_repos_fs_unlock_many, METH_VARARGS, (char *)"\n"
 
19770
                "svn_repos_fs_unlock_many(svn_repos_t * repos, apr_hash_t unlock_targets, svn_boolean_t break_lock, svn_fs_lock_callback_t lock_callback, \n"
 
19771
                "    apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t\n"
 
19772
                ""},
18375
19773
         { (char *)"svn_repos_fs_unlock", _wrap_svn_repos_fs_unlock, METH_VARARGS, (char *)"\n"
18376
19774
                "svn_repos_fs_unlock(svn_repos_t * repos, char const * path, char const * token, svn_boolean_t break_lock, \n"
18377
19775
                "    apr_pool_t pool) -> svn_error_t\n"
18410
19808
                "svn_repos_fs_change_node_prop(svn_fs_root_t * root, char const * path, char const * name, svn_string_t const * value, \n"
18411
19809
                "    apr_pool_t pool) -> svn_error_t\n"
18412
19810
                ""},
 
19811
         { (char *)"svn_repos_fs_get_inherited_props", _wrap_svn_repos_fs_get_inherited_props, METH_VARARGS, (char *)"\n"
 
19812
                "svn_repos_fs_get_inherited_props(svn_fs_root_t * root, char const * path, char const * propname, svn_repos_authz_func_t authz_read_func, \n"
 
19813
                "    apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t\n"
 
19814
                ""},
18413
19815
         { (char *)"svn_repos_fs_change_txn_prop", _wrap_svn_repos_fs_change_txn_prop, METH_VARARGS, (char *)"svn_repos_fs_change_txn_prop(svn_fs_txn_t * txn, char const * name, svn_string_t const * value, apr_pool_t pool) -> svn_error_t"},
18414
19816
         { (char *)"svn_repos_fs_change_txn_props", _wrap_svn_repos_fs_change_txn_props, METH_VARARGS, (char *)"svn_repos_fs_change_txn_props(svn_fs_txn_t * txn, apr_array_header_t props, apr_pool_t pool) -> svn_error_t"},
18415
19817
         { (char *)"svn_repos_node_t_kind_set", _wrap_svn_repos_node_t_kind_set, METH_VARARGS, (char *)"svn_repos_node_t_kind_set(svn_repos_node_t self, svn_node_kind_t kind)"},
18438
19840
                "    apr_pool_t pool) -> svn_error_t\n"
18439
19841
                ""},
18440
19842
         { (char *)"svn_repos_node_from_baton", _wrap_svn_repos_node_from_baton, METH_VARARGS, (char *)"svn_repos_node_from_baton(void * edit_baton) -> svn_repos_node_t"},
 
19843
         { (char *)"svn_repos_info_format", _wrap_svn_repos_info_format, METH_VARARGS, (char *)"svn_repos_info_format(svn_repos_t * repos, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
 
19844
         { (char *)"svn_repos_verify_fs3", _wrap_svn_repos_verify_fs3, METH_VARARGS, (char *)"\n"
 
19845
                "svn_repos_verify_fs3(svn_repos_t * repos, svn_revnum_t start_rev, svn_revnum_t end_rev, svn_boolean_t check_normalization, \n"
 
19846
                "    svn_boolean_t metadata_only, svn_repos_notify_func_t notify_func, \n"
 
19847
                "    void * notify_baton, svn_repos_verify_callback_t verify_callback, \n"
 
19848
                "    void * verify_baton, svn_cancel_func_t cancel, void * cancel_baton, apr_pool_t scratch_pool) -> svn_error_t\n"
 
19849
                ""},
18441
19850
         { (char *)"svn_repos_verify_fs2", _wrap_svn_repos_verify_fs2, METH_VARARGS, (char *)"\n"
18442
19851
                "svn_repos_verify_fs2(svn_repos_t * repos, svn_revnum_t start_rev, svn_revnum_t end_rev, svn_repos_notify_func_t notify_func, \n"
18443
19852
                "    void * notify_baton, svn_cancel_func_t cancel, void * cancel_baton, \n"
18463
19872
                "    svn_revnum_t end_rev, svn_boolean_t incremental, svn_cancel_func_t cancel_func, \n"
18464
19873
                "    apr_pool_t pool) -> svn_error_t\n"
18465
19874
                ""},
 
19875
         { (char *)"svn_repos_load_fs5", _wrap_svn_repos_load_fs5, METH_VARARGS, (char *)"\n"
 
19876
                "svn_repos_load_fs5(svn_repos_t * repos, svn_stream_t * dumpstream, svn_revnum_t start_rev, svn_revnum_t end_rev, \n"
 
19877
                "    enum svn_repos_load_uuid uuid_action, char const * parent_dir, \n"
 
19878
                "    svn_boolean_t use_pre_commit_hook, svn_boolean_t use_post_commit_hook, svn_boolean_t validate_props, \n"
 
19879
                "    svn_boolean_t ignore_dates, svn_repos_notify_func_t notify_func, \n"
 
19880
                "    void * notify_baton, svn_cancel_func_t cancel_func, apr_pool_t pool) -> svn_error_t\n"
 
19881
                ""},
18466
19882
         { (char *)"svn_repos_load_fs4", _wrap_svn_repos_load_fs4, METH_VARARGS, (char *)"\n"
18467
19883
                "svn_repos_load_fs4(svn_repos_t * repos, svn_stream_t * dumpstream, svn_revnum_t start_rev, svn_revnum_t end_rev, \n"
18468
19884
                "    enum svn_repos_load_uuid uuid_action, char const * parent_dir, \n"
18516
19932
                "svn_repos_parse_dumpstream3(svn_stream_t * stream, svn_repos_parse_fns3_t parse_fns, void * parse_baton, svn_boolean_t deltas_are_text, \n"
18517
19933
                "    svn_cancel_func_t cancel_func, apr_pool_t pool) -> svn_error_t\n"
18518
19934
                ""},
 
19935
         { (char *)"svn_repos_get_fs_build_parser5", _wrap_svn_repos_get_fs_build_parser5, METH_VARARGS, (char *)"\n"
 
19936
                "svn_repos_get_fs_build_parser5(svn_repos_t * repos, svn_revnum_t start_rev, svn_revnum_t end_rev, svn_boolean_t use_history, \n"
 
19937
                "    svn_boolean_t validate_props, enum svn_repos_load_uuid uuid_action, \n"
 
19938
                "    char const * parent_dir, svn_boolean_t use_pre_commit_hook, svn_boolean_t use_post_commit_hook, \n"
 
19939
                "    svn_boolean_t ignore_dates, svn_repos_notify_func_t notify_func, \n"
 
19940
                "    void * notify_baton, apr_pool_t pool) -> svn_error_t\n"
 
19941
                ""},
18519
19942
         { (char *)"svn_repos_get_fs_build_parser4", _wrap_svn_repos_get_fs_build_parser4, METH_VARARGS, (char *)"\n"
18520
19943
                "svn_repos_get_fs_build_parser4(svn_repos_t * repos, svn_revnum_t start_rev, svn_revnum_t end_rev, svn_boolean_t use_history, \n"
18521
19944
                "    svn_boolean_t validate_props, enum svn_repos_load_uuid uuid_action, \n"
18596
20019
                "svn_repos_check_revision_access(svn_repos_revision_access_level_t * access_level, svn_repos_t * repos, svn_revnum_t revision, \n"
18597
20020
                "    svn_repos_authz_func_t authz_read_func, apr_pool_t pool) -> svn_error_t\n"
18598
20021
                ""},
18599
 
         { (char *)"svn_repos_fs_get_inherited_props", _wrap_svn_repos_fs_get_inherited_props, METH_VARARGS, (char *)"\n"
18600
 
                "svn_repos_fs_get_inherited_props(svn_fs_root_t * root, char const * path, char const * propname, svn_repos_authz_func_t authz_read_func, \n"
18601
 
                "    apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t\n"
18602
 
                ""},
18603
 
         { (char *)"svn_repos_remember_client_capabilities", _wrap_svn_repos_remember_client_capabilities, METH_VARARGS, (char *)"svn_repos_remember_client_capabilities(svn_repos_t * repos, apr_array_header_t capabilities) -> svn_error_t"},
18604
20022
         { (char *)"svn_repos_t_swigregister", svn_repos_t_swigregister, METH_VARARGS, NULL},
18605
20023
         { (char *)"svn_authz_t_swigregister", svn_authz_t_swigregister, METH_VARARGS, NULL},
18606
20024
         { (char *)"svn_repos_parse_fns3_invoke_magic_header_record", _wrap_svn_repos_parse_fns3_invoke_magic_header_record, METH_VARARGS, (char *)"svn_repos_parse_fns3_invoke_magic_header_record(svn_repos_parse_fns3_t _obj, int version, void * parse_baton, apr_pool_t pool) -> svn_error_t"},
18634
20052
                "svn_repos_invoke_authz_callback(svn_repos_authz_callback_t _obj, svn_repos_authz_access_t required, svn_fs_root_t * root, \n"
18635
20053
                "    char const * path, void * baton, apr_pool_t pool) -> svn_error_t\n"
18636
20054
                ""},
18637
 
         { (char *)"svn_repos_invoke_file_rev_handler", _wrap_svn_repos_invoke_file_rev_handler, METH_VARARGS, (char *)"\n"
18638
 
                "svn_repos_invoke_file_rev_handler(svn_repos_file_rev_handler_t _obj, void * baton, char const * path, svn_revnum_t rev, \n"
18639
 
                "    apr_hash_t rev_props, apr_array_header_t prop_diffs, apr_pool_t pool) -> svn_error_t\n"
18640
 
                ""},
18641
20055
         { (char *)"svn_repos_invoke_notify_func", _wrap_svn_repos_invoke_notify_func, METH_VARARGS, (char *)"svn_repos_invoke_notify_func(svn_repos_notify_func_t _obj, void * baton, svn_repos_notify_t notify, apr_pool_t scratch_pool)"},
18642
20056
         { (char *)"svn_repos_invoke_freeze_func", _wrap_svn_repos_invoke_freeze_func, METH_VARARGS, (char *)"svn_repos_invoke_freeze_func(svn_repos_freeze_func_t _obj, void * baton, apr_pool_t pool) -> svn_error_t"},
18643
20057
         { (char *)"svn_repos_invoke_history_func", _wrap_svn_repos_invoke_history_func, METH_VARARGS, (char *)"\n"
18644
20058
                "svn_repos_invoke_history_func(svn_repos_history_func_t _obj, void * baton, char const * path, svn_revnum_t revision, \n"
18645
20059
                "    apr_pool_t pool) -> svn_error_t\n"
18646
20060
                ""},
 
20061
         { (char *)"svn_repos_invoke_file_rev_handler", _wrap_svn_repos_invoke_file_rev_handler, METH_VARARGS, (char *)"\n"
 
20062
                "svn_repos_invoke_file_rev_handler(svn_repos_file_rev_handler_t _obj, void * baton, char const * path, svn_revnum_t rev, \n"
 
20063
                "    apr_hash_t rev_props, apr_array_header_t prop_diffs, apr_pool_t pool) -> svn_error_t\n"
 
20064
                ""},
 
20065
         { (char *)"svn_repos_invoke_verify_callback", _wrap_svn_repos_invoke_verify_callback, METH_VARARGS, (char *)"\n"
 
20066
                "svn_repos_invoke_verify_callback(svn_repos_verify_callback_t _obj, void * baton, svn_revnum_t revision, svn_error_t verify_err, \n"
 
20067
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
20068
                ""},
18647
20069
         { (char *)"svn_repos_authz_func_t_swigregister", svn_repos_authz_func_t_swigregister, METH_VARARGS, NULL},
18648
20070
         { (char *)"svn_repos_authz_callback_t_swigregister", svn_repos_authz_callback_t_swigregister, METH_VARARGS, NULL},
18649
 
         { (char *)"svn_repos_file_rev_handler_t_swigregister", svn_repos_file_rev_handler_t_swigregister, METH_VARARGS, NULL},
18650
20071
         { (char *)"svn_repos_notify_func_t_swigregister", svn_repos_notify_func_t_swigregister, METH_VARARGS, NULL},
18651
20072
         { (char *)"svn_repos_freeze_func_t_swigregister", svn_repos_freeze_func_t_swigregister, METH_VARARGS, NULL},
18652
20073
         { (char *)"svn_repos_history_func_t_swigregister", svn_repos_history_func_t_swigregister, METH_VARARGS, NULL},
 
20074
         { (char *)"svn_repos_file_rev_handler_t_swigregister", svn_repos_file_rev_handler_t_swigregister, METH_VARARGS, NULL},
 
20075
         { (char *)"svn_repos_verify_callback_t_swigregister", svn_repos_verify_callback_t_swigregister, METH_VARARGS, NULL},
18653
20076
         { NULL, NULL, 0, NULL }
18654
20077
};
18655
20078
 
18676
20099
static swig_type_info _swigt__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_hash_t *,svn_revnum_t,char const *,char const *,char const *,apr_pool_t *)|svn_log_message_receiver_t", 0, 0, (void*)0, 0};
18677
20100
static swig_type_info _swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_pool_t *)|svn_repos_freeze_func_t", 0, 0, (void*)0, 0};
18678
20101
static swig_type_info _swigt__p_f_p_void_p_q_const__char__p_svn_error_t = {"_p_f_p_void_p_q_const__char__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *)|svn_error_t *(*)(void *,char const *)", 0, 0, (void*)0, 0};
 
20102
static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_lock_t const *,svn_error_t *,apr_pool_t *)|svn_fs_lock_callback_t", 0, 0, (void*)0, 0};
18679
20103
static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_string_t const *)|svn_error_t *(*)(void *,char const *,svn_string_t const *)", 0, 0, (void*)0, 0};
18680
20104
static swig_type_info _swigt__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 = {"_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", "struct svn_error_t *(*)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)|svn_repos_file_rev_handler_t", 0, 0, (void*)0, 0};
18681
20105
static swig_type_info _swigt__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 = {"_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", "struct svn_error_t *(*)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_boolean_t,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)|svn_file_rev_handler_t", 0, 0, (void*)0, 0};
18682
20106
static swig_type_info _swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_revnum_t,apr_pool_t *)|svn_repos_history_func_t", 0, 0, (void*)0, 0};
18683
20107
static swig_type_info _swigt__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void = {"_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void", "svn_repos_notify_func_t|void (*)(void *,struct svn_repos_notify_t const *,apr_pool_t *)", 0, 0, (void*)0, 0};
18684
20108
static swig_type_info _swigt__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,svn_log_entry_t *,apr_pool_t *)|svn_log_entry_receiver_t", 0, 0, (void*)0, 0};
 
20109
static swig_type_info _swigt__p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t", "svn_repos_verify_callback_t|struct svn_error_t *(*)(void *,svn_revnum_t,svn_error_t *,apr_pool_t *)", 0, 0, (void*)0, 0};
18685
20110
static swig_type_info _swigt__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(svn_repos_authz_access_t,svn_boolean_t *,svn_fs_root_t *,char const *,void *,apr_pool_t *)|svn_repos_authz_callback_t", 0, 0, (void*)0, 0};
18686
20111
static swig_type_info _swigt__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t = {"_p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t", "struct svn_error_t *(*)(svn_revnum_t,char const *,char const *,void *)|svn_commit_callback_t", 0, 0, (void*)0, 0};
18687
20112
static swig_type_info _swigt__p_int = {"_p_int", "int *|svn_boolean_t *|apr_status_t *", 0, 0, (void*)0, 0};
18698
20123
static swig_type_info _swigt__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 = {"_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", "struct svn_error_t *(**)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_boolean_t,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)|svn_file_rev_handler_t *", 0, 0, (void*)0, 0};
18699
20124
static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(void *,char const *,svn_revnum_t,apr_pool_t *)|svn_repos_history_func_t *", 0, 0, (void*)0, 0};
18700
20125
static swig_type_info _swigt__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void = {"_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void", "void (**)(void *,struct svn_repos_notify_t const *,apr_pool_t *)|svn_repos_notify_func_t *", 0, 0, (void*)0, 0};
 
20126
static swig_type_info _swigt__p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t", "svn_repos_verify_callback_t *|struct svn_error_t *(**)(void *,svn_revnum_t,svn_error_t *,apr_pool_t *)", 0, 0, (void*)0, 0};
18701
20127
static swig_type_info _swigt__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t = {"_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t", "svn_repos_authz_callback_t *|struct svn_error_t *(**)(svn_repos_authz_access_t,svn_boolean_t *,svn_fs_root_t *,char const *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
18702
20128
static swig_type_info _swigt__p_p_svn_authz_t = {"_p_p_svn_authz_t", "struct svn_authz_t **|svn_authz_t **", 0, 0, (void*)0, 0};
18703
20129
static swig_type_info _swigt__p_p_svn_delta_editor_t = {"_p_p_svn_delta_editor_t", "struct svn_delta_editor_t **|svn_delta_editor_t **", 0, 0, (void*)0, 0};
18710
20136
static swig_type_info _swigt__p_p_svn_repos_t = {"_p_p_svn_repos_t", "struct svn_repos_t **|svn_repos_t **", 0, 0, (void*)0, 0};
18711
20137
static swig_type_info _swigt__p_p_svn_stream_t = {"_p_p_svn_stream_t", "struct svn_stream_t **|svn_stream_t **", 0, 0, (void*)0, 0};
18712
20138
static swig_type_info _swigt__p_p_svn_string_t = {"_p_p_svn_string_t", "struct svn_string_t **|svn_string_t **", 0, 0, (void*)0, 0};
 
20139
static swig_type_info _swigt__p_p_svn_version_t = {"_p_p_svn_version_t", "struct svn_version_t **|svn_version_t **", 0, 0, (void*)0, 0};
18713
20140
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
18714
20141
static swig_type_info _swigt__p_svn_auth_baton_t = {"_p_svn_auth_baton_t", "struct svn_auth_baton_t *|svn_auth_baton_t *", 0, 0, (void*)0, 0};
18715
20142
static swig_type_info _swigt__p_svn_auth_cred_simple_t = {"_p_svn_auth_cred_simple_t", "struct svn_auth_cred_simple_t *|svn_auth_cred_simple_t *", 0, 0, (void*)0, 0};
18729
20156
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};
18730
20157
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};
18731
20158
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};
 
20159
static swig_type_info _swigt__p_svn_diff_hunk_t = {"_p_svn_diff_hunk_t", "svn_diff_hunk_t *", 0, 0, (void*)0, 0};
18732
20160
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};
18733
20161
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};
18734
20162
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};
18735
20163
static swig_type_info _swigt__p_svn_fs_access_t = {"_p_svn_fs_access_t", "struct svn_fs_access_t *|svn_fs_access_t *", 0, 0, (void*)0, 0};
18736
20164
static swig_type_info _swigt__p_svn_fs_dirent_t = {"_p_svn_fs_dirent_t", "struct svn_fs_dirent_t *|svn_fs_dirent_t *", 0, 0, (void*)0, 0};
 
20165
static swig_type_info _swigt__p_svn_fs_fsfs_info_t = {"_p_svn_fs_fsfs_info_t", "struct svn_fs_fsfs_info_t *|svn_fs_fsfs_info_t *", 0, 0, (void*)0, 0};
 
20166
static swig_type_info _swigt__p_svn_fs_fsx_info_t = {"_p_svn_fs_fsx_info_t", "struct svn_fs_fsx_info_t *|svn_fs_fsx_info_t *", 0, 0, (void*)0, 0};
18737
20167
static swig_type_info _swigt__p_svn_fs_history_t = {"_p_svn_fs_history_t", "struct svn_fs_history_t *|svn_fs_history_t *", 0, 0, (void*)0, 0};
18738
20168
static swig_type_info _swigt__p_svn_fs_id_t = {"_p_svn_fs_id_t", "struct svn_fs_id_t *|svn_fs_id_t *", 0, 0, (void*)0, 0};
 
20169
static swig_type_info _swigt__p_svn_fs_info_placeholder_t = {"_p_svn_fs_info_placeholder_t", "struct svn_fs_info_placeholder_t *|svn_fs_info_placeholder_t *", 0, 0, (void*)0, 0};
 
20170
static swig_type_info _swigt__p_svn_fs_lock_target_t = {"_p_svn_fs_lock_target_t", "struct svn_fs_lock_target_t *|svn_fs_lock_target_t *", 0, 0, (void*)0, 0};
 
20171
static swig_type_info _swigt__p_svn_fs_node_relation_t = {"_p_svn_fs_node_relation_t", "enum svn_fs_node_relation_t *|svn_fs_node_relation_t *", 0, 0, (void*)0, 0};
18739
20172
static swig_type_info _swigt__p_svn_fs_pack_notify_action_t = {"_p_svn_fs_pack_notify_action_t", "enum svn_fs_pack_notify_action_t *|svn_fs_pack_notify_action_t *", 0, 0, (void*)0, 0};
18740
20173
static swig_type_info _swigt__p_svn_fs_path_change2_t = {"_p_svn_fs_path_change2_t", "struct svn_fs_path_change2_t *|svn_fs_path_change2_t *", 0, 0, (void*)0, 0};
18741
20174
static swig_type_info _swigt__p_svn_fs_path_change_kind_t = {"_p_svn_fs_path_change_kind_t", "enum svn_fs_path_change_kind_t *|svn_fs_path_change_kind_t *", 0, 0, (void*)0, 0};
18743
20176
static swig_type_info _swigt__p_svn_fs_root_t = {"_p_svn_fs_root_t", "struct svn_fs_root_t *|svn_fs_root_t *", 0, 0, (void*)0, 0};
18744
20177
static swig_type_info _swigt__p_svn_fs_t = {"_p_svn_fs_t", "struct svn_fs_t *|svn_fs_t *", 0, 0, (void*)0, 0};
18745
20178
static swig_type_info _swigt__p_svn_fs_txn_t = {"_p_svn_fs_txn_t", "struct svn_fs_txn_t *|svn_fs_txn_t *", 0, 0, (void*)0, 0};
 
20179
static swig_type_info _swigt__p_svn_fs_upgrade_notify_action_t = {"_p_svn_fs_upgrade_notify_action_t", "enum svn_fs_upgrade_notify_action_t *|svn_fs_upgrade_notify_action_t *", 0, 0, (void*)0, 0};
18746
20180
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};
18747
20181
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};
18748
20182
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};
18809
20243
  &_swigt__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t,
18810
20244
  &_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t,
18811
20245
  &_swigt__p_f_p_void_p_q_const__char__p_svn_error_t,
 
20246
  &_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
18812
20247
  &_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t,
18813
20248
  &_swigt__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,
18814
20249
  &_swigt__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,
18815
20250
  &_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
18816
20251
  &_swigt__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
18817
20252
  &_swigt__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t,
 
20253
  &_swigt__p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
18818
20254
  &_swigt__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
18819
20255
  &_swigt__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t,
18820
20256
  &_swigt__p_int,
18831
20267
  &_swigt__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,
18832
20268
  &_swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
18833
20269
  &_swigt__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
 
20270
  &_swigt__p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
18834
20271
  &_swigt__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
18835
20272
  &_swigt__p_p_svn_authz_t,
18836
20273
  &_swigt__p_p_svn_delta_editor_t,
18843
20280
  &_swigt__p_p_svn_repos_t,
18844
20281
  &_swigt__p_p_svn_stream_t,
18845
20282
  &_swigt__p_p_svn_string_t,
 
20283
  &_swigt__p_p_svn_version_t,
18846
20284
  &_swigt__p_p_void,
18847
20285
  &_swigt__p_svn_auth_baton_t,
18848
20286
  &_swigt__p_svn_auth_cred_simple_t,
18862
20300
  &_swigt__p_svn_config_t,
18863
20301
  &_swigt__p_svn_delta_editor_t,
18864
20302
  &_swigt__p_svn_depth_t,
 
20303
  &_swigt__p_svn_diff_hunk_t,
18865
20304
  &_swigt__p_svn_dirent_t,
18866
20305
  &_swigt__p_svn_errno_t,
18867
20306
  &_swigt__p_svn_error_t,
18868
20307
  &_swigt__p_svn_fs_access_t,
18869
20308
  &_swigt__p_svn_fs_dirent_t,
 
20309
  &_swigt__p_svn_fs_fsfs_info_t,
 
20310
  &_swigt__p_svn_fs_fsx_info_t,
18870
20311
  &_swigt__p_svn_fs_history_t,
18871
20312
  &_swigt__p_svn_fs_id_t,
 
20313
  &_swigt__p_svn_fs_info_placeholder_t,
 
20314
  &_swigt__p_svn_fs_lock_target_t,
 
20315
  &_swigt__p_svn_fs_node_relation_t,
18872
20316
  &_swigt__p_svn_fs_pack_notify_action_t,
18873
20317
  &_swigt__p_svn_fs_path_change2_t,
18874
20318
  &_swigt__p_svn_fs_path_change_kind_t,
18876
20320
  &_swigt__p_svn_fs_root_t,
18877
20321
  &_swigt__p_svn_fs_t,
18878
20322
  &_swigt__p_svn_fs_txn_t,
 
20323
  &_swigt__p_svn_fs_upgrade_notify_action_t,
18879
20324
  &_swigt__p_svn_io_dirent2_t,
18880
20325
  &_swigt__p_svn_io_dirent_t,
18881
20326
  &_swigt__p_svn_io_file_del_t,
18942
20387
static swig_cast_info _swigc__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18943
20388
static swig_cast_info _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18944
20389
static swig_cast_info _swigc__p_f_p_void_p_q_const__char__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_q_const__char__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
20390
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18945
20391
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18946
20392
static swig_cast_info _swigc__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[] = {  {&_swigt__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, 0, 0, 0},{0, 0, 0, 0}};
18947
20393
static swig_cast_info _swigc__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[] = {  {&_swigt__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, 0, 0, 0},{0, 0, 0, 0}};
18948
20394
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18949
20395
static swig_cast_info _swigc__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void[] = {  {&_swigt__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, 0, 0, 0},{0, 0, 0, 0}};
18950
20396
static swig_cast_info _swigc__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
20397
static swig_cast_info _swigc__p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18951
20398
static swig_cast_info _swigc__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18952
20399
static swig_cast_info _swigc__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t[] = {  {&_swigt__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18953
20400
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
18964
20411
static swig_cast_info _swigc__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[] = {  {&_swigt__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, 0, 0, 0},{0, 0, 0, 0}};
18965
20412
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18966
20413
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void[] = {  {&_swigt__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, 0, 0, 0},{0, 0, 0, 0}};
 
20414
static swig_cast_info _swigc__p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18967
20415
static swig_cast_info _swigc__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
18968
20416
static swig_cast_info _swigc__p_p_svn_authz_t[] = {  {&_swigt__p_p_svn_authz_t, 0, 0, 0},{0, 0, 0, 0}};
18969
20417
static swig_cast_info _swigc__p_p_svn_delta_editor_t[] = {  {&_swigt__p_p_svn_delta_editor_t, 0, 0, 0},{0, 0, 0, 0}};
18976
20424
static swig_cast_info _swigc__p_p_svn_repos_t[] = {  {&_swigt__p_p_svn_repos_t, 0, 0, 0},{0, 0, 0, 0}};
18977
20425
static swig_cast_info _swigc__p_p_svn_stream_t[] = {  {&_swigt__p_p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
18978
20426
static swig_cast_info _swigc__p_p_svn_string_t[] = {  {&_swigt__p_p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
 
20427
static swig_cast_info _swigc__p_p_svn_version_t[] = {  {&_swigt__p_p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
18979
20428
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
18980
20429
static swig_cast_info _swigc__p_svn_auth_baton_t[] = {  {&_swigt__p_svn_auth_baton_t, 0, 0, 0},{0, 0, 0, 0}};
18981
20430
static swig_cast_info _swigc__p_svn_auth_cred_simple_t[] = {  {&_swigt__p_svn_auth_cred_simple_t, 0, 0, 0},{0, 0, 0, 0}};
18995
20444
static swig_cast_info _swigc__p_svn_config_t[] = {  {&_swigt__p_svn_config_t, 0, 0, 0},{0, 0, 0, 0}};
18996
20445
static swig_cast_info _swigc__p_svn_delta_editor_t[] = {  {&_swigt__p_svn_delta_editor_t, 0, 0, 0},{0, 0, 0, 0}};
18997
20446
static swig_cast_info _swigc__p_svn_depth_t[] = {  {&_swigt__p_svn_depth_t, 0, 0, 0},{0, 0, 0, 0}};
 
20447
static swig_cast_info _swigc__p_svn_diff_hunk_t[] = {  {&_swigt__p_svn_diff_hunk_t, 0, 0, 0},{0, 0, 0, 0}};
18998
20448
static swig_cast_info _swigc__p_svn_dirent_t[] = {  {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
18999
20449
static swig_cast_info _swigc__p_svn_errno_t[] = {  {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
19000
20450
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
19001
20451
static swig_cast_info _swigc__p_svn_fs_access_t[] = {  {&_swigt__p_svn_fs_access_t, 0, 0, 0},{0, 0, 0, 0}};
19002
20452
static swig_cast_info _swigc__p_svn_fs_dirent_t[] = {  {&_swigt__p_svn_fs_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
 
20453
static swig_cast_info _swigc__p_svn_fs_fsfs_info_t[] = {  {&_swigt__p_svn_fs_fsfs_info_t, 0, 0, 0},{0, 0, 0, 0}};
 
20454
static swig_cast_info _swigc__p_svn_fs_fsx_info_t[] = {  {&_swigt__p_svn_fs_fsx_info_t, 0, 0, 0},{0, 0, 0, 0}};
19003
20455
static swig_cast_info _swigc__p_svn_fs_history_t[] = {  {&_swigt__p_svn_fs_history_t, 0, 0, 0},{0, 0, 0, 0}};
19004
20456
static swig_cast_info _swigc__p_svn_fs_id_t[] = {  {&_swigt__p_svn_fs_id_t, 0, 0, 0},{0, 0, 0, 0}};
 
20457
static swig_cast_info _swigc__p_svn_fs_info_placeholder_t[] = {  {&_swigt__p_svn_fs_info_placeholder_t, 0, 0, 0},{0, 0, 0, 0}};
 
20458
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}};
 
20459
static swig_cast_info _swigc__p_svn_fs_node_relation_t[] = {  {&_swigt__p_svn_fs_node_relation_t, 0, 0, 0},{0, 0, 0, 0}};
19005
20460
static swig_cast_info _swigc__p_svn_fs_pack_notify_action_t[] = {  {&_swigt__p_svn_fs_pack_notify_action_t, 0, 0, 0},{0, 0, 0, 0}};
19006
20461
static swig_cast_info _swigc__p_svn_fs_path_change2_t[] = {  {&_swigt__p_svn_fs_path_change2_t, 0, 0, 0},{0, 0, 0, 0}};
19007
20462
static swig_cast_info _swigc__p_svn_fs_path_change_kind_t[] = {  {&_swigt__p_svn_fs_path_change_kind_t, 0, 0, 0},{0, 0, 0, 0}};
19009
20464
static swig_cast_info _swigc__p_svn_fs_root_t[] = {  {&_swigt__p_svn_fs_root_t, 0, 0, 0},{0, 0, 0, 0}};
19010
20465
static swig_cast_info _swigc__p_svn_fs_t[] = {  {&_swigt__p_svn_fs_t, 0, 0, 0},{0, 0, 0, 0}};
19011
20466
static swig_cast_info _swigc__p_svn_fs_txn_t[] = {  {&_swigt__p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
 
20467
static swig_cast_info _swigc__p_svn_fs_upgrade_notify_action_t[] = {  {&_swigt__p_svn_fs_upgrade_notify_action_t, 0, 0, 0},{0, 0, 0, 0}};
19012
20468
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
19013
20469
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
19014
20470
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}};
19075
20531
  _swigc__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t,
19076
20532
  _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t,
19077
20533
  _swigc__p_f_p_void_p_q_const__char__p_svn_error_t,
 
20534
  _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
19078
20535
  _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t,
19079
20536
  _swigc__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,
19080
20537
  _swigc__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,
19081
20538
  _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
19082
20539
  _swigc__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
19083
20540
  _swigc__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t,
 
20541
  _swigc__p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
19084
20542
  _swigc__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
19085
20543
  _swigc__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t,
19086
20544
  _swigc__p_int,
19097
20555
  _swigc__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,
19098
20556
  _swigc__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
19099
20557
  _swigc__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
 
20558
  _swigc__p_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
19100
20559
  _swigc__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
19101
20560
  _swigc__p_p_svn_authz_t,
19102
20561
  _swigc__p_p_svn_delta_editor_t,
19109
20568
  _swigc__p_p_svn_repos_t,
19110
20569
  _swigc__p_p_svn_stream_t,
19111
20570
  _swigc__p_p_svn_string_t,
 
20571
  _swigc__p_p_svn_version_t,
19112
20572
  _swigc__p_p_void,
19113
20573
  _swigc__p_svn_auth_baton_t,
19114
20574
  _swigc__p_svn_auth_cred_simple_t,
19128
20588
  _swigc__p_svn_config_t,
19129
20589
  _swigc__p_svn_delta_editor_t,
19130
20590
  _swigc__p_svn_depth_t,
 
20591
  _swigc__p_svn_diff_hunk_t,
19131
20592
  _swigc__p_svn_dirent_t,
19132
20593
  _swigc__p_svn_errno_t,
19133
20594
  _swigc__p_svn_error_t,
19134
20595
  _swigc__p_svn_fs_access_t,
19135
20596
  _swigc__p_svn_fs_dirent_t,
 
20597
  _swigc__p_svn_fs_fsfs_info_t,
 
20598
  _swigc__p_svn_fs_fsx_info_t,
19136
20599
  _swigc__p_svn_fs_history_t,
19137
20600
  _swigc__p_svn_fs_id_t,
 
20601
  _swigc__p_svn_fs_info_placeholder_t,
 
20602
  _swigc__p_svn_fs_lock_target_t,
 
20603
  _swigc__p_svn_fs_node_relation_t,
19138
20604
  _swigc__p_svn_fs_pack_notify_action_t,
19139
20605
  _swigc__p_svn_fs_path_change2_t,
19140
20606
  _swigc__p_svn_fs_path_change_kind_t,
19142
20608
  _swigc__p_svn_fs_root_t,
19143
20609
  _swigc__p_svn_fs_t,
19144
20610
  _swigc__p_svn_fs_txn_t,
 
20611
  _swigc__p_svn_fs_upgrade_notify_action_t,
19145
20612
  _swigc__p_svn_io_dirent2_t,
19146
20613
  _swigc__p_svn_io_dirent_t,
19147
20614
  _swigc__p_svn_io_file_del_t,
19199
20666
#endif
19200
20667
/* -----------------------------------------------------------------------------
19201
20668
 * Type initialization:
19202
 
 * This problem is tough by the requirement that no dynamic 
19203
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
20669
 * This problem is tough by the requirement that no dynamic
 
20670
 * memory is used. Also, since swig_type_info structures store pointers to
19204
20671
 * swig_cast_info structures and swig_cast_info structures store pointers back
19205
 
 * to swig_type_info structures, we need some lookup code at initialization. 
19206
 
 * The idea is that swig generates all the structures that are needed. 
19207
 
 * The runtime then collects these partially filled structures. 
19208
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
20672
 * to swig_type_info structures, we need some lookup code at initialization.
 
20673
 * The idea is that swig generates all the structures that are needed.
 
20674
 * The runtime then collects these partially filled structures.
 
20675
 * The SWIG_InitializeModule function takes these initial arrays out of
19209
20676
 * swig_module, and does all the lookup, filling in the swig_module.types
19210
20677
 * array with the correct data and linking the correct swig_cast_info
19211
20678
 * structures together.
19212
20679
 *
19213
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
20680
 * The generated swig_type_info structures are assigned staticly to an initial
19214
20681
 * array. We just loop through that array, and handle each type individually.
19215
20682
 * First we lookup if this type has been already loaded, and if so, use the
19216
20683
 * loaded structure instead of the generated one. Then we have to fill in the
19220
20687
 * a column is one of the swig_cast_info structures for that type.
19221
20688
 * The cast_initial array is actually an array of arrays, because each row has
19222
20689
 * a variable number of columns. So to actually build the cast linked list,
19223
 
 * we find the array of casts associated with the type, and loop through it 
 
20690
 * we find the array of casts associated with the type, and loop through it
19224
20691
 * adding the casts to the list. The one last trick we need to do is making
19225
20692
 * sure the type pointer in the swig_cast_info struct is correct.
19226
20693
 *
19227
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
20694
 * First off, we lookup the cast->type name to see if it is already loaded.
19228
20695
 * There are three cases to handle:
19229
20696
 *  1) If the cast->type has already been loaded AND the type we are adding
19230
20697
 *     casting info to has not been loaded (it is in this module), THEN we
19231
20698
 *     replace the cast->type pointer with the type pointer that has already
19232
20699
 *     been loaded.
19233
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
20700
 *  2) If BOTH types (the one we are adding casting info to, and the
19234
20701
 *     cast->type) are loaded, THEN the cast info has already been loaded by
19235
20702
 *     the previous module so we just ignore it.
19236
20703
 *  3) Finally, if cast->type has not already been loaded, then we add that
19293
20760
    module_head->next = &swig_module;
19294
20761
  }
19295
20762
  
19296
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
20763
  /* When multiple interpreters are used, a module could have already been initialized in
19297
20764
       a different interpreter, but not yet have a pointer in this interpreter.
19298
20765
       In this case, we do not want to continue adding types... everything should be
19299
20766
       set up already */
19874
21341
  SWIG_Python_SetConstant(d, "svn_node_action_add",SWIG_From_long((long)(svn_node_action_add)));
19875
21342
  SWIG_Python_SetConstant(d, "svn_node_action_delete",SWIG_From_long((long)(svn_node_action_delete)));
19876
21343
  SWIG_Python_SetConstant(d, "svn_node_action_replace",SWIG_From_long((long)(svn_node_action_replace)));
19877
 
  SWIG_Python_SetConstant(d, "svn_repos_load_uuid_default",SWIG_From_long((long)(svn_repos_load_uuid_default)));
19878
 
  SWIG_Python_SetConstant(d, "svn_repos_load_uuid_ignore",SWIG_From_long((long)(svn_repos_load_uuid_ignore)));
19879
 
  SWIG_Python_SetConstant(d, "svn_repos_load_uuid_force",SWIG_From_long((long)(svn_repos_load_uuid_force)));
19880
21344
  SWIG_Python_SetConstant(d, "svn_authz_none",SWIG_From_long((long)(svn_authz_none)));
19881
21345
  SWIG_Python_SetConstant(d, "svn_authz_read",SWIG_From_long((long)(svn_authz_read)));
19882
21346
  SWIG_Python_SetConstant(d, "svn_authz_write",SWIG_From_long((long)(svn_authz_write)));
19901
21365
  SWIG_Python_SetConstant(d, "svn_repos_notify_upgrade_start",SWIG_From_long((long)(svn_repos_notify_upgrade_start)));
19902
21366
  SWIG_Python_SetConstant(d, "svn_repos_notify_load_skipped_rev",SWIG_From_long((long)(svn_repos_notify_load_skipped_rev)));
19903
21367
  SWIG_Python_SetConstant(d, "svn_repos_notify_verify_rev_structure",SWIG_From_long((long)(svn_repos_notify_verify_rev_structure)));
 
21368
  SWIG_Python_SetConstant(d, "svn_repos_notify_pack_revprops",SWIG_From_long((long)(svn_repos_notify_pack_revprops)));
 
21369
  SWIG_Python_SetConstant(d, "svn_repos_notify_cleanup_revprops",SWIG_From_long((long)(svn_repos_notify_cleanup_revprops)));
 
21370
  SWIG_Python_SetConstant(d, "svn_repos_notify_format_bumped",SWIG_From_long((long)(svn_repos_notify_format_bumped)));
 
21371
  SWIG_Python_SetConstant(d, "svn_repos_notify_hotcopy_rev_range",SWIG_From_long((long)(svn_repos_notify_hotcopy_rev_range)));
19904
21372
  SWIG_Python_SetConstant(d, "svn_repos_notify_warning_found_old_reference",SWIG_From_long((long)(svn_repos_notify_warning_found_old_reference)));
19905
21373
  SWIG_Python_SetConstant(d, "svn_repos_notify_warning_found_old_mergeinfo",SWIG_From_long((long)(svn_repos_notify_warning_found_old_mergeinfo)));
19906
21374
  SWIG_Python_SetConstant(d, "svn_repos_notify_warning_invalid_fspath",SWIG_From_long((long)(svn_repos_notify_warning_invalid_fspath)));
 
21375
  SWIG_Python_SetConstant(d, "svn_repos_notify_warning_name_collision",SWIG_From_long((long)(svn_repos_notify_warning_name_collision)));
 
21376
  SWIG_Python_SetConstant(d, "svn_repos_notify_warning_mergeinfo_collision",SWIG_From_long((long)(svn_repos_notify_warning_mergeinfo_collision)));
 
21377
  SWIG_Python_SetConstant(d, "svn_repos_notify_warning_invalid_mergeinfo",SWIG_From_long((long)(svn_repos_notify_warning_invalid_mergeinfo)));
19907
21378
  SWIG_Python_SetConstant(d, "SVN_REPOS_CAPABILITY_MERGEINFO",SWIG_FromCharPtr("mergeinfo"));
19908
21379
  SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_MAGIC_HEADER",SWIG_FromCharPtr("SVN-fs-dump-format-version"));
19909
21380
  SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_FORMAT_VERSION",SWIG_From_long((long)(3)));
19929
21400
  SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_MD5",SWIG_FromCharPtr("Text-delta-base-md5"));
19930
21401
  SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_SHA1",SWIG_FromCharPtr("Text-delta-base-sha1"));
19931
21402
  SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_CHECKSUM",SWIG_FromCharPtr("Text-delta-base-md5"));
 
21403
  SWIG_Python_SetConstant(d, "svn_repos_load_uuid_default",SWIG_From_long((long)(svn_repos_load_uuid_default)));
 
21404
  SWIG_Python_SetConstant(d, "svn_repos_load_uuid_ignore",SWIG_From_long((long)(svn_repos_load_uuid_ignore)));
 
21405
  SWIG_Python_SetConstant(d, "svn_repos_load_uuid_force",SWIG_From_long((long)(svn_repos_load_uuid_force)));
19932
21406
  SWIG_Python_SetConstant(d, "svn_repos_revision_access_none",SWIG_From_long((long)(svn_repos_revision_access_none)));
19933
21407
  SWIG_Python_SetConstant(d, "svn_repos_revision_access_partial",SWIG_From_long((long)(svn_repos_revision_access_partial)));
19934
21408
  SWIG_Python_SetConstant(d, "svn_repos_revision_access_full",SWIG_From_long((long)(svn_repos_revision_access_full)));