← Back to branch summary

~ubuntu-branches/ubuntu/trusty/subversion/trusty-proposed

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/perl/native/svn_ra.c

  • Committer: Package Import Robot
  • Author(s): Andy Whitcroft
  • Date: 2012-06-21 15:36:36 UTC
  • mfrom: (0.4.13 sid)
  • Revision ID: package-import@ubuntu.com-20120621153636-amqqmuidgwgxz1ly
Tags: 1.7.5-1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - Create pot file on build.
  - Build a python-subversion-dbg package.
  - Build-depend on python-dbg.
  - Build-depend on default-jre-headless/-jdk.
  - Do not apply java-build patch.
  - debian/rules: Manually create the doxygen output directory, otherwise
    we get weird build failures when running parallel builds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/bindings/swig/perl/native/svn_ra.c
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.36
 
3
 * Version 2.0.4
4
4
 * 
5
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
10
10
 
11
11
#define SWIGPERL
12
12
#define SWIG_CASTRANK_MODE
 
13
 
13
14
/* -----------------------------------------------------------------------------
14
15
 *  This section contains generic SWIG labels for method/variable
15
16
 *  declarations/attributes, and other compiler dependent labels.
122
123
/* -----------------------------------------------------------------------------
123
124
 * swigrun.swg
124
125
 *
125
 
 * This file contains generic CAPI SWIG runtime support for pointer
 
126
 * This file contains generic C API SWIG runtime support for pointer
126
127
 * type checking.
127
128
 * ----------------------------------------------------------------------------- */
128
129
 
141
142
 
142
143
/*
143
144
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
144
 
  creating a static or dynamic library from the swig runtime code.
145
 
  In 99.9% of the cases, swig just needs to declare them as 'static'.
 
145
  creating a static or dynamic library from the SWIG runtime code.
 
146
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
146
147
  
147
 
  But only do this if is strictly necessary, ie, if you have problems
148
 
  with your compiler or so.
 
148
  But only do this if strictly necessary, ie, if you have problems
 
149
  with your compiler or suchlike.
149
150
*/
150
151
 
151
152
#ifndef SWIGRUNTIME
172
173
/* 
173
174
   Flags/methods for returning states.
174
175
   
175
 
   The swig conversion methods, as ConvertPtr, return and integer 
 
176
   The SWIG conversion methods, as ConvertPtr, return an integer 
176
177
   that tells if the conversion was successful or not. And if not,
177
178
   an error code can be returned (see swigerrors.swg for the codes).
178
179
   
179
180
   Use the following macros/flags to set or process the returning
180
181
   states.
181
182
   
182
 
   In old swig versions, you usually write code as:
 
183
   In old versions of SWIG, code such as the following was usually written:
183
184
 
184
185
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
185
186
       // success code
187
188
       //fail code
188
189
     }
189
190
 
190
 
   Now you can be more explicit as:
 
191
   Now you can be more explicit:
191
192
 
192
193
    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
193
194
    if (SWIG_IsOK(res)) {
196
197
      // fail code
197
198
    }
198
199
 
199
 
   that seems to be the same, but now you can also do
 
200
   which is the same really, but now you can also do
200
201
 
201
202
    Type *ptr;
202
203
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
214
215
    
215
216
   I.e., now SWIG_ConvertPtr can return new objects and you can
216
217
   identify the case and take care of the deallocation. Of course that
217
 
   requires also to SWIG_ConvertPtr to return new result values, as
 
218
   also requires SWIG_ConvertPtr to return new result values, such as
218
219
 
219
220
      int SWIG_ConvertPtr(obj, ptr,...) {         
220
221
        if (<obj is ok>) {                             
232
233
 
233
234
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
234
235
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
235
 
   swig errors code.
 
236
   SWIG errors code.
236
237
 
237
238
   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
238
239
   allows to return the 'cast rank', for example, if you have this
246
247
      fooi(1)   // cast rank '0'
247
248
 
248
249
   just use the SWIG_AddCast()/SWIG_CheckState()
249
 
 
250
 
 
251
 
 */
 
250
*/
 
251
 
252
252
#define SWIG_OK                    (0) 
253
253
#define SWIG_ERROR                 (-1)
254
254
#define SWIG_IsOK(r)               (r >= 0)
273
273
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
274
274
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
275
275
 
276
 
 
277
276
/* Cast-Rank Mode */
278
277
#if defined(SWIG_CASTRANK_MODE)
279
278
#  ifndef SWIG_TypeRank
296
295
#endif
297
296
 
298
297
 
299
 
 
300
 
 
301
298
#include <string.h>
302
299
 
303
300
#ifdef __cplusplus
394
391
}
395
392
 
396
393
 
397
 
/* think of this as a c++ template<> or a scheme macro */
398
 
#define SWIG_TypeCheck_Template(comparison, ty)         \
399
 
  if (ty) {                                             \
400
 
    swig_cast_info *iter = ty->cast;                    \
401
 
    while (iter) {                                      \
402
 
      if (comparison) {                                 \
403
 
        if (iter == ty->cast) return iter;              \
404
 
        /* Move iter to the top of the linked list */   \
405
 
        iter->prev->next = iter->next;                  \
406
 
        if (iter->next)                                 \
407
 
          iter->next->prev = iter->prev;                \
408
 
        iter->next = ty->cast;                          \
409
 
        iter->prev = 0;                                 \
410
 
        if (ty->cast) ty->cast->prev = iter;            \
411
 
        ty->cast = iter;                                \
412
 
        return iter;                                    \
413
 
      }                                                 \
414
 
      iter = iter->next;                                \
415
 
    }                                                   \
416
 
  }                                                     \
417
 
  return 0
418
 
 
419
394
/*
420
395
  Check the typename
421
396
*/
422
397
SWIGRUNTIME swig_cast_info *
423
398
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
424
 
  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 
399
  if (ty) {
 
400
    swig_cast_info *iter = ty->cast;
 
401
    while (iter) {
 
402
      if (strcmp(iter->type->name, c) == 0) {
 
403
        if (iter == ty->cast)
 
404
          return iter;
 
405
        /* Move iter to the top of the linked list */
 
406
        iter->prev->next = iter->next;
 
407
        if (iter->next)
 
408
          iter->next->prev = iter->prev;
 
409
        iter->next = ty->cast;
 
410
        iter->prev = 0;
 
411
        if (ty->cast) ty->cast->prev = iter;
 
412
        ty->cast = iter;
 
413
        return iter;
 
414
      }
 
415
      iter = iter->next;
 
416
    }
 
417
  }
 
418
  return 0;
425
419
}
426
420
 
427
 
/* Same as previous function, except strcmp is replaced with a pointer comparison */
 
421
/* 
 
422
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 
423
*/
428
424
SWIGRUNTIME swig_cast_info *
429
 
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
430
 
  SWIG_TypeCheck_Template(iter->type == from, into);
 
425
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 
426
  if (ty) {
 
427
    swig_cast_info *iter = ty->cast;
 
428
    while (iter) {
 
429
      if (iter->type == from) {
 
430
        if (iter == ty->cast)
 
431
          return iter;
 
432
        /* Move iter to the top of the linked list */
 
433
        iter->prev->next = iter->next;
 
434
        if (iter->next)
 
435
          iter->next->prev = iter->prev;
 
436
        iter->next = ty->cast;
 
437
        iter->prev = 0;
 
438
        if (ty->cast) ty->cast->prev = iter;
 
439
        ty->cast = iter;
 
440
        return iter;
 
441
      }
 
442
      iter = iter->next;
 
443
    }
 
444
  }
 
445
  return 0;
431
446
}
432
447
 
433
448
/*
879
894
 
880
895
/* for raw pointers */
881
896
#define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
 
897
#define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
882
898
#define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
883
899
 
884
900
/* for raw packed data */
1066
1082
  }
1067
1083
}
1068
1084
 
 
1085
/* Identical to SWIG_TypeCheck, except for strcmp comparison */
1069
1086
SWIGRUNTIME swig_cast_info *
1070
1087
SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1071
 
  SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) 
1072
 
                            || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty);
 
1088
  if (ty) {
 
1089
    swig_cast_info *iter = ty->cast;
 
1090
    while (iter) {
 
1091
      if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
 
1092
            (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
 
1093
        if (iter == ty->cast)
 
1094
          return iter;
 
1095
        /* Move iter to the top of the linked list */
 
1096
        iter->prev->next = iter->next;
 
1097
        if (iter->next)
 
1098
          iter->next->prev = iter->prev;
 
1099
        iter->next = ty->cast;
 
1100
        iter->prev = 0;
 
1101
        if (ty->cast) ty->cast->prev = iter;
 
1102
        ty->cast = iter;
 
1103
        return iter;
 
1104
      }
 
1105
      iter = iter->next;
 
1106
    }
 
1107
  }
 
1108
  return 0;
1073
1109
}
1074
1110
 
1075
 
 
1076
1111
/* Function for getting a pointer value */
1077
1112
 
1078
1113
SWIGRUNTIME int
1079
 
SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
 
1114
SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
1080
1115
  swig_cast_info *tc;
1081
1116
  void *voidptr = (void *)0;
1082
1117
  SV *tsv = 0;
 
1118
 
 
1119
  if (own)
 
1120
    *own = 0;
 
1121
 
1083
1122
  /* If magical, apply more magic */
1084
1123
  if (SvGMAGICAL(sv))
1085
1124
    mg_get(sv);
1111
1150
    return SWIG_OK;
1112
1151
  } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
1113
1152
    if (!SvROK(sv)) {
1114
 
      *(ptr) = (void *) 0;
1115
 
      return SWIG_OK;
 
1153
      /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value.  */
 
1154
      if (SvIOK(sv)) {
 
1155
        return SWIG_ERROR;
 
1156
      } else {
 
1157
        /* NULL pointer (reference to undef). */
 
1158
        *(ptr) = (void *) 0;
 
1159
        return SWIG_OK;
 
1160
      }
1116
1161
    } else {
1117
1162
      return SWIG_ERROR;
1118
1163
    }
1129
1174
    {
1130
1175
      int newmemory = 0;
1131
1176
      *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1132
 
      assert(!newmemory); /* newmemory handling not yet implemented */
 
1177
      if (newmemory == SWIG_CAST_NEW_MEMORY) {
 
1178
        assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
 
1179
        if (own)
 
1180
          *own = *own | SWIG_CAST_NEW_MEMORY;
 
1181
      }
1133
1182
    }
1134
1183
  } else {
1135
1184
    *ptr = voidptr;
1144
1193
     */
1145
1194
    SV *obj = sv;
1146
1195
    HV *stash = SvSTASH(SvRV(obj));
1147
 
    GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
 
1196
    GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1148
1197
    if (isGV(gv)) {
1149
1198
      HV *hv = GvHVn(gv);
1150
1199
      /*
1159
1208
  return SWIG_OK;
1160
1209
}
1161
1210
 
 
1211
SWIGRUNTIME int
 
1212
SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
 
1213
  return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
 
1214
}
 
1215
 
1162
1216
SWIGRUNTIME void
1163
1217
SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1164
 
  if (ptr && (flags & SWIG_SHADOW)) {
 
1218
  if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
1165
1219
    SV *self;
1166
1220
    SV *obj=newSV(0);
1167
1221
    HV *hash=newHV();
1170
1224
    stash=SvSTASH(SvRV(obj));
1171
1225
    if (flags & SWIG_POINTER_OWN) {
1172
1226
      HV *hv;
1173
 
      GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
 
1227
      GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1174
1228
      if (!isGV(gv))
1175
1229
        gv_init(gv, stash, "OWNER", 5, FALSE);
1176
1230
      hv=GvHVn(gv);
1336
1390
#ifdef do_close
1337
1391
  #undef do_close
1338
1392
#endif
 
1393
#ifdef do_exec
 
1394
  #undef do_exec
 
1395
#endif
1339
1396
#ifdef scalar
1340
1397
  #undef scalar
1341
1398
#endif
1420
1477
#ifdef open
1421
1478
  #undef open
1422
1479
#endif
 
1480
#ifdef readdir
 
1481
  #undef readdir
 
1482
#endif
 
1483
#ifdef bind
 
1484
  #undef bind
 
1485
#endif
 
1486
#ifdef access
 
1487
  #undef access
 
1488
#endif
 
1489
#ifdef stat
 
1490
  #undef stat
 
1491
#endif
1423
1492
 
1424
1493
 
1425
1494
 
1524
1593
#define SWIGTYPE_p_svn_diff_datasource_e swig_types[87]
1525
1594
#define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[88]
1526
1595
#define SWIGTYPE_p_svn_diff_file_options_t swig_types[89]
1527
 
#define SWIGTYPE_p_svn_diff_fns_t swig_types[90]
1528
 
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[91]
1529
 
#define SWIGTYPE_p_svn_diff_t swig_types[92]
1530
 
#define SWIGTYPE_p_svn_dirent_t swig_types[93]
1531
 
#define SWIGTYPE_p_svn_errno_t swig_types[94]
1532
 
#define SWIGTYPE_p_svn_error_t swig_types[95]
1533
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[96]
1534
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[97]
1535
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[98]
1536
 
#define SWIGTYPE_p_svn_lock_t swig_types[99]
1537
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[100]
1538
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[101]
1539
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[102]
1540
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[103]
1541
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[104]
1542
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[105]
1543
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[106]
1544
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[107]
1545
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[108]
1546
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[109]
1547
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[110]
1548
 
#define SWIGTYPE_p_svn_prop_kind swig_types[111]
1549
 
#define SWIGTYPE_p_svn_ra_callbacks2_t swig_types[112]
1550
 
#define SWIGTYPE_p_svn_ra_callbacks_t swig_types[113]
1551
 
#define SWIGTYPE_p_svn_ra_plugin_t swig_types[114]
1552
 
#define SWIGTYPE_p_svn_ra_reporter2_t swig_types[115]
1553
 
#define SWIGTYPE_p_svn_ra_reporter3_t swig_types[116]
1554
 
#define SWIGTYPE_p_svn_ra_reporter_t swig_types[117]
1555
 
#define SWIGTYPE_p_svn_ra_session_t swig_types[118]
1556
 
#define SWIGTYPE_p_svn_stream_t swig_types[119]
1557
 
#define SWIGTYPE_p_svn_string_t swig_types[120]
1558
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[121]
1559
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[122]
1560
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[123]
1561
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[124]
1562
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[125]
1563
 
#define SWIGTYPE_p_svn_version_t swig_types[126]
1564
 
#define SWIGTYPE_p_void swig_types[127]
1565
 
static swig_type_info *swig_types[129];
1566
 
static swig_module_info swig_module = {swig_types, 128, 0, 0, 0, 0};
 
1596
#define SWIGTYPE_p_svn_diff_fns2_t swig_types[90]
 
1597
#define SWIGTYPE_p_svn_diff_fns_t swig_types[91]
 
1598
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[92]
 
1599
#define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[93]
 
1600
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[94]
 
1601
#define SWIGTYPE_p_svn_diff_t swig_types[95]
 
1602
#define SWIGTYPE_p_svn_dirent_t swig_types[96]
 
1603
#define SWIGTYPE_p_svn_errno_t swig_types[97]
 
1604
#define SWIGTYPE_p_svn_error_t swig_types[98]
 
1605
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[99]
 
1606
#define SWIGTYPE_p_svn_io_dirent_t swig_types[100]
 
1607
#define SWIGTYPE_p_svn_io_file_del_t swig_types[101]
 
1608
#define SWIGTYPE_p_svn_location_segment_t swig_types[102]
 
1609
#define SWIGTYPE_p_svn_lock_t swig_types[103]
 
1610
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[104]
 
1611
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[105]
 
1612
#define SWIGTYPE_p_svn_log_entry_t swig_types[106]
 
1613
#define SWIGTYPE_p_svn_merge_range_t swig_types[107]
 
1614
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[108]
 
1615
#define SWIGTYPE_p_svn_node_kind_t swig_types[109]
 
1616
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[110]
 
1617
#define SWIGTYPE_p_svn_opt_revision_t swig_types[111]
 
1618
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[112]
 
1619
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[113]
 
1620
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[114]
 
1621
#define SWIGTYPE_p_svn_patch_file_t swig_types[115]
 
1622
#define SWIGTYPE_p_svn_patch_t swig_types[116]
 
1623
#define SWIGTYPE_p_svn_prop_kind swig_types[117]
 
1624
#define SWIGTYPE_p_svn_prop_patch_t swig_types[118]
 
1625
#define SWIGTYPE_p_svn_ra_callbacks2_t swig_types[119]
 
1626
#define SWIGTYPE_p_svn_ra_callbacks_t swig_types[120]
 
1627
#define SWIGTYPE_p_svn_ra_plugin_t swig_types[121]
 
1628
#define SWIGTYPE_p_svn_ra_reporter2_t swig_types[122]
 
1629
#define SWIGTYPE_p_svn_ra_reporter3_t swig_types[123]
 
1630
#define SWIGTYPE_p_svn_ra_reporter_t swig_types[124]
 
1631
#define SWIGTYPE_p_svn_ra_session_t swig_types[125]
 
1632
#define SWIGTYPE_p_svn_stream_mark_t swig_types[126]
 
1633
#define SWIGTYPE_p_svn_stream_t swig_types[127]
 
1634
#define SWIGTYPE_p_svn_string_t swig_types[128]
 
1635
#define SWIGTYPE_p_svn_stringbuf_t swig_types[129]
 
1636
#define SWIGTYPE_p_svn_tristate_t swig_types[130]
 
1637
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[131]
 
1638
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[132]
 
1639
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[133]
 
1640
#define SWIGTYPE_p_svn_version_checklist_t swig_types[134]
 
1641
#define SWIGTYPE_p_svn_version_t swig_types[135]
 
1642
#define SWIGTYPE_p_unsigned_long swig_types[136]
 
1643
#define SWIGTYPE_p_void swig_types[137]
 
1644
static swig_type_info *swig_types[139];
 
1645
static swig_module_info swig_module = {swig_types, 138, 0, 0, 0, 0};
1567
1646
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1568
1647
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1569
1648
 
1574
1653
#define SWIG_name   "SVN::_Ra::boot_SVN___Ra"
1575
1654
#define SWIG_prefix "SVN::_Ra::"
1576
1655
 
1577
 
#define SWIGVERSION 0x010336 
 
1656
#define SWIGVERSION 0x020004 
1578
1657
#define SWIG_VERSION SWIGVERSION
1579
1658
 
1580
1659
 
1622
1701
SWIGINTERN int
1623
1702
SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1624
1703
{
 
1704
  if (SvMAGICAL(obj)) {
 
1705
     SV *tmp = sv_newmortal();
 
1706
     SvSetSV(tmp, obj);
 
1707
     obj = tmp;
 
1708
  }
1625
1709
  if (SvPOK(obj)) {
1626
1710
    STRLEN len = 0;
1627
1711
    char *cstr = SvPV(obj, len); 
1700
1784
    const char *nptr = SvPV_nolen(obj);
1701
1785
    if (nptr) {
1702
1786
      char *endptr;
1703
 
      double v = strtod(nptr, &endptr);
 
1787
      double v;
 
1788
      errno = 0;
 
1789
      v = strtod(nptr, &endptr);
1704
1790
      if (errno == ERANGE) {
1705
1791
        errno = 0;
1706
1792
        return SWIG_OverflowError;
2103
2189
}
2104
2190
 
2105
2191
static svn_error_t * svn_ra_invoke_get_wc_prop_func(
2106
 
  svn_ra_get_wc_prop_func_t _obj, void *baton, const char *relpath, const char *name, const svn_string_t **value, apr_pool_t *pool) {
2107
 
  return _obj(baton, relpath, name, value, pool);
 
2192
  svn_ra_get_wc_prop_func_t _obj, void *baton, const char *path, const char *name, const svn_string_t **value, apr_pool_t *pool) {
 
2193
  return _obj(baton, path, name, value, pool);
2108
2194
}
2109
2195
 
2110
2196
static svn_error_t * svn_ra_invoke_set_wc_prop_func(
2207
2293
      
2208
2294
      
2209
2295
    }
2210
 
    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_version_t, 0 | SWIG_SHADOW); argvi++ ;
 
2296
    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_version_t, 0 | 0); argvi++ ;
2211
2297
    XSRETURN(argvi);
2212
2298
  fail:
2213
2299
    SWIG_croak_null();
2239
2325
      }
2240
2326
    }
2241
2327
    if (arg1) (arg1)->set_path = arg2;
2242
 
    
 
2328
    ST(argvi) = sv_newmortal();
2243
2329
    
2244
2330
    
2245
2331
    XSRETURN(argvi);
2303
2389
      }
2304
2390
    }
2305
2391
    if (arg1) (arg1)->delete_path = arg2;
2306
 
    
 
2392
    ST(argvi) = sv_newmortal();
2307
2393
    
2308
2394
    
2309
2395
    XSRETURN(argvi);
2367
2453
      }
2368
2454
    }
2369
2455
    if (arg1) (arg1)->link_path = arg2;
2370
 
    
 
2456
    ST(argvi) = sv_newmortal();
2371
2457
    
2372
2458
    
2373
2459
    XSRETURN(argvi);
2431
2517
      }
2432
2518
    }
2433
2519
    if (arg1) (arg1)->finish_report = arg2;
2434
 
    
 
2520
    ST(argvi) = sv_newmortal();
2435
2521
    
2436
2522
    
2437
2523
    XSRETURN(argvi);
2495
2581
      }
2496
2582
    }
2497
2583
    if (arg1) (arg1)->abort_report = arg2;
2498
 
    
 
2584
    ST(argvi) = sv_newmortal();
2499
2585
    
2500
2586
    
2501
2587
    XSRETURN(argvi);
2580
2666
      
2581
2667
      
2582
2668
    }
2583
 
    
 
2669
    ST(argvi) = sv_newmortal();
2584
2670
    
2585
2671
    XSRETURN(argvi);
2586
2672
  fail:
2614
2700
      }
2615
2701
    }
2616
2702
    if (arg1) (arg1)->set_path = arg2;
2617
 
    
 
2703
    ST(argvi) = sv_newmortal();
2618
2704
    
2619
2705
    
2620
2706
    XSRETURN(argvi);
2678
2764
      }
2679
2765
    }
2680
2766
    if (arg1) (arg1)->delete_path = arg2;
2681
 
    
 
2767
    ST(argvi) = sv_newmortal();
2682
2768
    
2683
2769
    
2684
2770
    XSRETURN(argvi);
2742
2828
      }
2743
2829
    }
2744
2830
    if (arg1) (arg1)->link_path = arg2;
2745
 
    
 
2831
    ST(argvi) = sv_newmortal();
2746
2832
    
2747
2833
    
2748
2834
    XSRETURN(argvi);
2806
2892
      }
2807
2893
    }
2808
2894
    if (arg1) (arg1)->finish_report = arg2;
2809
 
    
 
2895
    ST(argvi) = sv_newmortal();
2810
2896
    
2811
2897
    
2812
2898
    XSRETURN(argvi);
2870
2956
      }
2871
2957
    }
2872
2958
    if (arg1) (arg1)->abort_report = arg2;
2873
 
    
 
2959
    ST(argvi) = sv_newmortal();
2874
2960
    
2875
2961
    
2876
2962
    XSRETURN(argvi);
2955
3041
      
2956
3042
      
2957
3043
    }
2958
 
    
 
3044
    ST(argvi) = sv_newmortal();
2959
3045
    
2960
3046
    XSRETURN(argvi);
2961
3047
  fail:
2989
3075
      }
2990
3076
    }
2991
3077
    if (arg1) (arg1)->set_path = arg2;
2992
 
    
 
3078
    ST(argvi) = sv_newmortal();
2993
3079
    
2994
3080
    
2995
3081
    XSRETURN(argvi);
3053
3139
      }
3054
3140
    }
3055
3141
    if (arg1) (arg1)->delete_path = arg2;
3056
 
    
 
3142
    ST(argvi) = sv_newmortal();
3057
3143
    
3058
3144
    
3059
3145
    XSRETURN(argvi);
3117
3203
      }
3118
3204
    }
3119
3205
    if (arg1) (arg1)->link_path = arg2;
3120
 
    
 
3206
    ST(argvi) = sv_newmortal();
3121
3207
    
3122
3208
    
3123
3209
    XSRETURN(argvi);
3181
3267
      }
3182
3268
    }
3183
3269
    if (arg1) (arg1)->finish_report = arg2;
3184
 
    
 
3270
    ST(argvi) = sv_newmortal();
3185
3271
    
3186
3272
    
3187
3273
    XSRETURN(argvi);
3245
3331
      }
3246
3332
    }
3247
3333
    if (arg1) (arg1)->abort_report = arg2;
3248
 
    
 
3334
    ST(argvi) = sv_newmortal();
3249
3335
    
3250
3336
    
3251
3337
    XSRETURN(argvi);
3330
3416
      
3331
3417
      
3332
3418
    }
3333
 
    
 
3419
    ST(argvi) = sv_newmortal();
3334
3420
    
3335
3421
    XSRETURN(argvi);
3336
3422
  fail:
3364
3450
      }
3365
3451
    }
3366
3452
    if (arg1) (arg1)->open_tmp_file = arg2;
3367
 
    
 
3453
    ST(argvi) = sv_newmortal();
3368
3454
    
3369
3455
    
3370
3456
    XSRETURN(argvi);
3429
3515
    }
3430
3516
    arg2 = (svn_auth_baton_t *)(argp2);
3431
3517
    if (arg1) (arg1)->auth_baton = arg2;
3432
 
    
 
3518
    ST(argvi) = sv_newmortal();
3433
3519
    
3434
3520
    
3435
3521
    XSRETURN(argvi);
3493
3579
      }
3494
3580
    }
3495
3581
    if (arg1) (arg1)->get_wc_prop = arg2;
3496
 
    
 
3582
    ST(argvi) = sv_newmortal();
3497
3583
    
3498
3584
    
3499
3585
    XSRETURN(argvi);
3557
3643
      }
3558
3644
    }
3559
3645
    if (arg1) (arg1)->set_wc_prop = arg2;
3560
 
    
 
3646
    ST(argvi) = sv_newmortal();
3561
3647
    
3562
3648
    
3563
3649
    XSRETURN(argvi);
3621
3707
      }
3622
3708
    }
3623
3709
    if (arg1) (arg1)->push_wc_prop = arg2;
3624
 
    
 
3710
    ST(argvi) = sv_newmortal();
3625
3711
    
3626
3712
    
3627
3713
    XSRETURN(argvi);
3685
3771
      }
3686
3772
    }
3687
3773
    if (arg1) (arg1)->invalidate_wc_props = arg2;
3688
 
    
 
3774
    ST(argvi) = sv_newmortal();
3689
3775
    
3690
3776
    
3691
3777
    XSRETURN(argvi);
3749
3835
      }
3750
3836
    }
3751
3837
    if (arg1) (arg1)->progress_func = arg2;
3752
 
    
 
3838
    ST(argvi) = sv_newmortal();
3753
3839
    
3754
3840
    
3755
3841
    XSRETURN(argvi);
3812
3898
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_ra_callbacks2_t_progress_baton_set" "', argument " "2"" of type '" "void *""'"); 
3813
3899
    }
3814
3900
    if (arg1) (arg1)->progress_baton = arg2;
3815
 
    
 
3901
    ST(argvi) = sv_newmortal();
3816
3902
    
3817
3903
    
3818
3904
    XSRETURN(argvi);
3876
3962
      }
3877
3963
    }
3878
3964
    if (arg1) (arg1)->cancel_func = arg2;
3879
 
    
 
3965
    ST(argvi) = sv_newmortal();
3880
3966
    
3881
3967
    
3882
3968
    XSRETURN(argvi);
3940
4026
      }
3941
4027
    }
3942
4028
    if (arg1) (arg1)->get_client_string = arg2;
3943
 
    
 
4029
    ST(argvi) = sv_newmortal();
3944
4030
    
3945
4031
    
3946
4032
    XSRETURN(argvi);
4025
4111
      
4026
4112
      
4027
4113
    }
4028
 
    
 
4114
    ST(argvi) = sv_newmortal();
4029
4115
    
4030
4116
    XSRETURN(argvi);
4031
4117
  fail:
4059
4145
      }
4060
4146
    }
4061
4147
    if (arg1) (arg1)->open_tmp_file = arg2;
4062
 
    
 
4148
    ST(argvi) = sv_newmortal();
4063
4149
    
4064
4150
    
4065
4151
    XSRETURN(argvi);
4124
4210
    }
4125
4211
    arg2 = (svn_auth_baton_t *)(argp2);
4126
4212
    if (arg1) (arg1)->auth_baton = arg2;
4127
 
    
 
4213
    ST(argvi) = sv_newmortal();
4128
4214
    
4129
4215
    
4130
4216
    XSRETURN(argvi);
4188
4274
      }
4189
4275
    }
4190
4276
    if (arg1) (arg1)->get_wc_prop = arg2;
4191
 
    
 
4277
    ST(argvi) = sv_newmortal();
4192
4278
    
4193
4279
    
4194
4280
    XSRETURN(argvi);
4252
4338
      }
4253
4339
    }
4254
4340
    if (arg1) (arg1)->set_wc_prop = arg2;
4255
 
    
 
4341
    ST(argvi) = sv_newmortal();
4256
4342
    
4257
4343
    
4258
4344
    XSRETURN(argvi);
4316
4402
      }
4317
4403
    }
4318
4404
    if (arg1) (arg1)->push_wc_prop = arg2;
4319
 
    
 
4405
    ST(argvi) = sv_newmortal();
4320
4406
    
4321
4407
    
4322
4408
    XSRETURN(argvi);
4380
4466
      }
4381
4467
    }
4382
4468
    if (arg1) (arg1)->invalidate_wc_props = arg2;
4383
 
    
 
4469
    ST(argvi) = sv_newmortal();
4384
4470
    
4385
4471
    
4386
4472
    XSRETURN(argvi);
4465
4551
      
4466
4552
      
4467
4553
    }
4468
 
    
 
4554
    ST(argvi) = sv_newmortal();
4469
4555
    
4470
4556
    XSRETURN(argvi);
4471
4557
  fail:
4579
4665
}
4580
4666
 
4581
4667
 
 
4668
XS(_wrap_svn_ra_open4) {
 
4669
  {
 
4670
    svn_ra_session_t **arg1 = (svn_ra_session_t **) 0 ;
 
4671
    char **arg2 = (char **) 0 ;
 
4672
    char *arg3 = (char *) 0 ;
 
4673
    char *arg4 = (char *) 0 ;
 
4674
    svn_ra_callbacks2_t *arg5 = (svn_ra_callbacks2_t *) 0 ;
 
4675
    void *arg6 = (void *) 0 ;
 
4676
    apr_hash_t *arg7 = (apr_hash_t *) 0 ;
 
4677
    apr_pool_t *arg8 = (apr_pool_t *) 0 ;
 
4678
    apr_pool_t *_global_pool ;
 
4679
    svn_ra_session_t *temp1 ;
 
4680
    char *temp2 ;
 
4681
    int res3 ;
 
4682
    char *buf3 = 0 ;
 
4683
    int alloc3 = 0 ;
 
4684
    int res4 ;
 
4685
    char *buf4 = 0 ;
 
4686
    int alloc4 = 0 ;
 
4687
    void *argp5 = 0 ;
 
4688
    int res5 = 0 ;
 
4689
    int res6 ;
 
4690
    int argvi = 0;
 
4691
    svn_error_t *result = 0 ;
 
4692
    dXSARGS;
 
4693
    
 
4694
    {
 
4695
      _global_pool = arg8 = svn_swig_pl_make_pool (ST(items-1));
 
4696
    }
 
4697
    arg1 = &temp1;
 
4698
    arg2 = &temp2;
 
4699
    if ((items < 5) || (items > 6)) {
 
4700
      SWIG_croak("Usage: svn_ra_open4(repos_URL,uuid,callbacks,callback_baton,config,pool);");
 
4701
    }
 
4702
    res3 = SWIG_AsCharPtrAndSize(ST(0), &buf3, NULL, &alloc3);
 
4703
    if (!SWIG_IsOK(res3)) {
 
4704
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_ra_open4" "', argument " "3"" of type '" "char const *""'");
 
4705
    }
 
4706
    arg3 = (char *)(buf3);
 
4707
    res4 = SWIG_AsCharPtrAndSize(ST(1), &buf4, NULL, &alloc4);
 
4708
    if (!SWIG_IsOK(res4)) {
 
4709
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_ra_open4" "', argument " "4"" of type '" "char const *""'");
 
4710
    }
 
4711
    arg4 = (char *)(buf4);
 
4712
    res5 = SWIG_ConvertPtr(ST(2), &argp5,SWIGTYPE_p_svn_ra_callbacks2_t, 0 |  0 );
 
4713
    if (!SWIG_IsOK(res5)) {
 
4714
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_ra_open4" "', argument " "5"" of type '" "svn_ra_callbacks2_t const *""'"); 
 
4715
    }
 
4716
    arg5 = (svn_ra_callbacks2_t *)(argp5);
 
4717
    res6 = SWIG_ConvertPtr(ST(3),SWIG_as_voidptrptr(&arg6), 0, 0);
 
4718
    if (!SWIG_IsOK(res6)) {
 
4719
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svn_ra_open4" "', argument " "6"" of type '" "void *""'"); 
 
4720
    }
 
4721
    {
 
4722
      arg7 = svn_swig_pl_objs_to_hash_by_name (ST(4), "svn_config_t *",
 
4723
        _global_pool);
 
4724
    }
 
4725
    if (items > 5) {
 
4726
      
 
4727
    }
 
4728
    {
 
4729
      if (!arg5) {
 
4730
        SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
4731
      }
 
4732
    }
 
4733
    {
 
4734
      result = (svn_error_t *)svn_ra_open4(arg1,(char const **)arg2,(char const *)arg3,(char const *)arg4,(struct svn_ra_callbacks2_t const *)arg5,arg6,arg7,arg8);
 
4735
      
 
4736
      
 
4737
      
 
4738
    }
 
4739
    {
 
4740
      if (result) {
 
4741
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
4742
        
 
4743
        if (SvOK(exception_handler)) {
 
4744
          SV *callback_result;
 
4745
          
 
4746
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
4747
            &callback_result, "S", result,
 
4748
            SWIGTYPE_p_svn_error_t);
 
4749
        } else {
 
4750
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
4751
          argvi++;
 
4752
        }
 
4753
      }
 
4754
    }
 
4755
    {
 
4756
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_ra_session_t, 0); argvi++  ;
 
4757
    }
 
4758
    {
 
4759
      if (*arg2 == NULL) {
 
4760
        if (argvi >= items) EXTEND(sp,1);  ST(argvi) = &PL_sv_undef; argvi++  ;
 
4761
      } else {
 
4762
        if (argvi >= items) EXTEND(sp,1);  ST(argvi) = sv_2mortal(newSVpv(*arg2, 0)); argvi++  ;
 
4763
      }
 
4764
    }
 
4765
    
 
4766
    
 
4767
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
4768
    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
 
4769
    
 
4770
    
 
4771
    
 
4772
    
 
4773
    XSRETURN(argvi);
 
4774
  fail:
 
4775
    
 
4776
    
 
4777
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
4778
    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
 
4779
    
 
4780
    
 
4781
    
 
4782
    
 
4783
    SWIG_croak_null();
 
4784
  }
 
4785
}
 
4786
 
 
4787
 
4582
4788
XS(_wrap_svn_ra_open3) {
4583
4789
  {
4584
4790
    svn_ra_session_t **arg1 = (svn_ra_session_t **) 0 ;
5002
5208
}
5003
5209
 
5004
5210
 
 
5211
XS(_wrap_svn_ra_get_path_relative_to_session) {
 
5212
  {
 
5213
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
5214
    char **arg2 = (char **) 0 ;
 
5215
    char *arg3 = (char *) 0 ;
 
5216
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
5217
    apr_pool_t *_global_pool ;
 
5218
    void *argp1 = 0 ;
 
5219
    int res1 = 0 ;
 
5220
    char *temp2 ;
 
5221
    int res3 ;
 
5222
    char *buf3 = 0 ;
 
5223
    int alloc3 = 0 ;
 
5224
    int argvi = 0;
 
5225
    svn_error_t *result = 0 ;
 
5226
    dXSARGS;
 
5227
    
 
5228
    {
 
5229
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
5230
    }
 
5231
    arg2 = &temp2;
 
5232
    if ((items < 2) || (items > 3)) {
 
5233
      SWIG_croak("Usage: svn_ra_get_path_relative_to_session(ra_session,url,pool);");
 
5234
    }
 
5235
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_ra_session_t, 0 |  0 );
 
5236
    if (!SWIG_IsOK(res1)) {
 
5237
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_ra_get_path_relative_to_session" "', argument " "1"" of type '" "svn_ra_session_t *""'"); 
 
5238
    }
 
5239
    arg1 = (svn_ra_session_t *)(argp1);
 
5240
    res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
 
5241
    if (!SWIG_IsOK(res3)) {
 
5242
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_ra_get_path_relative_to_session" "', argument " "3"" of type '" "char const *""'");
 
5243
    }
 
5244
    arg3 = (char *)(buf3);
 
5245
    if (items > 2) {
 
5246
      
 
5247
    }
 
5248
    {
 
5249
      result = (svn_error_t *)svn_ra_get_path_relative_to_session(arg1,(char const **)arg2,(char const *)arg3,arg4);
 
5250
      
 
5251
      
 
5252
      
 
5253
    }
 
5254
    {
 
5255
      if (result) {
 
5256
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
5257
        
 
5258
        if (SvOK(exception_handler)) {
 
5259
          SV *callback_result;
 
5260
          
 
5261
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
5262
            &callback_result, "S", result,
 
5263
            SWIGTYPE_p_svn_error_t);
 
5264
        } else {
 
5265
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
5266
          argvi++;
 
5267
        }
 
5268
      }
 
5269
    }
 
5270
    {
 
5271
      if (*arg2 == NULL) {
 
5272
        if (argvi >= items) EXTEND(sp,1);  ST(argvi) = &PL_sv_undef; argvi++  ;
 
5273
      } else {
 
5274
        if (argvi >= items) EXTEND(sp,1);  ST(argvi) = sv_2mortal(newSVpv(*arg2, 0)); argvi++  ;
 
5275
      }
 
5276
    }
 
5277
    
 
5278
    
 
5279
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
5280
    
 
5281
    XSRETURN(argvi);
 
5282
  fail:
 
5283
    
 
5284
    
 
5285
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
5286
    
 
5287
    SWIG_croak_null();
 
5288
  }
 
5289
}
 
5290
 
 
5291
 
 
5292
XS(_wrap_svn_ra_get_path_relative_to_root) {
 
5293
  {
 
5294
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
5295
    char **arg2 = (char **) 0 ;
 
5296
    char *arg3 = (char *) 0 ;
 
5297
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
5298
    apr_pool_t *_global_pool ;
 
5299
    void *argp1 = 0 ;
 
5300
    int res1 = 0 ;
 
5301
    char *temp2 ;
 
5302
    int res3 ;
 
5303
    char *buf3 = 0 ;
 
5304
    int alloc3 = 0 ;
 
5305
    int argvi = 0;
 
5306
    svn_error_t *result = 0 ;
 
5307
    dXSARGS;
 
5308
    
 
5309
    {
 
5310
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
5311
    }
 
5312
    arg2 = &temp2;
 
5313
    if ((items < 2) || (items > 3)) {
 
5314
      SWIG_croak("Usage: svn_ra_get_path_relative_to_root(ra_session,url,pool);");
 
5315
    }
 
5316
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_ra_session_t, 0 |  0 );
 
5317
    if (!SWIG_IsOK(res1)) {
 
5318
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_ra_get_path_relative_to_root" "', argument " "1"" of type '" "svn_ra_session_t *""'"); 
 
5319
    }
 
5320
    arg1 = (svn_ra_session_t *)(argp1);
 
5321
    res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
 
5322
    if (!SWIG_IsOK(res3)) {
 
5323
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_ra_get_path_relative_to_root" "', argument " "3"" of type '" "char const *""'");
 
5324
    }
 
5325
    arg3 = (char *)(buf3);
 
5326
    if (items > 2) {
 
5327
      
 
5328
    }
 
5329
    {
 
5330
      result = (svn_error_t *)svn_ra_get_path_relative_to_root(arg1,(char const **)arg2,(char const *)arg3,arg4);
 
5331
      
 
5332
      
 
5333
      
 
5334
    }
 
5335
    {
 
5336
      if (result) {
 
5337
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
5338
        
 
5339
        if (SvOK(exception_handler)) {
 
5340
          SV *callback_result;
 
5341
          
 
5342
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
5343
            &callback_result, "S", result,
 
5344
            SWIGTYPE_p_svn_error_t);
 
5345
        } else {
 
5346
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
5347
          argvi++;
 
5348
        }
 
5349
      }
 
5350
    }
 
5351
    {
 
5352
      if (*arg2 == NULL) {
 
5353
        if (argvi >= items) EXTEND(sp,1);  ST(argvi) = &PL_sv_undef; argvi++  ;
 
5354
      } else {
 
5355
        if (argvi >= items) EXTEND(sp,1);  ST(argvi) = sv_2mortal(newSVpv(*arg2, 0)); argvi++  ;
 
5356
      }
 
5357
    }
 
5358
    
 
5359
    
 
5360
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
5361
    
 
5362
    XSRETURN(argvi);
 
5363
  fail:
 
5364
    
 
5365
    
 
5366
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
5367
    
 
5368
    SWIG_croak_null();
 
5369
  }
 
5370
}
 
5371
 
 
5372
 
5005
5373
XS(_wrap_svn_ra_get_latest_revnum) {
5006
5374
  {
5007
5375
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
5152
5520
}
5153
5521
 
5154
5522
 
 
5523
XS(_wrap_svn_ra_change_rev_prop2) {
 
5524
  {
 
5525
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
5526
    svn_revnum_t arg2 ;
 
5527
    char *arg3 = (char *) 0 ;
 
5528
    svn_string_t **arg4 = (svn_string_t **) 0 ;
 
5529
    svn_string_t *arg5 = (svn_string_t *) 0 ;
 
5530
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
5531
    apr_pool_t *_global_pool ;
 
5532
    void *argp1 = 0 ;
 
5533
    int res1 = 0 ;
 
5534
    long val2 ;
 
5535
    int ecode2 = 0 ;
 
5536
    int res3 ;
 
5537
    char *buf3 = 0 ;
 
5538
    int alloc3 = 0 ;
 
5539
    void *argp4 = 0 ;
 
5540
    int res4 = 0 ;
 
5541
    svn_string_t value5 ;
 
5542
    int argvi = 0;
 
5543
    SV * _saved[1] ;
 
5544
    svn_error_t *result = 0 ;
 
5545
    dXSARGS;
 
5546
    
 
5547
    {
 
5548
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
 
5549
    }
 
5550
    if ((items < 5) || (items > 6)) {
 
5551
      SWIG_croak("Usage: svn_ra_change_rev_prop2(session,rev,name,old_value_p,value,pool);");
 
5552
    }
 
5553
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_ra_session_t, 0 |  0 );
 
5554
    if (!SWIG_IsOK(res1)) {
 
5555
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_ra_change_rev_prop2" "', argument " "1"" of type '" "svn_ra_session_t *""'"); 
 
5556
    }
 
5557
    arg1 = (svn_ra_session_t *)(argp1);
 
5558
    ecode2 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
 
5559
    if (!SWIG_IsOK(ecode2)) {
 
5560
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svn_ra_change_rev_prop2" "', argument " "2"" of type '" "svn_revnum_t""'");
 
5561
    } 
 
5562
    arg2 = (svn_revnum_t)(val2);
 
5563
    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
 
5564
    if (!SWIG_IsOK(res3)) {
 
5565
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_ra_change_rev_prop2" "', argument " "3"" of type '" "char const *""'");
 
5566
    }
 
5567
    arg3 = (char *)(buf3);
 
5568
    res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_svn_string_t, 0 |  0 );
 
5569
    if (!SWIG_IsOK(res4)) {
 
5570
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_ra_change_rev_prop2" "', argument " "4"" of type '" "svn_string_t const *const *""'"); 
 
5571
    }
 
5572
    arg4 = (svn_string_t **)(argp4);
 
5573
    {
 
5574
      if (SvOK(ST(4))) {
 
5575
        value5.data = SvPV(ST(4), value5.len);
 
5576
        arg5 = &value5;
 
5577
      }
 
5578
      else {
 
5579
        arg5 = NULL;
 
5580
      }
 
5581
    }
 
5582
    if (items > 5) {
 
5583
      
 
5584
    }
 
5585
    _saved[0] = ST(3);
 
5586
    {
 
5587
      result = (svn_error_t *)svn_ra_change_rev_prop2(arg1,arg2,(char const *)arg3,(struct svn_string_t const *const *)arg4,(struct svn_string_t const *)arg5,arg6);
 
5588
      
 
5589
      
 
5590
      
 
5591
    }
 
5592
    {
 
5593
      if (result) {
 
5594
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
5595
        
 
5596
        if (SvOK(exception_handler)) {
 
5597
          SV *callback_result;
 
5598
          
 
5599
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
5600
            &callback_result, "S", result,
 
5601
            SWIGTYPE_p_svn_error_t);
 
5602
        } else {
 
5603
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
5604
          argvi++;
 
5605
        }
 
5606
      }
 
5607
    }
 
5608
    {
 
5609
      if (*arg4) {
 
5610
        if (argvi >= items) EXTEND(sp,1);  ST(argvi) = sv_2mortal(newSVpvn((*arg4)->data, (*arg4)->len)); argvi++  ;
 
5611
      } else {
 
5612
        if (argvi >= items) EXTEND(sp,1);  ST(argvi) = &PL_sv_undef; argvi++  ;
 
5613
      }
 
5614
    }
 
5615
    
 
5616
    
 
5617
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
5618
    
 
5619
    
 
5620
    
 
5621
    XSRETURN(argvi);
 
5622
  fail:
 
5623
    
 
5624
    
 
5625
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
5626
    
 
5627
    
 
5628
    
 
5629
    SWIG_croak_null();
 
5630
  }
 
5631
}
 
5632
 
 
5633
 
5155
5634
XS(_wrap_svn_ra_change_rev_prop) {
5156
5635
  {
5157
5636
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
8075
8554
    arg4 = (svn_revnum_t)(val4);
8076
8555
    res5 = SWIG_ConvertPtr(ST(3), &argp5,SWIGTYPE_p_apr_array_header_t, 0 |  0 );
8077
8556
    if (!SWIG_IsOK(res5)) {
8078
 
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_ra_get_locations" "', argument " "5"" of type '" "apr_array_header_t *""'"); 
 
8557
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_ra_get_locations" "', argument " "5"" of type '" "apr_array_header_t const *""'"); 
8079
8558
    }
8080
8559
    arg5 = (apr_array_header_t *)(argp5);
8081
8560
    if (items > 4) {
8082
8561
      
8083
8562
    }
8084
8563
    {
8085
 
      result = (svn_error_t *)svn_ra_get_locations(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
 
8564
      result = (svn_error_t *)svn_ra_get_locations(arg1,arg2,(char const *)arg3,arg4,(apr_array_header_t const *)arg5,arg6);
8086
8565
      
8087
8566
      
8088
8567
      
8717
9196
}
8718
9197
 
8719
9198
 
 
9199
XS(_wrap_svn_ra_get_locks2) {
 
9200
  {
 
9201
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
9202
    apr_hash_t **arg2 = (apr_hash_t **) 0 ;
 
9203
    char *arg3 = (char *) 0 ;
 
9204
    svn_depth_t arg4 ;
 
9205
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
9206
    apr_pool_t *_global_pool ;
 
9207
    void *argp1 = 0 ;
 
9208
    int res1 = 0 ;
 
9209
    apr_hash_t *temp2 ;
 
9210
    int res3 ;
 
9211
    char *buf3 = 0 ;
 
9212
    int alloc3 = 0 ;
 
9213
    int val4 ;
 
9214
    int ecode4 = 0 ;
 
9215
    int argvi = 0;
 
9216
    svn_error_t *result = 0 ;
 
9217
    dXSARGS;
 
9218
    
 
9219
    {
 
9220
      _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
 
9221
    }
 
9222
    arg2 = &temp2;
 
9223
    if ((items < 3) || (items > 4)) {
 
9224
      SWIG_croak("Usage: svn_ra_get_locks2(session,path,depth,pool);");
 
9225
    }
 
9226
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_ra_session_t, 0 |  0 );
 
9227
    if (!SWIG_IsOK(res1)) {
 
9228
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_ra_get_locks2" "', argument " "1"" of type '" "svn_ra_session_t *""'"); 
 
9229
    }
 
9230
    arg1 = (svn_ra_session_t *)(argp1);
 
9231
    res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
 
9232
    if (!SWIG_IsOK(res3)) {
 
9233
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_ra_get_locks2" "', argument " "3"" of type '" "char const *""'");
 
9234
    }
 
9235
    arg3 = (char *)(buf3);
 
9236
    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val4);
 
9237
    if (!SWIG_IsOK(ecode4)) {
 
9238
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "svn_ra_get_locks2" "', argument " "4"" of type '" "svn_depth_t""'");
 
9239
    } 
 
9240
    arg4 = (svn_depth_t)(val4);
 
9241
    if (items > 3) {
 
9242
      
 
9243
    }
 
9244
    {
 
9245
      result = (svn_error_t *)svn_ra_get_locks2(arg1,arg2,(char const *)arg3,arg4,arg5);
 
9246
      
 
9247
      
 
9248
      
 
9249
    }
 
9250
    {
 
9251
      if (result) {
 
9252
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
9253
        
 
9254
        if (SvOK(exception_handler)) {
 
9255
          SV *callback_result;
 
9256
          
 
9257
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
9258
            &callback_result, "S", result,
 
9259
            SWIGTYPE_p_svn_error_t);
 
9260
        } else {
 
9261
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
9262
          argvi++;
 
9263
        }
 
9264
      }
 
9265
    }
 
9266
    {
 
9267
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = svn_swig_pl_convert_hash(*arg2, SWIGTYPE_p_svn_lock_t); argvi++  ;
 
9268
    }
 
9269
    
 
9270
    
 
9271
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
9272
    
 
9273
    
 
9274
    XSRETURN(argvi);
 
9275
  fail:
 
9276
    
 
9277
    
 
9278
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
9279
    
 
9280
    
 
9281
    SWIG_croak_null();
 
9282
  }
 
9283
}
 
9284
 
 
9285
 
8720
9286
XS(_wrap_svn_ra_get_locks) {
8721
9287
  {
8722
9288
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
9011
9577
}
9012
9578
 
9013
9579
 
 
9580
XS(_wrap_svn_ra_get_deleted_rev) {
 
9581
  {
 
9582
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
9583
    char *arg2 = (char *) 0 ;
 
9584
    svn_revnum_t arg3 ;
 
9585
    svn_revnum_t arg4 ;
 
9586
    svn_revnum_t *arg5 = (svn_revnum_t *) 0 ;
 
9587
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
9588
    apr_pool_t *_global_pool ;
 
9589
    void *argp1 = 0 ;
 
9590
    int res1 = 0 ;
 
9591
    int res2 ;
 
9592
    char *buf2 = 0 ;
 
9593
    int alloc2 = 0 ;
 
9594
    long val3 ;
 
9595
    int ecode3 = 0 ;
 
9596
    long val4 ;
 
9597
    int ecode4 = 0 ;
 
9598
    svn_revnum_t temp5 ;
 
9599
    int res5 = SWIG_TMPOBJ ;
 
9600
    int argvi = 0;
 
9601
    svn_error_t *result = 0 ;
 
9602
    dXSARGS;
 
9603
    
 
9604
    {
 
9605
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
 
9606
    }
 
9607
    arg5 = &temp5;
 
9608
    if ((items < 4) || (items > 5)) {
 
9609
      SWIG_croak("Usage: svn_ra_get_deleted_rev(session,path,peg_revision,end_revision,pool);");
 
9610
    }
 
9611
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_ra_session_t, 0 |  0 );
 
9612
    if (!SWIG_IsOK(res1)) {
 
9613
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_ra_get_deleted_rev" "', argument " "1"" of type '" "svn_ra_session_t *""'"); 
 
9614
    }
 
9615
    arg1 = (svn_ra_session_t *)(argp1);
 
9616
    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
 
9617
    if (!SWIG_IsOK(res2)) {
 
9618
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_ra_get_deleted_rev" "', argument " "2"" of type '" "char const *""'");
 
9619
    }
 
9620
    arg2 = (char *)(buf2);
 
9621
    ecode3 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
 
9622
    if (!SWIG_IsOK(ecode3)) {
 
9623
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svn_ra_get_deleted_rev" "', argument " "3"" of type '" "svn_revnum_t""'");
 
9624
    } 
 
9625
    arg3 = (svn_revnum_t)(val3);
 
9626
    ecode4 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
 
9627
    if (!SWIG_IsOK(ecode4)) {
 
9628
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "svn_ra_get_deleted_rev" "', argument " "4"" of type '" "svn_revnum_t""'");
 
9629
    } 
 
9630
    arg4 = (svn_revnum_t)(val4);
 
9631
    if (items > 4) {
 
9632
      
 
9633
    }
 
9634
    {
 
9635
      result = (svn_error_t *)svn_ra_get_deleted_rev(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
 
9636
      
 
9637
      
 
9638
      
 
9639
    }
 
9640
    {
 
9641
      if (result) {
 
9642
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
9643
        
 
9644
        if (SvOK(exception_handler)) {
 
9645
          SV *callback_result;
 
9646
          
 
9647
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
9648
            &callback_result, "S", result,
 
9649
            SWIGTYPE_p_svn_error_t);
 
9650
        } else {
 
9651
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
9652
          argvi++;
 
9653
        }
 
9654
      }
 
9655
    }
 
9656
    if (SWIG_IsTmpObj(res5)) {
 
9657
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_From_long  SWIG_PERL_CALL_ARGS_1((*arg5)); argvi++  ;
 
9658
    } else {
 
9659
      int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0) : 0;
 
9660
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags); argvi++  ;
 
9661
    }
 
9662
    
 
9663
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
9664
    
 
9665
    
 
9666
    
 
9667
    
 
9668
    XSRETURN(argvi);
 
9669
  fail:
 
9670
    
 
9671
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
9672
    
 
9673
    
 
9674
    
 
9675
    
 
9676
    SWIG_croak_null();
 
9677
  }
 
9678
}
 
9679
 
 
9680
 
9014
9681
XS(_wrap_svn_ra_has_capability) {
9015
9682
  {
9016
9683
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
9092
9759
}
9093
9760
 
9094
9761
 
9095
 
XS(_wrap_svn_ra_get_deleted_rev) {
9096
 
  {
9097
 
    svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
9098
 
    char *arg2 = (char *) 0 ;
9099
 
    svn_revnum_t arg3 ;
9100
 
    svn_revnum_t arg4 ;
9101
 
    svn_revnum_t *arg5 = (svn_revnum_t *) 0 ;
9102
 
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
9103
 
    apr_pool_t *_global_pool ;
9104
 
    void *argp1 = 0 ;
9105
 
    int res1 = 0 ;
9106
 
    int res2 ;
9107
 
    char *buf2 = 0 ;
9108
 
    int alloc2 = 0 ;
9109
 
    long val3 ;
9110
 
    int ecode3 = 0 ;
9111
 
    long val4 ;
9112
 
    int ecode4 = 0 ;
9113
 
    svn_revnum_t temp5 ;
9114
 
    int res5 = SWIG_TMPOBJ ;
9115
 
    int argvi = 0;
9116
 
    svn_error_t *result = 0 ;
9117
 
    dXSARGS;
9118
 
    
9119
 
    {
9120
 
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
9121
 
    }
9122
 
    arg5 = &temp5;
9123
 
    if ((items < 4) || (items > 5)) {
9124
 
      SWIG_croak("Usage: svn_ra_get_deleted_rev(session,path,peg_revision,end_revision,pool);");
9125
 
    }
9126
 
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_ra_session_t, 0 |  0 );
9127
 
    if (!SWIG_IsOK(res1)) {
9128
 
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_ra_get_deleted_rev" "', argument " "1"" of type '" "svn_ra_session_t *""'"); 
9129
 
    }
9130
 
    arg1 = (svn_ra_session_t *)(argp1);
9131
 
    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
9132
 
    if (!SWIG_IsOK(res2)) {
9133
 
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_ra_get_deleted_rev" "', argument " "2"" of type '" "char const *""'");
9134
 
    }
9135
 
    arg2 = (char *)(buf2);
9136
 
    ecode3 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
9137
 
    if (!SWIG_IsOK(ecode3)) {
9138
 
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svn_ra_get_deleted_rev" "', argument " "3"" of type '" "svn_revnum_t""'");
9139
 
    } 
9140
 
    arg3 = (svn_revnum_t)(val3);
9141
 
    ecode4 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
9142
 
    if (!SWIG_IsOK(ecode4)) {
9143
 
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "svn_ra_get_deleted_rev" "', argument " "4"" of type '" "svn_revnum_t""'");
9144
 
    } 
9145
 
    arg4 = (svn_revnum_t)(val4);
9146
 
    if (items > 4) {
9147
 
      
9148
 
    }
9149
 
    {
9150
 
      result = (svn_error_t *)svn_ra_get_deleted_rev(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
9151
 
      
9152
 
      
9153
 
      
9154
 
    }
9155
 
    {
9156
 
      if (result) {
9157
 
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
9158
 
        
9159
 
        if (SvOK(exception_handler)) {
9160
 
          SV *callback_result;
9161
 
          
9162
 
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
9163
 
            &callback_result, "S", result,
9164
 
            SWIGTYPE_p_svn_error_t);
9165
 
        } else {
9166
 
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
9167
 
          argvi++;
9168
 
        }
9169
 
      }
9170
 
    }
9171
 
    if (SWIG_IsTmpObj(res5)) {
9172
 
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_From_long  SWIG_PERL_CALL_ARGS_1((*arg5)); argvi++  ;
9173
 
    } else {
9174
 
      int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0) : 0;
9175
 
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags); argvi++  ;
9176
 
    }
9177
 
    
9178
 
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9179
 
    
9180
 
    
9181
 
    
9182
 
    
9183
 
    XSRETURN(argvi);
9184
 
  fail:
9185
 
    
9186
 
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9187
 
    
9188
 
    
9189
 
    
9190
 
    
9191
 
    SWIG_croak_null();
9192
 
  }
9193
 
}
9194
 
 
9195
 
 
9196
9762
XS(_wrap_svn_ra_print_modules) {
9197
9763
  {
9198
9764
    svn_stringbuf_t *arg1 = (svn_stringbuf_t *) 0 ;
9361
9927
      memcpy(copied, arg2, len);
9362
9928
      arg1->name = copied;
9363
9929
    }
9364
 
    
 
9930
    ST(argvi) = sv_newmortal();
9365
9931
    
9366
9932
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9367
9933
    XSRETURN(argvi);
9434
10000
      memcpy(copied, arg2, len);
9435
10001
      arg1->description = copied;
9436
10002
    }
9437
 
    
 
10003
    ST(argvi) = sv_newmortal();
9438
10004
    
9439
10005
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9440
10006
    XSRETURN(argvi);
9498
10064
      }
9499
10065
    }
9500
10066
    if (arg1) (arg1)->open = arg2;
9501
 
    
 
10067
    ST(argvi) = sv_newmortal();
9502
10068
    
9503
10069
    
9504
10070
    XSRETURN(argvi);
9562
10128
      }
9563
10129
    }
9564
10130
    if (arg1) (arg1)->get_latest_revnum = arg2;
9565
 
    
 
10131
    ST(argvi) = sv_newmortal();
9566
10132
    
9567
10133
    
9568
10134
    XSRETURN(argvi);
9626
10192
      }
9627
10193
    }
9628
10194
    if (arg1) (arg1)->get_dated_revision = arg2;
9629
 
    
 
10195
    ST(argvi) = sv_newmortal();
9630
10196
    
9631
10197
    
9632
10198
    XSRETURN(argvi);
9690
10256
      }
9691
10257
    }
9692
10258
    if (arg1) (arg1)->change_rev_prop = arg2;
9693
 
    
 
10259
    ST(argvi) = sv_newmortal();
9694
10260
    
9695
10261
    
9696
10262
    XSRETURN(argvi);
9754
10320
      }
9755
10321
    }
9756
10322
    if (arg1) (arg1)->rev_proplist = arg2;
9757
 
    
 
10323
    ST(argvi) = sv_newmortal();
9758
10324
    
9759
10325
    
9760
10326
    XSRETURN(argvi);
9818
10384
      }
9819
10385
    }
9820
10386
    if (arg1) (arg1)->rev_prop = arg2;
9821
 
    
 
10387
    ST(argvi) = sv_newmortal();
9822
10388
    
9823
10389
    
9824
10390
    XSRETURN(argvi);
9882
10448
      }
9883
10449
    }
9884
10450
    if (arg1) (arg1)->get_commit_editor = arg2;
9885
 
    
 
10451
    ST(argvi) = sv_newmortal();
9886
10452
    
9887
10453
    
9888
10454
    XSRETURN(argvi);
9946
10512
      }
9947
10513
    }
9948
10514
    if (arg1) (arg1)->get_file = arg2;
9949
 
    
 
10515
    ST(argvi) = sv_newmortal();
9950
10516
    
9951
10517
    
9952
10518
    XSRETURN(argvi);
10010
10576
      }
10011
10577
    }
10012
10578
    if (arg1) (arg1)->get_dir = arg2;
10013
 
    
 
10579
    ST(argvi) = sv_newmortal();
10014
10580
    
10015
10581
    
10016
10582
    XSRETURN(argvi);
10074
10640
      }
10075
10641
    }
10076
10642
    if (arg1) (arg1)->do_update = arg2;
10077
 
    
 
10643
    ST(argvi) = sv_newmortal();
10078
10644
    
10079
10645
    
10080
10646
    XSRETURN(argvi);
10138
10704
      }
10139
10705
    }
10140
10706
    if (arg1) (arg1)->do_switch = arg2;
10141
 
    
 
10707
    ST(argvi) = sv_newmortal();
10142
10708
    
10143
10709
    
10144
10710
    XSRETURN(argvi);
10202
10768
      }
10203
10769
    }
10204
10770
    if (arg1) (arg1)->do_status = arg2;
10205
 
    
 
10771
    ST(argvi) = sv_newmortal();
10206
10772
    
10207
10773
    
10208
10774
    XSRETURN(argvi);
10266
10832
      }
10267
10833
    }
10268
10834
    if (arg1) (arg1)->do_diff = arg2;
10269
 
    
 
10835
    ST(argvi) = sv_newmortal();
10270
10836
    
10271
10837
    
10272
10838
    XSRETURN(argvi);
10330
10896
      }
10331
10897
    }
10332
10898
    if (arg1) (arg1)->get_log = arg2;
10333
 
    
 
10899
    ST(argvi) = sv_newmortal();
10334
10900
    
10335
10901
    
10336
10902
    XSRETURN(argvi);
10394
10960
      }
10395
10961
    }
10396
10962
    if (arg1) (arg1)->check_path = arg2;
10397
 
    
 
10963
    ST(argvi) = sv_newmortal();
10398
10964
    
10399
10965
    
10400
10966
    XSRETURN(argvi);
10458
11024
      }
10459
11025
    }
10460
11026
    if (arg1) (arg1)->get_uuid = arg2;
10461
 
    
 
11027
    ST(argvi) = sv_newmortal();
10462
11028
    
10463
11029
    
10464
11030
    XSRETURN(argvi);
10522
11088
      }
10523
11089
    }
10524
11090
    if (arg1) (arg1)->get_repos_root = arg2;
10525
 
    
 
11091
    ST(argvi) = sv_newmortal();
10526
11092
    
10527
11093
    
10528
11094
    XSRETURN(argvi);
10586
11152
      }
10587
11153
    }
10588
11154
    if (arg1) (arg1)->get_locations = arg2;
10589
 
    
 
11155
    ST(argvi) = sv_newmortal();
10590
11156
    
10591
11157
    
10592
11158
    XSRETURN(argvi);
10650
11216
      }
10651
11217
    }
10652
11218
    if (arg1) (arg1)->get_file_revs = arg2;
10653
 
    
 
11219
    ST(argvi) = sv_newmortal();
10654
11220
    
10655
11221
    
10656
11222
    XSRETURN(argvi);
10714
11280
      }
10715
11281
    }
10716
11282
    if (arg1) (arg1)->get_version = (svn_version_t const *(*)(void))arg2;
10717
 
    
 
11283
    ST(argvi) = sv_newmortal();
10718
11284
    
10719
11285
    
10720
11286
    XSRETURN(argvi);
10799
11365
      
10800
11366
      
10801
11367
    }
10802
 
    
 
11368
    ST(argvi) = sv_newmortal();
10803
11369
    
10804
11370
    XSRETURN(argvi);
10805
11371
  fail:
14386
14952
      
14387
14953
      
14388
14954
    }
14389
 
    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_version_t, 0 | SWIG_SHADOW); argvi++ ;
 
14955
    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_version_t, 0 | 0); argvi++ ;
14390
14956
    
14391
14957
    XSRETURN(argvi);
14392
14958
  fail:
14422
14988
    }
14423
14989
    arg5 = &temp5;
14424
14990
    if ((items < 4) || (items > 5)) {
14425
 
      SWIG_croak("Usage: svn_ra_invoke_get_wc_prop_func(_obj,baton,relpath,name,pool);");
 
14991
      SWIG_croak("Usage: svn_ra_invoke_get_wc_prop_func(_obj,baton,path,name,pool);");
14426
14992
    }
14427
14993
    {
14428
14994
      int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_p_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t);
15205
15771
      
15206
15772
      
15207
15773
    }
15208
 
    
 
15774
    ST(argvi) = sv_newmortal();
15209
15775
    
15210
15776
    
15211
15777
    
15586
16152
static swig_type_info _swigt__p_svn_diff_datasource_e = {"_p_svn_diff_datasource_e", "enum svn_diff_datasource_e *|svn_diff_datasource_e *", 0, 0, (void*)0, 0};
15587
16153
static swig_type_info _swigt__p_svn_diff_file_ignore_space_t = {"_p_svn_diff_file_ignore_space_t", "enum svn_diff_file_ignore_space_t *|svn_diff_file_ignore_space_t *", 0, 0, (void*)0, 0};
15588
16154
static swig_type_info _swigt__p_svn_diff_file_options_t = {"_p_svn_diff_file_options_t", "struct svn_diff_file_options_t *|svn_diff_file_options_t *", 0, 0, (void*)0, 0};
 
16155
static swig_type_info _swigt__p_svn_diff_fns2_t = {"_p_svn_diff_fns2_t", "struct svn_diff_fns2_t *|svn_diff_fns2_t *", 0, 0, (void*)0, 0};
15589
16156
static swig_type_info _swigt__p_svn_diff_fns_t = {"_p_svn_diff_fns_t", "struct svn_diff_fns_t *|svn_diff_fns_t *", 0, 0, (void*)0, 0};
 
16157
static swig_type_info _swigt__p_svn_diff_hunk_t = {"_p_svn_diff_hunk_t", "struct svn_diff_hunk_t *|svn_diff_hunk_t *", 0, 0, (void*)0, 0};
 
16158
static swig_type_info _swigt__p_svn_diff_operation_kind_e = {"_p_svn_diff_operation_kind_e", "svn_diff_operation_kind_t *|enum svn_diff_operation_kind_e *", 0, 0, (void*)0, 0};
15590
16159
static swig_type_info _swigt__p_svn_diff_output_fns_t = {"_p_svn_diff_output_fns_t", "struct svn_diff_output_fns_t *|svn_diff_output_fns_t *", 0, 0, (void*)0, 0};
15591
16160
static swig_type_info _swigt__p_svn_diff_t = {"_p_svn_diff_t", "struct svn_diff_t *|svn_diff_t *", 0, 0, (void*)0, 0};
15592
16161
static swig_type_info _swigt__p_svn_dirent_t = {"_p_svn_dirent_t", "struct svn_dirent_t *|svn_dirent_t *", 0, 0, (void*)0, 0};
15593
16162
static swig_type_info _swigt__p_svn_errno_t = {"_p_svn_errno_t", "enum svn_errno_t *|svn_errno_t *", 0, 0, (void*)0, 0};
15594
16163
static swig_type_info _swigt__p_svn_error_t = {"_p_svn_error_t", "struct svn_error_t *|svn_error_t *", 0, 0, (void*)0, 0};
 
16164
static swig_type_info _swigt__p_svn_io_dirent2_t = {"_p_svn_io_dirent2_t", "struct svn_io_dirent2_t *|svn_io_dirent2_t *", 0, 0, (void*)0, 0};
15595
16165
static swig_type_info _swigt__p_svn_io_dirent_t = {"_p_svn_io_dirent_t", "struct svn_io_dirent_t *|svn_io_dirent_t *", 0, 0, (void*)0, 0};
15596
16166
static swig_type_info _swigt__p_svn_io_file_del_t = {"_p_svn_io_file_del_t", "enum svn_io_file_del_t *|svn_io_file_del_t *", 0, 0, (void*)0, 0};
15597
16167
static swig_type_info _swigt__p_svn_location_segment_t = {"_p_svn_location_segment_t", "struct svn_location_segment_t *|svn_location_segment_t *", 0, 0, (void*)0, 0};
15607
16177
static swig_type_info _swigt__p_svn_opt_revision_value_t = {"_p_svn_opt_revision_value_t", "union svn_opt_revision_value_t *|svn_opt_revision_value_t *", 0, 0, (void*)0, 0};
15608
16178
static swig_type_info _swigt__p_svn_opt_subcommand_desc2_t = {"_p_svn_opt_subcommand_desc2_t", "struct svn_opt_subcommand_desc2_t *|svn_opt_subcommand_desc2_t *", 0, 0, (void*)0, 0};
15609
16179
static swig_type_info _swigt__p_svn_opt_subcommand_desc_t = {"_p_svn_opt_subcommand_desc_t", "struct svn_opt_subcommand_desc_t *|svn_opt_subcommand_desc_t *", 0, 0, (void*)0, 0};
 
16180
static swig_type_info _swigt__p_svn_patch_file_t = {"_p_svn_patch_file_t", "struct svn_patch_file_t *|svn_patch_file_t *", 0, 0, (void*)0, 0};
 
16181
static swig_type_info _swigt__p_svn_patch_t = {"_p_svn_patch_t", "struct svn_patch_t *|svn_patch_t *", 0, 0, (void*)0, 0};
15610
16182
static swig_type_info _swigt__p_svn_prop_kind = {"_p_svn_prop_kind", "svn_prop_kind_t *|enum svn_prop_kind *", 0, 0, (void*)0, 0};
 
16183
static swig_type_info _swigt__p_svn_prop_patch_t = {"_p_svn_prop_patch_t", "struct svn_prop_patch_t *|svn_prop_patch_t *", 0, 0, (void*)0, 0};
15611
16184
static swig_type_info _swigt__p_svn_ra_callbacks2_t = {"_p_svn_ra_callbacks2_t", "struct svn_ra_callbacks2_t *|svn_ra_callbacks2_t *", 0, 0, (void*)0, 0};
15612
16185
static swig_type_info _swigt__p_svn_ra_callbacks_t = {"_p_svn_ra_callbacks_t", "struct svn_ra_callbacks_t *|svn_ra_callbacks_t *", 0, 0, (void*)0, 0};
15613
16186
static swig_type_info _swigt__p_svn_ra_plugin_t = {"_p_svn_ra_plugin_t", "struct svn_ra_plugin_t *|svn_ra_plugin_t *", 0, 0, (void*)0, 0};
15615
16188
static swig_type_info _swigt__p_svn_ra_reporter3_t = {"_p_svn_ra_reporter3_t", "struct svn_ra_reporter3_t *|svn_ra_reporter3_t *", 0, 0, (void*)0, 0};
15616
16189
static swig_type_info _swigt__p_svn_ra_reporter_t = {"_p_svn_ra_reporter_t", "struct svn_ra_reporter_t *|svn_ra_reporter_t *", 0, 0, (void*)0, 0};
15617
16190
static swig_type_info _swigt__p_svn_ra_session_t = {"_p_svn_ra_session_t", "struct svn_ra_session_t *|svn_ra_session_t *", 0, 0, (void*)0, 0};
 
16191
static swig_type_info _swigt__p_svn_stream_mark_t = {"_p_svn_stream_mark_t", "struct svn_stream_mark_t *|svn_stream_mark_t *", 0, 0, (void*)0, 0};
15618
16192
static swig_type_info _swigt__p_svn_stream_t = {"_p_svn_stream_t", "struct svn_stream_t *|svn_stream_t *", 0, 0, (void*)0, 0};
15619
16193
static swig_type_info _swigt__p_svn_string_t = {"_p_svn_string_t", "struct svn_string_t *|svn_string_t *", 0, 0, (void*)0, 0};
15620
16194
static swig_type_info _swigt__p_svn_stringbuf_t = {"_p_svn_stringbuf_t", "struct svn_stringbuf_t *|svn_stringbuf_t *", 0, 0, (void*)0, 0};
 
16195
static swig_type_info _swigt__p_svn_tristate_t = {"_p_svn_tristate_t", "enum svn_tristate_t *|svn_tristate_t *", 0, 0, (void*)0, 0};
15621
16196
static swig_type_info _swigt__p_svn_txdelta_op_t = {"_p_svn_txdelta_op_t", "struct svn_txdelta_op_t *|svn_txdelta_op_t *", 0, 0, (void*)0, 0};
15622
16197
static swig_type_info _swigt__p_svn_txdelta_stream_t = {"_p_svn_txdelta_stream_t", "struct svn_txdelta_stream_t *|svn_txdelta_stream_t *", 0, 0, (void*)0, 0};
15623
16198
static swig_type_info _swigt__p_svn_txdelta_window_t = {"_p_svn_txdelta_window_t", "struct svn_txdelta_window_t *|svn_txdelta_window_t *", 0, 0, (void*)0, 0};
15624
16199
static swig_type_info _swigt__p_svn_version_checklist_t = {"_p_svn_version_checklist_t", "struct svn_version_checklist_t *|svn_version_checklist_t *", 0, 0, (void*)0, 0};
15625
16200
static swig_type_info _swigt__p_svn_version_t = {"_p_svn_version_t", "struct svn_version_t *|svn_version_t *", 0, 0, (void*)0, 0};
 
16201
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|svn_linenum_t *", 0, 0, (void*)0, 0};
15626
16202
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
15627
16203
 
15628
16204
static swig_type_info *swig_type_initial[] = {
15716
16292
  &_swigt__p_svn_diff_datasource_e,
15717
16293
  &_swigt__p_svn_diff_file_ignore_space_t,
15718
16294
  &_swigt__p_svn_diff_file_options_t,
 
16295
  &_swigt__p_svn_diff_fns2_t,
15719
16296
  &_swigt__p_svn_diff_fns_t,
 
16297
  &_swigt__p_svn_diff_hunk_t,
 
16298
  &_swigt__p_svn_diff_operation_kind_e,
15720
16299
  &_swigt__p_svn_diff_output_fns_t,
15721
16300
  &_swigt__p_svn_diff_t,
15722
16301
  &_swigt__p_svn_dirent_t,
15723
16302
  &_swigt__p_svn_errno_t,
15724
16303
  &_swigt__p_svn_error_t,
 
16304
  &_swigt__p_svn_io_dirent2_t,
15725
16305
  &_swigt__p_svn_io_dirent_t,
15726
16306
  &_swigt__p_svn_io_file_del_t,
15727
16307
  &_swigt__p_svn_location_segment_t,
15737
16317
  &_swigt__p_svn_opt_revision_value_t,
15738
16318
  &_swigt__p_svn_opt_subcommand_desc2_t,
15739
16319
  &_swigt__p_svn_opt_subcommand_desc_t,
 
16320
  &_swigt__p_svn_patch_file_t,
 
16321
  &_swigt__p_svn_patch_t,
15740
16322
  &_swigt__p_svn_prop_kind,
 
16323
  &_swigt__p_svn_prop_patch_t,
15741
16324
  &_swigt__p_svn_ra_callbacks2_t,
15742
16325
  &_swigt__p_svn_ra_callbacks_t,
15743
16326
  &_swigt__p_svn_ra_plugin_t,
15745
16328
  &_swigt__p_svn_ra_reporter3_t,
15746
16329
  &_swigt__p_svn_ra_reporter_t,
15747
16330
  &_swigt__p_svn_ra_session_t,
 
16331
  &_swigt__p_svn_stream_mark_t,
15748
16332
  &_swigt__p_svn_stream_t,
15749
16333
  &_swigt__p_svn_string_t,
15750
16334
  &_swigt__p_svn_stringbuf_t,
 
16335
  &_swigt__p_svn_tristate_t,
15751
16336
  &_swigt__p_svn_txdelta_op_t,
15752
16337
  &_swigt__p_svn_txdelta_stream_t,
15753
16338
  &_swigt__p_svn_txdelta_window_t,
15754
16339
  &_swigt__p_svn_version_checklist_t,
15755
16340
  &_swigt__p_svn_version_t,
 
16341
  &_swigt__p_unsigned_long,
15756
16342
  &_swigt__p_void,
15757
16343
};
15758
16344
 
15846
16432
static swig_cast_info _swigc__p_svn_diff_datasource_e[] = {  {&_swigt__p_svn_diff_datasource_e, 0, 0, 0},{0, 0, 0, 0}};
15847
16433
static swig_cast_info _swigc__p_svn_diff_file_ignore_space_t[] = {  {&_swigt__p_svn_diff_file_ignore_space_t, 0, 0, 0},{0, 0, 0, 0}};
15848
16434
static swig_cast_info _swigc__p_svn_diff_file_options_t[] = {  {&_swigt__p_svn_diff_file_options_t, 0, 0, 0},{0, 0, 0, 0}};
 
16435
static swig_cast_info _swigc__p_svn_diff_fns2_t[] = {  {&_swigt__p_svn_diff_fns2_t, 0, 0, 0},{0, 0, 0, 0}};
15849
16436
static swig_cast_info _swigc__p_svn_diff_fns_t[] = {  {&_swigt__p_svn_diff_fns_t, 0, 0, 0},{0, 0, 0, 0}};
 
16437
static swig_cast_info _swigc__p_svn_diff_hunk_t[] = {  {&_swigt__p_svn_diff_hunk_t, 0, 0, 0},{0, 0, 0, 0}};
 
16438
static swig_cast_info _swigc__p_svn_diff_operation_kind_e[] = {  {&_swigt__p_svn_diff_operation_kind_e, 0, 0, 0},{0, 0, 0, 0}};
15850
16439
static swig_cast_info _swigc__p_svn_diff_output_fns_t[] = {  {&_swigt__p_svn_diff_output_fns_t, 0, 0, 0},{0, 0, 0, 0}};
15851
16440
static swig_cast_info _swigc__p_svn_diff_t[] = {  {&_swigt__p_svn_diff_t, 0, 0, 0},{0, 0, 0, 0}};
15852
16441
static swig_cast_info _swigc__p_svn_dirent_t[] = {  {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
15853
16442
static swig_cast_info _swigc__p_svn_errno_t[] = {  {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
15854
16443
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
16444
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
15855
16445
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
15856
16446
static swig_cast_info _swigc__p_svn_io_file_del_t[] = {  {&_swigt__p_svn_io_file_del_t, 0, 0, 0},{0, 0, 0, 0}};
15857
16447
static swig_cast_info _swigc__p_svn_location_segment_t[] = {  {&_swigt__p_svn_location_segment_t, 0, 0, 0},{0, 0, 0, 0}};
15867
16457
static swig_cast_info _swigc__p_svn_opt_revision_value_t[] = {  {&_swigt__p_svn_opt_revision_value_t, 0, 0, 0},{0, 0, 0, 0}};
15868
16458
static swig_cast_info _swigc__p_svn_opt_subcommand_desc2_t[] = {  {&_swigt__p_svn_opt_subcommand_desc2_t, 0, 0, 0},{0, 0, 0, 0}};
15869
16459
static swig_cast_info _swigc__p_svn_opt_subcommand_desc_t[] = {  {&_swigt__p_svn_opt_subcommand_desc_t, 0, 0, 0},{0, 0, 0, 0}};
 
16460
static swig_cast_info _swigc__p_svn_patch_file_t[] = {  {&_swigt__p_svn_patch_file_t, 0, 0, 0},{0, 0, 0, 0}};
 
16461
static swig_cast_info _swigc__p_svn_patch_t[] = {  {&_swigt__p_svn_patch_t, 0, 0, 0},{0, 0, 0, 0}};
15870
16462
static swig_cast_info _swigc__p_svn_prop_kind[] = {  {&_swigt__p_svn_prop_kind, 0, 0, 0},{0, 0, 0, 0}};
 
16463
static swig_cast_info _swigc__p_svn_prop_patch_t[] = {  {&_swigt__p_svn_prop_patch_t, 0, 0, 0},{0, 0, 0, 0}};
15871
16464
static swig_cast_info _swigc__p_svn_ra_callbacks2_t[] = {  {&_swigt__p_svn_ra_callbacks2_t, 0, 0, 0},{0, 0, 0, 0}};
15872
16465
static swig_cast_info _swigc__p_svn_ra_callbacks_t[] = {  {&_swigt__p_svn_ra_callbacks_t, 0, 0, 0},{0, 0, 0, 0}};
15873
16466
static swig_cast_info _swigc__p_svn_ra_plugin_t[] = {  {&_swigt__p_svn_ra_plugin_t, 0, 0, 0},{0, 0, 0, 0}};
15875
16468
static swig_cast_info _swigc__p_svn_ra_reporter3_t[] = {  {&_swigt__p_svn_ra_reporter3_t, 0, 0, 0},{0, 0, 0, 0}};
15876
16469
static swig_cast_info _swigc__p_svn_ra_reporter_t[] = {  {&_swigt__p_svn_ra_reporter_t, 0, 0, 0},{0, 0, 0, 0}};
15877
16470
static swig_cast_info _swigc__p_svn_ra_session_t[] = {  {&_swigt__p_svn_ra_session_t, 0, 0, 0},{0, 0, 0, 0}};
 
16471
static swig_cast_info _swigc__p_svn_stream_mark_t[] = {  {&_swigt__p_svn_stream_mark_t, 0, 0, 0},{0, 0, 0, 0}};
15878
16472
static swig_cast_info _swigc__p_svn_stream_t[] = {  {&_swigt__p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
15879
16473
static swig_cast_info _swigc__p_svn_string_t[] = {  {&_swigt__p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
15880
16474
static swig_cast_info _swigc__p_svn_stringbuf_t[] = {  {&_swigt__p_svn_stringbuf_t, 0, 0, 0},{0, 0, 0, 0}};
 
16475
static swig_cast_info _swigc__p_svn_tristate_t[] = {  {&_swigt__p_svn_tristate_t, 0, 0, 0},{0, 0, 0, 0}};
15881
16476
static swig_cast_info _swigc__p_svn_txdelta_op_t[] = {  {&_swigt__p_svn_txdelta_op_t, 0, 0, 0},{0, 0, 0, 0}};
15882
16477
static swig_cast_info _swigc__p_svn_txdelta_stream_t[] = {  {&_swigt__p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
15883
16478
static swig_cast_info _swigc__p_svn_txdelta_window_t[] = {  {&_swigt__p_svn_txdelta_window_t, 0, 0, 0},{0, 0, 0, 0}};
15884
16479
static swig_cast_info _swigc__p_svn_version_checklist_t[] = {  {&_swigt__p_svn_version_checklist_t, 0, 0, 0},{0, 0, 0, 0}};
15885
16480
static swig_cast_info _swigc__p_svn_version_t[] = {  {&_swigt__p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
 
16481
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
15886
16482
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
15887
16483
 
15888
16484
static swig_cast_info *swig_cast_initial[] = {
15976
16572
  _swigc__p_svn_diff_datasource_e,
15977
16573
  _swigc__p_svn_diff_file_ignore_space_t,
15978
16574
  _swigc__p_svn_diff_file_options_t,
 
16575
  _swigc__p_svn_diff_fns2_t,
15979
16576
  _swigc__p_svn_diff_fns_t,
 
16577
  _swigc__p_svn_diff_hunk_t,
 
16578
  _swigc__p_svn_diff_operation_kind_e,
15980
16579
  _swigc__p_svn_diff_output_fns_t,
15981
16580
  _swigc__p_svn_diff_t,
15982
16581
  _swigc__p_svn_dirent_t,
15983
16582
  _swigc__p_svn_errno_t,
15984
16583
  _swigc__p_svn_error_t,
 
16584
  _swigc__p_svn_io_dirent2_t,
15985
16585
  _swigc__p_svn_io_dirent_t,
15986
16586
  _swigc__p_svn_io_file_del_t,
15987
16587
  _swigc__p_svn_location_segment_t,
15997
16597
  _swigc__p_svn_opt_revision_value_t,
15998
16598
  _swigc__p_svn_opt_subcommand_desc2_t,
15999
16599
  _swigc__p_svn_opt_subcommand_desc_t,
 
16600
  _swigc__p_svn_patch_file_t,
 
16601
  _swigc__p_svn_patch_t,
16000
16602
  _swigc__p_svn_prop_kind,
 
16603
  _swigc__p_svn_prop_patch_t,
16001
16604
  _swigc__p_svn_ra_callbacks2_t,
16002
16605
  _swigc__p_svn_ra_callbacks_t,
16003
16606
  _swigc__p_svn_ra_plugin_t,
16005
16608
  _swigc__p_svn_ra_reporter3_t,
16006
16609
  _swigc__p_svn_ra_reporter_t,
16007
16610
  _swigc__p_svn_ra_session_t,
 
16611
  _swigc__p_svn_stream_mark_t,
16008
16612
  _swigc__p_svn_stream_t,
16009
16613
  _swigc__p_svn_string_t,
16010
16614
  _swigc__p_svn_stringbuf_t,
 
16615
  _swigc__p_svn_tristate_t,
16011
16616
  _swigc__p_svn_txdelta_op_t,
16012
16617
  _swigc__p_svn_txdelta_stream_t,
16013
16618
  _swigc__p_svn_txdelta_window_t,
16014
16619
  _swigc__p_svn_version_checklist_t,
16015
16620
  _swigc__p_svn_version_t,
 
16621
  _swigc__p_unsigned_long,
16016
16622
  _swigc__p_void,
16017
16623
};
16018
16624
 
16104
16710
{"SVN::_Ra::delete_svn_ra_callbacks_t", _wrap_delete_svn_ra_callbacks_t},
16105
16711
{"SVN::_Ra::svn_ra_initialize", _wrap_svn_ra_initialize},
16106
16712
{"SVN::_Ra::svn_ra_create_callbacks", _wrap_svn_ra_create_callbacks},
 
16713
{"SVN::_Ra::svn_ra_open4", _wrap_svn_ra_open4},
16107
16714
{"SVN::_Ra::svn_ra_open3", _wrap_svn_ra_open3},
16108
16715
{"SVN::_Ra::svn_ra_open2", _wrap_svn_ra_open2},
16109
16716
{"SVN::_Ra::svn_ra_open", _wrap_svn_ra_open},
16110
16717
{"SVN::_Ra::svn_ra_reparent", _wrap_svn_ra_reparent},
16111
16718
{"SVN::_Ra::svn_ra_get_session_url", _wrap_svn_ra_get_session_url},
 
16719
{"SVN::_Ra::svn_ra_get_path_relative_to_session", _wrap_svn_ra_get_path_relative_to_session},
 
16720
{"SVN::_Ra::svn_ra_get_path_relative_to_root", _wrap_svn_ra_get_path_relative_to_root},
16112
16721
{"SVN::_Ra::svn_ra_get_latest_revnum", _wrap_svn_ra_get_latest_revnum},
16113
16722
{"SVN::_Ra::svn_ra_get_dated_revision", _wrap_svn_ra_get_dated_revision},
 
16723
{"SVN::_Ra::svn_ra_change_rev_prop2", _wrap_svn_ra_change_rev_prop2},
16114
16724
{"SVN::_Ra::svn_ra_change_rev_prop", _wrap_svn_ra_change_rev_prop},
16115
16725
{"SVN::_Ra::svn_ra_rev_proplist", _wrap_svn_ra_rev_proplist},
16116
16726
{"SVN::_Ra::svn_ra_rev_prop", _wrap_svn_ra_rev_prop},
16145
16755
{"SVN::_Ra::svn_ra_lock", _wrap_svn_ra_lock},
16146
16756
{"SVN::_Ra::svn_ra_unlock", _wrap_svn_ra_unlock},
16147
16757
{"SVN::_Ra::svn_ra_get_lock", _wrap_svn_ra_get_lock},
 
16758
{"SVN::_Ra::svn_ra_get_locks2", _wrap_svn_ra_get_locks2},
16148
16759
{"SVN::_Ra::svn_ra_get_locks", _wrap_svn_ra_get_locks},
16149
16760
{"SVN::_Ra::svn_ra_replay_range", _wrap_svn_ra_replay_range},
16150
16761
{"SVN::_Ra::svn_ra_replay", _wrap_svn_ra_replay},
 
16762
{"SVN::_Ra::svn_ra_get_deleted_rev", _wrap_svn_ra_get_deleted_rev},
16151
16763
{"SVN::_Ra::svn_ra_has_capability", _wrap_svn_ra_has_capability},
16152
 
{"SVN::_Ra::svn_ra_get_deleted_rev", _wrap_svn_ra_get_deleted_rev},
16153
16764
{"SVN::_Ra::svn_ra_print_modules", _wrap_svn_ra_print_modules},
16154
16765
{"SVN::_Ra::svn_ra_print_ra_libraries", _wrap_svn_ra_print_ra_libraries},
16155
16766
{"SVN::_Ra::svn_ra_plugin_t_name_set", _wrap_svn_ra_plugin_t_name_set},
16543
17154
    SvREADONLY_on(sv);
16544
17155
  }
16545
17156
  
16546
 
  /*@SWIG:/home/hwright/dev/release/roll/prefix/share/swig/1.3.36/perl5/perltypemaps.swg,64,%set_constant@*/ do {
 
17157
  /*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
16547
17158
    SV *sv = get_sv((char*) SWIG_prefix "SVN_RA_CAPABILITY_DEPTH", TRUE | 0x2 | GV_ADDMULTI);
16548
17159
    sv_setsv(sv, SWIG_FromCharPtr("depth"));
16549
17160
    SvREADONLY_on(sv);
16550
17161
  } while(0) /*@SWIG@*/;
16551
 
  /*@SWIG:/home/hwright/dev/release/roll/prefix/share/swig/1.3.36/perl5/perltypemaps.swg,64,%set_constant@*/ do {
 
17162
  /*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
16552
17163
    SV *sv = get_sv((char*) SWIG_prefix "SVN_RA_CAPABILITY_MERGEINFO", TRUE | 0x2 | GV_ADDMULTI);
16553
17164
    sv_setsv(sv, SWIG_FromCharPtr("mergeinfo"));
16554
17165
    SvREADONLY_on(sv);
16555
17166
  } while(0) /*@SWIG@*/;
16556
 
  /*@SWIG:/home/hwright/dev/release/roll/prefix/share/swig/1.3.36/perl5/perltypemaps.swg,64,%set_constant@*/ do {
 
17167
  /*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
16557
17168
    SV *sv = get_sv((char*) SWIG_prefix "SVN_RA_CAPABILITY_LOG_REVPROPS", TRUE | 0x2 | GV_ADDMULTI);
16558
17169
    sv_setsv(sv, SWIG_FromCharPtr("log-revprops"));
16559
17170
    SvREADONLY_on(sv);
16560
17171
  } while(0) /*@SWIG@*/;
16561
 
  /*@SWIG:/home/hwright/dev/release/roll/prefix/share/swig/1.3.36/perl5/perltypemaps.swg,64,%set_constant@*/ do {
 
17172
  /*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
16562
17173
    SV *sv = get_sv((char*) SWIG_prefix "SVN_RA_CAPABILITY_PARTIAL_REPLAY", TRUE | 0x2 | GV_ADDMULTI);
16563
17174
    sv_setsv(sv, SWIG_FromCharPtr("partial-replay"));
16564
17175
    SvREADONLY_on(sv);
16565
17176
  } while(0) /*@SWIG@*/;
16566
 
  /*@SWIG:/home/hwright/dev/release/roll/prefix/share/swig/1.3.36/perl5/perltypemaps.swg,64,%set_constant@*/ do {
 
17177
  /*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
16567
17178
    SV *sv = get_sv((char*) SWIG_prefix "SVN_RA_CAPABILITY_COMMIT_REVPROPS", TRUE | 0x2 | GV_ADDMULTI);
16568
17179
    sv_setsv(sv, SWIG_FromCharPtr("commit-revprops"));
16569
17180
    SvREADONLY_on(sv);
16570
17181
  } while(0) /*@SWIG@*/;
16571
 
  /*@SWIG:/home/hwright/dev/release/roll/prefix/share/swig/1.3.36/perl5/perltypemaps.swg,64,%set_constant@*/ do {
 
17182
  /*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
17183
    SV *sv = get_sv((char*) SWIG_prefix "SVN_RA_CAPABILITY_ATOMIC_REVPROPS", TRUE | 0x2 | GV_ADDMULTI);
 
17184
    sv_setsv(sv, SWIG_FromCharPtr("atomic-revprops"));
 
17185
    SvREADONLY_on(sv);
 
17186
  } while(0) /*@SWIG@*/;
 
17187
  /*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
16572
17188
    SV *sv = get_sv((char*) SWIG_prefix "SVN_RA_ABI_VERSION", TRUE | 0x2 | GV_ADDMULTI);
16573
17189
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(2)));
16574
17190
    SvREADONLY_on(sv);