← Back to branch summary

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

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/ruby/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
http://bugs.debian.org/791844
* Upload to unstable
* New upstream release.
  + Security fixes
    - CVE-2015-3184: Mixed anonymous/authenticated path-based authz with
      httpd 2.4
    - CVE-2015-3187: svn_repos_trace_node_locations() reveals paths hidden
      by authz
* Add >= 2.7 requirement for python-all-dev Build-Depends, needed to run
  tests.
* Remove Build-Conflicts against ruby-test-unit.  (Closes: #791844)
* Remove patches/apache_module_dependency in favor of expressing the
  dependencies in authz_svn.load/dav_svn.load.
* Build-Depend on apache2-dev (>= 2.4.16) to ensure ap_some_authn_required()
  is available when building mod_authz_svn and Depend on apache2-bin (>=
  2.4.16) for runtime support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/bindings/swig/ruby/svn_repos.c
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 2.0.9
4
 
 * 
5
 
 * This file is not intended to be easily readable and contains a number of 
 
3
 * Version 2.0.12
 
4
 *
 
5
 * This file is not intended to be easily readable and contains a number of
6
6
 * coding conventions designed to improve portability and efficiency. Do not make
7
 
 * changes to this file unless you know what you are doing--modify the SWIG 
8
 
 * interface file instead. 
 
7
 * changes to this file unless you know what you are doing--modify the SWIG
 
8
 * interface file instead.
9
9
 * ----------------------------------------------------------------------------- */
10
10
 
11
11
#define SWIGRUBY
41
41
#ifndef SWIGUNUSED
42
42
# if defined(__GNUC__)
43
43
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
44
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
44
#     define SWIGUNUSED __attribute__ ((__unused__))
45
45
#   else
46
46
#     define SWIGUNUSED
47
47
#   endif
48
48
# elif defined(__ICC)
49
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
 
49
#   define SWIGUNUSED __attribute__ ((__unused__))
50
50
# else
51
 
#   define SWIGUNUSED 
 
51
#   define SWIGUNUSED
52
52
# endif
53
53
#endif
54
54
 
55
55
#ifndef SWIG_MSC_UNSUPPRESS_4505
56
56
# if defined(_MSC_VER)
57
57
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
58
 
# endif 
 
58
# endif
59
59
#endif
60
60
 
61
61
#ifndef SWIGUNUSEDPARM
62
62
# ifdef __cplusplus
63
63
#   define SWIGUNUSEDPARM(p)
64
64
# else
65
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
65
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
66
66
# endif
67
67
#endif
68
68
 
105
105
#   define SWIGSTDCALL __stdcall
106
106
# else
107
107
#   define SWIGSTDCALL
108
 
# endif 
 
108
# endif
109
109
#endif
110
110
 
111
111
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
150
150
#ifndef SWIGUNUSED
151
151
# if defined(__GNUC__)
152
152
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
153
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
153
#     define SWIGUNUSED __attribute__ ((__unused__))
154
154
#   else
155
155
#     define SWIGUNUSED
156
156
#   endif
157
157
# elif defined(__ICC)
158
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
 
158
#   define SWIGUNUSED __attribute__ ((__unused__))
159
159
# else
160
 
#   define SWIGUNUSED 
 
160
#   define SWIGUNUSED
161
161
# endif
162
162
#endif
163
163
 
164
164
#ifndef SWIG_MSC_UNSUPPRESS_4505
165
165
# if defined(_MSC_VER)
166
166
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
167
 
# endif 
 
167
# endif
168
168
#endif
169
169
 
170
170
#ifndef SWIGUNUSEDPARM
171
171
# ifdef __cplusplus
172
172
#   define SWIGUNUSEDPARM(p)
173
173
# else
174
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
174
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
175
175
# endif
176
176
#endif
177
177
 
214
214
#   define SWIGSTDCALL __stdcall
215
215
# else
216
216
#   define SWIGSTDCALL
217
 
# endif 
 
217
# endif
218
218
#endif
219
219
 
220
220
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
252
252
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
253
253
  creating a static or dynamic library from the SWIG runtime code.
254
254
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
255
 
  
 
255
 
256
256
  But only do this if strictly necessary, ie, if you have problems
257
257
  with your compiler or suchlike.
258
258
*/
278
278
#define SWIG_POINTER_OWN           0x1
279
279
 
280
280
 
281
 
/* 
 
281
/*
282
282
   Flags/methods for returning states.
283
 
   
284
 
   The SWIG conversion methods, as ConvertPtr, return an integer 
 
283
 
 
284
   The SWIG conversion methods, as ConvertPtr, return an integer
285
285
   that tells if the conversion was successful or not. And if not,
286
286
   an error code can be returned (see swigerrors.swg for the codes).
287
 
   
 
287
 
288
288
   Use the following macros/flags to set or process the returning
289
289
   states.
290
 
   
 
290
 
291
291
   In old versions of SWIG, code such as the following was usually written:
292
292
 
293
293
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
320
320
    } else {
321
321
      // fail code
322
322
    }
323
 
    
 
323
 
324
324
   I.e., now SWIG_ConvertPtr can return new objects and you can
325
325
   identify the case and take care of the deallocation. Of course that
326
326
   also requires SWIG_ConvertPtr to return new result values, such as
327
327
 
328
 
      int SWIG_ConvertPtr(obj, ptr,...) {         
329
 
        if (<obj is ok>) {                             
330
 
          if (<need new object>) {                     
331
 
            *ptr = <ptr to new allocated object>; 
332
 
            return SWIG_NEWOBJ;                
333
 
          } else {                                     
334
 
            *ptr = <ptr to old object>;        
335
 
            return SWIG_OLDOBJ;                
336
 
          }                                    
337
 
        } else {                                       
338
 
          return SWIG_BADOBJ;                  
339
 
        }                                              
 
328
      int SWIG_ConvertPtr(obj, ptr,...) {
 
329
        if (<obj is ok>) {
 
330
          if (<need new object>) {
 
331
            *ptr = <ptr to new allocated object>;
 
332
            return SWIG_NEWOBJ;
 
333
          } else {
 
334
            *ptr = <ptr to old object>;
 
335
            return SWIG_OLDOBJ;
 
336
          }
 
337
        } else {
 
338
          return SWIG_BADOBJ;
 
339
        }
340
340
      }
341
341
 
342
342
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
350
350
       int fooi(int);
351
351
 
352
352
   and you call
353
 
 
 
353
 
354
354
      food(1)   // cast rank '1'  (1 -> 1.0)
355
355
      fooi(1)   // cast rank '0'
356
356
 
357
357
   just use the SWIG_AddCast()/SWIG_CheckState()
358
358
*/
359
359
 
360
 
#define SWIG_OK                    (0) 
 
360
#define SWIG_OK                    (0)
361
361
#define SWIG_ERROR                 (-1)
362
362
#define SWIG_IsOK(r)               (r >= 0)
363
 
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
 
363
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
364
364
 
365
365
/* The CastRankLimit says how many bits are used for the cast rank */
366
366
#define SWIG_CASTRANKLIMIT         (1 << 8)
391
391
#  endif
392
392
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
393
393
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
394
 
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
 
394
SWIGINTERNINLINE int SWIG_AddCast(int r) {
395
395
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
396
396
}
397
 
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
398
 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
 
397
SWIGINTERNINLINE int SWIG_CheckState(int r) {
 
398
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
399
399
}
400
400
#else /* no cast-rank mode */
401
 
#  define SWIG_AddCast
 
401
#  define SWIG_AddCast(r) (r)
402
402
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
403
403
#endif
404
404
 
442
442
  void                    *clientdata;          /* Language specific module data */
443
443
} swig_module_info;
444
444
 
445
 
/* 
 
445
/*
446
446
  Compare two type names skipping the space characters, therefore
447
447
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
448
448
 
462
462
 
463
463
/*
464
464
  Check type equivalence in a name list like <name1>|<name2>|...
 
465
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 
466
*/
 
467
SWIGRUNTIME int
 
468
SWIG_TypeCmp(const char *nb, const char *tb) {
 
469
  int equiv = 1;
 
470
  const char* te = tb + strlen(tb);
 
471
  const char* ne = nb;
 
472
  while (equiv != 0 && *ne) {
 
473
    for (nb = ne; *ne; ++ne) {
 
474
      if (*ne == '|') break;
 
475
    }
 
476
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
 
477
    if (*ne) ++ne;
 
478
  }
 
479
  return equiv;
 
480
}
 
481
 
 
482
/*
 
483
  Check type equivalence in a name list like <name1>|<name2>|...
465
484
  Return 0 if not equal, 1 if equal
466
485
*/
467
486
SWIGRUNTIME int
468
487
SWIG_TypeEquiv(const char *nb, const char *tb) {
469
 
  int equiv = 0;
470
 
  const char* te = tb + strlen(tb);
471
 
  const char* ne = nb;
472
 
  while (!equiv && *ne) {
473
 
    for (nb = ne; *ne; ++ne) {
474
 
      if (*ne == '|') break;
475
 
    }
476
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
477
 
    if (*ne) ++ne;
478
 
  }
479
 
  return equiv;
480
 
}
481
 
 
482
 
/*
483
 
  Check type equivalence in a name list like <name1>|<name2>|...
484
 
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
485
 
*/
486
 
SWIGRUNTIME int
487
 
SWIG_TypeCompare(const char *nb, const char *tb) {
488
 
  int equiv = 0;
489
 
  const char* te = tb + strlen(tb);
490
 
  const char* ne = nb;
491
 
  while (!equiv && *ne) {
492
 
    for (nb = ne; *ne; ++ne) {
493
 
      if (*ne == '|') break;
494
 
    }
495
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
496
 
    if (*ne) ++ne;
497
 
  }
498
 
  return equiv;
499
 
}
500
 
 
 
488
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 
489
}
501
490
 
502
491
/*
503
492
  Check the typename
526
515
  return 0;
527
516
}
528
517
 
529
 
/* 
 
518
/*
530
519
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
531
520
*/
532
521
SWIGRUNTIME swig_cast_info *
561
550
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
562
551
}
563
552
 
564
 
/* 
 
553
/*
565
554
   Dynamic pointer casting. Down an inheritance hierarchy
566
555
*/
567
556
SWIGRUNTIME swig_type_info *
605
594
    return type->name;
606
595
}
607
596
 
608
 
/* 
 
597
/*
609
598
   Set the clientdata field for a type
610
599
*/
611
600
SWIGRUNTIME void
613
602
  swig_cast_info *cast = ti->cast;
614
603
  /* if (ti->clientdata == clientdata) return; */
615
604
  ti->clientdata = clientdata;
616
 
  
 
605
 
617
606
  while (cast) {
618
607
    if (!cast->converter) {
619
608
      swig_type_info *tc = cast->type;
620
609
      if (!tc->clientdata) {
621
610
        SWIG_TypeClientData(tc, clientdata);
622
611
      }
623
 
    }    
 
612
    }
624
613
    cast = cast->next;
625
614
  }
626
615
}
629
618
  SWIG_TypeClientData(ti, clientdata);
630
619
  ti->owndata = 1;
631
620
}
632
 
  
 
621
 
633
622
/*
634
623
  Search for a swig_type_info structure only by mangled name
635
624
  Search is a O(log #types)
636
 
  
637
 
  We start searching at module start, and finish searching when start == end.  
 
625
 
 
626
  We start searching at module start, and finish searching when start == end.
638
627
  Note: if start == end at the beginning of the function, we go all the way around
639
628
  the circular list.
640
629
*/
641
630
SWIGRUNTIME swig_type_info *
642
 
SWIG_MangledTypeQueryModule(swig_module_info *start, 
643
 
                            swig_module_info *end, 
 
631
SWIG_MangledTypeQueryModule(swig_module_info *start,
 
632
                            swig_module_info *end,
644
633
                            const char *name) {
645
634
  swig_module_info *iter = start;
646
635
  do {
649
638
      register size_t r = iter->size - 1;
650
639
      do {
651
640
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
652
 
        register size_t i = (l + r) >> 1; 
 
641
        register size_t i = (l + r) >> 1;
653
642
        const char *iname = iter->types[i]->name;
654
643
        if (iname) {
655
644
          register int compare = strcmp(name, iname);
656
 
          if (compare == 0) {       
 
645
          if (compare == 0) {
657
646
            return iter->types[i];
658
647
          } else if (compare < 0) {
659
648
            if (i) {
678
667
  Search for a swig_type_info structure for either a mangled name or a human readable name.
679
668
  It first searches the mangled names of the types, which is a O(log #types)
680
669
  If a type is not found it then searches the human readable names, which is O(#types).
681
 
  
682
 
  We start searching at module start, and finish searching when start == end.  
 
670
 
 
671
  We start searching at module start, and finish searching when start == end.
683
672
  Note: if start == end at the beginning of the function, we go all the way around
684
673
  the circular list.
685
674
*/
686
675
SWIGRUNTIME swig_type_info *
687
 
SWIG_TypeQueryModule(swig_module_info *start, 
688
 
                     swig_module_info *end, 
 
676
SWIG_TypeQueryModule(swig_module_info *start,
 
677
                     swig_module_info *end,
689
678
                     const char *name) {
690
679
  /* STEP 1: Search the name field using binary search */
691
680
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
704
693
      iter = iter->next;
705
694
    } while (iter != end);
706
695
  }
707
 
  
 
696
 
708
697
  /* neither found a match */
709
698
  return 0;
710
699
}
711
700
 
712
 
/* 
 
701
/*
713
702
   Pack binary data into a string
714
703
*/
715
704
SWIGRUNTIME char *
725
714
  return c;
726
715
}
727
716
 
728
 
/* 
 
717
/*
729
718
   Unpack binary data from a string
730
719
*/
731
720
SWIGRUNTIME const char *
739
728
      uu = ((d - '0') << 4);
740
729
    else if ((d >= 'a') && (d <= 'f'))
741
730
      uu = ((d - ('a'-10)) << 4);
742
 
    else 
 
731
    else
743
732
      return (char *) 0;
744
733
    d = *(c++);
745
734
    if ((d >= '0') && (d <= '9'))
746
735
      uu |= (d - '0');
747
736
    else if ((d >= 'a') && (d <= 'f'))
748
737
      uu |= (d - ('a'-10));
749
 
    else 
 
738
    else
750
739
      return (char *) 0;
751
740
    *u = uu;
752
741
  }
753
742
  return c;
754
743
}
755
744
 
756
 
/* 
 
745
/*
757
746
   Pack 'void *' into a string buffer.
758
747
*/
759
748
SWIGRUNTIME char *
813
802
#endif
814
803
 
815
804
/*  Errors in SWIG */
816
 
#define  SWIG_UnknownError         -1 
817
 
#define  SWIG_IOError              -2 
818
 
#define  SWIG_RuntimeError         -3 
819
 
#define  SWIG_IndexError           -4 
820
 
#define  SWIG_TypeError            -5 
821
 
#define  SWIG_DivisionByZero       -6 
822
 
#define  SWIG_OverflowError        -7 
823
 
#define  SWIG_SyntaxError          -8 
824
 
#define  SWIG_ValueError           -9 
 
805
#define  SWIG_UnknownError         -1
 
806
#define  SWIG_IOError              -2
 
807
#define  SWIG_RuntimeError         -3
 
808
#define  SWIG_IndexError           -4
 
809
#define  SWIG_TypeError            -5
 
810
#define  SWIG_DivisionByZero       -6
 
811
#define  SWIG_OverflowError        -7
 
812
#define  SWIG_SyntaxError          -8
 
813
#define  SWIG_ValueError           -9
825
814
#define  SWIG_SystemError          -10
826
815
#define  SWIG_AttributeError       -11
827
 
#define  SWIG_MemoryError          -12 
 
816
#define  SWIG_MemoryError          -12
828
817
#define  SWIG_NullReferenceError   -13
829
818
 
830
819
 
1750
1739
SWIGINTERN
1751
1740
int SWIG_Ruby_isCallable( VALUE proc )
1752
1741
{
1753
 
  if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
 
1742
  if ( rb_respond_to( proc, swig_call_id ) )
1754
1743
    return 1;
1755
1744
  return 0;
1756
1745
}
1763
1752
SWIGINTERN
1764
1753
int SWIG_Ruby_arity( VALUE proc, int minimal )
1765
1754
{
1766
 
  if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
 
1755
  if ( rb_respond_to( proc, swig_arity_id ) )
1767
1756
    {
1768
1757
      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
1769
1758
      int arity = NUM2INT(num);
1813
1802
#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[18]
1814
1803
#define SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[19]
1815
1804
#define SWIGTYPE_p_f_p_void_p_q_const__char__p_svn_error_t swig_types[20]
1816
 
#define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t swig_types[21]
1817
 
#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]
1818
 
#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]
1819
 
#define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[24]
1820
 
#define SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void swig_types[25]
1821
 
#define SWIGTYPE_p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t swig_types[26]
1822
 
#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[27]
1823
 
#define SWIGTYPE_p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t swig_types[28]
1824
 
#define SWIGTYPE_p_int swig_types[29]
1825
 
#define SWIGTYPE_p_long swig_types[30]
1826
 
#define SWIGTYPE_p_p_apr_array_header_t swig_types[31]
1827
 
#define SWIGTYPE_p_p_apr_hash_t swig_types[32]
1828
 
#define SWIGTYPE_p_p_char swig_types[33]
1829
 
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[34]
1830
 
#define SWIGTYPE_p_p_svn_authz_t swig_types[35]
1831
 
#define SWIGTYPE_p_p_svn_delta_editor_t swig_types[36]
1832
 
#define SWIGTYPE_p_p_svn_dirent_t swig_types[37]
1833
 
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[38]
1834
 
#define SWIGTYPE_p_p_svn_lock_t swig_types[39]
1835
 
#define SWIGTYPE_p_p_svn_repos_parse_fns2_t swig_types[40]
1836
 
#define SWIGTYPE_p_p_svn_repos_parse_fns3_t swig_types[41]
1837
 
#define SWIGTYPE_p_p_svn_repos_parse_fns_t swig_types[42]
1838
 
#define SWIGTYPE_p_p_svn_repos_t swig_types[43]
1839
 
#define SWIGTYPE_p_p_svn_stream_t swig_types[44]
1840
 
#define SWIGTYPE_p_p_svn_string_t swig_types[45]
1841
 
#define SWIGTYPE_p_p_void swig_types[46]
1842
 
#define SWIGTYPE_p_svn_auth_baton_t swig_types[47]
1843
 
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[48]
1844
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[49]
1845
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[50]
1846
 
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[51]
1847
 
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[52]
1848
 
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[53]
1849
 
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[54]
1850
 
#define SWIGTYPE_p_svn_auth_provider_t swig_types[55]
1851
 
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[56]
1852
 
#define SWIGTYPE_p_svn_authz_t swig_types[57]
1853
 
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[58]
1854
 
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[59]
1855
 
#define SWIGTYPE_p_svn_checksum_t swig_types[60]
1856
 
#define SWIGTYPE_p_svn_commit_info_t swig_types[61]
1857
 
#define SWIGTYPE_p_svn_config_t swig_types[62]
1858
 
#define SWIGTYPE_p_svn_delta_editor_t swig_types[63]
1859
 
#define SWIGTYPE_p_svn_depth_t swig_types[64]
1860
 
#define SWIGTYPE_p_svn_diff_conflict_display_style_t swig_types[65]
1861
 
#define SWIGTYPE_p_svn_diff_datasource_e swig_types[66]
1862
 
#define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[67]
1863
 
#define SWIGTYPE_p_svn_diff_file_options_t swig_types[68]
1864
 
#define SWIGTYPE_p_svn_diff_fns2_t swig_types[69]
1865
 
#define SWIGTYPE_p_svn_diff_fns_t swig_types[70]
1866
 
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[71]
1867
 
#define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[72]
1868
 
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[73]
1869
 
#define SWIGTYPE_p_svn_diff_t swig_types[74]
1870
 
#define SWIGTYPE_p_svn_dirent_t swig_types[75]
1871
 
#define SWIGTYPE_p_svn_errno_t swig_types[76]
1872
 
#define SWIGTYPE_p_svn_error_t swig_types[77]
1873
 
#define SWIGTYPE_p_svn_fs_access_t swig_types[78]
1874
 
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[79]
1875
 
#define SWIGTYPE_p_svn_fs_history_t swig_types[80]
1876
 
#define SWIGTYPE_p_svn_fs_id_t swig_types[81]
1877
 
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[82]
1878
 
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[83]
1879
 
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[84]
1880
 
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[85]
1881
 
#define SWIGTYPE_p_svn_fs_root_t swig_types[86]
1882
 
#define SWIGTYPE_p_svn_fs_t swig_types[87]
1883
 
#define SWIGTYPE_p_svn_fs_txn_t swig_types[88]
1884
 
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[89]
1885
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[90]
1886
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[91]
1887
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[92]
1888
 
#define SWIGTYPE_p_svn_lock_t swig_types[93]
1889
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[94]
1890
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[95]
1891
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[96]
1892
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[97]
1893
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[98]
1894
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[99]
1895
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[100]
1896
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[101]
1897
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[102]
1898
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[103]
1899
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[104]
1900
 
#define SWIGTYPE_p_svn_patch_file_t swig_types[105]
1901
 
#define SWIGTYPE_p_svn_patch_t swig_types[106]
1902
 
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[107]
1903
 
#define SWIGTYPE_p_svn_prop_kind swig_types[108]
1904
 
#define SWIGTYPE_p_svn_prop_patch_t swig_types[109]
1905
 
#define SWIGTYPE_p_svn_repos_authz_access_t swig_types[110]
1906
 
#define SWIGTYPE_p_svn_repos_node_t swig_types[111]
1907
 
#define SWIGTYPE_p_svn_repos_notify_action_t swig_types[112]
1908
 
#define SWIGTYPE_p_svn_repos_notify_t swig_types[113]
1909
 
#define SWIGTYPE_p_svn_repos_notify_warning_t swig_types[114]
1910
 
#define SWIGTYPE_p_svn_repos_parse_fns2_t swig_types[115]
1911
 
#define SWIGTYPE_p_svn_repos_parse_fns3_t swig_types[116]
1912
 
#define SWIGTYPE_p_svn_repos_parse_fns_t swig_types[117]
1913
 
#define SWIGTYPE_p_svn_repos_revision_access_level_t swig_types[118]
1914
 
#define SWIGTYPE_p_svn_repos_t swig_types[119]
1915
 
#define SWIGTYPE_p_svn_stream_mark_t swig_types[120]
1916
 
#define SWIGTYPE_p_svn_stream_t swig_types[121]
1917
 
#define SWIGTYPE_p_svn_string_t swig_types[122]
1918
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[123]
1919
 
#define SWIGTYPE_p_svn_tristate_t swig_types[124]
1920
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[125]
1921
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[126]
1922
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[127]
1923
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[128]
1924
 
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[129]
1925
 
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[130]
1926
 
#define SWIGTYPE_p_svn_version_extended_t swig_types[131]
1927
 
#define SWIGTYPE_p_svn_version_t swig_types[132]
1928
 
#define SWIGTYPE_p_unsigned_long swig_types[133]
1929
 
#define SWIGTYPE_p_void swig_types[134]
1930
 
static swig_type_info *swig_types[136];
1931
 
static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
 
1805
#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[21]
 
1806
#define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t swig_types[22]
 
1807
#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[23]
 
1808
#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[24]
 
1809
#define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[25]
 
1810
#define SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void swig_types[26]
 
1811
#define SWIGTYPE_p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t swig_types[27]
 
1812
#define SWIGTYPE_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t swig_types[28]
 
1813
#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[29]
 
1814
#define SWIGTYPE_p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t swig_types[30]
 
1815
#define SWIGTYPE_p_int swig_types[31]
 
1816
#define SWIGTYPE_p_long swig_types[32]
 
1817
#define SWIGTYPE_p_p_apr_array_header_t swig_types[33]
 
1818
#define SWIGTYPE_p_p_apr_hash_t swig_types[34]
 
1819
#define SWIGTYPE_p_p_char swig_types[35]
 
1820
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[36]
 
1821
#define SWIGTYPE_p_p_svn_authz_t swig_types[37]
 
1822
#define SWIGTYPE_p_p_svn_delta_editor_t swig_types[38]
 
1823
#define SWIGTYPE_p_p_svn_dirent_t swig_types[39]
 
1824
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[40]
 
1825
#define SWIGTYPE_p_p_svn_lock_t swig_types[41]
 
1826
#define SWIGTYPE_p_p_svn_repos_parse_fns2_t swig_types[42]
 
1827
#define SWIGTYPE_p_p_svn_repos_parse_fns3_t swig_types[43]
 
1828
#define SWIGTYPE_p_p_svn_repos_parse_fns_t swig_types[44]
 
1829
#define SWIGTYPE_p_p_svn_repos_t swig_types[45]
 
1830
#define SWIGTYPE_p_p_svn_stream_t swig_types[46]
 
1831
#define SWIGTYPE_p_p_svn_string_t swig_types[47]
 
1832
#define SWIGTYPE_p_p_svn_version_t swig_types[48]
 
1833
#define SWIGTYPE_p_p_void swig_types[49]
 
1834
#define SWIGTYPE_p_svn_auth_baton_t swig_types[50]
 
1835
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[51]
 
1836
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[52]
 
1837
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[53]
 
1838
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[54]
 
1839
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[55]
 
1840
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[56]
 
1841
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[57]
 
1842
#define SWIGTYPE_p_svn_auth_provider_t swig_types[58]
 
1843
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[59]
 
1844
#define SWIGTYPE_p_svn_authz_t swig_types[60]
 
1845
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[61]
 
1846
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[62]
 
1847
#define SWIGTYPE_p_svn_checksum_t swig_types[63]
 
1848
#define SWIGTYPE_p_svn_commit_info_t swig_types[64]
 
1849
#define SWIGTYPE_p_svn_config_t swig_types[65]
 
1850
#define SWIGTYPE_p_svn_delta_editor_t swig_types[66]
 
1851
#define SWIGTYPE_p_svn_depth_t swig_types[67]
 
1852
#define SWIGTYPE_p_svn_diff_conflict_display_style_t swig_types[68]
 
1853
#define SWIGTYPE_p_svn_diff_datasource_e swig_types[69]
 
1854
#define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[70]
 
1855
#define SWIGTYPE_p_svn_diff_file_options_t swig_types[71]
 
1856
#define SWIGTYPE_p_svn_diff_fns2_t swig_types[72]
 
1857
#define SWIGTYPE_p_svn_diff_fns_t swig_types[73]
 
1858
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[74]
 
1859
#define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[75]
 
1860
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[76]
 
1861
#define SWIGTYPE_p_svn_diff_t swig_types[77]
 
1862
#define SWIGTYPE_p_svn_dirent_t swig_types[78]
 
1863
#define SWIGTYPE_p_svn_errno_t swig_types[79]
 
1864
#define SWIGTYPE_p_svn_error_t swig_types[80]
 
1865
#define SWIGTYPE_p_svn_fs_access_t swig_types[81]
 
1866
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[82]
 
1867
#define SWIGTYPE_p_svn_fs_fsfs_info_t swig_types[83]
 
1868
#define SWIGTYPE_p_svn_fs_fsx_info_t swig_types[84]
 
1869
#define SWIGTYPE_p_svn_fs_history_t swig_types[85]
 
1870
#define SWIGTYPE_p_svn_fs_id_t swig_types[86]
 
1871
#define SWIGTYPE_p_svn_fs_info_placeholder_t swig_types[87]
 
1872
#define SWIGTYPE_p_svn_fs_lock_target_t swig_types[88]
 
1873
#define SWIGTYPE_p_svn_fs_node_relation_t swig_types[89]
 
1874
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[90]
 
1875
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[91]
 
1876
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[92]
 
1877
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[93]
 
1878
#define SWIGTYPE_p_svn_fs_root_t swig_types[94]
 
1879
#define SWIGTYPE_p_svn_fs_t swig_types[95]
 
1880
#define SWIGTYPE_p_svn_fs_txn_t swig_types[96]
 
1881
#define SWIGTYPE_p_svn_fs_upgrade_notify_action_t swig_types[97]
 
1882
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[98]
 
1883
#define SWIGTYPE_p_svn_io_dirent_t swig_types[99]
 
1884
#define SWIGTYPE_p_svn_io_file_del_t swig_types[100]
 
1885
#define SWIGTYPE_p_svn_location_segment_t swig_types[101]
 
1886
#define SWIGTYPE_p_svn_lock_t swig_types[102]
 
1887
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[103]
 
1888
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[104]
 
1889
#define SWIGTYPE_p_svn_log_entry_t swig_types[105]
 
1890
#define SWIGTYPE_p_svn_merge_range_t swig_types[106]
 
1891
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[107]
 
1892
#define SWIGTYPE_p_svn_node_kind_t swig_types[108]
 
1893
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[109]
 
1894
#define SWIGTYPE_p_svn_opt_revision_t swig_types[110]
 
1895
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[111]
 
1896
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[112]
 
1897
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[113]
 
1898
#define SWIGTYPE_p_svn_patch_file_t swig_types[114]
 
1899
#define SWIGTYPE_p_svn_patch_t swig_types[115]
 
1900
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[116]
 
1901
#define SWIGTYPE_p_svn_prop_kind swig_types[117]
 
1902
#define SWIGTYPE_p_svn_prop_patch_t swig_types[118]
 
1903
#define SWIGTYPE_p_svn_repos_authz_access_t swig_types[119]
 
1904
#define SWIGTYPE_p_svn_repos_node_t swig_types[120]
 
1905
#define SWIGTYPE_p_svn_repos_notify_action_t swig_types[121]
 
1906
#define SWIGTYPE_p_svn_repos_notify_t swig_types[122]
 
1907
#define SWIGTYPE_p_svn_repos_notify_warning_t swig_types[123]
 
1908
#define SWIGTYPE_p_svn_repos_parse_fns2_t swig_types[124]
 
1909
#define SWIGTYPE_p_svn_repos_parse_fns3_t swig_types[125]
 
1910
#define SWIGTYPE_p_svn_repos_parse_fns_t swig_types[126]
 
1911
#define SWIGTYPE_p_svn_repos_revision_access_level_t swig_types[127]
 
1912
#define SWIGTYPE_p_svn_repos_t swig_types[128]
 
1913
#define SWIGTYPE_p_svn_stream_mark_t swig_types[129]
 
1914
#define SWIGTYPE_p_svn_stream_t swig_types[130]
 
1915
#define SWIGTYPE_p_svn_string_t swig_types[131]
 
1916
#define SWIGTYPE_p_svn_stringbuf_t swig_types[132]
 
1917
#define SWIGTYPE_p_svn_tristate_t swig_types[133]
 
1918
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[134]
 
1919
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[135]
 
1920
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[136]
 
1921
#define SWIGTYPE_p_svn_version_checklist_t swig_types[137]
 
1922
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[138]
 
1923
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[139]
 
1924
#define SWIGTYPE_p_svn_version_extended_t swig_types[140]
 
1925
#define SWIGTYPE_p_svn_version_t swig_types[141]
 
1926
#define SWIGTYPE_p_unsigned_long swig_types[142]
 
1927
#define SWIGTYPE_p_void swig_types[143]
 
1928
static swig_type_info *swig_types[145];
 
1929
static swig_module_info swig_module = {swig_types, 144, 0, 0, 0, 0};
1932
1930
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1933
1931
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1934
1932
 
1943
1941
#define SWIG_RUBY_THREAD_END_BLOCK
1944
1942
 
1945
1943
 
1946
 
#define SWIGVERSION 0x020009 
 
1944
#define SWIGVERSION 0x020012 
1947
1945
#define SWIG_VERSION SWIGVERSION
1948
1946
 
1949
1947
 
2006
2004
} 
2007
2005
 
2008
2006
 
2009
 
/*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 
2007
/*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
2010
2008
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
2011
2009
{
2012
2010
  VALUE obj = args[0];
2148
2146
}
2149
2147
 
2150
2148
 
2151
 
/*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 
2149
/*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
2152
2150
SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
2153
2151
{
2154
2152
  VALUE obj = args[0];
2352
2350
  return _obj(required, allowed, root, path, baton, pool);
2353
2351
}
2354
2352
 
2355
 
static svn_error_t * svn_repos_invoke_file_rev_handler(
2356
 
  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) {
2357
 
  return _obj(baton, path, rev, rev_props, delta_handler, delta_baton, prop_diffs, pool);
2358
 
}
2359
 
 
2360
2353
static void svn_repos_invoke_notify_func(
2361
2354
  svn_repos_notify_func_t _obj, void *baton, const svn_repos_notify_t *notify, apr_pool_t *scratch_pool) {
2362
2355
  _obj(baton, notify, scratch_pool);
2372
2365
  return _obj(baton, path, revision, pool);
2373
2366
}
2374
2367
 
 
2368
static svn_error_t * svn_repos_invoke_file_rev_handler(
 
2369
  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) {
 
2370
  return _obj(baton, path, rev, rev_props, delta_handler, delta_baton, prop_diffs, pool);
 
2371
}
 
2372
 
 
2373
static svn_error_t * svn_repos_invoke_verify_callback(
 
2374
  svn_repos_verify_callback_t _obj, void *baton, svn_revnum_t revision, svn_error_t *verify_err, apr_pool_t *scratch_pool) {
 
2375
  return _obj(baton, revision, verify_err, scratch_pool);
 
2376
}
 
2377
 
2375
2378
 
2376
2379
 
2377
2380
static VALUE
2515
2518
  arg6 = RTEST(argv[5]);
2516
2519
  arg7 = RTEST(argv[6]);
2517
2520
  {
2518
 
    arg8 = svn_swig_rb_cancel_func;
 
2521
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
2519
2522
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
2520
2523
  }
2521
2524
  if (argc > 8) {
3087
3090
 
3088
3091
 
3089
3092
SWIGINTERN VALUE
 
3093
_wrap_svn_repos_notify_t_start_revision_set(int argc, VALUE *argv, VALUE self) {
 
3094
  struct svn_repos_notify_t *arg1 = (struct svn_repos_notify_t *) 0 ;
 
3095
  svn_revnum_t arg2 ;
 
3096
  void *argp1 = 0 ;
 
3097
  int res1 = 0 ;
 
3098
  long val2 ;
 
3099
  int ecode2 = 0 ;
 
3100
  
 
3101
  if ((argc < 1) || (argc > 1)) {
 
3102
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
 
3103
  }
 
3104
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_repos_notify_t, 0 |  0 );
 
3105
  if (!SWIG_IsOK(res1)) {
 
3106
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_repos_notify_t *","start_revision", 1, self )); 
 
3107
  }
 
3108
  arg1 = (struct svn_repos_notify_t *)(argp1);
 
3109
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
 
3110
  if (!SWIG_IsOK(ecode2)) {
 
3111
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_revnum_t","start_revision", 2, argv[0] ));
 
3112
  } 
 
3113
  arg2 = (svn_revnum_t)(val2);
 
3114
  if (arg1) (arg1)->start_revision = arg2;
 
3115
  return Qnil;
 
3116
fail:
 
3117
  return Qnil;
 
3118
}
 
3119
 
 
3120
 
 
3121
SWIGINTERN VALUE
 
3122
_wrap_svn_repos_notify_t_start_revision_get(int argc, VALUE *argv, VALUE self) {
 
3123
  struct svn_repos_notify_t *arg1 = (struct svn_repos_notify_t *) 0 ;
 
3124
  void *argp1 = 0 ;
 
3125
  int res1 = 0 ;
 
3126
  svn_revnum_t result;
 
3127
  VALUE vresult = Qnil;
 
3128
  
 
3129
  if ((argc < 0) || (argc > 0)) {
 
3130
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
 
3131
  }
 
3132
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_repos_notify_t, 0 |  0 );
 
3133
  if (!SWIG_IsOK(res1)) {
 
3134
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_repos_notify_t *","start_revision", 1, self )); 
 
3135
  }
 
3136
  arg1 = (struct svn_repos_notify_t *)(argp1);
 
3137
  result = (svn_revnum_t) ((arg1)->start_revision);
 
3138
  vresult = SWIG_From_long((long)(result));
 
3139
  return vresult;
 
3140
fail:
 
3141
  return Qnil;
 
3142
}
 
3143
 
 
3144
 
 
3145
SWIGINTERN VALUE
 
3146
_wrap_svn_repos_notify_t_end_revision_set(int argc, VALUE *argv, VALUE self) {
 
3147
  struct svn_repos_notify_t *arg1 = (struct svn_repos_notify_t *) 0 ;
 
3148
  svn_revnum_t arg2 ;
 
3149
  void *argp1 = 0 ;
 
3150
  int res1 = 0 ;
 
3151
  long val2 ;
 
3152
  int ecode2 = 0 ;
 
3153
  
 
3154
  if ((argc < 1) || (argc > 1)) {
 
3155
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
 
3156
  }
 
3157
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_repos_notify_t, 0 |  0 );
 
3158
  if (!SWIG_IsOK(res1)) {
 
3159
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_repos_notify_t *","end_revision", 1, self )); 
 
3160
  }
 
3161
  arg1 = (struct svn_repos_notify_t *)(argp1);
 
3162
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
 
3163
  if (!SWIG_IsOK(ecode2)) {
 
3164
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_revnum_t","end_revision", 2, argv[0] ));
 
3165
  } 
 
3166
  arg2 = (svn_revnum_t)(val2);
 
3167
  if (arg1) (arg1)->end_revision = arg2;
 
3168
  return Qnil;
 
3169
fail:
 
3170
  return Qnil;
 
3171
}
 
3172
 
 
3173
 
 
3174
SWIGINTERN VALUE
 
3175
_wrap_svn_repos_notify_t_end_revision_get(int argc, VALUE *argv, VALUE self) {
 
3176
  struct svn_repos_notify_t *arg1 = (struct svn_repos_notify_t *) 0 ;
 
3177
  void *argp1 = 0 ;
 
3178
  int res1 = 0 ;
 
3179
  svn_revnum_t result;
 
3180
  VALUE vresult = Qnil;
 
3181
  
 
3182
  if ((argc < 0) || (argc > 0)) {
 
3183
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
 
3184
  }
 
3185
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_repos_notify_t, 0 |  0 );
 
3186
  if (!SWIG_IsOK(res1)) {
 
3187
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_repos_notify_t *","end_revision", 1, self )); 
 
3188
  }
 
3189
  arg1 = (struct svn_repos_notify_t *)(argp1);
 
3190
  result = (svn_revnum_t) ((arg1)->end_revision);
 
3191
  vresult = SWIG_From_long((long)(result));
 
3192
  return vresult;
 
3193
fail:
 
3194
  return Qnil;
 
3195
}
 
3196
 
 
3197
 
 
3198
SWIGINTERN VALUE
3090
3199
_wrap_svn_repos_notify_create(int argc, VALUE *argv, VALUE self) {
3091
3200
  svn_repos_notify_action_t arg1 ;
3092
3201
  apr_pool_t *arg2 = (apr_pool_t *) 0 ;
3197
3306
 
3198
3307
 
3199
3308
SWIGINTERN VALUE
 
3309
_wrap_svn_repos_open3(int argc, VALUE *argv, VALUE self) {
 
3310
  svn_repos_t **arg1 = (svn_repos_t **) 0 ;
 
3311
  char *arg2 = (char *) 0 ;
 
3312
  apr_hash_t *arg3 = (apr_hash_t *) 0 ;
 
3313
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
3314
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
3315
  VALUE _global_svn_swig_rb_pool ;
 
3316
  apr_pool_t *_global_pool ;
 
3317
  svn_repos_t *temp1 ;
 
3318
  svn_error_t *result = 0 ;
 
3319
  VALUE vresult = Qnil;
 
3320
  
 
3321
  {
 
3322
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
 
3323
    _global_pool = arg4;
 
3324
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
3325
  }
 
3326
  {
 
3327
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
 
3328
    _global_pool = arg5;
 
3329
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
3330
  }
 
3331
  arg1 = &temp1;
 
3332
  if ((argc < 2) || (argc > 4)) {
 
3333
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
 
3334
  }
 
3335
  {
 
3336
    arg2 = StringValueCStr(argv[0]);
 
3337
  }
 
3338
  {
 
3339
    VALUE rb_pool = Qnil;
 
3340
    if (!_global_pool) {
 
3341
      svn_swig_rb_get_pool(argc, argv, self, &rb_pool, &_global_pool);
 
3342
      svn_swig_rb_push_pool(rb_pool);
 
3343
    }
 
3344
    arg3 = (NIL_P(argv[1])) ? NULL :
 
3345
    svn_swig_rb_hash_to_apr_hash_string(argv[1], _global_pool);
 
3346
    _global_pool = NULL;
 
3347
    if (!NIL_P(rb_pool)) {
 
3348
      if (NIL_P(arg3)) {
 
3349
        svn_swig_rb_destroy_pool(rb_pool);
 
3350
      } else {
 
3351
        svn_swig_rb_set_pool_for_no_swig_type(argv[1], rb_pool);
 
3352
      }
 
3353
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
3354
    }
 
3355
  }
 
3356
  if (argc > 2) {
 
3357
    
 
3358
  }
 
3359
  if (argc > 3) {
 
3360
    
 
3361
  }
 
3362
  {
 
3363
    result = (svn_error_t *)svn_repos_open3(arg1,(char const *)arg2,arg3,arg4,arg5);
 
3364
    
 
3365
    
 
3366
    
 
3367
  }
 
3368
  {
 
3369
    if (result) {
 
3370
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
3371
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
3372
      svn_swig_rb_handle_svn_error(result);
 
3373
    }
 
3374
    vresult = Qnil;
 
3375
  }
 
3376
  {
 
3377
    VALUE tmp;
 
3378
    tmp = SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_t, 0);
 
3379
    if (rb_block_given_p()) {
 
3380
      rb_yield(tmp);
 
3381
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
3382
      DATA_PTR(tmp) = NULL;
 
3383
    } else {
 
3384
      vresult = SWIG_Ruby_AppendOutput(vresult, tmp);
 
3385
    }
 
3386
  }
 
3387
  {
 
3388
    VALUE target;
 
3389
    target = _global_vresult_address == &vresult ? self : vresult;
 
3390
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
3391
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
3392
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
3393
  }
 
3394
  {
 
3395
    VALUE target;
 
3396
    target = _global_vresult_address == &vresult ? self : vresult;
 
3397
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
3398
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
3399
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
3400
  }
 
3401
  return vresult;
 
3402
fail:
 
3403
  {
 
3404
    VALUE target;
 
3405
    target = _global_vresult_address == &vresult ? self : vresult;
 
3406
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
3407
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
3408
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
3409
  }
 
3410
  {
 
3411
    VALUE target;
 
3412
    target = _global_vresult_address == &vresult ? self : vresult;
 
3413
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
3414
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
3415
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
3416
  }
 
3417
  return Qnil;
 
3418
}
 
3419
 
 
3420
 
 
3421
SWIGINTERN VALUE
3200
3422
_wrap_svn_repos_open2(int argc, VALUE *argv, VALUE self) {
3201
3423
  svn_repos_t **arg1 = (svn_repos_t **) 0 ;
3202
3424
  char *arg2 = (char *) 0 ;
3749
3971
 
3750
3972
 
3751
3973
SWIGINTERN VALUE
 
3974
_wrap_svn_repos_capabilities(int argc, VALUE *argv, VALUE self) {
 
3975
  apr_hash_t **arg1 = (apr_hash_t **) 0 ;
 
3976
  svn_repos_t *arg2 = (svn_repos_t *) 0 ;
 
3977
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
3978
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
3979
  VALUE _global_svn_swig_rb_pool ;
 
3980
  apr_pool_t *_global_pool ;
 
3981
  apr_hash_t *temp1 ;
 
3982
  void *argp2 = 0 ;
 
3983
  int res2 = 0 ;
 
3984
  svn_error_t *result = 0 ;
 
3985
  VALUE vresult = Qnil;
 
3986
  
 
3987
  {
 
3988
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
 
3989
    _global_pool = arg3;
 
3990
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
3991
  }
 
3992
  {
 
3993
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
 
3994
    _global_pool = arg4;
 
3995
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
3996
  }
 
3997
  arg1 = &temp1;
 
3998
  if ((argc < 1) || (argc > 3)) {
 
3999
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
 
4000
  }
 
4001
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
4002
  if (!SWIG_IsOK(res2)) {
 
4003
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_capabilities", 2, argv[0] )); 
 
4004
  }
 
4005
  arg2 = (svn_repos_t *)(argp2);
 
4006
  if (argc > 1) {
 
4007
    
 
4008
  }
 
4009
  if (argc > 2) {
 
4010
    
 
4011
  }
 
4012
  {
 
4013
    if (!arg2) {
 
4014
      svn_swig_rb_raise_svn_repos_already_close();
 
4015
    }
 
4016
  }
 
4017
  {
 
4018
    result = (svn_error_t *)svn_repos_capabilities(arg1,arg2,arg3,arg4);
 
4019
    
 
4020
    
 
4021
    
 
4022
  }
 
4023
  {
 
4024
    if (result) {
 
4025
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4026
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4027
      svn_swig_rb_handle_svn_error(result);
 
4028
    }
 
4029
    vresult = Qnil;
 
4030
  }
 
4031
  {
 
4032
    /* FIXME: Missing argout typemap: svn_repos_capabilities arg 1 (apr_hash_t **) */
 
4033
    
 
4034
    
 
4035
    
 
4036
    
 
4037
    SWIG_exception(SWIG_ValueError, "svn_repos_capabilities is not implemented yet");
 
4038
    
 
4039
  }
 
4040
  {
 
4041
    VALUE target;
 
4042
    target = _global_vresult_address == &vresult ? self : vresult;
 
4043
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
4044
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4045
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4046
  }
 
4047
  {
 
4048
    VALUE target;
 
4049
    target = _global_vresult_address == &vresult ? self : vresult;
 
4050
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
4051
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4052
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4053
  }
 
4054
  return vresult;
 
4055
fail:
 
4056
  {
 
4057
    VALUE target;
 
4058
    target = _global_vresult_address == &vresult ? self : vresult;
 
4059
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
4060
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4061
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4062
  }
 
4063
  {
 
4064
    VALUE target;
 
4065
    target = _global_vresult_address == &vresult ? self : vresult;
 
4066
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
4067
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4068
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4069
  }
 
4070
  return Qnil;
 
4071
}
 
4072
 
 
4073
 
 
4074
SWIGINTERN VALUE
 
4075
_wrap_svn_repos_remember_client_capabilities(int argc, VALUE *argv, VALUE self) {
 
4076
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
4077
  apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
 
4078
  void *argp1 = 0 ;
 
4079
  int res1 = 0 ;
 
4080
  void *argp2 = 0 ;
 
4081
  int res2 = 0 ;
 
4082
  svn_error_t *result = 0 ;
 
4083
  VALUE vresult = Qnil;
 
4084
  
 
4085
  if ((argc < 2) || (argc > 2)) {
 
4086
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
 
4087
  }
 
4088
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
4089
  if (!SWIG_IsOK(res1)) {
 
4090
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_remember_client_capabilities", 1, argv[0] )); 
 
4091
  }
 
4092
  arg1 = (svn_repos_t *)(argp1);
 
4093
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_apr_array_header_t, 0 |  0 );
 
4094
  if (!SWIG_IsOK(res2)) {
 
4095
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "apr_array_header_t const *","svn_repos_remember_client_capabilities", 2, argv[1] )); 
 
4096
  }
 
4097
  arg2 = (apr_array_header_t *)(argp2);
 
4098
  {
 
4099
    if (!arg1) {
 
4100
      svn_swig_rb_raise_svn_repos_already_close();
 
4101
    }
 
4102
  }
 
4103
  {
 
4104
    result = (svn_error_t *)svn_repos_remember_client_capabilities(arg1,(apr_array_header_t const *)arg2);
 
4105
    
 
4106
    
 
4107
    
 
4108
  }
 
4109
  {
 
4110
    if (result) {
 
4111
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4112
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4113
      svn_swig_rb_handle_svn_error(result);
 
4114
    }
 
4115
    vresult = Qnil;
 
4116
  }
 
4117
  return vresult;
 
4118
fail:
 
4119
  return Qnil;
 
4120
}
 
4121
 
 
4122
 
 
4123
SWIGINTERN VALUE
 
4124
_wrap_svn_repos_fs_type(int argc, VALUE *argv, VALUE self) {
 
4125
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
4126
  apr_pool_t *arg2 = (apr_pool_t *) 0 ;
 
4127
  VALUE _global_svn_swig_rb_pool ;
 
4128
  apr_pool_t *_global_pool ;
 
4129
  void *argp1 = 0 ;
 
4130
  int res1 = 0 ;
 
4131
  char *result = 0 ;
 
4132
  VALUE vresult = Qnil;
 
4133
  
 
4134
  {
 
4135
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
 
4136
    _global_pool = arg2;
 
4137
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
4138
  }
 
4139
  if ((argc < 1) || (argc > 2)) {
 
4140
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
 
4141
  }
 
4142
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
4143
  if (!SWIG_IsOK(res1)) {
 
4144
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_fs_type", 1, argv[0] )); 
 
4145
  }
 
4146
  arg1 = (svn_repos_t *)(argp1);
 
4147
  if (argc > 1) {
 
4148
    
 
4149
  }
 
4150
  {
 
4151
    if (!arg1) {
 
4152
      svn_swig_rb_raise_svn_repos_already_close();
 
4153
    }
 
4154
  }
 
4155
  {
 
4156
    result = (char *)svn_repos_fs_type(arg1,arg2);
 
4157
    
 
4158
    
 
4159
    
 
4160
  }
 
4161
  {
 
4162
    if (result) {
 
4163
      vresult = rb_str_new2(result);
 
4164
    } else {
 
4165
      vresult = Qnil;
 
4166
    }
 
4167
  }
 
4168
  {
 
4169
    VALUE target;
 
4170
    target = _global_vresult_address == &vresult ? self : vresult;
 
4171
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
4172
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4173
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4174
  }
 
4175
  return vresult;
 
4176
fail:
 
4177
  {
 
4178
    VALUE target;
 
4179
    target = _global_vresult_address == &vresult ? self : vresult;
 
4180
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
4181
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4182
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4183
  }
 
4184
  return Qnil;
 
4185
}
 
4186
 
 
4187
 
 
4188
SWIGINTERN VALUE
 
4189
_wrap_svn_repos_hotcopy3(int argc, VALUE *argv, VALUE self) {
 
4190
  char *arg1 = (char *) 0 ;
 
4191
  char *arg2 = (char *) 0 ;
 
4192
  svn_boolean_t arg3 ;
 
4193
  svn_boolean_t arg4 ;
 
4194
  svn_repos_notify_func_t arg5 = (svn_repos_notify_func_t) 0 ;
 
4195
  void *arg6 = (void *) 0 ;
 
4196
  svn_cancel_func_t arg7 = (svn_cancel_func_t) 0 ;
 
4197
  void *arg8 = (void *) 0 ;
 
4198
  apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
4199
  VALUE _global_svn_swig_rb_pool ;
 
4200
  apr_pool_t *_global_pool ;
 
4201
  int res1 ;
 
4202
  char *buf1 = 0 ;
 
4203
  int alloc1 = 0 ;
 
4204
  int res2 ;
 
4205
  char *buf2 = 0 ;
 
4206
  int alloc2 = 0 ;
 
4207
  int res6 ;
 
4208
  svn_error_t *result = 0 ;
 
4209
  VALUE vresult = Qnil;
 
4210
  
 
4211
  {
 
4212
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg9);
 
4213
    _global_pool = arg9;
 
4214
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
4215
  }
 
4216
  if ((argc < 7) || (argc > 8)) {
 
4217
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
 
4218
  }
 
4219
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
 
4220
  if (!SWIG_IsOK(res1)) {
 
4221
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","svn_repos_hotcopy3", 1, argv[0] ));
 
4222
  }
 
4223
  arg1 = (char *)(buf1);
 
4224
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
 
4225
  if (!SWIG_IsOK(res2)) {
 
4226
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_repos_hotcopy3", 2, argv[1] ));
 
4227
  }
 
4228
  arg2 = (char *)(buf2);
 
4229
  arg3 = RTEST(argv[2]);
 
4230
  arg4 = RTEST(argv[3]);
 
4231
  {
 
4232
    int res = SWIG_ConvertFunctionPtr(argv[4], (void**)(&arg5), SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void);
 
4233
    if (!SWIG_IsOK(res)) {
 
4234
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_notify_func_t","svn_repos_hotcopy3", 5, argv[4] )); 
 
4235
    }
 
4236
  }
 
4237
  res6 = SWIG_ConvertPtr(argv[5],SWIG_as_voidptrptr(&arg6), 0, 0);
 
4238
  if (!SWIG_IsOK(res6)) {
 
4239
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void *","svn_repos_hotcopy3", 6, argv[5] )); 
 
4240
  }
 
4241
  {
 
4242
    arg7 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
 
4243
    arg8 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
 
4244
  }
 
4245
  if (argc > 7) {
 
4246
    
 
4247
  }
 
4248
  {
 
4249
    result = (svn_error_t *)svn_repos_hotcopy3((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
4250
    
 
4251
    
 
4252
    
 
4253
  }
 
4254
  {
 
4255
    if (result) {
 
4256
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4257
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4258
      svn_swig_rb_handle_svn_error(result);
 
4259
    }
 
4260
    vresult = Qnil;
 
4261
  }
 
4262
  {
 
4263
    svn_swig_rb_set_baton(vresult, (VALUE)arg8);
 
4264
  }
 
4265
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
 
4266
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
4267
  {
 
4268
    VALUE target;
 
4269
    target = _global_vresult_address == &vresult ? self : vresult;
 
4270
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
4271
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4272
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4273
  }
 
4274
  return vresult;
 
4275
fail:
 
4276
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
 
4277
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
4278
  {
 
4279
    VALUE target;
 
4280
    target = _global_vresult_address == &vresult ? self : vresult;
 
4281
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
4282
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
4283
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
4284
  }
 
4285
  return Qnil;
 
4286
}
 
4287
 
 
4288
 
 
4289
SWIGINTERN VALUE
3752
4290
_wrap_svn_repos_hotcopy2(int argc, VALUE *argv, VALUE self) {
3753
4291
  char *arg1 = (char *) 0 ;
3754
4292
  char *arg2 = (char *) 0 ;
3789
4327
  arg3 = RTEST(argv[2]);
3790
4328
  arg4 = RTEST(argv[3]);
3791
4329
  {
3792
 
    arg5 = svn_swig_rb_cancel_func;
 
4330
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
3793
4331
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
3794
4332
  }
3795
4333
  if (argc > 5) {
3953
4491
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_repos_fs_pack2", 3, argv[2] )); 
3954
4492
  }
3955
4493
  {
3956
 
    arg4 = svn_swig_rb_cancel_func;
 
4494
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
3957
4495
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
3958
4496
  }
3959
4497
  if (argc > 4) {
4041
4579
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_repos_fs_pack", 3, argv[2] )); 
4042
4580
  }
4043
4581
  {
4044
 
    arg4 = svn_swig_rb_cancel_func;
 
4582
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
4045
4583
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
4046
4584
  }
4047
4585
  if (argc > 4) {
4127
4665
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_repos_recover4", 4, argv[3] )); 
4128
4666
  }
4129
4667
  {
4130
 
    arg5 = svn_swig_rb_cancel_func;
 
4668
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
4131
4669
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
4132
4670
  }
4133
4671
  if (argc > 5) {
4201
4739
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
4202
4740
  }
4203
4741
  {
4204
 
    arg5 = svn_swig_rb_cancel_func;
 
4742
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
4205
4743
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
4206
4744
  }
4207
4745
  if (argc > 4) {
5774
6312
    }
5775
6313
  }
5776
6314
  {
5777
 
    arg13 = svn_swig_rb_repos_authz_func;
 
6315
    arg13 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
5778
6316
    arg14 = (void *)svn_swig_rb_make_baton(argv[10], _global_svn_swig_rb_pool);
5779
6317
  }
5780
6318
  ecode15 = SWIG_AsVal_unsigned_SS_long(argv[11], &val15);
5919
6457
    }
5920
6458
  }
5921
6459
  {
5922
 
    arg13 = svn_swig_rb_repos_authz_func;
 
6460
    arg13 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
5923
6461
    arg14 = (void *)svn_swig_rb_make_baton(argv[10], _global_svn_swig_rb_pool);
5924
6462
  }
5925
6463
  if (argc > 11) {
6063
6601
    }
6064
6602
  }
6065
6603
  {
6066
 
    arg13 = svn_swig_rb_repos_authz_func;
 
6604
    arg13 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
6067
6605
    arg14 = (void *)svn_swig_rb_make_baton(argv[10], _global_svn_swig_rb_pool);
6068
6606
  }
6069
6607
  if (argc > 11) {
6885
7423
    }
6886
7424
  }
6887
7425
  {
6888
 
    arg8 = svn_swig_rb_repos_authz_func;
 
7426
    arg8 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
6889
7427
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
6890
7428
  }
6891
7429
  arg10 = RTEST(argv[7]);
7011
7549
    }
7012
7550
  }
7013
7551
  {
7014
 
    arg8 = svn_swig_rb_repos_authz_func;
 
7552
    arg8 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
7015
7553
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
7016
7554
  }
7017
7555
  arg10 = RTEST(argv[7]);
7117
7655
    }
7118
7656
  }
7119
7657
  {
7120
 
    arg7 = svn_swig_rb_repos_authz_func;
 
7658
    arg7 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
7121
7659
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
7122
7660
  }
7123
7661
  if (argc > 6) {
7317
7855
    arg9 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
7318
7856
  }
7319
7857
  {
7320
 
    arg10 = svn_swig_rb_repos_authz_callback;
 
7858
    arg10 = (svn_repos_authz_callback_t) svn_swig_rb_repos_authz_callback;
7321
7859
    arg11 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
7322
7860
  }
7323
7861
  if (argc > 7) {
7456
7994
    arg10 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
7457
7995
  }
7458
7996
  {
7459
 
    arg11 = svn_swig_rb_repos_authz_callback;
 
7997
    arg11 = (svn_repos_authz_callback_t) svn_swig_rb_repos_authz_callback;
7460
7998
    arg12 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
7461
7999
  }
7462
8000
  if (argc > 8) {
7595
8133
    arg10 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
7596
8134
  }
7597
8135
  {
7598
 
    arg11 = svn_swig_rb_repos_authz_callback;
 
8136
    arg11 = (svn_repos_authz_callback_t) svn_swig_rb_repos_authz_callback;
7599
8137
    arg12 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
7600
8138
  }
7601
8139
  if (argc > 8) {
8289
8827
    arg2 = StringValueCStr(argv[1]);
8290
8828
  }
8291
8829
  {
8292
 
    arg3 = svn_swig_rb_repos_history_func;
 
8830
    arg3 = (svn_repos_history_func_t) svn_swig_rb_repos_history_func;
8293
8831
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
8294
8832
  }
8295
8833
  {
8296
 
    arg5 = svn_swig_rb_repos_authz_func;
 
8834
    arg5 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
8297
8835
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
8298
8836
  }
8299
8837
  ecode7 = SWIG_AsVal_long(argv[4], &val7);
8387
8925
    arg2 = StringValueCStr(argv[1]);
8388
8926
  }
8389
8927
  {
8390
 
    arg3 = svn_swig_rb_repos_history_func;
 
8928
    arg3 = (svn_repos_history_func_t) svn_swig_rb_repos_history_func;
8391
8929
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
8392
8930
  }
8393
8931
  ecode5 = SWIG_AsVal_long(argv[3], &val5);
8494
9032
    arg5 = svn_swig_rb_array_to_apr_array_revnum(argv[3], _global_pool);
8495
9033
  }
8496
9034
  {
8497
 
    arg6 = svn_swig_rb_repos_authz_func;
 
9035
    arg6 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
8498
9036
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
8499
9037
  }
8500
9038
  if (argc > 5) {
8612
9150
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "void *","svn_repos_node_location_segments", 7, argv[6] )); 
8613
9151
  }
8614
9152
  {
8615
 
    arg8 = svn_swig_rb_repos_authz_func;
 
9153
    arg8 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
8616
9154
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
8617
9155
  }
8618
9156
  if (argc > 8) {
8725
9263
    svn_swig_rb_strings_to_apr_array(argv[8], _global_pool);
8726
9264
  }
8727
9265
  {
8728
 
    arg10 = svn_swig_rb_repos_authz_func;
 
9266
    arg10 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
8729
9267
    arg11 = (void *)svn_swig_rb_make_baton(argv[9], _global_svn_swig_rb_pool);
8730
9268
  }
8731
9269
  {
8732
 
    arg12 = svn_swig_rb_log_entry_receiver;
 
9270
    arg12 = (svn_log_entry_receiver_t) svn_swig_rb_log_entry_receiver;
8733
9271
    arg13 = (void *)svn_swig_rb_make_baton(argv[10], _global_svn_swig_rb_pool);
8734
9272
  }
8735
9273
  if (argc > 11) {
8835
9373
  arg6 = RTEST(argv[5]);
8836
9374
  arg7 = RTEST(argv[6]);
8837
9375
  {
8838
 
    arg8 = svn_swig_rb_repos_authz_func;
 
9376
    arg8 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
8839
9377
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
8840
9378
  }
8841
9379
  {
8842
 
    arg10 = svn_swig_rb_log_receiver;
 
9380
    arg10 = (svn_log_message_receiver_t) svn_swig_rb_log_receiver;
8843
9381
    arg11 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
8844
9382
  }
8845
9383
  if (argc > 9) {
8937
9475
  arg5 = RTEST(argv[4]);
8938
9476
  arg6 = RTEST(argv[5]);
8939
9477
  {
8940
 
    arg7 = svn_swig_rb_repos_authz_func;
 
9478
    arg7 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
8941
9479
    arg8 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
8942
9480
  }
8943
9481
  {
8944
 
    arg9 = svn_swig_rb_log_receiver;
 
9482
    arg9 = (svn_log_message_receiver_t) svn_swig_rb_log_receiver;
8945
9483
    arg10 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
8946
9484
  }
8947
9485
  if (argc > 8) {
9037
9575
  arg5 = RTEST(argv[4]);
9038
9576
  arg6 = RTEST(argv[5]);
9039
9577
  {
9040
 
    arg7 = svn_swig_rb_log_receiver;
 
9578
    arg7 = (svn_log_message_receiver_t) svn_swig_rb_log_receiver;
9041
9579
    arg8 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
9042
9580
  }
9043
9581
  if (argc > 7) {
9130
9668
  }
9131
9669
  arg6 = RTEST(argv[4]);
9132
9670
  {
9133
 
    arg7 = svn_swig_rb_repos_authz_func;
 
9671
    arg7 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
9134
9672
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
9135
9673
  }
9136
9674
  if (argc > 6) {
9230
9768
  arg4 = (svn_revnum_t)(val4);
9231
9769
  arg5 = RTEST(argv[4]);
9232
9770
  {
9233
 
    arg6 = svn_swig_rb_repos_authz_func;
 
9771
    arg6 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
9234
9772
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
9235
9773
  }
9236
9774
  {
9334
9872
  } 
9335
9873
  arg4 = (svn_revnum_t)(val4);
9336
9874
  {
9337
 
    arg5 = svn_swig_rb_repos_authz_func;
 
9875
    arg5 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
9338
9876
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
9339
9877
  }
9340
9878
  {
9341
 
    arg7 = svn_swig_rb_repos_file_rev_handler;
 
9879
    arg7 = (svn_repos_file_rev_handler_t) svn_swig_rb_repos_file_rev_handler;
9342
9880
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
9343
9881
  }
9344
9882
  if (argc > 6) {
9766
10304
 
9767
10305
 
9768
10306
SWIGINTERN VALUE
 
10307
_wrap_svn_repos_fs_lock_many(int argc, VALUE *argv, VALUE self) {
 
10308
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
10309
  apr_hash_t *arg2 = (apr_hash_t *) 0 ;
 
10310
  char *arg3 = (char *) 0 ;
 
10311
  svn_boolean_t arg4 ;
 
10312
  apr_time_t arg5 ;
 
10313
  svn_boolean_t arg6 ;
 
10314
  svn_fs_lock_callback_t arg7 = (svn_fs_lock_callback_t) 0 ;
 
10315
  void *arg8 = (void *) 0 ;
 
10316
  apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
10317
  apr_pool_t *arg10 = (apr_pool_t *) 0 ;
 
10318
  VALUE _global_svn_swig_rb_pool ;
 
10319
  apr_pool_t *_global_pool ;
 
10320
  void *argp1 = 0 ;
 
10321
  int res1 = 0 ;
 
10322
  void *argp2 = 0 ;
 
10323
  int res2 = 0 ;
 
10324
  int res8 ;
 
10325
  svn_error_t *result = 0 ;
 
10326
  VALUE vresult = Qnil;
 
10327
  
 
10328
  {
 
10329
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg9);
 
10330
    _global_pool = arg9;
 
10331
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
10332
  }
 
10333
  {
 
10334
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg10);
 
10335
    _global_pool = arg10;
 
10336
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
10337
  }
 
10338
  if ((argc < 8) || (argc > 10)) {
 
10339
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
 
10340
  }
 
10341
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
10342
  if (!SWIG_IsOK(res1)) {
 
10343
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_fs_lock_many", 1, argv[0] )); 
 
10344
  }
 
10345
  arg1 = (svn_repos_t *)(argp1);
 
10346
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_apr_hash_t, 0 |  0 );
 
10347
  if (!SWIG_IsOK(res2)) {
 
10348
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "apr_hash_t *","svn_repos_fs_lock_many", 2, argv[1] )); 
 
10349
  }
 
10350
  arg2 = (apr_hash_t *)(argp2);
 
10351
  {
 
10352
    if (NIL_P(argv[2])) {
 
10353
      arg3 = NULL;
 
10354
    } else {
 
10355
      arg3 = StringValuePtr(argv[2]);
 
10356
    }
 
10357
  }
 
10358
  arg4 = RTEST(argv[3]);
 
10359
  {
 
10360
    arg5 = (apr_time_t)NUM2LL(argv[4]);
 
10361
  }
 
10362
  arg6 = RTEST(argv[5]);
 
10363
  {
 
10364
    int res = SWIG_ConvertFunctionPtr(argv[6], (void**)(&arg7), 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);
 
10365
    if (!SWIG_IsOK(res)) {
 
10366
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_fs_lock_callback_t","svn_repos_fs_lock_many", 7, argv[6] )); 
 
10367
    }
 
10368
  }
 
10369
  res8 = SWIG_ConvertPtr(argv[7],SWIG_as_voidptrptr(&arg8), 0, 0);
 
10370
  if (!SWIG_IsOK(res8)) {
 
10371
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "void *","svn_repos_fs_lock_many", 8, argv[7] )); 
 
10372
  }
 
10373
  if (argc > 8) {
 
10374
    
 
10375
  }
 
10376
  if (argc > 9) {
 
10377
    
 
10378
  }
 
10379
  {
 
10380
    if (!arg1) {
 
10381
      svn_swig_rb_raise_svn_repos_already_close();
 
10382
    }
 
10383
  }
 
10384
  {
 
10385
    result = (svn_error_t *)svn_repos_fs_lock_many(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
 
10386
    
 
10387
    
 
10388
    
 
10389
  }
 
10390
  {
 
10391
    if (result) {
 
10392
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10393
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10394
      svn_swig_rb_handle_svn_error(result);
 
10395
    }
 
10396
    vresult = Qnil;
 
10397
  }
 
10398
  {
 
10399
    VALUE target;
 
10400
    target = _global_vresult_address == &vresult ? self : vresult;
 
10401
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10402
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10403
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10404
  }
 
10405
  {
 
10406
    VALUE target;
 
10407
    target = _global_vresult_address == &vresult ? self : vresult;
 
10408
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10409
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10410
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10411
  }
 
10412
  return vresult;
 
10413
fail:
 
10414
  {
 
10415
    VALUE target;
 
10416
    target = _global_vresult_address == &vresult ? self : vresult;
 
10417
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10418
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10419
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10420
  }
 
10421
  {
 
10422
    VALUE target;
 
10423
    target = _global_vresult_address == &vresult ? self : vresult;
 
10424
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10425
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10426
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10427
  }
 
10428
  return Qnil;
 
10429
}
 
10430
 
 
10431
 
 
10432
SWIGINTERN VALUE
9769
10433
_wrap_svn_repos_fs_lock(int argc, VALUE *argv, VALUE self) {
9770
10434
  svn_lock_t **arg1 = (svn_lock_t **) 0 ;
9771
10435
  svn_repos_t *arg2 = (svn_repos_t *) 0 ;
9874
10538
 
9875
10539
 
9876
10540
SWIGINTERN VALUE
 
10541
_wrap_svn_repos_fs_unlock_many(int argc, VALUE *argv, VALUE self) {
 
10542
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
10543
  apr_hash_t *arg2 = (apr_hash_t *) 0 ;
 
10544
  svn_boolean_t arg3 ;
 
10545
  svn_fs_lock_callback_t arg4 = (svn_fs_lock_callback_t) 0 ;
 
10546
  void *arg5 = (void *) 0 ;
 
10547
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
10548
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
 
10549
  VALUE _global_svn_swig_rb_pool ;
 
10550
  apr_pool_t *_global_pool ;
 
10551
  void *argp1 = 0 ;
 
10552
  int res1 = 0 ;
 
10553
  void *argp2 = 0 ;
 
10554
  int res2 = 0 ;
 
10555
  int res5 ;
 
10556
  svn_error_t *result = 0 ;
 
10557
  VALUE vresult = Qnil;
 
10558
  
 
10559
  {
 
10560
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
 
10561
    _global_pool = arg6;
 
10562
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
10563
  }
 
10564
  {
 
10565
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
 
10566
    _global_pool = arg7;
 
10567
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
10568
  }
 
10569
  if ((argc < 5) || (argc > 7)) {
 
10570
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
 
10571
  }
 
10572
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
10573
  if (!SWIG_IsOK(res1)) {
 
10574
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_fs_unlock_many", 1, argv[0] )); 
 
10575
  }
 
10576
  arg1 = (svn_repos_t *)(argp1);
 
10577
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_apr_hash_t, 0 |  0 );
 
10578
  if (!SWIG_IsOK(res2)) {
 
10579
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "apr_hash_t *","svn_repos_fs_unlock_many", 2, argv[1] )); 
 
10580
  }
 
10581
  arg2 = (apr_hash_t *)(argp2);
 
10582
  arg3 = RTEST(argv[2]);
 
10583
  {
 
10584
    int res = SWIG_ConvertFunctionPtr(argv[3], (void**)(&arg4), 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);
 
10585
    if (!SWIG_IsOK(res)) {
 
10586
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_fs_lock_callback_t","svn_repos_fs_unlock_many", 4, argv[3] )); 
 
10587
    }
 
10588
  }
 
10589
  res5 = SWIG_ConvertPtr(argv[4],SWIG_as_voidptrptr(&arg5), 0, 0);
 
10590
  if (!SWIG_IsOK(res5)) {
 
10591
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "void *","svn_repos_fs_unlock_many", 5, argv[4] )); 
 
10592
  }
 
10593
  if (argc > 5) {
 
10594
    
 
10595
  }
 
10596
  if (argc > 6) {
 
10597
    
 
10598
  }
 
10599
  {
 
10600
    if (!arg1) {
 
10601
      svn_swig_rb_raise_svn_repos_already_close();
 
10602
    }
 
10603
  }
 
10604
  {
 
10605
    result = (svn_error_t *)svn_repos_fs_unlock_many(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
 
10606
    
 
10607
    
 
10608
    
 
10609
  }
 
10610
  {
 
10611
    if (result) {
 
10612
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10613
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10614
      svn_swig_rb_handle_svn_error(result);
 
10615
    }
 
10616
    vresult = Qnil;
 
10617
  }
 
10618
  {
 
10619
    VALUE target;
 
10620
    target = _global_vresult_address == &vresult ? self : vresult;
 
10621
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10622
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10623
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10624
  }
 
10625
  {
 
10626
    VALUE target;
 
10627
    target = _global_vresult_address == &vresult ? self : vresult;
 
10628
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10629
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10630
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10631
  }
 
10632
  return vresult;
 
10633
fail:
 
10634
  {
 
10635
    VALUE target;
 
10636
    target = _global_vresult_address == &vresult ? self : vresult;
 
10637
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10638
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10639
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10640
  }
 
10641
  {
 
10642
    VALUE target;
 
10643
    target = _global_vresult_address == &vresult ? self : vresult;
 
10644
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10645
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10646
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10647
  }
 
10648
  return Qnil;
 
10649
}
 
10650
 
 
10651
 
 
10652
SWIGINTERN VALUE
9877
10653
_wrap_svn_repos_fs_unlock(int argc, VALUE *argv, VALUE self) {
9878
10654
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
9879
10655
  char *arg2 = (char *) 0 ;
9991
10767
    arg4 = svn_swig_rb_to_depth(argv[2]);
9992
10768
  }
9993
10769
  {
9994
 
    arg5 = svn_swig_rb_repos_authz_func;
 
10770
    arg5 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
9995
10771
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
9996
10772
  }
9997
10773
  if (argc > 4) {
10076
10852
    arg3 = StringValueCStr(argv[1]);
10077
10853
  }
10078
10854
  {
10079
 
    arg4 = svn_swig_rb_repos_authz_func;
 
10855
    arg4 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
10080
10856
    arg5 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
10081
10857
  }
10082
10858
  if (argc > 3) {
10203
10979
  arg7 = RTEST(argv[6]);
10204
10980
  arg8 = RTEST(argv[7]);
10205
10981
  {
10206
 
    arg9 = svn_swig_rb_repos_authz_func;
 
10982
    arg9 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
10207
10983
    arg10 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
10208
10984
  }
10209
10985
  if (argc > 9) {
10327
11103
  arg6 = RTEST(argv[5]);
10328
11104
  arg7 = RTEST(argv[6]);
10329
11105
  {
10330
 
    arg8 = svn_swig_rb_repos_authz_func;
 
11106
    arg8 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
10331
11107
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
10332
11108
  }
10333
11109
  if (argc > 8) {
10440
11216
    }
10441
11217
  }
10442
11218
  {
10443
 
    arg6 = svn_swig_rb_repos_authz_func;
 
11219
    arg6 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
10444
11220
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
10445
11221
  }
10446
11222
  if (argc > 6) {
10643
11419
  }
10644
11420
  arg4 = (char *)(buf4);
10645
11421
  {
10646
 
    arg5 = svn_swig_rb_repos_authz_func;
 
11422
    arg5 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
10647
11423
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
10648
11424
  }
10649
11425
  if (argc > 4) {
10735
11511
  } 
10736
11512
  arg3 = (svn_revnum_t)(val3);
10737
11513
  {
10738
 
    arg4 = svn_swig_rb_repos_authz_func;
 
11514
    arg4 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
10739
11515
    arg5 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
10740
11516
  }
10741
11517
  if (argc > 3) {
10871
11647
 
10872
11648
 
10873
11649
SWIGINTERN VALUE
 
11650
_wrap_svn_repos_fs_get_inherited_props(int argc, VALUE *argv, VALUE self) {
 
11651
  apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
 
11652
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
11653
  char *arg3 = (char *) 0 ;
 
11654
  char *arg4 = (char *) 0 ;
 
11655
  svn_repos_authz_func_t arg5 = (svn_repos_authz_func_t) 0 ;
 
11656
  void *arg6 = (void *) 0 ;
 
11657
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
 
11658
  apr_pool_t *arg8 = (apr_pool_t *) 0 ;
 
11659
  VALUE _global_svn_swig_rb_pool ;
 
11660
  apr_pool_t *_global_pool ;
 
11661
  apr_array_header_t *temp1 ;
 
11662
  void *argp2 = 0 ;
 
11663
  int res2 = 0 ;
 
11664
  int res4 ;
 
11665
  char *buf4 = 0 ;
 
11666
  int alloc4 = 0 ;
 
11667
  svn_error_t *result = 0 ;
 
11668
  VALUE vresult = Qnil;
 
11669
  
 
11670
  {
 
11671
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
 
11672
    _global_pool = arg7;
 
11673
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
11674
  }
 
11675
  {
 
11676
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg8);
 
11677
    _global_pool = arg8;
 
11678
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
11679
  }
 
11680
  arg1 = &temp1;
 
11681
  if ((argc < 4) || (argc > 6)) {
 
11682
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
 
11683
  }
 
11684
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
11685
  if (!SWIG_IsOK(res2)) {
 
11686
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_fs_root_t *","svn_repos_fs_get_inherited_props", 2, argv[0] )); 
 
11687
  }
 
11688
  arg2 = (svn_fs_root_t *)(argp2);
 
11689
  {
 
11690
    arg3 = StringValueCStr(argv[1]);
 
11691
  }
 
11692
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
 
11693
  if (!SWIG_IsOK(res4)) {
 
11694
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","svn_repos_fs_get_inherited_props", 4, argv[2] ));
 
11695
  }
 
11696
  arg4 = (char *)(buf4);
 
11697
  {
 
11698
    arg5 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
 
11699
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
 
11700
  }
 
11701
  if (argc > 4) {
 
11702
    
 
11703
  }
 
11704
  if (argc > 5) {
 
11705
    
 
11706
  }
 
11707
  {
 
11708
    result = (svn_error_t *)svn_repos_fs_get_inherited_props(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7,arg8);
 
11709
    
 
11710
    
 
11711
    
 
11712
  }
 
11713
  {
 
11714
    if (result) {
 
11715
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
11716
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
11717
      svn_swig_rb_handle_svn_error(result);
 
11718
    }
 
11719
    vresult = Qnil;
 
11720
  }
 
11721
  {
 
11722
    /* FIXME: Missing argout typemap: svn_repos_fs_get_inherited_props arg 1 (apr_array_header_t **) */
 
11723
    
 
11724
    
 
11725
    
 
11726
    
 
11727
    SWIG_exception(SWIG_ValueError, "svn_repos_fs_get_inherited_props is not implemented yet");
 
11728
    
 
11729
  }
 
11730
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
 
11731
  {
 
11732
    VALUE target;
 
11733
    target = _global_vresult_address == &vresult ? self : vresult;
 
11734
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
11735
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
11736
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
11737
  }
 
11738
  {
 
11739
    VALUE target;
 
11740
    target = _global_vresult_address == &vresult ? self : vresult;
 
11741
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
11742
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
11743
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
11744
  }
 
11745
  return vresult;
 
11746
fail:
 
11747
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
 
11748
  {
 
11749
    VALUE target;
 
11750
    target = _global_vresult_address == &vresult ? self : vresult;
 
11751
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
11752
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
11753
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
11754
  }
 
11755
  {
 
11756
    VALUE target;
 
11757
    target = _global_vresult_address == &vresult ? self : vresult;
 
11758
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
11759
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
11760
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
11761
  }
 
11762
  return Qnil;
 
11763
}
 
11764
 
 
11765
 
 
11766
SWIGINTERN VALUE
10874
11767
_wrap_svn_repos_fs_change_txn_prop(int argc, VALUE *argv, VALUE self) {
10875
11768
  svn_fs_txn_t *arg1 = (svn_fs_txn_t *) 0 ;
10876
11769
  char *arg2 = (char *) 0 ;
11716
12609
 
11717
12610
 
11718
12611
SWIGINTERN VALUE
 
12612
_wrap_svn_repos_info_format(int argc, VALUE *argv, VALUE self) {
 
12613
  int *arg1 = (int *) 0 ;
 
12614
  svn_version_t **arg2 = (svn_version_t **) 0 ;
 
12615
  svn_repos_t *arg3 = (svn_repos_t *) 0 ;
 
12616
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
12617
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
12618
  VALUE _global_svn_swig_rb_pool ;
 
12619
  apr_pool_t *_global_pool ;
 
12620
  int temp1 ;
 
12621
  int res1 = SWIG_TMPOBJ ;
 
12622
  svn_version_t *temp2 ;
 
12623
  void *argp3 = 0 ;
 
12624
  int res3 = 0 ;
 
12625
  svn_error_t *result = 0 ;
 
12626
  VALUE vresult = Qnil;
 
12627
  
 
12628
  {
 
12629
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
 
12630
    _global_pool = arg4;
 
12631
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
12632
  }
 
12633
  {
 
12634
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
 
12635
    _global_pool = arg5;
 
12636
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
12637
  }
 
12638
  arg1 = &temp1;
 
12639
  arg2 = &temp2;
 
12640
  if ((argc < 1) || (argc > 3)) {
 
12641
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
 
12642
  }
 
12643
  res3 = SWIG_ConvertPtr(argv[0], &argp3,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
12644
  if (!SWIG_IsOK(res3)) {
 
12645
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_info_format", 3, argv[0] )); 
 
12646
  }
 
12647
  arg3 = (svn_repos_t *)(argp3);
 
12648
  if (argc > 1) {
 
12649
    
 
12650
  }
 
12651
  if (argc > 2) {
 
12652
    
 
12653
  }
 
12654
  {
 
12655
    if (!arg3) {
 
12656
      svn_swig_rb_raise_svn_repos_already_close();
 
12657
    }
 
12658
  }
 
12659
  {
 
12660
    result = (svn_error_t *)svn_repos_info_format(arg1,arg2,arg3,arg4,arg5);
 
12661
    
 
12662
    
 
12663
    
 
12664
  }
 
12665
  {
 
12666
    if (result) {
 
12667
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
12668
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
12669
      svn_swig_rb_handle_svn_error(result);
 
12670
    }
 
12671
    vresult = Qnil;
 
12672
  }
 
12673
  if (SWIG_IsTmpObj(res1)) {
 
12674
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
 
12675
  } else {
 
12676
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
12677
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
 
12678
  }
 
12679
  {
 
12680
    /* FIXME: Missing argout typemap: svn_repos_info_format arg 2 (svn_version_t **) */
 
12681
    
 
12682
    
 
12683
    
 
12684
    
 
12685
    SWIG_exception(SWIG_ValueError, "svn_repos_info_format is not implemented yet");
 
12686
    
 
12687
  }
 
12688
  {
 
12689
    VALUE target;
 
12690
    target = _global_vresult_address == &vresult ? self : vresult;
 
12691
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
12692
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
12693
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
12694
  }
 
12695
  {
 
12696
    VALUE target;
 
12697
    target = _global_vresult_address == &vresult ? self : vresult;
 
12698
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
12699
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
12700
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
12701
  }
 
12702
  return vresult;
 
12703
fail:
 
12704
  {
 
12705
    VALUE target;
 
12706
    target = _global_vresult_address == &vresult ? self : vresult;
 
12707
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
12708
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
12709
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
12710
  }
 
12711
  {
 
12712
    VALUE target;
 
12713
    target = _global_vresult_address == &vresult ? self : vresult;
 
12714
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
12715
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
12716
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
12717
  }
 
12718
  return Qnil;
 
12719
}
 
12720
 
 
12721
 
 
12722
SWIGINTERN VALUE
 
12723
_wrap_svn_repos_verify_fs3(int argc, VALUE *argv, VALUE self) {
 
12724
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
12725
  svn_revnum_t arg2 ;
 
12726
  svn_revnum_t arg3 ;
 
12727
  svn_boolean_t arg4 ;
 
12728
  svn_boolean_t arg5 ;
 
12729
  svn_repos_notify_func_t arg6 = (svn_repos_notify_func_t) 0 ;
 
12730
  void *arg7 = (void *) 0 ;
 
12731
  svn_repos_verify_callback_t arg8 = (svn_repos_verify_callback_t) 0 ;
 
12732
  void *arg9 = (void *) 0 ;
 
12733
  svn_cancel_func_t arg10 = (svn_cancel_func_t) 0 ;
 
12734
  void *arg11 = (void *) 0 ;
 
12735
  apr_pool_t *arg12 = (apr_pool_t *) 0 ;
 
12736
  VALUE _global_svn_swig_rb_pool ;
 
12737
  apr_pool_t *_global_pool ;
 
12738
  void *argp1 = 0 ;
 
12739
  int res1 = 0 ;
 
12740
  long val2 ;
 
12741
  int ecode2 = 0 ;
 
12742
  long val3 ;
 
12743
  int ecode3 = 0 ;
 
12744
  int res7 ;
 
12745
  int res9 ;
 
12746
  int res11 ;
 
12747
  svn_error_t *result = 0 ;
 
12748
  VALUE vresult = Qnil;
 
12749
  
 
12750
  {
 
12751
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg12);
 
12752
    _global_pool = arg12;
 
12753
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
12754
  }
 
12755
  if ((argc < 11) || (argc > 12)) {
 
12756
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
 
12757
  }
 
12758
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
12759
  if (!SWIG_IsOK(res1)) {
 
12760
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_verify_fs3", 1, argv[0] )); 
 
12761
  }
 
12762
  arg1 = (svn_repos_t *)(argp1);
 
12763
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
 
12764
  if (!SWIG_IsOK(ecode2)) {
 
12765
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_verify_fs3", 2, argv[1] ));
 
12766
  } 
 
12767
  arg2 = (svn_revnum_t)(val2);
 
12768
  ecode3 = SWIG_AsVal_long(argv[2], &val3);
 
12769
  if (!SWIG_IsOK(ecode3)) {
 
12770
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_verify_fs3", 3, argv[2] ));
 
12771
  } 
 
12772
  arg3 = (svn_revnum_t)(val3);
 
12773
  arg4 = RTEST(argv[3]);
 
12774
  arg5 = RTEST(argv[4]);
 
12775
  {
 
12776
    int res = SWIG_ConvertFunctionPtr(argv[5], (void**)(&arg6), SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void);
 
12777
    if (!SWIG_IsOK(res)) {
 
12778
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_notify_func_t","svn_repos_verify_fs3", 6, argv[5] )); 
 
12779
    }
 
12780
  }
 
12781
  res7 = SWIG_ConvertPtr(argv[6],SWIG_as_voidptrptr(&arg7), 0, 0);
 
12782
  if (!SWIG_IsOK(res7)) {
 
12783
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "void *","svn_repos_verify_fs3", 7, argv[6] )); 
 
12784
  }
 
12785
  {
 
12786
    int res = SWIG_ConvertFunctionPtr(argv[7], (void**)(&arg8), SWIGTYPE_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t);
 
12787
    if (!SWIG_IsOK(res)) {
 
12788
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_verify_callback_t","svn_repos_verify_fs3", 8, argv[7] )); 
 
12789
    }
 
12790
  }
 
12791
  res9 = SWIG_ConvertPtr(argv[8],SWIG_as_voidptrptr(&arg9), 0, 0);
 
12792
  if (!SWIG_IsOK(res9)) {
 
12793
    SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "void *","svn_repos_verify_fs3", 9, argv[8] )); 
 
12794
  }
 
12795
  {
 
12796
    int res = SWIG_ConvertFunctionPtr(argv[9], (void**)(&arg10), SWIGTYPE_p_f_p_void__p_svn_error_t);
 
12797
    if (!SWIG_IsOK(res)) {
 
12798
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_cancel_func_t","svn_repos_verify_fs3", 10, argv[9] )); 
 
12799
    }
 
12800
  }
 
12801
  res11 = SWIG_ConvertPtr(argv[10],SWIG_as_voidptrptr(&arg11), 0, 0);
 
12802
  if (!SWIG_IsOK(res11)) {
 
12803
    SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "void *","svn_repos_verify_fs3", 11, argv[10] )); 
 
12804
  }
 
12805
  if (argc > 11) {
 
12806
    
 
12807
  }
 
12808
  {
 
12809
    if (!arg1) {
 
12810
      svn_swig_rb_raise_svn_repos_already_close();
 
12811
    }
 
12812
  }
 
12813
  {
 
12814
    result = (svn_error_t *)svn_repos_verify_fs3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
 
12815
    
 
12816
    
 
12817
    
 
12818
  }
 
12819
  {
 
12820
    if (result) {
 
12821
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
12822
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
12823
      svn_swig_rb_handle_svn_error(result);
 
12824
    }
 
12825
    vresult = Qnil;
 
12826
  }
 
12827
  {
 
12828
    VALUE target;
 
12829
    target = _global_vresult_address == &vresult ? self : vresult;
 
12830
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
12831
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
12832
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
12833
  }
 
12834
  return vresult;
 
12835
fail:
 
12836
  {
 
12837
    VALUE target;
 
12838
    target = _global_vresult_address == &vresult ? self : vresult;
 
12839
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
12840
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
12841
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
12842
  }
 
12843
  return Qnil;
 
12844
}
 
12845
 
 
12846
 
 
12847
SWIGINTERN VALUE
11719
12848
_wrap_svn_repos_verify_fs2(int argc, VALUE *argv, VALUE self) {
11720
12849
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
11721
12850
  svn_revnum_t arg2 ;
11874
13003
  } 
11875
13004
  arg4 = (svn_revnum_t)(val4);
11876
13005
  {
11877
 
    arg5 = svn_swig_rb_cancel_func;
 
13006
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
11878
13007
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
11879
13008
  }
11880
13009
  if (argc > 5) {
11986
13115
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "void *","svn_repos_dump_fs3", 8, argv[7] )); 
11987
13116
  }
11988
13117
  {
11989
 
    arg9 = svn_swig_rb_cancel_func;
 
13118
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
11990
13119
    arg10 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
11991
13120
  }
11992
13121
  if (argc > 9) {
12091
13220
  arg5 = (svn_revnum_t)(val5);
12092
13221
  arg6 = RTEST(argv[5]);
12093
13222
  {
12094
 
    arg7 = svn_swig_rb_cancel_func;
 
13223
    arg7 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
12095
13224
    arg8 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
12096
13225
  }
12097
13226
  if (argc > 7) {
12140
13269
 
12141
13270
 
12142
13271
SWIGINTERN VALUE
 
13272
_wrap_svn_repos_load_fs5(int argc, VALUE *argv, VALUE self) {
 
13273
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
 
13274
  svn_stream_t *arg2 = (svn_stream_t *) 0 ;
 
13275
  svn_revnum_t arg3 ;
 
13276
  svn_revnum_t arg4 ;
 
13277
  enum svn_repos_load_uuid arg5 ;
 
13278
  char *arg6 = (char *) 0 ;
 
13279
  svn_boolean_t arg7 ;
 
13280
  svn_boolean_t arg8 ;
 
13281
  svn_boolean_t arg9 ;
 
13282
  svn_boolean_t arg10 ;
 
13283
  svn_repos_notify_func_t arg11 = (svn_repos_notify_func_t) 0 ;
 
13284
  void *arg12 = (void *) 0 ;
 
13285
  svn_cancel_func_t arg13 = (svn_cancel_func_t) 0 ;
 
13286
  void *arg14 = (void *) 0 ;
 
13287
  apr_pool_t *arg15 = (apr_pool_t *) 0 ;
 
13288
  VALUE _global_svn_swig_rb_pool ;
 
13289
  apr_pool_t *_global_pool ;
 
13290
  void *argp1 = 0 ;
 
13291
  int res1 = 0 ;
 
13292
  long val3 ;
 
13293
  int ecode3 = 0 ;
 
13294
  long val4 ;
 
13295
  int ecode4 = 0 ;
 
13296
  int val5 ;
 
13297
  int ecode5 = 0 ;
 
13298
  int res12 ;
 
13299
  svn_error_t *result = 0 ;
 
13300
  VALUE vresult = Qnil;
 
13301
  
 
13302
  {
 
13303
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg15);
 
13304
    _global_pool = arg15;
 
13305
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
13306
  }
 
13307
  if ((argc < 13) || (argc > 14)) {
 
13308
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 13)",argc); SWIG_fail;
 
13309
  }
 
13310
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
13311
  if (!SWIG_IsOK(res1)) {
 
13312
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_load_fs5", 1, argv[0] )); 
 
13313
  }
 
13314
  arg1 = (svn_repos_t *)(argp1);
 
13315
  {
 
13316
    arg2 = svn_swig_rb_make_stream(argv[1]);
 
13317
  }
 
13318
  ecode3 = SWIG_AsVal_long(argv[2], &val3);
 
13319
  if (!SWIG_IsOK(ecode3)) {
 
13320
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_load_fs5", 3, argv[2] ));
 
13321
  } 
 
13322
  arg3 = (svn_revnum_t)(val3);
 
13323
  ecode4 = SWIG_AsVal_long(argv[3], &val4);
 
13324
  if (!SWIG_IsOK(ecode4)) {
 
13325
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_load_fs5", 4, argv[3] ));
 
13326
  } 
 
13327
  arg4 = (svn_revnum_t)(val4);
 
13328
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
 
13329
  if (!SWIG_IsOK(ecode5)) {
 
13330
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "enum svn_repos_load_uuid","svn_repos_load_fs5", 5, argv[4] ));
 
13331
  } 
 
13332
  arg5 = (enum svn_repos_load_uuid)(val5);
 
13333
  {
 
13334
    if (NIL_P(argv[5])) {
 
13335
      arg6 = NULL;
 
13336
    } else {
 
13337
      arg6 = StringValuePtr(argv[5]);
 
13338
    }
 
13339
  }
 
13340
  arg7 = RTEST(argv[6]);
 
13341
  arg8 = RTEST(argv[7]);
 
13342
  arg9 = RTEST(argv[8]);
 
13343
  arg10 = RTEST(argv[9]);
 
13344
  {
 
13345
    int res = SWIG_ConvertFunctionPtr(argv[10], (void**)(&arg11), SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void);
 
13346
    if (!SWIG_IsOK(res)) {
 
13347
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_notify_func_t","svn_repos_load_fs5", 11, argv[10] )); 
 
13348
    }
 
13349
  }
 
13350
  res12 = SWIG_ConvertPtr(argv[11],SWIG_as_voidptrptr(&arg12), 0, 0);
 
13351
  if (!SWIG_IsOK(res12)) {
 
13352
    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "void *","svn_repos_load_fs5", 12, argv[11] )); 
 
13353
  }
 
13354
  {
 
13355
    arg13 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
 
13356
    arg14 = (void *)svn_swig_rb_make_baton(argv[12], _global_svn_swig_rb_pool);
 
13357
  }
 
13358
  if (argc > 13) {
 
13359
    
 
13360
  }
 
13361
  {
 
13362
    if (!arg1) {
 
13363
      svn_swig_rb_raise_svn_repos_already_close();
 
13364
    }
 
13365
  }
 
13366
  {
 
13367
    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);
 
13368
    
 
13369
    
 
13370
    
 
13371
  }
 
13372
  {
 
13373
    if (result) {
 
13374
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
13375
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
13376
      svn_swig_rb_handle_svn_error(result);
 
13377
    }
 
13378
    vresult = Qnil;
 
13379
  }
 
13380
  {
 
13381
    svn_swig_rb_set_baton(vresult, (VALUE)arg14);
 
13382
  }
 
13383
  {
 
13384
    VALUE target;
 
13385
    target = _global_vresult_address == &vresult ? self : vresult;
 
13386
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
13387
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
13388
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
13389
  }
 
13390
  return vresult;
 
13391
fail:
 
13392
  {
 
13393
    VALUE target;
 
13394
    target = _global_vresult_address == &vresult ? self : vresult;
 
13395
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
13396
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
13397
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
13398
  }
 
13399
  return Qnil;
 
13400
}
 
13401
 
 
13402
 
 
13403
SWIGINTERN VALUE
12143
13404
_wrap_svn_repos_load_fs4(int argc, VALUE *argv, VALUE self) {
12144
13405
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
12145
13406
  svn_stream_t *arg2 = (svn_stream_t *) 0 ;
12221
13482
    SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "void *","svn_repos_load_fs4", 11, argv[10] )); 
12222
13483
  }
12223
13484
  {
12224
 
    arg12 = svn_swig_rb_cancel_func;
 
13485
    arg12 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
12225
13486
    arg13 = (void *)svn_swig_rb_make_baton(argv[11], _global_svn_swig_rb_pool);
12226
13487
  }
12227
13488
  if (argc > 12) {
12335
13596
    SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "void *","svn_repos_load_fs3", 9, argv[8] )); 
12336
13597
  }
12337
13598
  {
12338
 
    arg10 = svn_swig_rb_cancel_func;
 
13599
    arg10 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
12339
13600
    arg11 = (void *)svn_swig_rb_make_baton(argv[9], _global_svn_swig_rb_pool);
12340
13601
  }
12341
13602
  if (argc > 10) {
12442
13703
  arg6 = RTEST(argv[5]);
12443
13704
  arg7 = RTEST(argv[6]);
12444
13705
  {
12445
 
    arg8 = svn_swig_rb_cancel_func;
 
13706
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
12446
13707
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
12447
13708
  }
12448
13709
  if (argc > 8) {
12545
13806
    }
12546
13807
  }
12547
13808
  {
12548
 
    arg6 = svn_swig_rb_cancel_func;
 
13809
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
12549
13810
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
12550
13811
  }
12551
13812
  if (argc > 6) {
13258
14519
  }
13259
14520
  arg4 = RTEST(argv[3]);
13260
14521
  {
13261
 
    arg5 = svn_swig_rb_cancel_func;
 
14522
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
13262
14523
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
13263
14524
  }
13264
14525
  if (argc > 5) {
13302
14563
 
13303
14564
 
13304
14565
SWIGINTERN VALUE
 
14566
_wrap_svn_repos_get_fs_build_parser5(int argc, VALUE *argv, VALUE self) {
 
14567
  svn_repos_parse_fns3_t **arg1 = (svn_repos_parse_fns3_t **) 0 ;
 
14568
  void **arg2 = (void **) 0 ;
 
14569
  svn_repos_t *arg3 = (svn_repos_t *) 0 ;
 
14570
  svn_revnum_t arg4 ;
 
14571
  svn_revnum_t arg5 ;
 
14572
  svn_boolean_t arg6 ;
 
14573
  svn_boolean_t arg7 ;
 
14574
  enum svn_repos_load_uuid arg8 ;
 
14575
  char *arg9 = (char *) 0 ;
 
14576
  svn_boolean_t arg10 ;
 
14577
  svn_boolean_t arg11 ;
 
14578
  svn_boolean_t arg12 ;
 
14579
  svn_repos_notify_func_t arg13 = (svn_repos_notify_func_t) 0 ;
 
14580
  void *arg14 = (void *) 0 ;
 
14581
  apr_pool_t *arg15 = (apr_pool_t *) 0 ;
 
14582
  VALUE _global_svn_swig_rb_pool ;
 
14583
  apr_pool_t *_global_pool ;
 
14584
  svn_repos_parse_fns3_t *temp1 ;
 
14585
  void *temp2 ;
 
14586
  void *argp3 = 0 ;
 
14587
  int res3 = 0 ;
 
14588
  long val4 ;
 
14589
  int ecode4 = 0 ;
 
14590
  long val5 ;
 
14591
  int ecode5 = 0 ;
 
14592
  int val8 ;
 
14593
  int ecode8 = 0 ;
 
14594
  int res14 ;
 
14595
  svn_error_t *result = 0 ;
 
14596
  VALUE vresult = Qnil;
 
14597
  
 
14598
  {
 
14599
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg15);
 
14600
    _global_pool = arg15;
 
14601
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
14602
  }
 
14603
  arg1 = &temp1;
 
14604
  arg2 = &temp2;
 
14605
  if ((argc < 12) || (argc > 13)) {
 
14606
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
 
14607
  }
 
14608
  res3 = SWIG_ConvertPtr(argv[0], &argp3,SWIGTYPE_p_svn_repos_t, 0 |  0 );
 
14609
  if (!SWIG_IsOK(res3)) {
 
14610
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_get_fs_build_parser5", 3, argv[0] )); 
 
14611
  }
 
14612
  arg3 = (svn_repos_t *)(argp3);
 
14613
  ecode4 = SWIG_AsVal_long(argv[1], &val4);
 
14614
  if (!SWIG_IsOK(ecode4)) {
 
14615
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_get_fs_build_parser5", 4, argv[1] ));
 
14616
  } 
 
14617
  arg4 = (svn_revnum_t)(val4);
 
14618
  ecode5 = SWIG_AsVal_long(argv[2], &val5);
 
14619
  if (!SWIG_IsOK(ecode5)) {
 
14620
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_get_fs_build_parser5", 5, argv[2] ));
 
14621
  } 
 
14622
  arg5 = (svn_revnum_t)(val5);
 
14623
  arg6 = RTEST(argv[3]);
 
14624
  arg7 = RTEST(argv[4]);
 
14625
  ecode8 = SWIG_AsVal_int(argv[5], &val8);
 
14626
  if (!SWIG_IsOK(ecode8)) {
 
14627
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "enum svn_repos_load_uuid","svn_repos_get_fs_build_parser5", 8, argv[5] ));
 
14628
  } 
 
14629
  arg8 = (enum svn_repos_load_uuid)(val8);
 
14630
  {
 
14631
    if (NIL_P(argv[6])) {
 
14632
      arg9 = NULL;
 
14633
    } else {
 
14634
      arg9 = StringValuePtr(argv[6]);
 
14635
    }
 
14636
  }
 
14637
  arg10 = RTEST(argv[7]);
 
14638
  arg11 = RTEST(argv[8]);
 
14639
  arg12 = RTEST(argv[9]);
 
14640
  {
 
14641
    int res = SWIG_ConvertFunctionPtr(argv[10], (void**)(&arg13), SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void);
 
14642
    if (!SWIG_IsOK(res)) {
 
14643
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_notify_func_t","svn_repos_get_fs_build_parser5", 13, argv[10] )); 
 
14644
    }
 
14645
  }
 
14646
  res14 = SWIG_ConvertPtr(argv[11],SWIG_as_voidptrptr(&arg14), 0, 0);
 
14647
  if (!SWIG_IsOK(res14)) {
 
14648
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "void *","svn_repos_get_fs_build_parser5", 14, argv[11] )); 
 
14649
  }
 
14650
  if (argc > 12) {
 
14651
    
 
14652
  }
 
14653
  {
 
14654
    if (!arg3) {
 
14655
      svn_swig_rb_raise_svn_repos_already_close();
 
14656
    }
 
14657
  }
 
14658
  {
 
14659
    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);
 
14660
    
 
14661
    
 
14662
    
 
14663
  }
 
14664
  {
 
14665
    if (result) {
 
14666
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
14667
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
14668
      svn_swig_rb_handle_svn_error(result);
 
14669
    }
 
14670
    vresult = Qnil;
 
14671
  }
 
14672
  {
 
14673
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns3_t, 0));
 
14674
  }
 
14675
  {
 
14676
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
 
14677
  }
 
14678
  {
 
14679
    VALUE target;
 
14680
    target = _global_vresult_address == &vresult ? self : vresult;
 
14681
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
14682
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
14683
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
14684
  }
 
14685
  return vresult;
 
14686
fail:
 
14687
  {
 
14688
    VALUE target;
 
14689
    target = _global_vresult_address == &vresult ? self : vresult;
 
14690
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
14691
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
14692
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
14693
  }
 
14694
  return Qnil;
 
14695
}
 
14696
 
 
14697
 
 
14698
SWIGINTERN VALUE
13305
14699
_wrap_svn_repos_get_fs_build_parser4(int argc, VALUE *argv, VALUE self) {
13306
14700
  svn_repos_parse_fns3_t **arg1 = (svn_repos_parse_fns3_t **) 0 ;
13307
14701
  void **arg2 = (void **) 0 ;
13403
14797
    vresult = Qnil;
13404
14798
  }
13405
14799
  {
13406
 
    /* FIXME: Missing argout typemap: svn_repos_get_fs_build_parser4 arg 1 (svn_repos_parse_fns3_t const **) */
13407
 
    
13408
 
    
13409
 
    
13410
 
    
13411
 
    SWIG_exception(SWIG_ValueError, "svn_repos_get_fs_build_parser4 is not implemented yet");
13412
 
    
 
14800
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns3_t, 0));
13413
14801
  }
13414
14802
  {
13415
14803
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
14515
15903
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_repos_parse_dumpstream2", 3, argv[2] )); 
14516
15904
  }
14517
15905
  {
14518
 
    arg4 = svn_swig_rb_cancel_func;
 
15906
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
14519
15907
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
14520
15908
  }
14521
15909
  if (argc > 4) {
14595
15983
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_repos_parse_dumpstream", 3, argv[2] )); 
14596
15984
  }
14597
15985
  {
14598
 
    arg4 = svn_swig_rb_cancel_func;
 
15986
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
14599
15987
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
14600
15988
  }
14601
15989
  if (argc > 4) {
14724
16112
    vresult = Qnil;
14725
16113
  }
14726
16114
  {
14727
 
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns2_t, 0));
 
16115
    /* FIXME: Missing argout typemap: svn_repos_get_fs_build_parser3 arg 1 (svn_repos_parse_fns2_t const **) */
 
16116
    
 
16117
    
 
16118
    
 
16119
    
 
16120
    SWIG_exception(SWIG_ValueError, "svn_repos_get_fs_build_parser3 is not implemented yet");
 
16121
    
14728
16122
  }
14729
16123
  {
14730
16124
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
14824
16218
    vresult = Qnil;
14825
16219
  }
14826
16220
  {
14827
 
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns2_t, 0));
 
16221
    /* FIXME: Missing argout typemap: svn_repos_get_fs_build_parser2 arg 1 (svn_repos_parse_fns2_t const **) */
 
16222
    
 
16223
    
 
16224
    
 
16225
    
 
16226
    SWIG_exception(SWIG_ValueError, "svn_repos_get_fs_build_parser2 is not implemented yet");
 
16227
    
14828
16228
  }
14829
16229
  {
14830
16230
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
15305
16705
  } 
15306
16706
  arg3 = (svn_revnum_t)(val3);
15307
16707
  {
15308
 
    arg4 = svn_swig_rb_repos_authz_func;
 
16708
    arg4 = (svn_repos_authz_func_t) svn_swig_rb_repos_authz_func;
15309
16709
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
15310
16710
  }
15311
16711
  if (argc > 4) {
15351
16751
 
15352
16752
 
15353
16753
SWIGINTERN VALUE
15354
 
_wrap_svn_repos_fs_get_inherited_props(int argc, VALUE *argv, VALUE self) {
15355
 
  apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
15356
 
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
15357
 
  char *arg3 = (char *) 0 ;
15358
 
  char *arg4 = (char *) 0 ;
15359
 
  svn_repos_authz_func_t arg5 = (svn_repos_authz_func_t) 0 ;
15360
 
  void *arg6 = (void *) 0 ;
15361
 
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
15362
 
  apr_pool_t *arg8 = (apr_pool_t *) 0 ;
15363
 
  VALUE _global_svn_swig_rb_pool ;
15364
 
  apr_pool_t *_global_pool ;
15365
 
  apr_array_header_t *temp1 ;
15366
 
  void *argp2 = 0 ;
15367
 
  int res2 = 0 ;
15368
 
  int res4 ;
15369
 
  char *buf4 = 0 ;
15370
 
  int alloc4 = 0 ;
15371
 
  svn_error_t *result = 0 ;
15372
 
  VALUE vresult = Qnil;
15373
 
  
15374
 
  {
15375
 
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
15376
 
    _global_pool = arg7;
15377
 
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
15378
 
  }
15379
 
  {
15380
 
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg8);
15381
 
    _global_pool = arg8;
15382
 
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
15383
 
  }
15384
 
  arg1 = &temp1;
15385
 
  if ((argc < 4) || (argc > 6)) {
15386
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
15387
 
  }
15388
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
15389
 
  if (!SWIG_IsOK(res2)) {
15390
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_fs_root_t *","svn_repos_fs_get_inherited_props", 2, argv[0] )); 
15391
 
  }
15392
 
  arg2 = (svn_fs_root_t *)(argp2);
15393
 
  {
15394
 
    arg3 = StringValueCStr(argv[1]);
15395
 
  }
15396
 
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
15397
 
  if (!SWIG_IsOK(res4)) {
15398
 
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","svn_repos_fs_get_inherited_props", 4, argv[2] ));
15399
 
  }
15400
 
  arg4 = (char *)(buf4);
15401
 
  {
15402
 
    arg5 = svn_swig_rb_repos_authz_func;
15403
 
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
15404
 
  }
15405
 
  if (argc > 4) {
15406
 
    
15407
 
  }
15408
 
  if (argc > 5) {
15409
 
    
15410
 
  }
15411
 
  {
15412
 
    result = (svn_error_t *)svn_repos_fs_get_inherited_props(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7,arg8);
15413
 
    
15414
 
    
15415
 
    
15416
 
  }
15417
 
  {
15418
 
    if (result) {
15419
 
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
15420
 
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
15421
 
      svn_swig_rb_handle_svn_error(result);
15422
 
    }
15423
 
    vresult = Qnil;
15424
 
  }
15425
 
  {
15426
 
    /* FIXME: Missing argout typemap: svn_repos_fs_get_inherited_props arg 1 (apr_array_header_t **) */
15427
 
    
15428
 
    
15429
 
    
15430
 
    
15431
 
    SWIG_exception(SWIG_ValueError, "svn_repos_fs_get_inherited_props is not implemented yet");
15432
 
    
15433
 
  }
15434
 
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
15435
 
  {
15436
 
    VALUE target;
15437
 
    target = _global_vresult_address == &vresult ? self : vresult;
15438
 
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
15439
 
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
15440
 
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
15441
 
  }
15442
 
  {
15443
 
    VALUE target;
15444
 
    target = _global_vresult_address == &vresult ? self : vresult;
15445
 
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
15446
 
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
15447
 
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
15448
 
  }
15449
 
  return vresult;
15450
 
fail:
15451
 
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
15452
 
  {
15453
 
    VALUE target;
15454
 
    target = _global_vresult_address == &vresult ? self : vresult;
15455
 
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
15456
 
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
15457
 
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
15458
 
  }
15459
 
  {
15460
 
    VALUE target;
15461
 
    target = _global_vresult_address == &vresult ? self : vresult;
15462
 
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
15463
 
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
15464
 
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
15465
 
  }
15466
 
  return Qnil;
15467
 
}
15468
 
 
15469
 
 
15470
 
SWIGINTERN VALUE
15471
 
_wrap_svn_repos_remember_client_capabilities(int argc, VALUE *argv, VALUE self) {
15472
 
  svn_repos_t *arg1 = (svn_repos_t *) 0 ;
15473
 
  apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
15474
 
  void *argp1 = 0 ;
15475
 
  int res1 = 0 ;
15476
 
  void *argp2 = 0 ;
15477
 
  int res2 = 0 ;
15478
 
  svn_error_t *result = 0 ;
15479
 
  VALUE vresult = Qnil;
15480
 
  
15481
 
  if ((argc < 2) || (argc > 2)) {
15482
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
15483
 
  }
15484
 
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_repos_t, 0 |  0 );
15485
 
  if (!SWIG_IsOK(res1)) {
15486
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_remember_client_capabilities", 1, argv[0] )); 
15487
 
  }
15488
 
  arg1 = (svn_repos_t *)(argp1);
15489
 
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_apr_array_header_t, 0 |  0 );
15490
 
  if (!SWIG_IsOK(res2)) {
15491
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "apr_array_header_t const *","svn_repos_remember_client_capabilities", 2, argv[1] )); 
15492
 
  }
15493
 
  arg2 = (apr_array_header_t *)(argp2);
15494
 
  {
15495
 
    if (!arg1) {
15496
 
      svn_swig_rb_raise_svn_repos_already_close();
15497
 
    }
15498
 
  }
15499
 
  {
15500
 
    result = (svn_error_t *)svn_repos_remember_client_capabilities(arg1,(apr_array_header_t const *)arg2);
15501
 
    
15502
 
    
15503
 
    
15504
 
  }
15505
 
  {
15506
 
    if (result) {
15507
 
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
15508
 
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
15509
 
      svn_swig_rb_handle_svn_error(result);
15510
 
    }
15511
 
    vresult = Qnil;
15512
 
  }
15513
 
  return vresult;
15514
 
fail:
15515
 
  return Qnil;
15516
 
}
15517
 
 
15518
 
 
15519
 
SWIGINTERN VALUE
15520
16754
_wrap_svn_repos_parse_fns3_invoke_magic_header_record(int argc, VALUE *argv, VALUE self) {
15521
16755
  svn_repos_parse_fns3_t *arg1 = (svn_repos_parse_fns3_t *) 0 ;
15522
16756
  int arg2 ;
17060
18294
 
17061
18295
 
17062
18296
SWIGINTERN VALUE
 
18297
_wrap_svn_repos_invoke_notify_func(int argc, VALUE *argv, VALUE self) {
 
18298
  svn_repos_notify_func_t arg1 = (svn_repos_notify_func_t) 0 ;
 
18299
  void *arg2 = (void *) 0 ;
 
18300
  svn_repos_notify_t *arg3 = (svn_repos_notify_t *) 0 ;
 
18301
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
18302
  VALUE _global_svn_swig_rb_pool ;
 
18303
  apr_pool_t *_global_pool ;
 
18304
  int res2 ;
 
18305
  void *argp3 = 0 ;
 
18306
  int res3 = 0 ;
 
18307
  
 
18308
  {
 
18309
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
 
18310
    _global_pool = arg4;
 
18311
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
18312
  }
 
18313
  if ((argc < 3) || (argc > 4)) {
 
18314
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
 
18315
  }
 
18316
  {
 
18317
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void);
 
18318
    if (!SWIG_IsOK(res)) {
 
18319
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_notify_func_t","svn_repos_invoke_notify_func", 1, argv[0] )); 
 
18320
    }
 
18321
  }
 
18322
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
 
18323
  if (!SWIG_IsOK(res2)) {
 
18324
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_repos_invoke_notify_func", 2, argv[1] )); 
 
18325
  }
 
18326
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_svn_repos_notify_t, 0 |  0 );
 
18327
  if (!SWIG_IsOK(res3)) {
 
18328
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "svn_repos_notify_t const *","svn_repos_invoke_notify_func", 3, argv[2] )); 
 
18329
  }
 
18330
  arg3 = (svn_repos_notify_t *)(argp3);
 
18331
  if (argc > 3) {
 
18332
    
 
18333
  }
 
18334
  {
 
18335
    svn_repos_invoke_notify_func(arg1,arg2,(struct svn_repos_notify_t const *)arg3,arg4);
 
18336
    
 
18337
    
 
18338
    
 
18339
  }
 
18340
  {
 
18341
    VALUE target;
 
18342
    target = _global_vresult_address == &vresult ? self : vresult;
 
18343
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
18344
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
18345
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
18346
  }
 
18347
  return Qnil;
 
18348
fail:
 
18349
  {
 
18350
    VALUE target;
 
18351
    target = _global_vresult_address == &vresult ? self : vresult;
 
18352
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
18353
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
18354
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
18355
  }
 
18356
  return Qnil;
 
18357
}
 
18358
 
 
18359
 
 
18360
SWIGINTERN VALUE
 
18361
_wrap_svn_repos_invoke_freeze_func(int argc, VALUE *argv, VALUE self) {
 
18362
  svn_repos_freeze_func_t arg1 = (svn_repos_freeze_func_t) 0 ;
 
18363
  void *arg2 = (void *) 0 ;
 
18364
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
18365
  VALUE _global_svn_swig_rb_pool ;
 
18366
  apr_pool_t *_global_pool ;
 
18367
  int res2 ;
 
18368
  svn_error_t *result = 0 ;
 
18369
  VALUE vresult = Qnil;
 
18370
  
 
18371
  {
 
18372
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
 
18373
    _global_pool = arg3;
 
18374
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
18375
  }
 
18376
  if ((argc < 2) || (argc > 3)) {
 
18377
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
 
18378
  }
 
18379
  {
 
18380
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t);
 
18381
    if (!SWIG_IsOK(res)) {
 
18382
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_freeze_func_t","svn_repos_invoke_freeze_func", 1, argv[0] )); 
 
18383
    }
 
18384
  }
 
18385
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
 
18386
  if (!SWIG_IsOK(res2)) {
 
18387
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_repos_invoke_freeze_func", 2, argv[1] )); 
 
18388
  }
 
18389
  if (argc > 2) {
 
18390
    
 
18391
  }
 
18392
  {
 
18393
    result = (svn_error_t *)svn_repos_invoke_freeze_func(arg1,arg2,arg3);
 
18394
    
 
18395
    
 
18396
    
 
18397
  }
 
18398
  {
 
18399
    if (result) {
 
18400
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
18401
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
18402
      svn_swig_rb_handle_svn_error(result);
 
18403
    }
 
18404
    vresult = Qnil;
 
18405
  }
 
18406
  {
 
18407
    VALUE target;
 
18408
    target = _global_vresult_address == &vresult ? self : vresult;
 
18409
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
18410
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
18411
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
18412
  }
 
18413
  return vresult;
 
18414
fail:
 
18415
  {
 
18416
    VALUE target;
 
18417
    target = _global_vresult_address == &vresult ? self : vresult;
 
18418
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
18419
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
18420
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
18421
  }
 
18422
  return Qnil;
 
18423
}
 
18424
 
 
18425
 
 
18426
SWIGINTERN VALUE
 
18427
_wrap_svn_repos_invoke_history_func(int argc, VALUE *argv, VALUE self) {
 
18428
  svn_repos_history_func_t arg1 = (svn_repos_history_func_t) 0 ;
 
18429
  void *arg2 = (void *) 0 ;
 
18430
  char *arg3 = (char *) 0 ;
 
18431
  svn_revnum_t arg4 ;
 
18432
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
18433
  VALUE _global_svn_swig_rb_pool ;
 
18434
  apr_pool_t *_global_pool ;
 
18435
  int res2 ;
 
18436
  long val4 ;
 
18437
  int ecode4 = 0 ;
 
18438
  svn_error_t *result = 0 ;
 
18439
  VALUE vresult = Qnil;
 
18440
  
 
18441
  {
 
18442
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
 
18443
    _global_pool = arg5;
 
18444
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
18445
  }
 
18446
  if ((argc < 4) || (argc > 5)) {
 
18447
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
 
18448
  }
 
18449
  {
 
18450
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t);
 
18451
    if (!SWIG_IsOK(res)) {
 
18452
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_history_func_t","svn_repos_invoke_history_func", 1, argv[0] )); 
 
18453
    }
 
18454
  }
 
18455
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
 
18456
  if (!SWIG_IsOK(res2)) {
 
18457
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_repos_invoke_history_func", 2, argv[1] )); 
 
18458
  }
 
18459
  {
 
18460
    arg3 = StringValueCStr(argv[2]);
 
18461
  }
 
18462
  ecode4 = SWIG_AsVal_long(argv[3], &val4);
 
18463
  if (!SWIG_IsOK(ecode4)) {
 
18464
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_invoke_history_func", 4, argv[3] ));
 
18465
  } 
 
18466
  arg4 = (svn_revnum_t)(val4);
 
18467
  if (argc > 4) {
 
18468
    
 
18469
  }
 
18470
  {
 
18471
    result = (svn_error_t *)svn_repos_invoke_history_func(arg1,arg2,(char const *)arg3,arg4,arg5);
 
18472
    
 
18473
    
 
18474
    
 
18475
  }
 
18476
  {
 
18477
    if (result) {
 
18478
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
18479
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
18480
      svn_swig_rb_handle_svn_error(result);
 
18481
    }
 
18482
    vresult = Qnil;
 
18483
  }
 
18484
  {
 
18485
    VALUE target;
 
18486
    target = _global_vresult_address == &vresult ? self : vresult;
 
18487
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
18488
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
18489
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
18490
  }
 
18491
  return vresult;
 
18492
fail:
 
18493
  {
 
18494
    VALUE target;
 
18495
    target = _global_vresult_address == &vresult ? self : vresult;
 
18496
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
18497
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
18498
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
18499
  }
 
18500
  return Qnil;
 
18501
}
 
18502
 
 
18503
 
 
18504
SWIGINTERN VALUE
17063
18505
_wrap_svn_repos_invoke_file_rev_handler(int argc, VALUE *argv, VALUE self) {
17064
18506
  svn_repos_file_rev_handler_t arg1 = (svn_repos_file_rev_handler_t) 0 ;
17065
18507
  void *arg2 = (void *) 0 ;
17166
18608
 
17167
18609
 
17168
18610
SWIGINTERN VALUE
17169
 
_wrap_svn_repos_invoke_notify_func(int argc, VALUE *argv, VALUE self) {
17170
 
  svn_repos_notify_func_t arg1 = (svn_repos_notify_func_t) 0 ;
17171
 
  void *arg2 = (void *) 0 ;
17172
 
  svn_repos_notify_t *arg3 = (svn_repos_notify_t *) 0 ;
17173
 
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
17174
 
  VALUE _global_svn_swig_rb_pool ;
17175
 
  apr_pool_t *_global_pool ;
17176
 
  int res2 ;
17177
 
  void *argp3 = 0 ;
17178
 
  int res3 = 0 ;
17179
 
  
17180
 
  {
17181
 
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
17182
 
    _global_pool = arg4;
17183
 
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
17184
 
  }
17185
 
  if ((argc < 3) || (argc > 4)) {
17186
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
17187
 
  }
17188
 
  {
17189
 
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void);
17190
 
    if (!SWIG_IsOK(res)) {
17191
 
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_notify_func_t","svn_repos_invoke_notify_func", 1, argv[0] )); 
17192
 
    }
17193
 
  }
17194
 
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
17195
 
  if (!SWIG_IsOK(res2)) {
17196
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_repos_invoke_notify_func", 2, argv[1] )); 
17197
 
  }
17198
 
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_svn_repos_notify_t, 0 |  0 );
17199
 
  if (!SWIG_IsOK(res3)) {
17200
 
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "svn_repos_notify_t const *","svn_repos_invoke_notify_func", 3, argv[2] )); 
17201
 
  }
17202
 
  arg3 = (svn_repos_notify_t *)(argp3);
17203
 
  if (argc > 3) {
17204
 
    
17205
 
  }
17206
 
  {
17207
 
    svn_repos_invoke_notify_func(arg1,arg2,(struct svn_repos_notify_t const *)arg3,arg4);
17208
 
    
17209
 
    
17210
 
    
17211
 
  }
17212
 
  {
17213
 
    VALUE target;
17214
 
    target = _global_vresult_address == &vresult ? self : vresult;
17215
 
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
17216
 
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
17217
 
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
17218
 
  }
17219
 
  return Qnil;
17220
 
fail:
17221
 
  {
17222
 
    VALUE target;
17223
 
    target = _global_vresult_address == &vresult ? self : vresult;
17224
 
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
17225
 
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
17226
 
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
17227
 
  }
17228
 
  return Qnil;
17229
 
}
17230
 
 
17231
 
 
17232
 
SWIGINTERN VALUE
17233
 
_wrap_svn_repos_invoke_freeze_func(int argc, VALUE *argv, VALUE self) {
17234
 
  svn_repos_freeze_func_t arg1 = (svn_repos_freeze_func_t) 0 ;
17235
 
  void *arg2 = (void *) 0 ;
17236
 
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
17237
 
  VALUE _global_svn_swig_rb_pool ;
17238
 
  apr_pool_t *_global_pool ;
17239
 
  int res2 ;
17240
 
  svn_error_t *result = 0 ;
17241
 
  VALUE vresult = Qnil;
17242
 
  
17243
 
  {
17244
 
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
17245
 
    _global_pool = arg3;
17246
 
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
17247
 
  }
17248
 
  if ((argc < 2) || (argc > 3)) {
17249
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
17250
 
  }
17251
 
  {
17252
 
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t);
17253
 
    if (!SWIG_IsOK(res)) {
17254
 
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_freeze_func_t","svn_repos_invoke_freeze_func", 1, argv[0] )); 
17255
 
    }
17256
 
  }
17257
 
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
17258
 
  if (!SWIG_IsOK(res2)) {
17259
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_repos_invoke_freeze_func", 2, argv[1] )); 
17260
 
  }
17261
 
  if (argc > 2) {
17262
 
    
17263
 
  }
17264
 
  {
17265
 
    result = (svn_error_t *)svn_repos_invoke_freeze_func(arg1,arg2,arg3);
17266
 
    
17267
 
    
17268
 
    
17269
 
  }
17270
 
  {
17271
 
    if (result) {
17272
 
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
17273
 
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
17274
 
      svn_swig_rb_handle_svn_error(result);
17275
 
    }
17276
 
    vresult = Qnil;
17277
 
  }
17278
 
  {
17279
 
    VALUE target;
17280
 
    target = _global_vresult_address == &vresult ? self : vresult;
17281
 
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
17282
 
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
17283
 
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
17284
 
  }
17285
 
  return vresult;
17286
 
fail:
17287
 
  {
17288
 
    VALUE target;
17289
 
    target = _global_vresult_address == &vresult ? self : vresult;
17290
 
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
17291
 
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
17292
 
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
17293
 
  }
17294
 
  return Qnil;
17295
 
}
17296
 
 
17297
 
 
17298
 
SWIGINTERN VALUE
17299
 
_wrap_svn_repos_invoke_history_func(int argc, VALUE *argv, VALUE self) {
17300
 
  svn_repos_history_func_t arg1 = (svn_repos_history_func_t) 0 ;
17301
 
  void *arg2 = (void *) 0 ;
17302
 
  char *arg3 = (char *) 0 ;
17303
 
  svn_revnum_t arg4 ;
 
18611
_wrap_svn_repos_invoke_verify_callback(int argc, VALUE *argv, VALUE self) {
 
18612
  svn_repos_verify_callback_t arg1 = (svn_repos_verify_callback_t) 0 ;
 
18613
  void *arg2 = (void *) 0 ;
 
18614
  svn_revnum_t arg3 ;
 
18615
  svn_error_t *arg4 = (svn_error_t *) 0 ;
17304
18616
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
17305
18617
  VALUE _global_svn_swig_rb_pool ;
17306
18618
  apr_pool_t *_global_pool ;
17307
18619
  int res2 ;
17308
 
  long val4 ;
17309
 
  int ecode4 = 0 ;
 
18620
  long val3 ;
 
18621
  int ecode3 = 0 ;
 
18622
  void *argp4 = 0 ;
 
18623
  int res4 = 0 ;
17310
18624
  svn_error_t *result = 0 ;
17311
18625
  VALUE vresult = Qnil;
17312
18626
  
17319
18633
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
17320
18634
  }
17321
18635
  {
17322
 
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t);
 
18636
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t);
17323
18637
    if (!SWIG_IsOK(res)) {
17324
 
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_history_func_t","svn_repos_invoke_history_func", 1, argv[0] )); 
 
18638
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_repos_verify_callback_t","svn_repos_invoke_verify_callback", 1, argv[0] )); 
17325
18639
    }
17326
18640
  }
17327
18641
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
17328
18642
  if (!SWIG_IsOK(res2)) {
17329
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_repos_invoke_history_func", 2, argv[1] )); 
17330
 
  }
17331
 
  {
17332
 
    arg3 = StringValueCStr(argv[2]);
17333
 
  }
17334
 
  ecode4 = SWIG_AsVal_long(argv[3], &val4);
17335
 
  if (!SWIG_IsOK(ecode4)) {
17336
 
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_invoke_history_func", 4, argv[3] ));
 
18643
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_repos_invoke_verify_callback", 2, argv[1] )); 
 
18644
  }
 
18645
  ecode3 = SWIG_AsVal_long(argv[2], &val3);
 
18646
  if (!SWIG_IsOK(ecode3)) {
 
18647
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "svn_revnum_t","svn_repos_invoke_verify_callback", 3, argv[2] ));
17337
18648
  } 
17338
 
  arg4 = (svn_revnum_t)(val4);
 
18649
  arg3 = (svn_revnum_t)(val3);
 
18650
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_svn_error_t, 0 |  0 );
 
18651
  if (!SWIG_IsOK(res4)) {
 
18652
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "svn_error_t *","svn_repos_invoke_verify_callback", 4, argv[3] )); 
 
18653
  }
 
18654
  arg4 = (svn_error_t *)(argp4);
17339
18655
  if (argc > 4) {
17340
18656
    
17341
18657
  }
17342
18658
  {
17343
 
    result = (svn_error_t *)svn_repos_invoke_history_func(arg1,arg2,(char const *)arg3,arg4,arg5);
 
18659
    result = (svn_error_t *)svn_repos_invoke_verify_callback(arg1,arg2,arg3,arg4,arg5);
17344
18660
    
17345
18661
    
17346
18662
    
17397
18713
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};
17398
18714
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};
17399
18715
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};
 
18716
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};
17400
18717
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};
17401
18718
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};
17402
18719
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};
17403
18720
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};
17404
18721
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};
17405
18722
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};
 
18723
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};
17406
18724
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};
17407
18725
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};
17408
18726
static swig_type_info _swigt__p_int = {"_p_int", "int *|svn_boolean_t *|apr_status_t *", 0, 0, (void*)0, 0};
17422
18740
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};
17423
18741
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};
17424
18742
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};
 
18743
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};
17425
18744
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
17426
18745
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};
17427
18746
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};
17456
18775
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};
17457
18776
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};
17458
18777
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};
 
18778
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};
 
18779
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};
17459
18780
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};
17460
18781
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};
 
18782
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};
 
18783
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};
 
18784
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};
17461
18785
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};
17462
18786
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};
17463
18787
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};
17465
18789
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};
17466
18790
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};
17467
18791
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};
 
18792
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};
17468
18793
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};
17469
18794
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};
17470
18795
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};
17534
18859
  &_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,
17535
18860
  &_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t,
17536
18861
  &_swigt__p_f_p_void_p_q_const__char__p_svn_error_t,
 
18862
  &_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,
17537
18863
  &_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t,
17538
18864
  &_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,
17539
18865
  &_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,
17540
18866
  &_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
17541
18867
  &_swigt__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
17542
18868
  &_swigt__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t,
 
18869
  &_swigt__p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
17543
18870
  &_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,
17544
18871
  &_swigt__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t,
17545
18872
  &_swigt__p_int,
17559
18886
  &_swigt__p_p_svn_repos_t,
17560
18887
  &_swigt__p_p_svn_stream_t,
17561
18888
  &_swigt__p_p_svn_string_t,
 
18889
  &_swigt__p_p_svn_version_t,
17562
18890
  &_swigt__p_p_void,
17563
18891
  &_swigt__p_svn_auth_baton_t,
17564
18892
  &_swigt__p_svn_auth_cred_simple_t,
17593
18921
  &_swigt__p_svn_error_t,
17594
18922
  &_swigt__p_svn_fs_access_t,
17595
18923
  &_swigt__p_svn_fs_dirent_t,
 
18924
  &_swigt__p_svn_fs_fsfs_info_t,
 
18925
  &_swigt__p_svn_fs_fsx_info_t,
17596
18926
  &_swigt__p_svn_fs_history_t,
17597
18927
  &_swigt__p_svn_fs_id_t,
 
18928
  &_swigt__p_svn_fs_info_placeholder_t,
 
18929
  &_swigt__p_svn_fs_lock_target_t,
 
18930
  &_swigt__p_svn_fs_node_relation_t,
17598
18931
  &_swigt__p_svn_fs_pack_notify_action_t,
17599
18932
  &_swigt__p_svn_fs_path_change2_t,
17600
18933
  &_swigt__p_svn_fs_path_change_kind_t,
17602
18935
  &_swigt__p_svn_fs_root_t,
17603
18936
  &_swigt__p_svn_fs_t,
17604
18937
  &_swigt__p_svn_fs_txn_t,
 
18938
  &_swigt__p_svn_fs_upgrade_notify_action_t,
17605
18939
  &_swigt__p_svn_io_dirent2_t,
17606
18940
  &_swigt__p_svn_io_dirent_t,
17607
18941
  &_swigt__p_svn_io_file_del_t,
17671
19005
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}};
17672
19006
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}};
17673
19007
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}};
 
19008
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}};
17674
19009
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}};
17675
19010
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}};
17676
19011
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}};
17677
19012
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}};
17678
19013
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}};
17679
19014
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}};
 
19015
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}};
17680
19016
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}};
17681
19017
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}};
17682
19018
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
17696
19032
static swig_cast_info _swigc__p_p_svn_repos_t[] = {  {&_swigt__p_p_svn_repos_t, 0, 0, 0},{0, 0, 0, 0}};
17697
19033
static swig_cast_info _swigc__p_p_svn_stream_t[] = {  {&_swigt__p_p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
17698
19034
static swig_cast_info _swigc__p_p_svn_string_t[] = {  {&_swigt__p_p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
 
19035
static swig_cast_info _swigc__p_p_svn_version_t[] = {  {&_swigt__p_p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
17699
19036
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
17700
19037
static swig_cast_info _swigc__p_svn_auth_baton_t[] = {  {&_swigt__p_svn_auth_baton_t, 0, 0, 0},{0, 0, 0, 0}};
17701
19038
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}};
17730
19067
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
17731
19068
static swig_cast_info _swigc__p_svn_fs_access_t[] = {  {&_swigt__p_svn_fs_access_t, 0, 0, 0},{0, 0, 0, 0}};
17732
19069
static swig_cast_info _swigc__p_svn_fs_dirent_t[] = {  {&_swigt__p_svn_fs_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
 
19070
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}};
 
19071
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}};
17733
19072
static swig_cast_info _swigc__p_svn_fs_history_t[] = {  {&_swigt__p_svn_fs_history_t, 0, 0, 0},{0, 0, 0, 0}};
17734
19073
static swig_cast_info _swigc__p_svn_fs_id_t[] = {  {&_swigt__p_svn_fs_id_t, 0, 0, 0},{0, 0, 0, 0}};
 
19074
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}};
 
19075
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}};
 
19076
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}};
17735
19077
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}};
17736
19078
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}};
17737
19079
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}};
17739
19081
static swig_cast_info _swigc__p_svn_fs_root_t[] = {  {&_swigt__p_svn_fs_root_t, 0, 0, 0},{0, 0, 0, 0}};
17740
19082
static swig_cast_info _swigc__p_svn_fs_t[] = {  {&_swigt__p_svn_fs_t, 0, 0, 0},{0, 0, 0, 0}};
17741
19083
static swig_cast_info _swigc__p_svn_fs_txn_t[] = {  {&_swigt__p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
 
19084
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}};
17742
19085
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
17743
19086
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
17744
19087
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}};
17808
19151
  _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,
17809
19152
  _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t,
17810
19153
  _swigc__p_f_p_void_p_q_const__char__p_svn_error_t,
 
19154
  _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,
17811
19155
  _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t,
17812
19156
  _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,
17813
19157
  _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,
17814
19158
  _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
17815
19159
  _swigc__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
17816
19160
  _swigc__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t,
 
19161
  _swigc__p_f_p_void_svn_revnum_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
17817
19162
  _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,
17818
19163
  _swigc__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t,
17819
19164
  _swigc__p_int,
17833
19178
  _swigc__p_p_svn_repos_t,
17834
19179
  _swigc__p_p_svn_stream_t,
17835
19180
  _swigc__p_p_svn_string_t,
 
19181
  _swigc__p_p_svn_version_t,
17836
19182
  _swigc__p_p_void,
17837
19183
  _swigc__p_svn_auth_baton_t,
17838
19184
  _swigc__p_svn_auth_cred_simple_t,
17867
19213
  _swigc__p_svn_error_t,
17868
19214
  _swigc__p_svn_fs_access_t,
17869
19215
  _swigc__p_svn_fs_dirent_t,
 
19216
  _swigc__p_svn_fs_fsfs_info_t,
 
19217
  _swigc__p_svn_fs_fsx_info_t,
17870
19218
  _swigc__p_svn_fs_history_t,
17871
19219
  _swigc__p_svn_fs_id_t,
 
19220
  _swigc__p_svn_fs_info_placeholder_t,
 
19221
  _swigc__p_svn_fs_lock_target_t,
 
19222
  _swigc__p_svn_fs_node_relation_t,
17872
19223
  _swigc__p_svn_fs_pack_notify_action_t,
17873
19224
  _swigc__p_svn_fs_path_change2_t,
17874
19225
  _swigc__p_svn_fs_path_change_kind_t,
17876
19227
  _swigc__p_svn_fs_root_t,
17877
19228
  _swigc__p_svn_fs_t,
17878
19229
  _swigc__p_svn_fs_txn_t,
 
19230
  _swigc__p_svn_fs_upgrade_notify_action_t,
17879
19231
  _swigc__p_svn_io_dirent2_t,
17880
19232
  _swigc__p_svn_io_dirent_t,
17881
19233
  _swigc__p_svn_io_file_del_t,
17929
19281
 
17930
19282
/* -----------------------------------------------------------------------------
17931
19283
 * Type initialization:
17932
 
 * This problem is tough by the requirement that no dynamic 
17933
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
19284
 * This problem is tough by the requirement that no dynamic
 
19285
 * memory is used. Also, since swig_type_info structures store pointers to
17934
19286
 * swig_cast_info structures and swig_cast_info structures store pointers back
17935
 
 * to swig_type_info structures, we need some lookup code at initialization. 
17936
 
 * The idea is that swig generates all the structures that are needed. 
17937
 
 * The runtime then collects these partially filled structures. 
17938
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
19287
 * to swig_type_info structures, we need some lookup code at initialization.
 
19288
 * The idea is that swig generates all the structures that are needed.
 
19289
 * The runtime then collects these partially filled structures.
 
19290
 * The SWIG_InitializeModule function takes these initial arrays out of
17939
19291
 * swig_module, and does all the lookup, filling in the swig_module.types
17940
19292
 * array with the correct data and linking the correct swig_cast_info
17941
19293
 * structures together.
17942
19294
 *
17943
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
19295
 * The generated swig_type_info structures are assigned staticly to an initial
17944
19296
 * array. We just loop through that array, and handle each type individually.
17945
19297
 * First we lookup if this type has been already loaded, and if so, use the
17946
19298
 * loaded structure instead of the generated one. Then we have to fill in the
17950
19302
 * a column is one of the swig_cast_info structures for that type.
17951
19303
 * The cast_initial array is actually an array of arrays, because each row has
17952
19304
 * a variable number of columns. So to actually build the cast linked list,
17953
 
 * we find the array of casts associated with the type, and loop through it 
 
19305
 * we find the array of casts associated with the type, and loop through it
17954
19306
 * adding the casts to the list. The one last trick we need to do is making
17955
19307
 * sure the type pointer in the swig_cast_info struct is correct.
17956
19308
 *
17957
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
19309
 * First off, we lookup the cast->type name to see if it is already loaded.
17958
19310
 * There are three cases to handle:
17959
19311
 *  1) If the cast->type has already been loaded AND the type we are adding
17960
19312
 *     casting info to has not been loaded (it is in this module), THEN we
17961
19313
 *     replace the cast->type pointer with the type pointer that has already
17962
19314
 *     been loaded.
17963
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
19315
 *  2) If BOTH types (the one we are adding casting info to, and the
17964
19316
 *     cast->type) are loaded, THEN the cast info has already been loaded by
17965
19317
 *     the previous module so we just ignore it.
17966
19318
 *  3) Finally, if cast->type has not already been loaded, then we add that
18023
19375
    module_head->next = &swig_module;
18024
19376
  }
18025
19377
 
18026
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
19378
  /* When multiple interpreters are used, a module could have already been initialized in
18027
19379
     a different interpreter, but not yet have a pointer in this interpreter.
18028
19380
     In this case, we do not want to continue adding types... everything should be
18029
19381
     set up already */
18037
19389
    swig_type_info *type = 0;
18038
19390
    swig_type_info *ret;
18039
19391
    swig_cast_info *cast;
18040
 
  
 
19392
 
18041
19393
#ifdef SWIGRUNTIME_DEBUG
18042
19394
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
18043
19395
#endif
18064
19416
    /* Insert casting types */
18065
19417
    cast = swig_module.cast_initial[i];
18066
19418
    while (cast->type) {
18067
 
    
 
19419
 
18068
19420
      /* Don't need to add information already in the list */
18069
19421
      ret = 0;
18070
19422
#ifdef SWIGRUNTIME_DEBUG
18192
19544
  rb_define_const(mRepos, "Svn_node_action_add", SWIG_From_int((int)(svn_node_action_add)));
18193
19545
  rb_define_const(mRepos, "Svn_node_action_delete", SWIG_From_int((int)(svn_node_action_delete)));
18194
19546
  rb_define_const(mRepos, "Svn_node_action_replace", SWIG_From_int((int)(svn_node_action_replace)));
18195
 
  rb_define_const(mRepos, "Svn_repos_load_uuid_default", SWIG_From_int((int)(svn_repos_load_uuid_default)));
18196
 
  rb_define_const(mRepos, "Svn_repos_load_uuid_ignore", SWIG_From_int((int)(svn_repos_load_uuid_ignore)));
18197
 
  rb_define_const(mRepos, "Svn_repos_load_uuid_force", SWIG_From_int((int)(svn_repos_load_uuid_force)));
18198
19547
  rb_define_const(mRepos, "Svn_authz_none", SWIG_From_int((int)(svn_authz_none)));
18199
19548
  rb_define_const(mRepos, "Svn_authz_read", SWIG_From_int((int)(svn_authz_read)));
18200
19549
  rb_define_const(mRepos, "Svn_authz_write", SWIG_From_int((int)(svn_authz_write)));
18219
19568
  rb_define_const(mRepos, "Svn_repos_notify_upgrade_start", SWIG_From_int((int)(svn_repos_notify_upgrade_start)));
18220
19569
  rb_define_const(mRepos, "Svn_repos_notify_load_skipped_rev", SWIG_From_int((int)(svn_repos_notify_load_skipped_rev)));
18221
19570
  rb_define_const(mRepos, "Svn_repos_notify_verify_rev_structure", SWIG_From_int((int)(svn_repos_notify_verify_rev_structure)));
 
19571
  rb_define_const(mRepos, "Svn_repos_notify_pack_revprops", SWIG_From_int((int)(svn_repos_notify_pack_revprops)));
 
19572
  rb_define_const(mRepos, "Svn_repos_notify_cleanup_revprops", SWIG_From_int((int)(svn_repos_notify_cleanup_revprops)));
 
19573
  rb_define_const(mRepos, "Svn_repos_notify_format_bumped", SWIG_From_int((int)(svn_repos_notify_format_bumped)));
 
19574
  rb_define_const(mRepos, "Svn_repos_notify_hotcopy_rev_range", SWIG_From_int((int)(svn_repos_notify_hotcopy_rev_range)));
18222
19575
  rb_define_const(mRepos, "Svn_repos_notify_warning_found_old_reference", SWIG_From_int((int)(svn_repos_notify_warning_found_old_reference)));
18223
19576
  rb_define_const(mRepos, "Svn_repos_notify_warning_found_old_mergeinfo", SWIG_From_int((int)(svn_repos_notify_warning_found_old_mergeinfo)));
18224
19577
  rb_define_const(mRepos, "Svn_repos_notify_warning_invalid_fspath", SWIG_From_int((int)(svn_repos_notify_warning_invalid_fspath)));
 
19578
  rb_define_const(mRepos, "Svn_repos_notify_warning_name_collision", SWIG_From_int((int)(svn_repos_notify_warning_name_collision)));
 
19579
  rb_define_const(mRepos, "Svn_repos_notify_warning_mergeinfo_collision", SWIG_From_int((int)(svn_repos_notify_warning_mergeinfo_collision)));
 
19580
  rb_define_const(mRepos, "Svn_repos_notify_warning_invalid_mergeinfo", SWIG_From_int((int)(svn_repos_notify_warning_invalid_mergeinfo)));
18225
19581
  
18226
19582
  SwigClassSvn_repos_notify_t.klass = rb_define_class_under(mRepos, "Svn_repos_notify_t", rb_cObject);
18227
19583
  SWIG_TypeClientData(SWIGTYPE_p_svn_repos_notify_t, (void *) &SwigClassSvn_repos_notify_t);
18244
19600
  rb_define_method(SwigClassSvn_repos_notify_t.klass, "node_action", _wrap_svn_repos_notify_t_node_action_get, -1);
18245
19601
  rb_define_method(SwigClassSvn_repos_notify_t.klass, "path=", _wrap_svn_repos_notify_t_path_set, -1);
18246
19602
  rb_define_method(SwigClassSvn_repos_notify_t.klass, "path", _wrap_svn_repos_notify_t_path_get, -1);
 
19603
  rb_define_method(SwigClassSvn_repos_notify_t.klass, "start_revision=", _wrap_svn_repos_notify_t_start_revision_set, -1);
 
19604
  rb_define_method(SwigClassSvn_repos_notify_t.klass, "start_revision", _wrap_svn_repos_notify_t_start_revision_get, -1);
 
19605
  rb_define_method(SwigClassSvn_repos_notify_t.klass, "end_revision=", _wrap_svn_repos_notify_t_end_revision_set, -1);
 
19606
  rb_define_method(SwigClassSvn_repos_notify_t.klass, "end_revision", _wrap_svn_repos_notify_t_end_revision_get, -1);
18247
19607
  SwigClassSvn_repos_notify_t.mark = 0;
18248
19608
  SwigClassSvn_repos_notify_t.trackObjects = 0;
18249
19609
  rb_define_module_function(mRepos, "svn_repos_notify_create", _wrap_svn_repos_notify_create, -1);
18250
19610
  rb_define_module_function(mRepos, "svn_repos_find_root_path", _wrap_svn_repos_find_root_path, -1);
 
19611
  rb_define_module_function(mRepos, "svn_repos_open3", _wrap_svn_repos_open3, -1);
18251
19612
  rb_define_module_function(mRepos, "svn_repos_open2", _wrap_svn_repos_open2, -1);
18252
19613
  rb_define_module_function(mRepos, "svn_repos_open", _wrap_svn_repos_open, -1);
18253
19614
  rb_define_module_function(mRepos, "svn_repos_create", _wrap_svn_repos_create, -1);
18255
19616
  rb_define_module_function(mRepos, "svn_repos_upgrade", _wrap_svn_repos_upgrade, -1);
18256
19617
  rb_define_module_function(mRepos, "svn_repos_delete", _wrap_svn_repos_delete, -1);
18257
19618
  rb_define_module_function(mRepos, "svn_repos_has_capability", _wrap_svn_repos_has_capability, -1);
 
19619
  rb_define_module_function(mRepos, "svn_repos_capabilities", _wrap_svn_repos_capabilities, -1);
18258
19620
  rb_define_const(mRepos, "SVN_REPOS_CAPABILITY_MERGEINFO", SWIG_FromCharPtr("mergeinfo"));
 
19621
  rb_define_module_function(mRepos, "svn_repos_remember_client_capabilities", _wrap_svn_repos_remember_client_capabilities, -1);
 
19622
  rb_define_module_function(mRepos, "svn_repos_fs_type", _wrap_svn_repos_fs_type, -1);
 
19623
  rb_define_module_function(mRepos, "svn_repos_hotcopy3", _wrap_svn_repos_hotcopy3, -1);
18259
19624
  rb_define_module_function(mRepos, "svn_repos_hotcopy2", _wrap_svn_repos_hotcopy2, -1);
18260
19625
  rb_define_module_function(mRepos, "svn_repos_hotcopy", _wrap_svn_repos_hotcopy, -1);
18261
19626
  rb_define_module_function(mRepos, "svn_repos_fs_pack2", _wrap_svn_repos_fs_pack2, -1);
18324
19689
  rb_define_module_function(mRepos, "svn_repos_fs_begin_txn_for_commit2", _wrap_svn_repos_fs_begin_txn_for_commit2, -1);
18325
19690
  rb_define_module_function(mRepos, "svn_repos_fs_begin_txn_for_commit", _wrap_svn_repos_fs_begin_txn_for_commit, -1);
18326
19691
  rb_define_module_function(mRepos, "svn_repos_fs_begin_txn_for_update", _wrap_svn_repos_fs_begin_txn_for_update, -1);
 
19692
  rb_define_module_function(mRepos, "svn_repos_fs_lock_many", _wrap_svn_repos_fs_lock_many, -1);
18327
19693
  rb_define_module_function(mRepos, "svn_repos_fs_lock", _wrap_svn_repos_fs_lock, -1);
 
19694
  rb_define_module_function(mRepos, "svn_repos_fs_unlock_many", _wrap_svn_repos_fs_unlock_many, -1);
18328
19695
  rb_define_module_function(mRepos, "svn_repos_fs_unlock", _wrap_svn_repos_fs_unlock, -1);
18329
19696
  rb_define_module_function(mRepos, "svn_repos_fs_get_locks2", _wrap_svn_repos_fs_get_locks2, -1);
18330
19697
  rb_define_module_function(mRepos, "svn_repos_fs_get_locks", _wrap_svn_repos_fs_get_locks, -1);
18335
19702
  rb_define_module_function(mRepos, "svn_repos_fs_revision_prop", _wrap_svn_repos_fs_revision_prop, -1);
18336
19703
  rb_define_module_function(mRepos, "svn_repos_fs_revision_proplist", _wrap_svn_repos_fs_revision_proplist, -1);
18337
19704
  rb_define_module_function(mRepos, "svn_repos_fs_change_node_prop", _wrap_svn_repos_fs_change_node_prop, -1);
 
19705
  rb_define_module_function(mRepos, "svn_repos_fs_get_inherited_props", _wrap_svn_repos_fs_get_inherited_props, -1);
18338
19706
  rb_define_module_function(mRepos, "svn_repos_fs_change_txn_prop", _wrap_svn_repos_fs_change_txn_prop, -1);
18339
19707
  rb_define_module_function(mRepos, "svn_repos_fs_change_txn_props", _wrap_svn_repos_fs_change_txn_props, -1);
18340
19708
  
18365
19733
  SwigClassSvn_repos_node_t.trackObjects = 0;
18366
19734
  rb_define_module_function(mRepos, "svn_repos_node_editor", _wrap_svn_repos_node_editor, -1);
18367
19735
  rb_define_module_function(mRepos, "svn_repos_node_from_baton", _wrap_svn_repos_node_from_baton, -1);
 
19736
  rb_define_module_function(mRepos, "svn_repos_info_format", _wrap_svn_repos_info_format, -1);
18368
19737
  rb_define_const(mRepos, "SVN_REPOS_DUMPFILE_MAGIC_HEADER", SWIG_FromCharPtr("SVN-fs-dump-format-version"));
18369
19738
  rb_define_const(mRepos, "SVN_REPOS_DUMPFILE_FORMAT_VERSION", SWIG_From_int((int)(3)));
18370
19739
  rb_define_const(mRepos, "SVN_REPOS_DUMPFILE_FORMAT_VERSION_DELTAS", SWIG_From_int((int)(3)));
18389
19758
  rb_define_const(mRepos, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_MD5", SWIG_FromCharPtr("Text-delta-base-md5"));
18390
19759
  rb_define_const(mRepos, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_SHA1", SWIG_FromCharPtr("Text-delta-base-sha1"));
18391
19760
  rb_define_const(mRepos, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_CHECKSUM", SWIG_FromCharPtr("Text-delta-base-md5"));
 
19761
  rb_define_const(mRepos, "Svn_repos_load_uuid_default", SWIG_From_int((int)(svn_repos_load_uuid_default)));
 
19762
  rb_define_const(mRepos, "Svn_repos_load_uuid_ignore", SWIG_From_int((int)(svn_repos_load_uuid_ignore)));
 
19763
  rb_define_const(mRepos, "Svn_repos_load_uuid_force", SWIG_From_int((int)(svn_repos_load_uuid_force)));
 
19764
  rb_define_module_function(mRepos, "svn_repos_verify_fs3", _wrap_svn_repos_verify_fs3, -1);
18392
19765
  rb_define_module_function(mRepos, "svn_repos_verify_fs2", _wrap_svn_repos_verify_fs2, -1);
18393
19766
  rb_define_module_function(mRepos, "svn_repos_verify_fs", _wrap_svn_repos_verify_fs, -1);
18394
19767
  rb_define_module_function(mRepos, "svn_repos_dump_fs3", _wrap_svn_repos_dump_fs3, -1);
18395
19768
  rb_define_module_function(mRepos, "svn_repos_dump_fs", _wrap_svn_repos_dump_fs, -1);
 
19769
  rb_define_module_function(mRepos, "svn_repos_load_fs5", _wrap_svn_repos_load_fs5, -1);
18396
19770
  rb_define_module_function(mRepos, "svn_repos_load_fs4", _wrap_svn_repos_load_fs4, -1);
18397
19771
  rb_define_module_function(mRepos, "svn_repos_load_fs3", _wrap_svn_repos_load_fs3, -1);
18398
19772
  rb_define_module_function(mRepos, "svn_repos_load_fs2", _wrap_svn_repos_load_fs2, -1);
18428
19802
  SwigClassSvn_repos_parse_fns3_t.mark = 0;
18429
19803
  SwigClassSvn_repos_parse_fns3_t.trackObjects = 0;
18430
19804
  rb_define_module_function(mRepos, "svn_repos_parse_dumpstream3", _wrap_svn_repos_parse_dumpstream3, -1);
 
19805
  rb_define_module_function(mRepos, "svn_repos_get_fs_build_parser5", _wrap_svn_repos_get_fs_build_parser5, -1);
18431
19806
  rb_define_module_function(mRepos, "svn_repos_get_fs_build_parser4", _wrap_svn_repos_get_fs_build_parser4, -1);
18432
19807
  
18433
19808
  SwigClassSvn_repos_parse_fns2_t.klass = rb_define_class_under(mRepos, "Svn_repos_parse_fns2_t", rb_cObject);
18494
19869
  rb_define_const(mRepos, "Svn_repos_revision_access_partial", SWIG_From_int((int)(svn_repos_revision_access_partial)));
18495
19870
  rb_define_const(mRepos, "Svn_repos_revision_access_full", SWIG_From_int((int)(svn_repos_revision_access_full)));
18496
19871
  rb_define_module_function(mRepos, "svn_repos_check_revision_access", _wrap_svn_repos_check_revision_access, -1);
18497
 
  rb_define_module_function(mRepos, "svn_repos_fs_get_inherited_props", _wrap_svn_repos_fs_get_inherited_props, -1);
18498
 
  rb_define_module_function(mRepos, "svn_repos_remember_client_capabilities", _wrap_svn_repos_remember_client_capabilities, -1);
18499
19872
  rb_define_module_function(mRepos, "svn_repos_parse_fns3_invoke_magic_header_record", _wrap_svn_repos_parse_fns3_invoke_magic_header_record, -1);
18500
19873
  rb_define_module_function(mRepos, "svn_repos_parse_fns3_invoke_uuid_record", _wrap_svn_repos_parse_fns3_invoke_uuid_record, -1);
18501
19874
  rb_define_module_function(mRepos, "svn_repos_parse_fns3_invoke_new_revision_record", _wrap_svn_repos_parse_fns3_invoke_new_revision_record, -1);
18521
19894
  rb_define_module_function(mRepos, "svn_repos_parse_fns2_invoke_close_revision", _wrap_svn_repos_parse_fns2_invoke_close_revision, -1);
18522
19895
  rb_define_module_function(mRepos, "svn_repos_invoke_authz_func", _wrap_svn_repos_invoke_authz_func, -1);
18523
19896
  rb_define_module_function(mRepos, "svn_repos_invoke_authz_callback", _wrap_svn_repos_invoke_authz_callback, -1);
18524
 
  rb_define_module_function(mRepos, "svn_repos_invoke_file_rev_handler", _wrap_svn_repos_invoke_file_rev_handler, -1);
18525
19897
  rb_define_module_function(mRepos, "svn_repos_invoke_notify_func", _wrap_svn_repos_invoke_notify_func, -1);
18526
19898
  rb_define_module_function(mRepos, "svn_repos_invoke_freeze_func", _wrap_svn_repos_invoke_freeze_func, -1);
18527
19899
  rb_define_module_function(mRepos, "svn_repos_invoke_history_func", _wrap_svn_repos_invoke_history_func, -1);
 
19900
  rb_define_module_function(mRepos, "svn_repos_invoke_file_rev_handler", _wrap_svn_repos_invoke_file_rev_handler, -1);
 
19901
  rb_define_module_function(mRepos, "svn_repos_invoke_verify_callback", _wrap_svn_repos_invoke_verify_callback, -1);
18528
19902
  
18529
19903
  {
18530
19904
    VALUE cSvnrepos;