← 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_wc.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_wc.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);
1986
1975
#define SWIG_RUBY_THREAD_END_BLOCK
1987
1976
 
1988
1977
 
1989
 
#define SWIGVERSION 0x020009 
 
1978
#define SWIGVERSION 0x020012 
1990
1979
#define SWIG_VERSION SWIGVERSION
1991
1980
 
1992
1981
 
2119
2108
} 
2120
2109
 
2121
2110
 
2122
 
/*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 
2111
/*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
2123
2112
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
2124
2113
{
2125
2114
  VALUE obj = args[0];
2199
2188
    return svn_wc_external_item2_dup(self, pool);
2200
2189
  }
2201
2190
 
2202
 
/*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 
2191
/*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
2203
2192
SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
2204
2193
{
2205
2194
  VALUE obj = args[0];
2711
2700
  } 
2712
2701
  arg5 = (int)(val5);
2713
2702
  {
2714
 
    arg6 = svn_swig_rb_cancel_func;
 
2703
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
2715
2704
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
2716
2705
  }
2717
2706
  if (argc > 5) {
2978
2967
  } 
2979
2968
  arg5 = (int)(val5);
2980
2969
  {
2981
 
    arg6 = svn_swig_rb_cancel_func;
 
2970
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
2982
2971
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
2983
2972
  }
2984
2973
  if (argc > 5) {
3243
3232
  } 
3244
3233
  arg6 = (int)(val6);
3245
3234
  {
3246
 
    arg7 = svn_swig_rb_cancel_func;
 
3235
    arg7 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
3247
3236
    arg8 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
3248
3237
  }
3249
3238
  if (argc > 4) {
3506
3495
  } 
3507
3496
  arg5 = (int)(val5);
3508
3497
  {
3509
 
    arg6 = svn_swig_rb_cancel_func;
 
3498
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
3510
3499
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
3511
3500
  }
3512
3501
  if (argc > 5) {
7350
7339
}
7351
7340
 
7352
7341
 
7353
 
static swig_class SwigClassSvn_wc_conflict_description2_t;
7354
 
 
7355
 
SWIGINTERN VALUE
7356
 
_wrap_svn_wc_conflict_description2_t_local_abspath_set(int argc, VALUE *argv, VALUE self) {
7357
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7358
 
  char *arg2 = (char *) 0 ;
7359
 
  void *argp1 = 0 ;
7360
 
  int res1 = 0 ;
7361
 
  int res2 ;
7362
 
  char *buf2 = 0 ;
7363
 
  int alloc2 = 0 ;
7364
 
  
7365
 
  if ((argc < 1) || (argc > 1)) {
7366
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7367
 
  }
7368
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7369
 
  if (!SWIG_IsOK(res1)) {
7370
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","local_abspath", 1, self )); 
7371
 
  }
7372
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7373
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7374
 
  if (!SWIG_IsOK(res2)) {
7375
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","local_abspath", 2, argv[0] ));
7376
 
  }
7377
 
  arg2 = (char *)(buf2);
7378
 
  {
7379
 
    apr_size_t len = strlen(arg2) + 1;
7380
 
    char *copied;
7381
 
    if (arg1->local_abspath) free((char *)arg1->local_abspath);
7382
 
    copied = malloc(len);
7383
 
    memcpy(copied, arg2, len);
7384
 
    arg1->local_abspath = copied;
7385
 
  }
7386
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7387
 
  return Qnil;
7388
 
fail:
7389
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7390
 
  return Qnil;
7391
 
}
7392
 
 
7393
 
 
7394
 
SWIGINTERN VALUE
7395
 
_wrap_svn_wc_conflict_description2_t_local_abspath_get(int argc, VALUE *argv, VALUE self) {
7396
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7397
 
  void *argp1 = 0 ;
7398
 
  int res1 = 0 ;
7399
 
  char *result = 0 ;
7400
 
  VALUE vresult = Qnil;
7401
 
  
7402
 
  if ((argc < 0) || (argc > 0)) {
7403
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7404
 
  }
7405
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7406
 
  if (!SWIG_IsOK(res1)) {
7407
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","local_abspath", 1, self )); 
7408
 
  }
7409
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7410
 
  result = (char *) ((arg1)->local_abspath);
7411
 
  {
7412
 
    if (result) {
7413
 
      vresult = rb_str_new2(result);
7414
 
    } else {
7415
 
      vresult = Qnil;
7416
 
    }
7417
 
  }
7418
 
  return vresult;
7419
 
fail:
7420
 
  return Qnil;
7421
 
}
7422
 
 
7423
 
 
7424
 
SWIGINTERN VALUE
7425
 
_wrap_svn_wc_conflict_description2_t_node_kind_set(int argc, VALUE *argv, VALUE self) {
7426
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7427
 
  svn_node_kind_t arg2 ;
7428
 
  void *argp1 = 0 ;
7429
 
  int res1 = 0 ;
7430
 
  int val2 ;
7431
 
  int ecode2 = 0 ;
7432
 
  
7433
 
  if ((argc < 1) || (argc > 1)) {
7434
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7435
 
  }
7436
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7437
 
  if (!SWIG_IsOK(res1)) {
7438
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","node_kind", 1, self )); 
7439
 
  }
7440
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7441
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
7442
 
  if (!SWIG_IsOK(ecode2)) {
7443
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_node_kind_t","node_kind", 2, argv[0] ));
7444
 
  } 
7445
 
  arg2 = (svn_node_kind_t)(val2);
7446
 
  if (arg1) (arg1)->node_kind = arg2;
7447
 
  return Qnil;
7448
 
fail:
7449
 
  return Qnil;
7450
 
}
7451
 
 
7452
 
 
7453
 
SWIGINTERN VALUE
7454
 
_wrap_svn_wc_conflict_description2_t_node_kind_get(int argc, VALUE *argv, VALUE self) {
7455
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7456
 
  void *argp1 = 0 ;
7457
 
  int res1 = 0 ;
7458
 
  svn_node_kind_t result;
7459
 
  VALUE vresult = Qnil;
7460
 
  
7461
 
  if ((argc < 0) || (argc > 0)) {
7462
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7463
 
  }
7464
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7465
 
  if (!SWIG_IsOK(res1)) {
7466
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","node_kind", 1, self )); 
7467
 
  }
7468
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7469
 
  result = (svn_node_kind_t) ((arg1)->node_kind);
7470
 
  vresult = SWIG_From_int((int)(result));
7471
 
  return vresult;
7472
 
fail:
7473
 
  return Qnil;
7474
 
}
7475
 
 
7476
 
 
7477
 
SWIGINTERN VALUE
7478
 
_wrap_svn_wc_conflict_description2_t_kind_set(int argc, VALUE *argv, VALUE self) {
7479
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7480
 
  svn_wc_conflict_kind_t arg2 ;
7481
 
  void *argp1 = 0 ;
7482
 
  int res1 = 0 ;
7483
 
  int val2 ;
7484
 
  int ecode2 = 0 ;
7485
 
  
7486
 
  if ((argc < 1) || (argc > 1)) {
7487
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7488
 
  }
7489
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7490
 
  if (!SWIG_IsOK(res1)) {
7491
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","kind", 1, self )); 
7492
 
  }
7493
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7494
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
7495
 
  if (!SWIG_IsOK(ecode2)) {
7496
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_wc_conflict_kind_t","kind", 2, argv[0] ));
7497
 
  } 
7498
 
  arg2 = (svn_wc_conflict_kind_t)(val2);
7499
 
  if (arg1) (arg1)->kind = arg2;
7500
 
  return Qnil;
7501
 
fail:
7502
 
  return Qnil;
7503
 
}
7504
 
 
7505
 
 
7506
 
SWIGINTERN VALUE
7507
 
_wrap_svn_wc_conflict_description2_t_kind_get(int argc, VALUE *argv, VALUE self) {
7508
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7509
 
  void *argp1 = 0 ;
7510
 
  int res1 = 0 ;
7511
 
  svn_wc_conflict_kind_t result;
7512
 
  VALUE vresult = Qnil;
7513
 
  
7514
 
  if ((argc < 0) || (argc > 0)) {
7515
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7516
 
  }
7517
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7518
 
  if (!SWIG_IsOK(res1)) {
7519
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","kind", 1, self )); 
7520
 
  }
7521
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7522
 
  result = (svn_wc_conflict_kind_t) ((arg1)->kind);
7523
 
  vresult = SWIG_From_int((int)(result));
7524
 
  return vresult;
7525
 
fail:
7526
 
  return Qnil;
7527
 
}
7528
 
 
7529
 
 
7530
 
SWIGINTERN VALUE
7531
 
_wrap_svn_wc_conflict_description2_t_property_name_set(int argc, VALUE *argv, VALUE self) {
7532
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7533
 
  char *arg2 = (char *) 0 ;
7534
 
  void *argp1 = 0 ;
7535
 
  int res1 = 0 ;
7536
 
  int res2 ;
7537
 
  char *buf2 = 0 ;
7538
 
  int alloc2 = 0 ;
7539
 
  
7540
 
  if ((argc < 1) || (argc > 1)) {
7541
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7542
 
  }
7543
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7544
 
  if (!SWIG_IsOK(res1)) {
7545
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","property_name", 1, self )); 
7546
 
  }
7547
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7548
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7549
 
  if (!SWIG_IsOK(res2)) {
7550
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","property_name", 2, argv[0] ));
7551
 
  }
7552
 
  arg2 = (char *)(buf2);
7553
 
  {
7554
 
    apr_size_t len = strlen(arg2) + 1;
7555
 
    char *copied;
7556
 
    if (arg1->property_name) free((char *)arg1->property_name);
7557
 
    copied = malloc(len);
7558
 
    memcpy(copied, arg2, len);
7559
 
    arg1->property_name = copied;
7560
 
  }
7561
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7562
 
  return Qnil;
7563
 
fail:
7564
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7565
 
  return Qnil;
7566
 
}
7567
 
 
7568
 
 
7569
 
SWIGINTERN VALUE
7570
 
_wrap_svn_wc_conflict_description2_t_property_name_get(int argc, VALUE *argv, VALUE self) {
7571
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7572
 
  void *argp1 = 0 ;
7573
 
  int res1 = 0 ;
7574
 
  char *result = 0 ;
7575
 
  VALUE vresult = Qnil;
7576
 
  
7577
 
  if ((argc < 0) || (argc > 0)) {
7578
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7579
 
  }
7580
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7581
 
  if (!SWIG_IsOK(res1)) {
7582
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","property_name", 1, self )); 
7583
 
  }
7584
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7585
 
  result = (char *) ((arg1)->property_name);
7586
 
  {
7587
 
    if (result) {
7588
 
      vresult = rb_str_new2(result);
7589
 
    } else {
7590
 
      vresult = Qnil;
7591
 
    }
7592
 
  }
7593
 
  return vresult;
7594
 
fail:
7595
 
  return Qnil;
7596
 
}
7597
 
 
7598
 
 
7599
 
SWIGINTERN VALUE
7600
 
_wrap_svn_wc_conflict_description2_t_is_binary_set(int argc, VALUE *argv, VALUE self) {
7601
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7602
 
  svn_boolean_t arg2 ;
7603
 
  void *argp1 = 0 ;
7604
 
  int res1 = 0 ;
7605
 
  
7606
 
  if ((argc < 1) || (argc > 1)) {
7607
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7608
 
  }
7609
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7610
 
  if (!SWIG_IsOK(res1)) {
7611
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","is_binary", 1, self )); 
7612
 
  }
7613
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7614
 
  arg2 = RTEST(argv[0]);
7615
 
  if (arg1) (arg1)->is_binary = arg2;
7616
 
  return Qnil;
7617
 
fail:
7618
 
  return Qnil;
7619
 
}
7620
 
 
7621
 
 
7622
 
SWIGINTERN VALUE
7623
 
_wrap_svn_wc_conflict_description2_t_is_binary_get(int argc, VALUE *argv, VALUE self) {
7624
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7625
 
  void *argp1 = 0 ;
7626
 
  int res1 = 0 ;
7627
 
  svn_boolean_t result;
7628
 
  VALUE vresult = Qnil;
7629
 
  
7630
 
  if ((argc < 0) || (argc > 0)) {
7631
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7632
 
  }
7633
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7634
 
  if (!SWIG_IsOK(res1)) {
7635
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","is_binary", 1, self )); 
7636
 
  }
7637
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7638
 
  result = (svn_boolean_t) ((arg1)->is_binary);
7639
 
  vresult = result ? Qtrue : Qfalse;
7640
 
  return vresult;
7641
 
fail:
7642
 
  return Qnil;
7643
 
}
7644
 
 
7645
 
 
7646
 
SWIGINTERN VALUE
7647
 
_wrap_svn_wc_conflict_description2_t_mime_type_set(int argc, VALUE *argv, VALUE self) {
7648
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7649
 
  char *arg2 = (char *) 0 ;
7650
 
  void *argp1 = 0 ;
7651
 
  int res1 = 0 ;
7652
 
  int res2 ;
7653
 
  char *buf2 = 0 ;
7654
 
  int alloc2 = 0 ;
7655
 
  
7656
 
  if ((argc < 1) || (argc > 1)) {
7657
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7658
 
  }
7659
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7660
 
  if (!SWIG_IsOK(res1)) {
7661
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","mime_type", 1, self )); 
7662
 
  }
7663
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7664
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7665
 
  if (!SWIG_IsOK(res2)) {
7666
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","mime_type", 2, argv[0] ));
7667
 
  }
7668
 
  arg2 = (char *)(buf2);
7669
 
  {
7670
 
    apr_size_t len = strlen(arg2) + 1;
7671
 
    char *copied;
7672
 
    if (arg1->mime_type) free((char *)arg1->mime_type);
7673
 
    copied = malloc(len);
7674
 
    memcpy(copied, arg2, len);
7675
 
    arg1->mime_type = copied;
7676
 
  }
7677
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7678
 
  return Qnil;
7679
 
fail:
7680
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7681
 
  return Qnil;
7682
 
}
7683
 
 
7684
 
 
7685
 
SWIGINTERN VALUE
7686
 
_wrap_svn_wc_conflict_description2_t_mime_type_get(int argc, VALUE *argv, VALUE self) {
7687
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7688
 
  void *argp1 = 0 ;
7689
 
  int res1 = 0 ;
7690
 
  char *result = 0 ;
7691
 
  VALUE vresult = Qnil;
7692
 
  
7693
 
  if ((argc < 0) || (argc > 0)) {
7694
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7695
 
  }
7696
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7697
 
  if (!SWIG_IsOK(res1)) {
7698
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","mime_type", 1, self )); 
7699
 
  }
7700
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7701
 
  result = (char *) ((arg1)->mime_type);
7702
 
  {
7703
 
    if (result) {
7704
 
      vresult = rb_str_new2(result);
7705
 
    } else {
7706
 
      vresult = Qnil;
7707
 
    }
7708
 
  }
7709
 
  return vresult;
7710
 
fail:
7711
 
  return Qnil;
7712
 
}
7713
 
 
7714
 
 
7715
 
SWIGINTERN VALUE
7716
 
_wrap_svn_wc_conflict_description2_t_action_set(int argc, VALUE *argv, VALUE self) {
7717
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7718
 
  svn_wc_conflict_action_t arg2 ;
7719
 
  void *argp1 = 0 ;
7720
 
  int res1 = 0 ;
7721
 
  int val2 ;
7722
 
  int ecode2 = 0 ;
7723
 
  
7724
 
  if ((argc < 1) || (argc > 1)) {
7725
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7726
 
  }
7727
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7728
 
  if (!SWIG_IsOK(res1)) {
7729
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","action", 1, self )); 
7730
 
  }
7731
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7732
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
7733
 
  if (!SWIG_IsOK(ecode2)) {
7734
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_wc_conflict_action_t","action", 2, argv[0] ));
7735
 
  } 
7736
 
  arg2 = (svn_wc_conflict_action_t)(val2);
7737
 
  if (arg1) (arg1)->action = arg2;
7738
 
  return Qnil;
7739
 
fail:
7740
 
  return Qnil;
7741
 
}
7742
 
 
7743
 
 
7744
 
SWIGINTERN VALUE
7745
 
_wrap_svn_wc_conflict_description2_t_action_get(int argc, VALUE *argv, VALUE self) {
7746
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7747
 
  void *argp1 = 0 ;
7748
 
  int res1 = 0 ;
7749
 
  svn_wc_conflict_action_t result;
7750
 
  VALUE vresult = Qnil;
7751
 
  
7752
 
  if ((argc < 0) || (argc > 0)) {
7753
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7754
 
  }
7755
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7756
 
  if (!SWIG_IsOK(res1)) {
7757
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","action", 1, self )); 
7758
 
  }
7759
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7760
 
  result = (svn_wc_conflict_action_t) ((arg1)->action);
7761
 
  vresult = SWIG_From_int((int)(result));
7762
 
  return vresult;
7763
 
fail:
7764
 
  return Qnil;
7765
 
}
7766
 
 
7767
 
 
7768
 
SWIGINTERN VALUE
7769
 
_wrap_svn_wc_conflict_description2_t_reason_set(int argc, VALUE *argv, VALUE self) {
7770
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7771
 
  svn_wc_conflict_reason_t arg2 ;
7772
 
  void *argp1 = 0 ;
7773
 
  int res1 = 0 ;
7774
 
  int val2 ;
7775
 
  int ecode2 = 0 ;
7776
 
  
7777
 
  if ((argc < 1) || (argc > 1)) {
7778
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7779
 
  }
7780
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7781
 
  if (!SWIG_IsOK(res1)) {
7782
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","reason", 1, self )); 
7783
 
  }
7784
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7785
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
7786
 
  if (!SWIG_IsOK(ecode2)) {
7787
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_wc_conflict_reason_t","reason", 2, argv[0] ));
7788
 
  } 
7789
 
  arg2 = (svn_wc_conflict_reason_t)(val2);
7790
 
  if (arg1) (arg1)->reason = arg2;
7791
 
  return Qnil;
7792
 
fail:
7793
 
  return Qnil;
7794
 
}
7795
 
 
7796
 
 
7797
 
SWIGINTERN VALUE
7798
 
_wrap_svn_wc_conflict_description2_t_reason_get(int argc, VALUE *argv, VALUE self) {
7799
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7800
 
  void *argp1 = 0 ;
7801
 
  int res1 = 0 ;
7802
 
  svn_wc_conflict_reason_t result;
7803
 
  VALUE vresult = Qnil;
7804
 
  
7805
 
  if ((argc < 0) || (argc > 0)) {
7806
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7807
 
  }
7808
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7809
 
  if (!SWIG_IsOK(res1)) {
7810
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","reason", 1, self )); 
7811
 
  }
7812
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7813
 
  result = (svn_wc_conflict_reason_t) ((arg1)->reason);
7814
 
  vresult = SWIG_From_int((int)(result));
7815
 
  return vresult;
7816
 
fail:
7817
 
  return Qnil;
7818
 
}
7819
 
 
7820
 
 
7821
 
SWIGINTERN VALUE
7822
 
_wrap_svn_wc_conflict_description2_t_base_abspath_set(int argc, VALUE *argv, VALUE self) {
7823
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7824
 
  char *arg2 = (char *) 0 ;
7825
 
  void *argp1 = 0 ;
7826
 
  int res1 = 0 ;
7827
 
  int res2 ;
7828
 
  char *buf2 = 0 ;
7829
 
  int alloc2 = 0 ;
7830
 
  
7831
 
  if ((argc < 1) || (argc > 1)) {
7832
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7833
 
  }
7834
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7835
 
  if (!SWIG_IsOK(res1)) {
7836
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","base_abspath", 1, self )); 
7837
 
  }
7838
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7839
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7840
 
  if (!SWIG_IsOK(res2)) {
7841
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","base_abspath", 2, argv[0] ));
7842
 
  }
7843
 
  arg2 = (char *)(buf2);
7844
 
  {
7845
 
    apr_size_t len = strlen(arg2) + 1;
7846
 
    char *copied;
7847
 
    if (arg1->base_abspath) free((char *)arg1->base_abspath);
7848
 
    copied = malloc(len);
7849
 
    memcpy(copied, arg2, len);
7850
 
    arg1->base_abspath = copied;
7851
 
  }
7852
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7853
 
  return Qnil;
7854
 
fail:
7855
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7856
 
  return Qnil;
7857
 
}
7858
 
 
7859
 
 
7860
 
SWIGINTERN VALUE
7861
 
_wrap_svn_wc_conflict_description2_t_base_abspath_get(int argc, VALUE *argv, VALUE self) {
7862
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7863
 
  void *argp1 = 0 ;
7864
 
  int res1 = 0 ;
7865
 
  char *result = 0 ;
7866
 
  VALUE vresult = Qnil;
7867
 
  
7868
 
  if ((argc < 0) || (argc > 0)) {
7869
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7870
 
  }
7871
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7872
 
  if (!SWIG_IsOK(res1)) {
7873
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","base_abspath", 1, self )); 
7874
 
  }
7875
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7876
 
  result = (char *) ((arg1)->base_abspath);
7877
 
  {
7878
 
    if (result) {
7879
 
      vresult = rb_str_new2(result);
7880
 
    } else {
7881
 
      vresult = Qnil;
7882
 
    }
7883
 
  }
7884
 
  return vresult;
7885
 
fail:
7886
 
  return Qnil;
7887
 
}
7888
 
 
7889
 
 
7890
 
SWIGINTERN VALUE
7891
 
_wrap_svn_wc_conflict_description2_t_their_abspath_set(int argc, VALUE *argv, VALUE self) {
7892
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7893
 
  char *arg2 = (char *) 0 ;
7894
 
  void *argp1 = 0 ;
7895
 
  int res1 = 0 ;
7896
 
  int res2 ;
7897
 
  char *buf2 = 0 ;
7898
 
  int alloc2 = 0 ;
7899
 
  
7900
 
  if ((argc < 1) || (argc > 1)) {
7901
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7902
 
  }
7903
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7904
 
  if (!SWIG_IsOK(res1)) {
7905
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","their_abspath", 1, self )); 
7906
 
  }
7907
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7908
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7909
 
  if (!SWIG_IsOK(res2)) {
7910
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","their_abspath", 2, argv[0] ));
7911
 
  }
7912
 
  arg2 = (char *)(buf2);
7913
 
  {
7914
 
    apr_size_t len = strlen(arg2) + 1;
7915
 
    char *copied;
7916
 
    if (arg1->their_abspath) free((char *)arg1->their_abspath);
7917
 
    copied = malloc(len);
7918
 
    memcpy(copied, arg2, len);
7919
 
    arg1->their_abspath = copied;
7920
 
  }
7921
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7922
 
  return Qnil;
7923
 
fail:
7924
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7925
 
  return Qnil;
7926
 
}
7927
 
 
7928
 
 
7929
 
SWIGINTERN VALUE
7930
 
_wrap_svn_wc_conflict_description2_t_their_abspath_get(int argc, VALUE *argv, VALUE self) {
7931
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7932
 
  void *argp1 = 0 ;
7933
 
  int res1 = 0 ;
7934
 
  char *result = 0 ;
7935
 
  VALUE vresult = Qnil;
7936
 
  
7937
 
  if ((argc < 0) || (argc > 0)) {
7938
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7939
 
  }
7940
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7941
 
  if (!SWIG_IsOK(res1)) {
7942
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","their_abspath", 1, self )); 
7943
 
  }
7944
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7945
 
  result = (char *) ((arg1)->their_abspath);
7946
 
  {
7947
 
    if (result) {
7948
 
      vresult = rb_str_new2(result);
7949
 
    } else {
7950
 
      vresult = Qnil;
7951
 
    }
7952
 
  }
7953
 
  return vresult;
7954
 
fail:
7955
 
  return Qnil;
7956
 
}
7957
 
 
7958
 
 
7959
 
SWIGINTERN VALUE
7960
 
_wrap_svn_wc_conflict_description2_t_my_abspath_set(int argc, VALUE *argv, VALUE self) {
7961
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
7962
 
  char *arg2 = (char *) 0 ;
7963
 
  void *argp1 = 0 ;
7964
 
  int res1 = 0 ;
7965
 
  int res2 ;
7966
 
  char *buf2 = 0 ;
7967
 
  int alloc2 = 0 ;
7968
 
  
7969
 
  if ((argc < 1) || (argc > 1)) {
7970
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7971
 
  }
7972
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
7973
 
  if (!SWIG_IsOK(res1)) {
7974
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","my_abspath", 1, self )); 
7975
 
  }
7976
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
7977
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7978
 
  if (!SWIG_IsOK(res2)) {
7979
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","my_abspath", 2, argv[0] ));
7980
 
  }
7981
 
  arg2 = (char *)(buf2);
7982
 
  {
7983
 
    apr_size_t len = strlen(arg2) + 1;
7984
 
    char *copied;
7985
 
    if (arg1->my_abspath) free((char *)arg1->my_abspath);
7986
 
    copied = malloc(len);
7987
 
    memcpy(copied, arg2, len);
7988
 
    arg1->my_abspath = copied;
7989
 
  }
7990
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7991
 
  return Qnil;
7992
 
fail:
7993
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7994
 
  return Qnil;
7995
 
}
7996
 
 
7997
 
 
7998
 
SWIGINTERN VALUE
7999
 
_wrap_svn_wc_conflict_description2_t_my_abspath_get(int argc, VALUE *argv, VALUE self) {
8000
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8001
 
  void *argp1 = 0 ;
8002
 
  int res1 = 0 ;
8003
 
  char *result = 0 ;
8004
 
  VALUE vresult = Qnil;
8005
 
  
8006
 
  if ((argc < 0) || (argc > 0)) {
8007
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8008
 
  }
8009
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8010
 
  if (!SWIG_IsOK(res1)) {
8011
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","my_abspath", 1, self )); 
8012
 
  }
8013
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8014
 
  result = (char *) ((arg1)->my_abspath);
8015
 
  {
8016
 
    if (result) {
8017
 
      vresult = rb_str_new2(result);
8018
 
    } else {
8019
 
      vresult = Qnil;
8020
 
    }
8021
 
  }
8022
 
  return vresult;
8023
 
fail:
8024
 
  return Qnil;
8025
 
}
8026
 
 
8027
 
 
8028
 
SWIGINTERN VALUE
8029
 
_wrap_svn_wc_conflict_description2_t_merged_file_set(int argc, VALUE *argv, VALUE self) {
8030
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8031
 
  char *arg2 = (char *) 0 ;
8032
 
  void *argp1 = 0 ;
8033
 
  int res1 = 0 ;
8034
 
  int res2 ;
8035
 
  char *buf2 = 0 ;
8036
 
  int alloc2 = 0 ;
8037
 
  
8038
 
  if ((argc < 1) || (argc > 1)) {
8039
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8040
 
  }
8041
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8042
 
  if (!SWIG_IsOK(res1)) {
8043
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","merged_file", 1, self )); 
8044
 
  }
8045
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8046
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8047
 
  if (!SWIG_IsOK(res2)) {
8048
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","merged_file", 2, argv[0] ));
8049
 
  }
8050
 
  arg2 = (char *)(buf2);
8051
 
  {
8052
 
    apr_size_t len = strlen(arg2) + 1;
8053
 
    char *copied;
8054
 
    if (arg1->merged_file) free((char *)arg1->merged_file);
8055
 
    copied = malloc(len);
8056
 
    memcpy(copied, arg2, len);
8057
 
    arg1->merged_file = copied;
8058
 
  }
8059
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8060
 
  return Qnil;
8061
 
fail:
8062
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8063
 
  return Qnil;
8064
 
}
8065
 
 
8066
 
 
8067
 
SWIGINTERN VALUE
8068
 
_wrap_svn_wc_conflict_description2_t_merged_file_get(int argc, VALUE *argv, VALUE self) {
8069
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8070
 
  void *argp1 = 0 ;
8071
 
  int res1 = 0 ;
8072
 
  char *result = 0 ;
8073
 
  VALUE vresult = Qnil;
8074
 
  
8075
 
  if ((argc < 0) || (argc > 0)) {
8076
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8077
 
  }
8078
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8079
 
  if (!SWIG_IsOK(res1)) {
8080
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","merged_file", 1, self )); 
8081
 
  }
8082
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8083
 
  result = (char *) ((arg1)->merged_file);
8084
 
  {
8085
 
    if (result) {
8086
 
      vresult = rb_str_new2(result);
8087
 
    } else {
8088
 
      vresult = Qnil;
8089
 
    }
8090
 
  }
8091
 
  return vresult;
8092
 
fail:
8093
 
  return Qnil;
8094
 
}
8095
 
 
8096
 
 
8097
 
SWIGINTERN VALUE
8098
 
_wrap_svn_wc_conflict_description2_t_operation_set(int argc, VALUE *argv, VALUE self) {
8099
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8100
 
  svn_wc_operation_t arg2 ;
8101
 
  void *argp1 = 0 ;
8102
 
  int res1 = 0 ;
8103
 
  int val2 ;
8104
 
  int ecode2 = 0 ;
8105
 
  
8106
 
  if ((argc < 1) || (argc > 1)) {
8107
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8108
 
  }
8109
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8110
 
  if (!SWIG_IsOK(res1)) {
8111
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","operation", 1, self )); 
8112
 
  }
8113
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8114
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
8115
 
  if (!SWIG_IsOK(ecode2)) {
8116
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_wc_operation_t","operation", 2, argv[0] ));
8117
 
  } 
8118
 
  arg2 = (svn_wc_operation_t)(val2);
8119
 
  if (arg1) (arg1)->operation = arg2;
8120
 
  return Qnil;
8121
 
fail:
8122
 
  return Qnil;
8123
 
}
8124
 
 
8125
 
 
8126
 
SWIGINTERN VALUE
8127
 
_wrap_svn_wc_conflict_description2_t_operation_get(int argc, VALUE *argv, VALUE self) {
8128
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8129
 
  void *argp1 = 0 ;
8130
 
  int res1 = 0 ;
8131
 
  svn_wc_operation_t result;
8132
 
  VALUE vresult = Qnil;
8133
 
  
8134
 
  if ((argc < 0) || (argc > 0)) {
8135
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8136
 
  }
8137
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8138
 
  if (!SWIG_IsOK(res1)) {
8139
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","operation", 1, self )); 
8140
 
  }
8141
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8142
 
  result = (svn_wc_operation_t) ((arg1)->operation);
8143
 
  vresult = SWIG_From_int((int)(result));
8144
 
  return vresult;
8145
 
fail:
8146
 
  return Qnil;
8147
 
}
8148
 
 
8149
 
 
8150
 
SWIGINTERN VALUE
8151
 
_wrap_svn_wc_conflict_description2_t_src_left_version_set(int argc, VALUE *argv, VALUE self) {
8152
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8153
 
  svn_wc_conflict_version_t *arg2 = (svn_wc_conflict_version_t *) 0 ;
8154
 
  void *argp1 = 0 ;
8155
 
  int res1 = 0 ;
8156
 
  void *argp2 = 0 ;
8157
 
  int res2 = 0 ;
8158
 
  
8159
 
  if ((argc < 1) || (argc > 1)) {
8160
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8161
 
  }
8162
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8163
 
  if (!SWIG_IsOK(res1)) {
8164
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","src_left_version", 1, self )); 
8165
 
  }
8166
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8167
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_svn_wc_conflict_version_t, SWIG_POINTER_DISOWN |  0 );
8168
 
  if (!SWIG_IsOK(res2)) {
8169
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_wc_conflict_version_t const *","src_left_version", 2, argv[0] )); 
8170
 
  }
8171
 
  arg2 = (svn_wc_conflict_version_t *)(argp2);
8172
 
  if (arg1) (arg1)->src_left_version = (svn_wc_conflict_version_t const *)arg2;
8173
 
  return Qnil;
8174
 
fail:
8175
 
  return Qnil;
8176
 
}
8177
 
 
8178
 
 
8179
 
SWIGINTERN VALUE
8180
 
_wrap_svn_wc_conflict_description2_t_src_left_version_get(int argc, VALUE *argv, VALUE self) {
8181
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8182
 
  void *argp1 = 0 ;
8183
 
  int res1 = 0 ;
8184
 
  svn_wc_conflict_version_t *result = 0 ;
8185
 
  VALUE vresult = Qnil;
8186
 
  
8187
 
  if ((argc < 0) || (argc > 0)) {
8188
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8189
 
  }
8190
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8191
 
  if (!SWIG_IsOK(res1)) {
8192
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","src_left_version", 1, self )); 
8193
 
  }
8194
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8195
 
  result = (svn_wc_conflict_version_t *) ((arg1)->src_left_version);
8196
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_wc_conflict_version_t, 0 |  0 );
8197
 
  return vresult;
8198
 
fail:
8199
 
  return Qnil;
8200
 
}
8201
 
 
8202
 
 
8203
 
SWIGINTERN VALUE
8204
 
_wrap_svn_wc_conflict_description2_t_src_right_version_set(int argc, VALUE *argv, VALUE self) {
8205
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8206
 
  svn_wc_conflict_version_t *arg2 = (svn_wc_conflict_version_t *) 0 ;
8207
 
  void *argp1 = 0 ;
8208
 
  int res1 = 0 ;
8209
 
  void *argp2 = 0 ;
8210
 
  int res2 = 0 ;
8211
 
  
8212
 
  if ((argc < 1) || (argc > 1)) {
8213
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8214
 
  }
8215
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8216
 
  if (!SWIG_IsOK(res1)) {
8217
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","src_right_version", 1, self )); 
8218
 
  }
8219
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8220
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_svn_wc_conflict_version_t, SWIG_POINTER_DISOWN |  0 );
8221
 
  if (!SWIG_IsOK(res2)) {
8222
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_wc_conflict_version_t const *","src_right_version", 2, argv[0] )); 
8223
 
  }
8224
 
  arg2 = (svn_wc_conflict_version_t *)(argp2);
8225
 
  if (arg1) (arg1)->src_right_version = (svn_wc_conflict_version_t const *)arg2;
8226
 
  return Qnil;
8227
 
fail:
8228
 
  return Qnil;
8229
 
}
8230
 
 
8231
 
 
8232
 
SWIGINTERN VALUE
8233
 
_wrap_svn_wc_conflict_description2_t_src_right_version_get(int argc, VALUE *argv, VALUE self) {
8234
 
  struct svn_wc_conflict_description2_t *arg1 = (struct svn_wc_conflict_description2_t *) 0 ;
8235
 
  void *argp1 = 0 ;
8236
 
  int res1 = 0 ;
8237
 
  svn_wc_conflict_version_t *result = 0 ;
8238
 
  VALUE vresult = Qnil;
8239
 
  
8240
 
  if ((argc < 0) || (argc > 0)) {
8241
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8242
 
  }
8243
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
8244
 
  if (!SWIG_IsOK(res1)) {
8245
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_description2_t *","src_right_version", 1, self )); 
8246
 
  }
8247
 
  arg1 = (struct svn_wc_conflict_description2_t *)(argp1);
8248
 
  result = (svn_wc_conflict_version_t *) ((arg1)->src_right_version);
8249
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_wc_conflict_version_t, 0 |  0 );
8250
 
  return vresult;
8251
 
fail:
8252
 
  return Qnil;
8253
 
}
8254
 
 
8255
 
 
8256
 
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
8257
 
SWIGINTERN VALUE
8258
 
_wrap_svn_wc_conflict_description2_t_allocate(VALUE self) {
8259
 
#else
8260
 
  SWIGINTERN VALUE
8261
 
  _wrap_svn_wc_conflict_description2_t_allocate(int argc, VALUE *argv, VALUE self) {
8262
 
#endif
8263
 
    
8264
 
    
8265
 
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_svn_wc_conflict_description2_t);
8266
 
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
8267
 
    rb_obj_call_init(vresult, argc, argv);
8268
 
#endif
8269
 
    return vresult;
8270
 
  }
8271
 
  
8272
 
 
8273
 
SWIGINTERN VALUE
8274
 
_wrap_new_svn_wc_conflict_description2_t(int argc, VALUE *argv, VALUE self) {
8275
 
  struct svn_wc_conflict_description2_t *result = 0 ;
8276
 
  
8277
 
  if ((argc < 0) || (argc > 0)) {
8278
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8279
 
  }
8280
 
  {
8281
 
    result = (struct svn_wc_conflict_description2_t *)calloc(1, sizeof(struct svn_wc_conflict_description2_t));
8282
 
    DATA_PTR(self) = result;
8283
 
    
8284
 
    
8285
 
    
8286
 
  }
8287
 
  return self;
8288
 
fail:
8289
 
  return Qnil;
8290
 
}
8291
 
 
8292
 
 
8293
 
SWIGINTERN void
8294
 
free_svn_wc_conflict_description2_t(struct svn_wc_conflict_description2_t *arg1) {
8295
 
    free((char *) arg1);
8296
 
}
8297
 
 
8298
7342
static swig_class SwigClassSvn_wc_conflict_description_t;
8299
7343
 
8300
7344
SWIGINTERN VALUE
9762
8806
 
9763
8807
 
9764
8808
SWIGINTERN VALUE
 
8809
_wrap_svn_wc_conflict_description2_dup(int argc, VALUE *argv, VALUE self) {
 
8810
  svn_wc_conflict_description2_t *arg1 = (svn_wc_conflict_description2_t *) 0 ;
 
8811
  apr_pool_t *arg2 = (apr_pool_t *) 0 ;
 
8812
  VALUE _global_svn_swig_rb_pool ;
 
8813
  apr_pool_t *_global_pool ;
 
8814
  void *argp1 = 0 ;
 
8815
  int res1 = 0 ;
 
8816
  svn_wc_conflict_description2_t *result = 0 ;
 
8817
  VALUE vresult = Qnil;
 
8818
  
 
8819
  {
 
8820
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
 
8821
    _global_pool = arg2;
 
8822
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
8823
  }
 
8824
  if ((argc < 1) || (argc > 2)) {
 
8825
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
 
8826
  }
 
8827
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
 
8828
  if (!SWIG_IsOK(res1)) {
 
8829
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_wc_conflict_description2_t const *","svn_wc_conflict_description2_dup", 1, argv[0] )); 
 
8830
  }
 
8831
  arg1 = (svn_wc_conflict_description2_t *)(argp1);
 
8832
  if (argc > 1) {
 
8833
    
 
8834
  }
 
8835
  {
 
8836
    result = (svn_wc_conflict_description2_t *)svn_wc_conflict_description2_dup((struct svn_wc_conflict_description2_t const *)arg1,arg2);
 
8837
    
 
8838
    
 
8839
    
 
8840
  }
 
8841
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_wc_conflict_description2_t, 0 |  0 );
 
8842
  {
 
8843
    VALUE target;
 
8844
    target = _global_vresult_address == &vresult ? self : vresult;
 
8845
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
8846
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
8847
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
8848
  }
 
8849
  return vresult;
 
8850
fail:
 
8851
  {
 
8852
    VALUE target;
 
8853
    target = _global_vresult_address == &vresult ? self : vresult;
 
8854
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
8855
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
8856
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
8857
  }
 
8858
  return Qnil;
 
8859
}
 
8860
 
 
8861
 
 
8862
SWIGINTERN VALUE
9765
8863
_wrap_svn_wc__conflict_description2_dup(int argc, VALUE *argv, VALUE self) {
9766
8864
  svn_wc_conflict_description2_t *arg1 = (svn_wc_conflict_description2_t *) 0 ;
9767
8865
  apr_pool_t *arg2 = (apr_pool_t *) 0 ;
9815
8913
}
9816
8914
 
9817
8915
 
9818
 
static swig_class SwigClassSvn_wc_conflict_result_t;
9819
 
 
9820
 
SWIGINTERN VALUE
9821
 
_wrap_svn_wc_conflict_result_t_choice_set(int argc, VALUE *argv, VALUE self) {
9822
 
  struct svn_wc_conflict_result_t *arg1 = (struct svn_wc_conflict_result_t *) 0 ;
9823
 
  svn_wc_conflict_choice_t arg2 ;
9824
 
  void *argp1 = 0 ;
9825
 
  int res1 = 0 ;
9826
 
  int val2 ;
9827
 
  int ecode2 = 0 ;
9828
 
  
9829
 
  if ((argc < 1) || (argc > 1)) {
9830
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9831
 
  }
9832
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_result_t, 0 |  0 );
9833
 
  if (!SWIG_IsOK(res1)) {
9834
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_result_t *","choice", 1, self )); 
9835
 
  }
9836
 
  arg1 = (struct svn_wc_conflict_result_t *)(argp1);
9837
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
9838
 
  if (!SWIG_IsOK(ecode2)) {
9839
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_wc_conflict_choice_t","choice", 2, argv[0] ));
9840
 
  } 
9841
 
  arg2 = (svn_wc_conflict_choice_t)(val2);
9842
 
  if (arg1) (arg1)->choice = arg2;
9843
 
  return Qnil;
9844
 
fail:
9845
 
  return Qnil;
9846
 
}
9847
 
 
9848
 
 
9849
 
SWIGINTERN VALUE
9850
 
_wrap_svn_wc_conflict_result_t_choice_get(int argc, VALUE *argv, VALUE self) {
9851
 
  struct svn_wc_conflict_result_t *arg1 = (struct svn_wc_conflict_result_t *) 0 ;
9852
 
  void *argp1 = 0 ;
9853
 
  int res1 = 0 ;
9854
 
  svn_wc_conflict_choice_t result;
9855
 
  VALUE vresult = Qnil;
9856
 
  
9857
 
  if ((argc < 0) || (argc > 0)) {
9858
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9859
 
  }
9860
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_result_t, 0 |  0 );
9861
 
  if (!SWIG_IsOK(res1)) {
9862
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_result_t *","choice", 1, self )); 
9863
 
  }
9864
 
  arg1 = (struct svn_wc_conflict_result_t *)(argp1);
9865
 
  result = (svn_wc_conflict_choice_t) ((arg1)->choice);
9866
 
  vresult = SWIG_From_int((int)(result));
9867
 
  return vresult;
9868
 
fail:
9869
 
  return Qnil;
9870
 
}
9871
 
 
9872
 
 
9873
 
SWIGINTERN VALUE
9874
 
_wrap_svn_wc_conflict_result_t_merged_file_set(int argc, VALUE *argv, VALUE self) {
9875
 
  struct svn_wc_conflict_result_t *arg1 = (struct svn_wc_conflict_result_t *) 0 ;
9876
 
  char *arg2 = (char *) 0 ;
9877
 
  void *argp1 = 0 ;
9878
 
  int res1 = 0 ;
9879
 
  int res2 ;
9880
 
  char *buf2 = 0 ;
9881
 
  int alloc2 = 0 ;
9882
 
  
9883
 
  if ((argc < 1) || (argc > 1)) {
9884
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9885
 
  }
9886
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_result_t, 0 |  0 );
9887
 
  if (!SWIG_IsOK(res1)) {
9888
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_result_t *","merged_file", 1, self )); 
9889
 
  }
9890
 
  arg1 = (struct svn_wc_conflict_result_t *)(argp1);
9891
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
9892
 
  if (!SWIG_IsOK(res2)) {
9893
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","merged_file", 2, argv[0] ));
9894
 
  }
9895
 
  arg2 = (char *)(buf2);
9896
 
  {
9897
 
    apr_size_t len = strlen(arg2) + 1;
9898
 
    char *copied;
9899
 
    if (arg1->merged_file) free((char *)arg1->merged_file);
9900
 
    copied = malloc(len);
9901
 
    memcpy(copied, arg2, len);
9902
 
    arg1->merged_file = copied;
9903
 
  }
9904
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9905
 
  return Qnil;
9906
 
fail:
9907
 
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9908
 
  return Qnil;
9909
 
}
9910
 
 
9911
 
 
9912
 
SWIGINTERN VALUE
9913
 
_wrap_svn_wc_conflict_result_t_merged_file_get(int argc, VALUE *argv, VALUE self) {
9914
 
  struct svn_wc_conflict_result_t *arg1 = (struct svn_wc_conflict_result_t *) 0 ;
9915
 
  void *argp1 = 0 ;
9916
 
  int res1 = 0 ;
9917
 
  char *result = 0 ;
9918
 
  VALUE vresult = Qnil;
9919
 
  
9920
 
  if ((argc < 0) || (argc > 0)) {
9921
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9922
 
  }
9923
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_result_t, 0 |  0 );
9924
 
  if (!SWIG_IsOK(res1)) {
9925
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_result_t *","merged_file", 1, self )); 
9926
 
  }
9927
 
  arg1 = (struct svn_wc_conflict_result_t *)(argp1);
9928
 
  result = (char *) ((arg1)->merged_file);
9929
 
  {
9930
 
    if (result) {
9931
 
      vresult = rb_str_new2(result);
9932
 
    } else {
9933
 
      vresult = Qnil;
9934
 
    }
9935
 
  }
9936
 
  return vresult;
9937
 
fail:
9938
 
  return Qnil;
9939
 
}
9940
 
 
9941
 
 
9942
 
SWIGINTERN VALUE
9943
 
_wrap_svn_wc_conflict_result_t_save_merged_set(int argc, VALUE *argv, VALUE self) {
9944
 
  struct svn_wc_conflict_result_t *arg1 = (struct svn_wc_conflict_result_t *) 0 ;
9945
 
  svn_boolean_t arg2 ;
9946
 
  void *argp1 = 0 ;
9947
 
  int res1 = 0 ;
9948
 
  
9949
 
  if ((argc < 1) || (argc > 1)) {
9950
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9951
 
  }
9952
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_result_t, 0 |  0 );
9953
 
  if (!SWIG_IsOK(res1)) {
9954
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_result_t *","save_merged", 1, self )); 
9955
 
  }
9956
 
  arg1 = (struct svn_wc_conflict_result_t *)(argp1);
9957
 
  arg2 = RTEST(argv[0]);
9958
 
  if (arg1) (arg1)->save_merged = arg2;
9959
 
  return Qnil;
9960
 
fail:
9961
 
  return Qnil;
9962
 
}
9963
 
 
9964
 
 
9965
 
SWIGINTERN VALUE
9966
 
_wrap_svn_wc_conflict_result_t_save_merged_get(int argc, VALUE *argv, VALUE self) {
9967
 
  struct svn_wc_conflict_result_t *arg1 = (struct svn_wc_conflict_result_t *) 0 ;
9968
 
  void *argp1 = 0 ;
9969
 
  int res1 = 0 ;
9970
 
  svn_boolean_t result;
9971
 
  VALUE vresult = Qnil;
9972
 
  
9973
 
  if ((argc < 0) || (argc > 0)) {
9974
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9975
 
  }
9976
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_conflict_result_t, 0 |  0 );
9977
 
  if (!SWIG_IsOK(res1)) {
9978
 
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_conflict_result_t *","save_merged", 1, self )); 
9979
 
  }
9980
 
  arg1 = (struct svn_wc_conflict_result_t *)(argp1);
9981
 
  result = (svn_boolean_t) ((arg1)->save_merged);
9982
 
  vresult = result ? Qtrue : Qfalse;
9983
 
  return vresult;
9984
 
fail:
9985
 
  return Qnil;
9986
 
}
9987
 
 
9988
 
 
9989
 
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
9990
 
SWIGINTERN VALUE
9991
 
_wrap_svn_wc_conflict_result_t_allocate(VALUE self) {
9992
 
#else
9993
 
  SWIGINTERN VALUE
9994
 
  _wrap_svn_wc_conflict_result_t_allocate(int argc, VALUE *argv, VALUE self) {
9995
 
#endif
9996
 
    
9997
 
    
9998
 
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_svn_wc_conflict_result_t);
9999
 
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
10000
 
    rb_obj_call_init(vresult, argc, argv);
10001
 
#endif
10002
 
    return vresult;
10003
 
  }
10004
 
  
10005
 
 
10006
 
SWIGINTERN VALUE
10007
 
_wrap_new_svn_wc_conflict_result_t(int argc, VALUE *argv, VALUE self) {
10008
 
  struct svn_wc_conflict_result_t *result = 0 ;
10009
 
  
10010
 
  if ((argc < 0) || (argc > 0)) {
10011
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10012
 
  }
10013
 
  {
10014
 
    result = (struct svn_wc_conflict_result_t *)calloc(1, sizeof(struct svn_wc_conflict_result_t));
10015
 
    DATA_PTR(self) = result;
10016
 
    
10017
 
    
10018
 
    
10019
 
  }
10020
 
  return self;
10021
 
fail:
10022
 
  return Qnil;
10023
 
}
10024
 
 
10025
 
 
10026
 
SWIGINTERN void
10027
 
free_svn_wc_conflict_result_t(struct svn_wc_conflict_result_t *arg1) {
10028
 
    free((char *) arg1);
10029
 
}
10030
 
 
10031
8916
SWIGINTERN VALUE
10032
8917
_wrap_svn_wc_create_conflict_result(int argc, VALUE *argv, VALUE self) {
10033
8918
  svn_wc_conflict_choice_t arg1 ;
16273
15158
  }
16274
15159
  arg2 = (svn_wc_adm_access_t *)(argp2);
16275
15160
  {
16276
 
    arg3 = svn_swig_rb_wc_entry_callbacks2();
 
15161
    arg3 = (svn_wc_entry_callbacks2_t *) svn_swig_rb_wc_entry_callbacks2();
16277
15162
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
16278
15163
  }
16279
15164
  {
16281
15166
  }
16282
15167
  arg6 = RTEST(argv[4]);
16283
15168
  {
16284
 
    arg7 = svn_swig_rb_cancel_func;
 
15169
    arg7 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
16285
15170
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
16286
15171
  }
16287
15172
  if (argc > 6) {
16378
15263
  }
16379
15264
  arg5 = RTEST(argv[4]);
16380
15265
  {
16381
 
    arg6 = svn_swig_rb_cancel_func;
 
15266
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
16382
15267
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
16383
15268
  }
16384
15269
  if (argc > 6) {
18793
17678
}
18794
17679
 
18795
17680
 
 
17681
SWIGINTERN VALUE
 
17682
_wrap_svn_wc_status3_t_actual_kind_set(int argc, VALUE *argv, VALUE self) {
 
17683
  struct svn_wc_status3_t *arg1 = (struct svn_wc_status3_t *) 0 ;
 
17684
  svn_node_kind_t arg2 ;
 
17685
  void *argp1 = 0 ;
 
17686
  int res1 = 0 ;
 
17687
  int val2 ;
 
17688
  int ecode2 = 0 ;
 
17689
  
 
17690
  if ((argc < 1) || (argc > 1)) {
 
17691
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
 
17692
  }
 
17693
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_status3_t, 0 |  0 );
 
17694
  if (!SWIG_IsOK(res1)) {
 
17695
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_status3_t *","actual_kind", 1, self )); 
 
17696
  }
 
17697
  arg1 = (struct svn_wc_status3_t *)(argp1);
 
17698
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
 
17699
  if (!SWIG_IsOK(ecode2)) {
 
17700
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_node_kind_t","actual_kind", 2, argv[0] ));
 
17701
  } 
 
17702
  arg2 = (svn_node_kind_t)(val2);
 
17703
  if (arg1) (arg1)->actual_kind = arg2;
 
17704
  return Qnil;
 
17705
fail:
 
17706
  return Qnil;
 
17707
}
 
17708
 
 
17709
 
 
17710
SWIGINTERN VALUE
 
17711
_wrap_svn_wc_status3_t_actual_kind_get(int argc, VALUE *argv, VALUE self) {
 
17712
  struct svn_wc_status3_t *arg1 = (struct svn_wc_status3_t *) 0 ;
 
17713
  void *argp1 = 0 ;
 
17714
  int res1 = 0 ;
 
17715
  svn_node_kind_t result;
 
17716
  VALUE vresult = Qnil;
 
17717
  
 
17718
  if ((argc < 0) || (argc > 0)) {
 
17719
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
 
17720
  }
 
17721
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_wc_status3_t, 0 |  0 );
 
17722
  if (!SWIG_IsOK(res1)) {
 
17723
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_wc_status3_t *","actual_kind", 1, self )); 
 
17724
  }
 
17725
  arg1 = (struct svn_wc_status3_t *)(argp1);
 
17726
  result = (svn_node_kind_t) ((arg1)->actual_kind);
 
17727
  vresult = SWIG_From_int((int)(result));
 
17728
  return vresult;
 
17729
fail:
 
17730
  return Qnil;
 
17731
}
 
17732
 
 
17733
 
18796
17734
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
18797
17735
SWIGINTERN VALUE
18798
17736
_wrap_svn_wc_status3_t_allocate(VALUE self) {
20781
19719
    SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "void *","svn_wc_walk_status", 9, argv[8] )); 
20782
19720
  }
20783
19721
  {
20784
 
    arg10 = svn_swig_rb_cancel_func;
 
19722
    arg10 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
20785
19723
    arg11 = (void *)svn_swig_rb_make_baton(argv[9], _global_svn_swig_rb_pool);
20786
19724
  }
20787
19725
  if (argc > 10) {
20923
19861
    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "void *","svn_wc_get_status_editor5", 15, argv[10] )); 
20924
19862
  }
20925
19863
  {
20926
 
    arg16 = svn_swig_rb_cancel_func;
 
19864
    arg16 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
20927
19865
    arg17 = (void *)svn_swig_rb_make_baton(argv[11], _global_svn_swig_rb_pool);
20928
19866
  }
20929
19867
  if (argc > 12) {
21083
20021
    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "void *","svn_wc_get_status_editor4", 12, argv[7] )); 
21084
20022
  }
21085
20023
  {
21086
 
    arg13 = svn_swig_rb_cancel_func;
 
20024
    arg13 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
21087
20025
    arg14 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
21088
20026
  }
21089
20027
  res15 = SWIG_ConvertPtr(argv[9], &argp15,SWIGTYPE_p_svn_wc_traversal_info_t, 0 |  0 );
21218
20156
  }
21219
20157
  arg10 = (apr_array_header_t *)(argp10);
21220
20158
  {
21221
 
    arg11 = svn_swig_rb_wc_status_func;
 
20159
    arg11 = (svn_wc_status_func2_t) svn_swig_rb_wc_status_func;
21222
20160
    arg12 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
21223
20161
  }
21224
20162
  {
21225
 
    arg13 = svn_swig_rb_cancel_func;
 
20163
    arg13 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
21226
20164
    arg14 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
21227
20165
  }
21228
20166
  res15 = SWIG_ConvertPtr(argv[8], &argp15,SWIGTYPE_p_svn_wc_traversal_info_t, 0 |  0 );
21355
20293
  arg9 = RTEST(argv[4]);
21356
20294
  arg10 = RTEST(argv[5]);
21357
20295
  {
21358
 
    arg11 = svn_swig_rb_wc_status_func;
 
20296
    arg11 = (svn_wc_status_func2_t) svn_swig_rb_wc_status_func;
21359
20297
    arg12 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
21360
20298
  }
21361
20299
  {
21362
 
    arg13 = svn_swig_rb_cancel_func;
 
20300
    arg13 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
21363
20301
    arg14 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
21364
20302
  }
21365
20303
  res15 = SWIG_ConvertPtr(argv[8], &argp15,SWIGTYPE_p_svn_wc_traversal_info_t, 0 |  0 );
21500
20438
    SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "void *","svn_wc_get_status_editor", 11, argv[7] )); 
21501
20439
  }
21502
20440
  {
21503
 
    arg12 = svn_swig_rb_cancel_func;
 
20441
    arg12 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
21504
20442
    arg13 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
21505
20443
  }
21506
20444
  res14 = SWIG_ConvertPtr(argv[9], &argp14,SWIGTYPE_p_svn_wc_traversal_info_t, 0 |  0 );
21689
20627
  arg3 = (char *)(buf3);
21690
20628
  arg4 = RTEST(argv[3]);
21691
20629
  {
21692
 
    arg5 = svn_swig_rb_cancel_func;
 
20630
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
21693
20631
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
21694
20632
  }
21695
20633
  {
21696
 
    arg7 = svn_swig_rb_notify_func2;
 
20634
    arg7 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
21697
20635
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
21698
20636
  }
21699
20637
  if (argc > 6) {
21787
20725
  }
21788
20726
  arg3 = (char *)(buf3);
21789
20727
  {
21790
 
    arg4 = svn_swig_rb_cancel_func;
 
20728
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
21791
20729
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
21792
20730
  }
21793
20731
  {
21794
 
    arg6 = svn_swig_rb_notify_func2;
 
20732
    arg6 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
21795
20733
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
21796
20734
  }
21797
20735
  if (argc > 5) {
21886
20824
  }
21887
20825
  arg3 = (char *)(buf3);
21888
20826
  {
21889
 
    arg4 = svn_swig_rb_cancel_func;
 
20827
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
21890
20828
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
21891
20829
  }
21892
20830
  {
21992
20930
  arg3 = (char *)(buf3);
21993
20931
  arg4 = RTEST(argv[3]);
21994
20932
  {
21995
 
    arg5 = svn_swig_rb_cancel_func;
 
20933
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
21996
20934
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
21997
20935
  }
21998
20936
  {
21999
 
    arg7 = svn_swig_rb_notify_func2;
 
20937
    arg7 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22000
20938
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
22001
20939
  }
22002
20940
  if (argc > 6) {
22085
21023
  arg3 = RTEST(argv[2]);
22086
21024
  arg4 = RTEST(argv[3]);
22087
21025
  {
22088
 
    arg5 = svn_swig_rb_cancel_func;
 
21026
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
22089
21027
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
22090
21028
  }
22091
21029
  {
22092
 
    arg7 = svn_swig_rb_notify_func2;
 
21030
    arg7 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22093
21031
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
22094
21032
  }
22095
21033
  if (argc > 6) {
22173
21111
  }
22174
21112
  arg2 = (svn_wc_adm_access_t *)(argp2);
22175
21113
  {
22176
 
    arg3 = svn_swig_rb_cancel_func;
 
21114
    arg3 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
22177
21115
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
22178
21116
  }
22179
21117
  {
22180
 
    arg5 = svn_swig_rb_notify_func2;
 
21118
    arg5 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22181
21119
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
22182
21120
  }
22183
21121
  arg7 = RTEST(argv[4]);
22261
21199
  }
22262
21200
  arg2 = (svn_wc_adm_access_t *)(argp2);
22263
21201
  {
22264
 
    arg3 = svn_swig_rb_cancel_func;
 
21202
    arg3 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
22265
21203
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
22266
21204
  }
22267
21205
  {
22268
 
    arg5 = svn_swig_rb_notify_func2;
 
21206
    arg5 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22269
21207
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
22270
21208
  }
22271
21209
  if (argc > 4) {
22349
21287
  }
22350
21288
  arg2 = (svn_wc_adm_access_t *)(argp2);
22351
21289
  {
22352
 
    arg3 = svn_swig_rb_cancel_func;
 
21290
    arg3 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
22353
21291
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
22354
21292
  }
22355
21293
  {
22405
21343
 
22406
21344
 
22407
21345
SWIGINTERN VALUE
 
21346
_wrap_svn_wc_add_from_disk3(int argc, VALUE *argv, VALUE self) {
 
21347
  svn_wc_context_t *arg1 = (svn_wc_context_t *) 0 ;
 
21348
  char *arg2 = (char *) 0 ;
 
21349
  apr_hash_t *arg3 = (apr_hash_t *) 0 ;
 
21350
  svn_boolean_t arg4 ;
 
21351
  svn_wc_notify_func2_t arg5 = (svn_wc_notify_func2_t) 0 ;
 
21352
  void *arg6 = (void *) 0 ;
 
21353
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
 
21354
  VALUE _global_svn_swig_rb_pool ;
 
21355
  apr_pool_t *_global_pool ;
 
21356
  void *argp1 = 0 ;
 
21357
  int res1 = 0 ;
 
21358
  int res2 ;
 
21359
  char *buf2 = 0 ;
 
21360
  int alloc2 = 0 ;
 
21361
  svn_error_t *result = 0 ;
 
21362
  VALUE vresult = Qnil;
 
21363
  
 
21364
  {
 
21365
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
 
21366
    _global_pool = arg7;
 
21367
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
21368
  }
 
21369
  if ((argc < 5) || (argc > 6)) {
 
21370
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
 
21371
  }
 
21372
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_wc_context_t, 0 |  0 );
 
21373
  if (!SWIG_IsOK(res1)) {
 
21374
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_wc_context_t *","svn_wc_add_from_disk3", 1, argv[0] )); 
 
21375
  }
 
21376
  arg1 = (svn_wc_context_t *)(argp1);
 
21377
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
 
21378
  if (!SWIG_IsOK(res2)) {
 
21379
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_wc_add_from_disk3", 2, argv[1] ));
 
21380
  }
 
21381
  arg2 = (char *)(buf2);
 
21382
  {
 
21383
    VALUE rb_pool = Qnil;
 
21384
    if (!_global_pool) {
 
21385
      svn_swig_rb_get_pool(argc, argv, self, &rb_pool, &_global_pool);
 
21386
      svn_swig_rb_push_pool(rb_pool);
 
21387
    }
 
21388
    arg3 = svn_swig_rb_hash_to_apr_hash_svn_string(argv[2], _global_pool);
 
21389
    _global_pool = NULL;
 
21390
    if (!NIL_P(rb_pool)) {
 
21391
      if (NIL_P(arg3)) {
 
21392
        svn_swig_rb_destroy_pool(rb_pool);
 
21393
      } else {
 
21394
        svn_swig_rb_set_pool_for_no_swig_type(argv[2], rb_pool);
 
21395
      }
 
21396
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
21397
    }
 
21398
  }
 
21399
  arg4 = RTEST(argv[3]);
 
21400
  {
 
21401
    arg5 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
 
21402
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
 
21403
  }
 
21404
  if (argc > 5) {
 
21405
    
 
21406
  }
 
21407
  {
 
21408
    result = (svn_error_t *)svn_wc_add_from_disk3(arg1,(char const *)arg2,(apr_hash_t const *)arg3,arg4,arg5,arg6,arg7);
 
21409
    
 
21410
    
 
21411
    
 
21412
  }
 
21413
  {
 
21414
    if (result) {
 
21415
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
21416
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
21417
      svn_swig_rb_handle_svn_error(result);
 
21418
    }
 
21419
    vresult = Qnil;
 
21420
  }
 
21421
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
21422
  {
 
21423
    VALUE target;
 
21424
    target = _global_vresult_address == &vresult ? self : vresult;
 
21425
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
21426
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
21427
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
21428
  }
 
21429
  return vresult;
 
21430
fail:
 
21431
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
21432
  {
 
21433
    VALUE target;
 
21434
    target = _global_vresult_address == &vresult ? self : vresult;
 
21435
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
21436
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
21437
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
21438
  }
 
21439
  return Qnil;
 
21440
}
 
21441
 
 
21442
 
 
21443
SWIGINTERN VALUE
22408
21444
_wrap_svn_wc_add_from_disk2(int argc, VALUE *argv, VALUE self) {
22409
21445
  svn_wc_context_t *arg1 = (svn_wc_context_t *) 0 ;
22410
21446
  char *arg2 = (char *) 0 ;
22458
21494
    }
22459
21495
  }
22460
21496
  {
22461
 
    arg4 = svn_swig_rb_notify_func2;
 
21497
    arg4 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22462
21498
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
22463
21499
  }
22464
21500
  if (argc > 4) {
22536
21572
  }
22537
21573
  arg2 = (char *)(buf2);
22538
21574
  {
22539
 
    arg3 = svn_swig_rb_notify_func2;
 
21575
    arg3 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22540
21576
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
22541
21577
  }
22542
21578
  if (argc > 3) {
22636
21672
  } 
22637
21673
  arg5 = (svn_revnum_t)(val5);
22638
21674
  {
22639
 
    arg6 = svn_swig_rb_cancel_func;
 
21675
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
22640
21676
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
22641
21677
  }
22642
21678
  {
22643
 
    arg8 = svn_swig_rb_notify_func2;
 
21679
    arg8 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22644
21680
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
22645
21681
  }
22646
21682
  if (argc > 7) {
22743
21779
  } 
22744
21780
  arg5 = (svn_revnum_t)(val5);
22745
21781
  {
22746
 
    arg6 = svn_swig_rb_cancel_func;
 
21782
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
22747
21783
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
22748
21784
  }
22749
21785
  {
22750
 
    arg8 = svn_swig_rb_notify_func2;
 
21786
    arg8 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22751
21787
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
22752
21788
  }
22753
21789
  if (argc > 7) {
22846
21882
  } 
22847
21883
  arg4 = (svn_revnum_t)(val4);
22848
21884
  {
22849
 
    arg5 = svn_swig_rb_cancel_func;
 
21885
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
22850
21886
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
22851
21887
  }
22852
21888
  {
22853
 
    arg7 = svn_swig_rb_notify_func2;
 
21889
    arg7 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
22854
21890
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
22855
21891
  }
22856
21892
  if (argc > 6) {
22950
21986
  } 
22951
21987
  arg4 = (svn_revnum_t)(val4);
22952
21988
  {
22953
 
    arg5 = svn_swig_rb_cancel_func;
 
21989
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
22954
21990
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
22955
21991
  }
22956
21992
  {
23101
22137
  } 
23102
22138
  arg8 = (svn_revnum_t)(val8);
23103
22139
  {
23104
 
    arg9 = svn_swig_rb_cancel_func;
 
22140
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
23105
22141
    arg10 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
23106
22142
  }
23107
22143
  if (argc > 9) {
23244
22280
  } 
23245
22281
  arg8 = (svn_revnum_t)(val8);
23246
22282
  {
23247
 
    arg9 = svn_swig_rb_cancel_func;
 
22283
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
23248
22284
    arg10 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
23249
22285
  }
23250
22286
  {
23251
 
    arg11 = svn_swig_rb_notify_func2;
 
22287
    arg11 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
23252
22288
    arg12 = (void *)svn_swig_rb_make_baton(argv[9], _global_svn_swig_rb_pool);
23253
22289
  }
23254
22290
  if (argc > 10) {
23590
22626
  arg3 = RTEST(argv[2]);
23591
22627
  arg4 = RTEST(argv[3]);
23592
22628
  {
23593
 
    arg5 = svn_swig_rb_cancel_func;
 
22629
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
23594
22630
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
23595
22631
  }
23596
22632
  if (argc > 5) {
23675
22711
  arg3 = RTEST(argv[2]);
23676
22712
  arg4 = RTEST(argv[3]);
23677
22713
  {
23678
 
    arg5 = svn_swig_rb_cancel_func;
 
22714
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
23679
22715
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
23680
22716
  }
23681
22717
  if (argc > 5) {
23783
22819
  } 
23784
22820
  arg7 = (svn_wc_conflict_choice_t)(val7);
23785
22821
  {
23786
 
    arg8 = svn_swig_rb_cancel_func;
 
22822
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
23787
22823
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
23788
22824
  }
23789
22825
  {
23790
 
    arg10 = svn_swig_rb_notify_func2;
 
22826
    arg10 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
23791
22827
    arg11 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
23792
22828
  }
23793
22829
  if (argc > 9) {
23890
22926
  } 
23891
22927
  arg7 = (svn_wc_conflict_choice_t)(val7);
23892
22928
  {
23893
 
    arg8 = svn_swig_rb_notify_func2;
 
22929
    arg8 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
23894
22930
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
23895
22931
  }
23896
22932
  {
23897
 
    arg10 = svn_swig_rb_cancel_func;
 
22933
    arg10 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
23898
22934
    arg11 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
23899
22935
  }
23900
22936
  if (argc > 9) {
23993
23029
  } 
23994
23030
  arg6 = (svn_wc_conflict_choice_t)(val6);
23995
23031
  {
23996
 
    arg7 = svn_swig_rb_notify_func2;
 
23032
    arg7 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
23997
23033
    arg8 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
23998
23034
  }
23999
23035
  {
24000
 
    arg9 = svn_swig_rb_cancel_func;
 
23036
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
24001
23037
    arg10 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
24002
23038
  }
24003
23039
  if (argc > 8) {
24086
23122
  arg4 = RTEST(argv[3]);
24087
23123
  arg5 = RTEST(argv[4]);
24088
23124
  {
24089
 
    arg6 = svn_swig_rb_notify_func2;
 
23125
    arg6 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
24090
23126
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
24091
23127
  }
24092
23128
  {
24093
 
    arg8 = svn_swig_rb_cancel_func;
 
23129
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
24094
23130
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
24095
23131
  }
24096
23132
  if (argc > 7) {
24227
23263
 
24228
23264
 
24229
23265
SWIGINTERN VALUE
 
23266
_wrap_svn_wc_queue_committed4(int argc, VALUE *argv, VALUE self) {
 
23267
  svn_wc_committed_queue_t *arg1 = (svn_wc_committed_queue_t *) 0 ;
 
23268
  svn_wc_context_t *arg2 = (svn_wc_context_t *) 0 ;
 
23269
  char *arg3 = (char *) 0 ;
 
23270
  svn_boolean_t arg4 ;
 
23271
  svn_boolean_t arg5 ;
 
23272
  apr_array_header_t *arg6 = (apr_array_header_t *) 0 ;
 
23273
  svn_boolean_t arg7 ;
 
23274
  svn_boolean_t arg8 ;
 
23275
  svn_checksum_t *arg9 = (svn_checksum_t *) 0 ;
 
23276
  apr_pool_t *arg10 = (apr_pool_t *) 0 ;
 
23277
  VALUE _global_svn_swig_rb_pool ;
 
23278
  apr_pool_t *_global_pool ;
 
23279
  void *argp1 = 0 ;
 
23280
  int res1 = 0 ;
 
23281
  void *argp2 = 0 ;
 
23282
  int res2 = 0 ;
 
23283
  int res3 ;
 
23284
  char *buf3 = 0 ;
 
23285
  int alloc3 = 0 ;
 
23286
  void *argp9 = 0 ;
 
23287
  int res9 = 0 ;
 
23288
  svn_error_t *result = 0 ;
 
23289
  VALUE vresult = Qnil;
 
23290
  
 
23291
  {
 
23292
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg10);
 
23293
    _global_pool = arg10;
 
23294
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
23295
  }
 
23296
  if ((argc < 9) || (argc > 10)) {
 
23297
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
 
23298
  }
 
23299
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_wc_committed_queue_t, 0 |  0 );
 
23300
  if (!SWIG_IsOK(res1)) {
 
23301
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_wc_committed_queue_t *","svn_wc_queue_committed4", 1, argv[0] )); 
 
23302
  }
 
23303
  arg1 = (svn_wc_committed_queue_t *)(argp1);
 
23304
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_svn_wc_context_t, 0 |  0 );
 
23305
  if (!SWIG_IsOK(res2)) {
 
23306
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_wc_context_t *","svn_wc_queue_committed4", 2, argv[1] )); 
 
23307
  }
 
23308
  arg2 = (svn_wc_context_t *)(argp2);
 
23309
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
 
23310
  if (!SWIG_IsOK(res3)) {
 
23311
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_wc_queue_committed4", 3, argv[2] ));
 
23312
  }
 
23313
  arg3 = (char *)(buf3);
 
23314
  arg4 = RTEST(argv[3]);
 
23315
  arg5 = RTEST(argv[4]);
 
23316
  {
 
23317
    VALUE rb_pool;
 
23318
    apr_pool_t *pool;
 
23319
    
 
23320
    svn_swig_rb_get_pool(argc, argv, self, &rb_pool, &pool);
 
23321
    
 
23322
    arg6 = svn_swig_rb_to_apr_array_prop(argv[5], pool);
 
23323
  }
 
23324
  arg7 = RTEST(argv[6]);
 
23325
  arg8 = RTEST(argv[7]);
 
23326
  res9 = SWIG_ConvertPtr(argv[8], &argp9,SWIGTYPE_p_svn_checksum_t, 0 |  0 );
 
23327
  if (!SWIG_IsOK(res9)) {
 
23328
    SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "svn_checksum_t const *","svn_wc_queue_committed4", 9, argv[8] )); 
 
23329
  }
 
23330
  arg9 = (svn_checksum_t *)(argp9);
 
23331
  if (argc > 9) {
 
23332
    
 
23333
  }
 
23334
  {
 
23335
    result = (svn_error_t *)svn_wc_queue_committed4(arg1,arg2,(char const *)arg3,arg4,arg5,(apr_array_header_t const *)arg6,arg7,arg8,(struct svn_checksum_t const *)arg9,arg10);
 
23336
    
 
23337
    
 
23338
    
 
23339
  }
 
23340
  {
 
23341
    if (result) {
 
23342
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
23343
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
23344
      svn_swig_rb_handle_svn_error(result);
 
23345
    }
 
23346
    vresult = Qnil;
 
23347
  }
 
23348
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
23349
  {
 
23350
    VALUE target;
 
23351
    target = _global_vresult_address == &vresult ? self : vresult;
 
23352
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
23353
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
23354
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
23355
  }
 
23356
  return vresult;
 
23357
fail:
 
23358
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
23359
  {
 
23360
    VALUE target;
 
23361
    target = _global_vresult_address == &vresult ? self : vresult;
 
23362
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
23363
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
23364
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
23365
  }
 
23366
  return Qnil;
 
23367
}
 
23368
 
 
23369
 
 
23370
SWIGINTERN VALUE
24230
23371
_wrap_svn_wc_queue_committed3(int argc, VALUE *argv, VALUE self) {
24231
23372
  svn_wc_committed_queue_t *arg1 = (svn_wc_committed_queue_t *) 0 ;
24232
23373
  svn_wc_context_t *arg2 = (svn_wc_context_t *) 0 ;
24487
23628
  }
24488
23629
  arg6 = RTEST(argv[5]);
24489
23630
  arg7 = RTEST(argv[6]);
24490
 
  {
24491
 
    if (NIL_P(argv[7])) {
24492
 
      arg8 = NULL;
24493
 
    } else if (RSTRING_LEN(argv[7]) != APR_MD5_DIGESTSIZE) {
24494
 
      rb_raise(rb_eArgError, "digest size (%d) must be %d",
24495
 
        RSTRING_LEN(argv[7]), APR_MD5_DIGESTSIZE);
24496
 
    } else {
24497
 
      arg8 = (unsigned char *)StringValuePtr(argv[7]);
24498
 
    }
24499
 
  }
 
23631
  
24500
23632
  if (argc > 8) {
24501
23633
    
24502
23634
  }
24599
23731
    }
24600
23732
  }
24601
23733
  {
24602
 
    arg6 = svn_swig_rb_cancel_func;
 
23734
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
24603
23735
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
24604
23736
  }
24605
23737
  if (argc > 6) {
24808
23940
  }
24809
23941
  arg8 = RTEST(argv[7]);
24810
23942
  arg9 = RTEST(argv[8]);
24811
 
  {
24812
 
    if (NIL_P(argv[9])) {
24813
 
      arg10 = NULL;
24814
 
    } else if (RSTRING_LEN(argv[9]) != APR_MD5_DIGESTSIZE) {
24815
 
      rb_raise(rb_eArgError, "digest size (%d) must be %d",
24816
 
        RSTRING_LEN(argv[9]), APR_MD5_DIGESTSIZE);
24817
 
    } else {
24818
 
      arg10 = (unsigned char *)StringValuePtr(argv[9]);
24819
 
    }
24820
 
  }
 
23943
  
24821
23944
  if (argc > 10) {
24822
23945
    
24823
23946
  }
24929
24052
    arg7 = svn_swig_rb_to_apr_array_prop(argv[6], pool);
24930
24053
  }
24931
24054
  arg8 = RTEST(argv[7]);
24932
 
  {
24933
 
    if (NIL_P(argv[8])) {
24934
 
      arg9 = NULL;
24935
 
    } else if (RSTRING_LEN(argv[8]) != APR_MD5_DIGESTSIZE) {
24936
 
      rb_raise(rb_eArgError, "digest size (%d) must be %d",
24937
 
        RSTRING_LEN(argv[8]), APR_MD5_DIGESTSIZE);
24938
 
    } else {
24939
 
      arg9 = (unsigned char *)StringValuePtr(argv[8]);
24940
 
    }
24941
 
  }
 
24055
  
24942
24056
  if (argc > 9) {
24943
24057
    
24944
24058
  }
25240
24354
  }
25241
24355
  arg2 = (char *)(buf2);
25242
24356
  {
25243
 
    arg3 = svn_swig_rb_ra_reporter3;
 
24357
    arg3 = (svn_ra_reporter3_t *) svn_swig_rb_get_ra_reporter3();
25244
24358
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
25245
24359
  }
25246
24360
  arg5 = RTEST(argv[3]);
25251
24365
  arg8 = RTEST(argv[6]);
25252
24366
  arg9 = RTEST(argv[7]);
25253
24367
  {
25254
 
    arg10 = svn_swig_rb_cancel_func;
 
24368
    arg10 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
25255
24369
    arg11 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
25256
24370
  }
25257
24371
  {
25258
 
    arg12 = svn_swig_rb_notify_func2;
 
24372
    arg12 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
25259
24373
    arg13 = (void *)svn_swig_rb_make_baton(argv[9], _global_svn_swig_rb_pool);
25260
24374
  }
25261
24375
  if (argc > 10) {
25346
24460
  }
25347
24461
  arg2 = (svn_wc_adm_access_t *)(argp2);
25348
24462
  {
25349
 
    arg3 = svn_swig_rb_ra_reporter3;
 
24463
    arg3 = (svn_ra_reporter3_t *) svn_swig_rb_get_ra_reporter3();
25350
24464
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
25351
24465
  }
25352
24466
  arg5 = RTEST(argv[3]);
25357
24471
  arg8 = RTEST(argv[6]);
25358
24472
  arg9 = RTEST(argv[7]);
25359
24473
  {
25360
 
    arg10 = svn_swig_rb_notify_func2;
 
24474
    arg10 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
25361
24475
    arg11 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
25362
24476
  }
25363
24477
  res12 = SWIG_ConvertPtr(argv[9], &argp12,SWIGTYPE_p_svn_wc_traversal_info_t, 0 |  0 );
25449
24563
  }
25450
24564
  arg2 = (svn_wc_adm_access_t *)(argp2);
25451
24565
  {
25452
 
    arg3 = svn_swig_rb_ra_reporter3;
 
24566
    arg3 = (svn_ra_reporter3_t *) svn_swig_rb_get_ra_reporter3();
25453
24567
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
25454
24568
  }
25455
24569
  arg5 = RTEST(argv[3]);
25459
24573
  arg7 = RTEST(argv[5]);
25460
24574
  arg8 = RTEST(argv[6]);
25461
24575
  {
25462
 
    arg9 = svn_swig_rb_notify_func2;
 
24576
    arg9 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
25463
24577
    arg10 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
25464
24578
  }
25465
24579
  res11 = SWIG_ConvertPtr(argv[8], &argp11,SWIGTYPE_p_svn_wc_traversal_info_t, 0 |  0 );
25565
24679
  arg6 = RTEST(argv[5]);
25566
24680
  arg7 = RTEST(argv[6]);
25567
24681
  {
25568
 
    arg8 = svn_swig_rb_notify_func2;
 
24682
    arg8 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
25569
24683
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
25570
24684
  }
25571
24685
  res10 = SWIG_ConvertPtr(argv[8], &argp10,SWIGTYPE_p_svn_wc_traversal_info_t, 0 |  0 );
26309
25423
    SWIG_exception_fail(SWIG_ArgError(res21), Ruby_Format_TypeError( "", "void *","svn_wc_get_update_editor4", 21, argv[18] )); 
26310
25424
  }
26311
25425
  {
26312
 
    arg22 = svn_swig_rb_cancel_func;
 
25426
    arg22 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
26313
25427
    arg23 = (void *)svn_swig_rb_make_baton(argv[19], _global_svn_swig_rb_pool);
26314
25428
  }
26315
25429
  {
26316
 
    arg24 = svn_swig_rb_notify_func2;
 
25430
    arg24 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
26317
25431
    arg25 = (void *)svn_swig_rb_make_baton(argv[20], _global_svn_swig_rb_pool);
26318
25432
  }
26319
25433
  if (argc > 21) {
26458
25572
  arg6 = RTEST(argv[5]);
26459
25573
  arg7 = RTEST(argv[6]);
26460
25574
  {
26461
 
    arg8 = svn_swig_rb_notify_func2;
 
25575
    arg8 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
26462
25576
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
26463
25577
  }
26464
25578
  {
26465
 
    arg10 = svn_swig_rb_cancel_func;
 
25579
    arg10 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
26466
25580
    arg11 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
26467
25581
  }
26468
25582
  {
26610
25724
  arg4 = RTEST(argv[3]);
26611
25725
  arg5 = RTEST(argv[4]);
26612
25726
  {
26613
 
    arg6 = svn_swig_rb_notify_func2;
 
25727
    arg6 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
26614
25728
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
26615
25729
  }
26616
25730
  {
26617
 
    arg8 = svn_swig_rb_cancel_func;
 
25731
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
26618
25732
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
26619
25733
  }
26620
25734
  {
26752
25866
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "void *","svn_wc_get_update_editor", 7, argv[6] )); 
26753
25867
  }
26754
25868
  {
26755
 
    arg8 = svn_swig_rb_cancel_func;
 
25869
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
26756
25870
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
26757
25871
  }
26758
25872
  {
26958
26072
    SWIG_exception_fail(SWIG_ArgError(res20), Ruby_Format_TypeError( "", "void *","svn_wc_get_switch_editor4", 20, argv[17] )); 
26959
26073
  }
26960
26074
  {
26961
 
    arg21 = svn_swig_rb_cancel_func;
 
26075
    arg21 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
26962
26076
    arg22 = (void *)svn_swig_rb_make_baton(argv[18], _global_svn_swig_rb_pool);
26963
26077
  }
26964
26078
  {
26965
 
    arg23 = svn_swig_rb_notify_func2;
 
26079
    arg23 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
26966
26080
    arg24 = (void *)svn_swig_rb_make_baton(argv[19], _global_svn_swig_rb_pool);
26967
26081
  }
26968
26082
  if (argc > 20) {
27116
26230
  arg7 = RTEST(argv[6]);
27117
26231
  arg8 = RTEST(argv[7]);
27118
26232
  {
27119
 
    arg9 = svn_swig_rb_notify_func2;
 
26233
    arg9 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
27120
26234
    arg10 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
27121
26235
  }
27122
26236
  {
27123
 
    arg11 = svn_swig_rb_cancel_func;
 
26237
    arg11 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
27124
26238
    arg12 = (void *)svn_swig_rb_make_baton(argv[9], _global_svn_swig_rb_pool);
27125
26239
  }
27126
26240
  {
27268
26382
  arg5 = RTEST(argv[4]);
27269
26383
  arg6 = RTEST(argv[5]);
27270
26384
  {
27271
 
    arg7 = svn_swig_rb_notify_func2;
 
26385
    arg7 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
27272
26386
    arg8 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
27273
26387
  }
27274
26388
  {
27275
 
    arg9 = svn_swig_rb_cancel_func;
 
26389
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
27276
26390
    arg10 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
27277
26391
  }
27278
26392
  {
27421
26535
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "void *","svn_wc_get_switch_editor", 8, argv[7] )); 
27422
26536
  }
27423
26537
  {
27424
 
    arg9 = svn_swig_rb_cancel_func;
 
26538
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
27425
26539
    arg10 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
27426
26540
  }
27427
26541
  {
28050
27164
  }
28051
27165
  arg7 = (apr_array_header_t *)(argp7);
28052
27166
  {
28053
 
    arg8 = svn_swig_rb_cancel_func;
 
27167
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
28054
27168
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
28055
27169
  }
28056
27170
  {
28057
 
    arg10 = svn_swig_rb_notify_func2;
 
27171
    arg10 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
28058
27172
    arg11 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
28059
27173
  }
28060
27174
  if (argc > 9) {
28159
27273
  arg4 = (svn_wc_adm_access_t *)(argp4);
28160
27274
  arg5 = RTEST(argv[4]);
28161
27275
  {
28162
 
    arg6 = svn_swig_rb_notify_func2;
 
27276
    arg6 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
28163
27277
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
28164
27278
  }
28165
27279
  if (argc > 6) {
28703
27817
    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "void *","svn_wc_get_diff_editor6", 15, argv[12] )); 
28704
27818
  }
28705
27819
  {
28706
 
    arg16 = svn_swig_rb_cancel_func;
 
27820
    arg16 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
28707
27821
    arg17 = (void *)svn_swig_rb_make_baton(argv[13], _global_svn_swig_rb_pool);
28708
27822
  }
28709
27823
  if (argc > 14) {
28842
27956
  arg7 = RTEST(argv[6]);
28843
27957
  arg8 = RTEST(argv[7]);
28844
27958
  {
28845
 
    arg9 = svn_swig_rb_cancel_func;
 
27959
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
28846
27960
    arg10 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
28847
27961
  }
28848
27962
  res11 = SWIG_ConvertPtr(argv[9], &argp11,SWIGTYPE_p_apr_array_header_t, 0 |  0 );
28949
28063
  }
28950
28064
  arg2 = (char *)(buf2);
28951
28065
  {
28952
 
    arg3 = svn_swig_rb_wc_diff_callbacks2();
 
28066
    arg3 = (svn_wc_diff_callbacks2_t *) svn_swig_rb_wc_diff_callbacks2();
28953
28067
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
28954
28068
  }
28955
28069
  {
28959
28073
  arg7 = RTEST(argv[5]);
28960
28074
  arg8 = RTEST(argv[6]);
28961
28075
  {
28962
 
    arg9 = svn_swig_rb_cancel_func;
 
28076
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
28963
28077
    arg10 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
28964
28078
  }
28965
28079
  res11 = SWIG_ConvertPtr(argv[8], &argp11,SWIGTYPE_p_apr_array_header_t, 0 |  0 );
29063
28177
  }
29064
28178
  arg2 = (char *)(buf2);
29065
28179
  {
29066
 
    arg3 = svn_swig_rb_wc_diff_callbacks2();
 
28180
    arg3 = (svn_wc_diff_callbacks2_t *) svn_swig_rb_wc_diff_callbacks2();
29067
28181
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
29068
28182
  }
29069
28183
  arg5 = RTEST(argv[3]);
29071
28185
  arg7 = RTEST(argv[5]);
29072
28186
  arg8 = RTEST(argv[6]);
29073
28187
  {
29074
 
    arg9 = svn_swig_rb_cancel_func;
 
28188
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
29075
28189
    arg10 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
29076
28190
  }
29077
28191
  if (argc > 8) {
29186
28300
  arg7 = RTEST(argv[6]);
29187
28301
  arg8 = RTEST(argv[7]);
29188
28302
  {
29189
 
    arg9 = svn_swig_rb_cancel_func;
 
28303
    arg9 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
29190
28304
    arg10 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
29191
28305
  }
29192
28306
  if (argc > 9) {
29299
28413
  arg6 = RTEST(argv[5]);
29300
28414
  arg7 = RTEST(argv[6]);
29301
28415
  {
29302
 
    arg8 = svn_swig_rb_cancel_func;
 
28416
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
29303
28417
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
29304
28418
  }
29305
28419
  if (argc > 8) {
29418
28532
  }
29419
28533
  arg9 = (apr_array_header_t *)(argp9);
29420
28534
  {
29421
 
    arg10 = svn_swig_rb_cancel_func;
 
28535
    arg10 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
29422
28536
    arg11 = (void *)svn_swig_rb_make_baton(argv[9], _global_svn_swig_rb_pool);
29423
28537
  }
29424
28538
  if (argc > 10) {
29604
28718
  }
29605
28719
  arg2 = (char *)(buf2);
29606
28720
  {
29607
 
    arg3 = svn_swig_rb_wc_diff_callbacks2();
 
28721
    arg3 = (svn_wc_diff_callbacks2_t *) svn_swig_rb_wc_diff_callbacks2();
29608
28722
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
29609
28723
  }
29610
28724
  {
29693
28807
  }
29694
28808
  arg2 = (char *)(buf2);
29695
28809
  {
29696
 
    arg3 = svn_swig_rb_wc_diff_callbacks2();
 
28810
    arg3 = (svn_wc_diff_callbacks2_t *) svn_swig_rb_wc_diff_callbacks2();
29697
28811
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
29698
28812
  }
29699
28813
  arg5 = RTEST(argv[3]);
30266
29380
    SWIG_exception_fail(SWIG_ArgError(res18), Ruby_Format_TypeError( "", "void *","svn_wc_merge5", 18, argv[16] )); 
30267
29381
  }
30268
29382
  {
30269
 
    arg19 = svn_swig_rb_cancel_func;
 
29383
    arg19 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
30270
29384
    arg20 = (void *)svn_swig_rb_make_baton(argv[17], _global_svn_swig_rb_pool);
30271
29385
  }
30272
29386
  if (argc > 18) {
30471
29585
    SWIG_exception_fail(SWIG_ArgError(res16), Ruby_Format_TypeError( "", "void *","svn_wc_merge4", 16, argv[14] )); 
30472
29586
  }
30473
29587
  {
30474
 
    arg17 = svn_swig_rb_cancel_func;
 
29588
    arg17 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
30475
29589
    arg18 = (void *)svn_swig_rb_make_baton(argv[15], _global_svn_swig_rb_pool);
30476
29590
  }
30477
29591
  if (argc > 16) {
31116
30230
    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "void *","svn_wc_merge_props3", 10, argv[9] )); 
31117
30231
  }
31118
30232
  {
31119
 
    arg11 = svn_swig_rb_cancel_func;
 
30233
    arg11 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
31120
30234
    arg12 = (void *)svn_swig_rb_make_baton(argv[10], _global_svn_swig_rb_pool);
31121
30235
  }
31122
30236
  if (argc > 11) {
31754
30868
 
31755
30869
 
31756
30870
SWIGINTERN VALUE
 
30871
_wrap_svn_wc_cleanup4(int argc, VALUE *argv, VALUE self) {
 
30872
  svn_wc_context_t *arg1 = (svn_wc_context_t *) 0 ;
 
30873
  char *arg2 = (char *) 0 ;
 
30874
  svn_boolean_t arg3 ;
 
30875
  svn_boolean_t arg4 ;
 
30876
  svn_boolean_t arg5 ;
 
30877
  svn_boolean_t arg6 ;
 
30878
  svn_cancel_func_t arg7 = (svn_cancel_func_t) 0 ;
 
30879
  void *arg8 = (void *) 0 ;
 
30880
  svn_wc_notify_func2_t arg9 = (svn_wc_notify_func2_t) 0 ;
 
30881
  void *arg10 = (void *) 0 ;
 
30882
  apr_pool_t *arg11 = (apr_pool_t *) 0 ;
 
30883
  VALUE _global_svn_swig_rb_pool ;
 
30884
  apr_pool_t *_global_pool ;
 
30885
  void *argp1 = 0 ;
 
30886
  int res1 = 0 ;
 
30887
  int res2 ;
 
30888
  char *buf2 = 0 ;
 
30889
  int alloc2 = 0 ;
 
30890
  svn_error_t *result = 0 ;
 
30891
  VALUE vresult = Qnil;
 
30892
  
 
30893
  {
 
30894
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg11);
 
30895
    _global_pool = arg11;
 
30896
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
30897
  }
 
30898
  if ((argc < 8) || (argc > 9)) {
 
30899
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
 
30900
  }
 
30901
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_wc_context_t, 0 |  0 );
 
30902
  if (!SWIG_IsOK(res1)) {
 
30903
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_wc_context_t *","svn_wc_cleanup4", 1, argv[0] )); 
 
30904
  }
 
30905
  arg1 = (svn_wc_context_t *)(argp1);
 
30906
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
 
30907
  if (!SWIG_IsOK(res2)) {
 
30908
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_wc_cleanup4", 2, argv[1] ));
 
30909
  }
 
30910
  arg2 = (char *)(buf2);
 
30911
  arg3 = RTEST(argv[2]);
 
30912
  arg4 = RTEST(argv[3]);
 
30913
  arg5 = RTEST(argv[4]);
 
30914
  arg6 = RTEST(argv[5]);
 
30915
  {
 
30916
    arg7 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
 
30917
    arg8 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
 
30918
  }
 
30919
  {
 
30920
    arg9 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
 
30921
    arg10 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
 
30922
  }
 
30923
  if (argc > 8) {
 
30924
    
 
30925
  }
 
30926
  {
 
30927
    result = (svn_error_t *)svn_wc_cleanup4(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
 
30928
    
 
30929
    
 
30930
    
 
30931
  }
 
30932
  {
 
30933
    if (result) {
 
30934
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
30935
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
30936
      svn_swig_rb_handle_svn_error(result);
 
30937
    }
 
30938
    vresult = Qnil;
 
30939
  }
 
30940
  {
 
30941
    svn_swig_rb_set_baton(vresult, (VALUE)arg8);
 
30942
  }
 
30943
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
30944
  {
 
30945
    VALUE target;
 
30946
    target = _global_vresult_address == &vresult ? self : vresult;
 
30947
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
30948
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
30949
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
30950
  }
 
30951
  return vresult;
 
30952
fail:
 
30953
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
30954
  {
 
30955
    VALUE target;
 
30956
    target = _global_vresult_address == &vresult ? self : vresult;
 
30957
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
30958
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
30959
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
30960
  }
 
30961
  return Qnil;
 
30962
}
 
30963
 
 
30964
 
 
30965
SWIGINTERN VALUE
31757
30966
_wrap_svn_wc_cleanup3(int argc, VALUE *argv, VALUE self) {
31758
30967
  svn_wc_context_t *arg1 = (svn_wc_context_t *) 0 ;
31759
30968
  char *arg2 = (char *) 0 ;
31789
30998
  }
31790
30999
  arg2 = (char *)(buf2);
31791
31000
  {
31792
 
    arg3 = svn_swig_rb_cancel_func;
 
31001
    arg3 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
31793
31002
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
31794
31003
  }
31795
31004
  if (argc > 3) {
31870
31079
    }
31871
31080
  }
31872
31081
  {
31873
 
    arg3 = svn_swig_rb_cancel_func;
 
31082
    arg3 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
31874
31083
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
31875
31084
  }
31876
31085
  if (argc > 3) {
31959
31168
    }
31960
31169
  }
31961
31170
  {
31962
 
    arg4 = svn_swig_rb_cancel_func;
 
31171
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
31963
31172
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
31964
31173
  }
31965
31174
  if (argc > 4) {
32055
31264
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_wc_upgrade", 4, argv[3] )); 
32056
31265
  }
32057
31266
  {
32058
 
    arg5 = svn_swig_rb_cancel_func;
 
31267
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
32059
31268
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
32060
31269
  }
32061
31270
  {
32062
 
    arg7 = svn_swig_rb_notify_func2;
 
31271
    arg7 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
32063
31272
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
32064
31273
  }
32065
31274
  if (argc > 6) {
32158
31367
  }
32159
31368
  arg4 = (char *)(buf4);
32160
31369
  {
32161
 
    arg5 = svn_swig_rb_wc_relocation_validator3;
 
31370
    arg5 = (svn_wc_relocation_validator3_t) svn_swig_rb_wc_relocation_validator3;
32162
31371
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
32163
31372
  }
32164
31373
  if (argc > 5) {
32260
31469
  arg4 = (char *)(buf4);
32261
31470
  arg5 = RTEST(argv[4]);
32262
31471
  {
32263
 
    arg6 = svn_swig_rb_wc_relocation_validator3;
 
31472
    arg6 = (svn_wc_relocation_validator3_t) svn_swig_rb_wc_relocation_validator3;
32264
31473
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
32265
31474
  }
32266
31475
  if (argc > 6) {
32525
31734
 
32526
31735
 
32527
31736
SWIGINTERN VALUE
 
31737
_wrap_svn_wc_revert5(int argc, VALUE *argv, VALUE self) {
 
31738
  svn_wc_context_t *arg1 = (svn_wc_context_t *) 0 ;
 
31739
  char *arg2 = (char *) 0 ;
 
31740
  svn_depth_t arg3 ;
 
31741
  svn_boolean_t arg4 ;
 
31742
  apr_array_header_t *arg5 = (apr_array_header_t *) 0 ;
 
31743
  svn_boolean_t arg6 ;
 
31744
  svn_boolean_t arg7 ;
 
31745
  svn_cancel_func_t arg8 = (svn_cancel_func_t) 0 ;
 
31746
  void *arg9 = (void *) 0 ;
 
31747
  svn_wc_notify_func2_t arg10 = (svn_wc_notify_func2_t) 0 ;
 
31748
  void *arg11 = (void *) 0 ;
 
31749
  apr_pool_t *arg12 = (apr_pool_t *) 0 ;
 
31750
  VALUE _global_svn_swig_rb_pool ;
 
31751
  apr_pool_t *_global_pool ;
 
31752
  void *argp1 = 0 ;
 
31753
  int res1 = 0 ;
 
31754
  int res2 ;
 
31755
  char *buf2 = 0 ;
 
31756
  int alloc2 = 0 ;
 
31757
  void *argp5 = 0 ;
 
31758
  int res5 = 0 ;
 
31759
  svn_error_t *result = 0 ;
 
31760
  VALUE vresult = Qnil;
 
31761
  
 
31762
  {
 
31763
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg12);
 
31764
    _global_pool = arg12;
 
31765
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
31766
  }
 
31767
  if ((argc < 9) || (argc > 10)) {
 
31768
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
 
31769
  }
 
31770
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_wc_context_t, 0 |  0 );
 
31771
  if (!SWIG_IsOK(res1)) {
 
31772
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_wc_context_t *","svn_wc_revert5", 1, argv[0] )); 
 
31773
  }
 
31774
  arg1 = (svn_wc_context_t *)(argp1);
 
31775
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
 
31776
  if (!SWIG_IsOK(res2)) {
 
31777
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_wc_revert5", 2, argv[1] ));
 
31778
  }
 
31779
  arg2 = (char *)(buf2);
 
31780
  {
 
31781
    arg3 = svn_swig_rb_to_depth(argv[2]);
 
31782
  }
 
31783
  arg4 = RTEST(argv[3]);
 
31784
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_apr_array_header_t, 0 |  0 );
 
31785
  if (!SWIG_IsOK(res5)) {
 
31786
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_array_header_t const *","svn_wc_revert5", 5, argv[4] )); 
 
31787
  }
 
31788
  arg5 = (apr_array_header_t *)(argp5);
 
31789
  arg6 = RTEST(argv[5]);
 
31790
  arg7 = RTEST(argv[6]);
 
31791
  {
 
31792
    arg8 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
 
31793
    arg9 = (void *)svn_swig_rb_make_baton(argv[7], _global_svn_swig_rb_pool);
 
31794
  }
 
31795
  {
 
31796
    arg10 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
 
31797
    arg11 = (void *)svn_swig_rb_make_baton(argv[8], _global_svn_swig_rb_pool);
 
31798
  }
 
31799
  if (argc > 9) {
 
31800
    
 
31801
  }
 
31802
  {
 
31803
    result = (svn_error_t *)svn_wc_revert5(arg1,(char const *)arg2,arg3,arg4,(apr_array_header_t const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
 
31804
    
 
31805
    
 
31806
    
 
31807
  }
 
31808
  {
 
31809
    if (result) {
 
31810
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
31811
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
31812
      svn_swig_rb_handle_svn_error(result);
 
31813
    }
 
31814
    vresult = Qnil;
 
31815
  }
 
31816
  {
 
31817
    svn_swig_rb_set_baton(vresult, (VALUE)arg9);
 
31818
  }
 
31819
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
31820
  {
 
31821
    VALUE target;
 
31822
    target = _global_vresult_address == &vresult ? self : vresult;
 
31823
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
31824
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
31825
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
31826
  }
 
31827
  return vresult;
 
31828
fail:
 
31829
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
31830
  {
 
31831
    VALUE target;
 
31832
    target = _global_vresult_address == &vresult ? self : vresult;
 
31833
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
31834
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
31835
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
31836
  }
 
31837
  return Qnil;
 
31838
}
 
31839
 
 
31840
 
 
31841
SWIGINTERN VALUE
32528
31842
_wrap_svn_wc_revert4(int argc, VALUE *argv, VALUE self) {
32529
31843
  svn_wc_context_t *arg1 = (svn_wc_context_t *) 0 ;
32530
31844
  char *arg2 = (char *) 0 ;
32576
31890
  }
32577
31891
  arg5 = (apr_array_header_t *)(argp5);
32578
31892
  {
32579
 
    arg6 = svn_swig_rb_cancel_func;
 
31893
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
32580
31894
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
32581
31895
  }
32582
31896
  {
32583
 
    arg8 = svn_swig_rb_notify_func2;
 
31897
    arg8 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
32584
31898
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
32585
31899
  }
32586
31900
  if (argc > 7) {
32677
31991
  }
32678
31992
  arg5 = (apr_array_header_t *)(argp5);
32679
31993
  {
32680
 
    arg6 = svn_swig_rb_cancel_func;
 
31994
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
32681
31995
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
32682
31996
  }
32683
31997
  {
32684
 
    arg8 = svn_swig_rb_notify_func2;
 
31998
    arg8 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
32685
31999
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
32686
32000
  }
32687
32001
  if (argc > 7) {
32768
32082
  arg3 = RTEST(argv[2]);
32769
32083
  arg4 = RTEST(argv[3]);
32770
32084
  {
32771
 
    arg5 = svn_swig_rb_cancel_func;
 
32085
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
32772
32086
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
32773
32087
  }
32774
32088
  {
32775
 
    arg7 = svn_swig_rb_notify_func2;
 
32089
    arg7 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
32776
32090
    arg8 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
32777
32091
  }
32778
32092
  if (argc > 6) {
32860
32174
  arg3 = RTEST(argv[2]);
32861
32175
  arg4 = RTEST(argv[3]);
32862
32176
  {
32863
 
    arg5 = svn_swig_rb_cancel_func;
 
32177
    arg5 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
32864
32178
    arg6 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
32865
32179
  }
32866
32180
  {
34874
34188
  }
34875
34189
  arg3 = RTEST(argv[2]);
34876
34190
  {
34877
 
    arg4 = svn_swig_rb_cancel_func;
 
34191
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
34878
34192
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
34879
34193
  }
34880
34194
  if (argc > 4) {
34974
34288
  }
34975
34289
  arg5 = RTEST(argv[3]);
34976
34290
  {
34977
 
    arg6 = svn_swig_rb_cancel_func;
 
34291
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
34978
34292
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
34979
34293
  }
34980
34294
  if (argc > 5) {
35093
34407
  }
35094
34408
  arg5 = (apr_array_header_t *)(argp5);
35095
34409
  {
35096
 
    arg6 = svn_swig_rb_cancel_func;
 
34410
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
35097
34411
    arg7 = (void *)svn_swig_rb_make_baton(argv[5], _global_svn_swig_rb_pool);
35098
34412
  }
35099
34413
  {
35100
 
    arg8 = svn_swig_rb_notify_func2;
 
34414
    arg8 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
35101
34415
    arg9 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
35102
34416
  }
35103
34417
  if (argc > 7) {
35184
34498
  }
35185
34499
  arg3 = (svn_wc_adm_access_t *)(argp3);
35186
34500
  {
35187
 
    arg4 = svn_swig_rb_cancel_func;
 
34501
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
35188
34502
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
35189
34503
  }
35190
34504
  {
35191
 
    arg6 = svn_swig_rb_notify_func2;
 
34505
    arg6 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
35192
34506
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
35193
34507
  }
35194
34508
  if (argc > 5) {
35294
34608
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void *","svn_wc_get_changelists", 6, argv[5] )); 
35295
34609
  }
35296
34610
  {
35297
 
    arg7 = svn_swig_rb_cancel_func;
 
34611
    arg7 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
35298
34612
    arg8 = (void *)svn_swig_rb_make_baton(argv[6], _global_svn_swig_rb_pool);
35299
34613
  }
35300
34614
  if (argc > 7) {
35381
34695
    arg3 = svn_swig_rb_to_depth(argv[2]);
35382
34696
  }
35383
34697
  {
35384
 
    arg4 = svn_swig_rb_cancel_func;
 
34698
    arg4 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
35385
34699
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
35386
34700
  }
35387
34701
  {
35388
 
    arg6 = svn_swig_rb_notify_func2;
 
34702
    arg6 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
35389
34703
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
35390
34704
  }
35391
34705
  if (argc > 5) {
35472
34786
    arg3 = svn_swig_rb_to_depth(argv[2]);
35473
34787
  }
35474
34788
  {
35475
 
    arg4 = svn_swig_rb_notify_func2;
 
34789
    arg4 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
35476
34790
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
35477
34791
  }
35478
34792
  {
35479
 
    arg6 = svn_swig_rb_cancel_func;
 
34793
    arg6 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
35480
34794
    arg7 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
35481
34795
  }
35482
34796
  if (argc > 5) {
35559
34873
  }
35560
34874
  arg2 = (char *)(buf2);
35561
34875
  {
35562
 
    arg3 = svn_swig_rb_cancel_func;
 
34876
    arg3 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
35563
34877
    arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
35564
34878
  }
35565
34879
  {
35566
 
    arg5 = svn_swig_rb_notify_func2;
 
34880
    arg5 = (svn_wc_notify_func2_t) svn_swig_rb_notify_func2;
35567
34881
    arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
35568
34882
  }
35569
34883
  if (argc > 4) {
41701
41015
 
41702
41016
/* -----------------------------------------------------------------------------
41703
41017
 * Type initialization:
41704
 
 * This problem is tough by the requirement that no dynamic 
41705
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
41018
 * This problem is tough by the requirement that no dynamic
 
41019
 * memory is used. Also, since swig_type_info structures store pointers to
41706
41020
 * swig_cast_info structures and swig_cast_info structures store pointers back
41707
 
 * to swig_type_info structures, we need some lookup code at initialization. 
41708
 
 * The idea is that swig generates all the structures that are needed. 
41709
 
 * The runtime then collects these partially filled structures. 
41710
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
41021
 * to swig_type_info structures, we need some lookup code at initialization.
 
41022
 * The idea is that swig generates all the structures that are needed.
 
41023
 * The runtime then collects these partially filled structures.
 
41024
 * The SWIG_InitializeModule function takes these initial arrays out of
41711
41025
 * swig_module, and does all the lookup, filling in the swig_module.types
41712
41026
 * array with the correct data and linking the correct swig_cast_info
41713
41027
 * structures together.
41714
41028
 *
41715
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
41029
 * The generated swig_type_info structures are assigned staticly to an initial
41716
41030
 * array. We just loop through that array, and handle each type individually.
41717
41031
 * First we lookup if this type has been already loaded, and if so, use the
41718
41032
 * loaded structure instead of the generated one. Then we have to fill in the
41722
41036
 * a column is one of the swig_cast_info structures for that type.
41723
41037
 * The cast_initial array is actually an array of arrays, because each row has
41724
41038
 * a variable number of columns. So to actually build the cast linked list,
41725
 
 * we find the array of casts associated with the type, and loop through it 
 
41039
 * we find the array of casts associated with the type, and loop through it
41726
41040
 * adding the casts to the list. The one last trick we need to do is making
41727
41041
 * sure the type pointer in the swig_cast_info struct is correct.
41728
41042
 *
41729
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
41043
 * First off, we lookup the cast->type name to see if it is already loaded.
41730
41044
 * There are three cases to handle:
41731
41045
 *  1) If the cast->type has already been loaded AND the type we are adding
41732
41046
 *     casting info to has not been loaded (it is in this module), THEN we
41733
41047
 *     replace the cast->type pointer with the type pointer that has already
41734
41048
 *     been loaded.
41735
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
41049
 *  2) If BOTH types (the one we are adding casting info to, and the
41736
41050
 *     cast->type) are loaded, THEN the cast info has already been loaded by
41737
41051
 *     the previous module so we just ignore it.
41738
41052
 *  3) Finally, if cast->type has not already been loaded, then we add that
41795
41109
    module_head->next = &swig_module;
41796
41110
  }
41797
41111
 
41798
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
41112
  /* When multiple interpreters are used, a module could have already been initialized in
41799
41113
     a different interpreter, but not yet have a pointer in this interpreter.
41800
41114
     In this case, we do not want to continue adding types... everything should be
41801
41115
     set up already */
41809
41123
    swig_type_info *type = 0;
41810
41124
    swig_type_info *ret;
41811
41125
    swig_cast_info *cast;
41812
 
  
 
41126
 
41813
41127
#ifdef SWIGRUNTIME_DEBUG
41814
41128
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41815
41129
#endif
41836
41150
    /* Insert casting types */
41837
41151
    cast = swig_module.cast_initial[i];
41838
41152
    while (cast->type) {
41839
 
    
 
41153
 
41840
41154
      /* Don't need to add information already in the list */
41841
41155
      ret = 0;
41842
41156
#ifdef SWIGRUNTIME_DEBUG
42101
41415
  rb_define_const(mWc, "Svn_wc_notify_left_local_modifications", SWIG_From_int((int)(svn_wc_notify_left_local_modifications)));
42102
41416
  rb_define_const(mWc, "Svn_wc_notify_foreign_copy_begin", SWIG_From_int((int)(svn_wc_notify_foreign_copy_begin)));
42103
41417
  rb_define_const(mWc, "Svn_wc_notify_move_broken", SWIG_From_int((int)(svn_wc_notify_move_broken)));
 
41418
  rb_define_const(mWc, "Svn_wc_notify_cleanup_external", SWIG_From_int((int)(svn_wc_notify_cleanup_external)));
 
41419
  rb_define_const(mWc, "Svn_wc_notify_failed_requires_target", SWIG_From_int((int)(svn_wc_notify_failed_requires_target)));
 
41420
  rb_define_const(mWc, "Svn_wc_notify_info_external", SWIG_From_int((int)(svn_wc_notify_info_external)));
 
41421
  rb_define_const(mWc, "Svn_wc_notify_commit_finalizing", SWIG_From_int((int)(svn_wc_notify_commit_finalizing)));
42104
41422
  rb_define_const(mWc, "Svn_wc_notify_state_inapplicable", SWIG_From_int((int)(svn_wc_notify_state_inapplicable)));
42105
41423
  rb_define_const(mWc, "Svn_wc_notify_state_unknown", SWIG_From_int((int)(svn_wc_notify_state_unknown)));
42106
41424
  rb_define_const(mWc, "Svn_wc_notify_state_unchanged", SWIG_From_int((int)(svn_wc_notify_state_unchanged)));
42214
41532
  rb_define_module_function(mWc, "svn_wc_conflict_version_create", _wrap_svn_wc_conflict_version_create, -1);
42215
41533
  rb_define_module_function(mWc, "svn_wc_conflict_version_dup", _wrap_svn_wc_conflict_version_dup, -1);
42216
41534
  
42217
 
  SwigClassSvn_wc_conflict_description2_t.klass = rb_define_class_under(mWc, "Svn_wc_conflict_description2_t", rb_cObject);
42218
 
  SWIG_TypeClientData(SWIGTYPE_p_svn_wc_conflict_description2_t, (void *) &SwigClassSvn_wc_conflict_description2_t);
42219
 
  rb_define_alloc_func(SwigClassSvn_wc_conflict_description2_t.klass, _wrap_svn_wc_conflict_description2_t_allocate);
42220
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "initialize", _wrap_new_svn_wc_conflict_description2_t, -1);
42221
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "local_abspath=", _wrap_svn_wc_conflict_description2_t_local_abspath_set, -1);
42222
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "local_abspath", _wrap_svn_wc_conflict_description2_t_local_abspath_get, -1);
42223
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "node_kind=", _wrap_svn_wc_conflict_description2_t_node_kind_set, -1);
42224
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "node_kind", _wrap_svn_wc_conflict_description2_t_node_kind_get, -1);
42225
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "kind=", _wrap_svn_wc_conflict_description2_t_kind_set, -1);
42226
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "kind", _wrap_svn_wc_conflict_description2_t_kind_get, -1);
42227
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "property_name=", _wrap_svn_wc_conflict_description2_t_property_name_set, -1);
42228
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "property_name", _wrap_svn_wc_conflict_description2_t_property_name_get, -1);
42229
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "is_binary=", _wrap_svn_wc_conflict_description2_t_is_binary_set, -1);
42230
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "is_binary", _wrap_svn_wc_conflict_description2_t_is_binary_get, -1);
42231
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "mime_type=", _wrap_svn_wc_conflict_description2_t_mime_type_set, -1);
42232
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "mime_type", _wrap_svn_wc_conflict_description2_t_mime_type_get, -1);
42233
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "action=", _wrap_svn_wc_conflict_description2_t_action_set, -1);
42234
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "action", _wrap_svn_wc_conflict_description2_t_action_get, -1);
42235
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "reason=", _wrap_svn_wc_conflict_description2_t_reason_set, -1);
42236
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "reason", _wrap_svn_wc_conflict_description2_t_reason_get, -1);
42237
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "base_abspath=", _wrap_svn_wc_conflict_description2_t_base_abspath_set, -1);
42238
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "base_abspath", _wrap_svn_wc_conflict_description2_t_base_abspath_get, -1);
42239
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "their_abspath=", _wrap_svn_wc_conflict_description2_t_their_abspath_set, -1);
42240
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "their_abspath", _wrap_svn_wc_conflict_description2_t_their_abspath_get, -1);
42241
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "my_abspath=", _wrap_svn_wc_conflict_description2_t_my_abspath_set, -1);
42242
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "my_abspath", _wrap_svn_wc_conflict_description2_t_my_abspath_get, -1);
42243
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "merged_file=", _wrap_svn_wc_conflict_description2_t_merged_file_set, -1);
42244
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "merged_file", _wrap_svn_wc_conflict_description2_t_merged_file_get, -1);
42245
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "operation=", _wrap_svn_wc_conflict_description2_t_operation_set, -1);
42246
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "operation", _wrap_svn_wc_conflict_description2_t_operation_get, -1);
42247
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "src_left_version=", _wrap_svn_wc_conflict_description2_t_src_left_version_set, -1);
42248
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "src_left_version", _wrap_svn_wc_conflict_description2_t_src_left_version_get, -1);
42249
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "src_right_version=", _wrap_svn_wc_conflict_description2_t_src_right_version_set, -1);
42250
 
  rb_define_method(SwigClassSvn_wc_conflict_description2_t.klass, "src_right_version", _wrap_svn_wc_conflict_description2_t_src_right_version_get, -1);
42251
 
  SwigClassSvn_wc_conflict_description2_t.mark = 0;
42252
 
  SwigClassSvn_wc_conflict_description2_t.destroy = (void (*)(void *)) free_svn_wc_conflict_description2_t;
42253
 
  SwigClassSvn_wc_conflict_description2_t.trackObjects = 0;
42254
 
  
42255
41535
  SwigClassSvn_wc_conflict_description_t.klass = rb_define_class_under(mWc, "Svn_wc_conflict_description_t", rb_cObject);
42256
41536
  SWIG_TypeClientData(SWIGTYPE_p_svn_wc_conflict_description_t, (void *) &SwigClassSvn_wc_conflict_description_t);
42257
41537
  rb_define_alloc_func(SwigClassSvn_wc_conflict_description_t.klass, _wrap_svn_wc_conflict_description_t_allocate);
42297
41577
  rb_define_module_function(mWc, "svn_wc_conflict_description_create_prop", _wrap_svn_wc_conflict_description_create_prop, -1);
42298
41578
  rb_define_module_function(mWc, "svn_wc_conflict_description_create_tree2", _wrap_svn_wc_conflict_description_create_tree2, -1);
42299
41579
  rb_define_module_function(mWc, "svn_wc_conflict_description_create_tree", _wrap_svn_wc_conflict_description_create_tree, -1);
 
41580
  rb_define_module_function(mWc, "svn_wc_conflict_description2_dup", _wrap_svn_wc_conflict_description2_dup, -1);
42300
41581
  rb_define_module_function(mWc, "svn_wc__conflict_description2_dup", _wrap_svn_wc__conflict_description2_dup, -1);
 
41582
  rb_define_const(mWc, "Svn_wc_conflict_choose_undefined", SWIG_From_int((int)(svn_wc_conflict_choose_undefined)));
42301
41583
  rb_define_const(mWc, "Svn_wc_conflict_choose_postpone", SWIG_From_int((int)(svn_wc_conflict_choose_postpone)));
42302
41584
  rb_define_const(mWc, "Svn_wc_conflict_choose_base", SWIG_From_int((int)(svn_wc_conflict_choose_base)));
42303
41585
  rb_define_const(mWc, "Svn_wc_conflict_choose_theirs_full", SWIG_From_int((int)(svn_wc_conflict_choose_theirs_full)));
42306
41588
  rb_define_const(mWc, "Svn_wc_conflict_choose_mine_conflict", SWIG_From_int((int)(svn_wc_conflict_choose_mine_conflict)));
42307
41589
  rb_define_const(mWc, "Svn_wc_conflict_choose_merged", SWIG_From_int((int)(svn_wc_conflict_choose_merged)));
42308
41590
  rb_define_const(mWc, "Svn_wc_conflict_choose_unspecified", SWIG_From_int((int)(svn_wc_conflict_choose_unspecified)));
42309
 
  
42310
 
  SwigClassSvn_wc_conflict_result_t.klass = rb_define_class_under(mWc, "Svn_wc_conflict_result_t", rb_cObject);
42311
 
  SWIG_TypeClientData(SWIGTYPE_p_svn_wc_conflict_result_t, (void *) &SwigClassSvn_wc_conflict_result_t);
42312
 
  rb_define_alloc_func(SwigClassSvn_wc_conflict_result_t.klass, _wrap_svn_wc_conflict_result_t_allocate);
42313
 
  rb_define_method(SwigClassSvn_wc_conflict_result_t.klass, "initialize", _wrap_new_svn_wc_conflict_result_t, -1);
42314
 
  rb_define_method(SwigClassSvn_wc_conflict_result_t.klass, "choice=", _wrap_svn_wc_conflict_result_t_choice_set, -1);
42315
 
  rb_define_method(SwigClassSvn_wc_conflict_result_t.klass, "choice", _wrap_svn_wc_conflict_result_t_choice_get, -1);
42316
 
  rb_define_method(SwigClassSvn_wc_conflict_result_t.klass, "merged_file=", _wrap_svn_wc_conflict_result_t_merged_file_set, -1);
42317
 
  rb_define_method(SwigClassSvn_wc_conflict_result_t.klass, "merged_file", _wrap_svn_wc_conflict_result_t_merged_file_get, -1);
42318
 
  rb_define_method(SwigClassSvn_wc_conflict_result_t.klass, "save_merged=", _wrap_svn_wc_conflict_result_t_save_merged_set, -1);
42319
 
  rb_define_method(SwigClassSvn_wc_conflict_result_t.klass, "save_merged", _wrap_svn_wc_conflict_result_t_save_merged_get, -1);
42320
 
  SwigClassSvn_wc_conflict_result_t.mark = 0;
42321
 
  SwigClassSvn_wc_conflict_result_t.destroy = (void (*)(void *)) free_svn_wc_conflict_result_t;
42322
 
  SwigClassSvn_wc_conflict_result_t.trackObjects = 0;
42323
41591
  rb_define_module_function(mWc, "svn_wc_create_conflict_result", _wrap_svn_wc_create_conflict_result, -1);
42324
41592
  
42325
41593
  SwigClassSvn_wc_diff_callbacks4_t.klass = rb_define_class_under(mWc, "Svn_wc_diff_callbacks4_t", rb_cObject);
42661
41929
  rb_define_method(SwigClassSvn_wc_status3_t.klass, "moved_to_abspath", _wrap_svn_wc_status3_t_moved_to_abspath_get, -1);
42662
41930
  rb_define_method(SwigClassSvn_wc_status3_t.klass, "file_external=", _wrap_svn_wc_status3_t_file_external_set, -1);
42663
41931
  rb_define_method(SwigClassSvn_wc_status3_t.klass, "file_external", _wrap_svn_wc_status3_t_file_external_get, -1);
 
41932
  rb_define_method(SwigClassSvn_wc_status3_t.klass, "actual_kind=", _wrap_svn_wc_status3_t_actual_kind_set, -1);
 
41933
  rb_define_method(SwigClassSvn_wc_status3_t.klass, "actual_kind", _wrap_svn_wc_status3_t_actual_kind_get, -1);
42664
41934
  SwigClassSvn_wc_status3_t.mark = 0;
42665
41935
  SwigClassSvn_wc_status3_t.destroy = (void (*)(void *)) free_svn_wc_status3_t;
42666
41936
  SwigClassSvn_wc_status3_t.trackObjects = 0;
42753
42023
  rb_define_module_function(mWc, "svn_wc_delete3", _wrap_svn_wc_delete3, -1);
42754
42024
  rb_define_module_function(mWc, "svn_wc_delete2", _wrap_svn_wc_delete2, -1);
42755
42025
  rb_define_module_function(mWc, "svn_wc_delete", _wrap_svn_wc_delete, -1);
 
42026
  rb_define_module_function(mWc, "svn_wc_add_from_disk3", _wrap_svn_wc_add_from_disk3, -1);
42756
42027
  rb_define_module_function(mWc, "svn_wc_add_from_disk2", _wrap_svn_wc_add_from_disk2, -1);
42757
42028
  rb_define_module_function(mWc, "svn_wc_add_from_disk", _wrap_svn_wc_add_from_disk, -1);
42758
42029
  rb_define_module_function(mWc, "svn_wc_add4", _wrap_svn_wc_add4, -1);
42770
42041
  rb_define_module_function(mWc, "svn_wc_resolved_conflict3", _wrap_svn_wc_resolved_conflict3, -1);
42771
42042
  rb_define_module_function(mWc, "svn_wc_resolved_conflict2", _wrap_svn_wc_resolved_conflict2, -1);
42772
42043
  rb_define_module_function(mWc, "svn_wc_resolved_conflict", _wrap_svn_wc_resolved_conflict, -1);
 
42044
  rb_define_module_function(mWc, "svn_wc_queue_committed4", _wrap_svn_wc_queue_committed4, -1);
42773
42045
  rb_define_module_function(mWc, "svn_wc_queue_committed3", _wrap_svn_wc_queue_committed3, -1);
42774
42046
  rb_define_module_function(mWc, "svn_wc_queue_committed2", _wrap_svn_wc_queue_committed2, -1);
42775
42047
  rb_define_module_function(mWc, "svn_wc_queue_committed", _wrap_svn_wc_queue_committed, -1);
42840
42112
  rb_define_module_function(mWc, "svn_wc_get_pristine_contents2", _wrap_svn_wc_get_pristine_contents2, -1);
42841
42113
  rb_define_module_function(mWc, "svn_wc_get_pristine_contents", _wrap_svn_wc_get_pristine_contents, -1);
42842
42114
  rb_define_module_function(mWc, "svn_wc_get_pristine_copy_path", _wrap_svn_wc_get_pristine_copy_path, -1);
 
42115
  rb_define_module_function(mWc, "svn_wc_cleanup4", _wrap_svn_wc_cleanup4, -1);
42843
42116
  rb_define_module_function(mWc, "svn_wc_cleanup3", _wrap_svn_wc_cleanup3, -1);
42844
42117
  rb_define_module_function(mWc, "svn_wc_cleanup2", _wrap_svn_wc_cleanup2, -1);
42845
42118
  rb_define_module_function(mWc, "svn_wc_cleanup", _wrap_svn_wc_cleanup, -1);
42848
42121
  rb_define_module_function(mWc, "svn_wc_relocate3", _wrap_svn_wc_relocate3, -1);
42849
42122
  rb_define_module_function(mWc, "svn_wc_relocate2", _wrap_svn_wc_relocate2, -1);
42850
42123
  rb_define_module_function(mWc, "svn_wc_relocate", _wrap_svn_wc_relocate, -1);
 
42124
  rb_define_module_function(mWc, "svn_wc_revert5", _wrap_svn_wc_revert5, -1);
42851
42125
  rb_define_module_function(mWc, "svn_wc_revert4", _wrap_svn_wc_revert4, -1);
42852
42126
  rb_define_module_function(mWc, "svn_wc_revert3", _wrap_svn_wc_revert3, -1);
42853
42127
  rb_define_module_function(mWc, "svn_wc_revert2", _wrap_svn_wc_revert2, -1);