← Back to branch summary

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

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/perl/native/svn_fs.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/perl/native/svn_fs.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 SWIGPERL
42
42
#ifndef SWIGUNUSED
43
43
# if defined(__GNUC__)
44
44
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
45
#     define SWIGUNUSED __attribute__ ((__unused__))
46
46
#   else
47
47
#     define SWIGUNUSED
48
48
#   endif
49
49
# elif defined(__ICC)
50
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
 
50
#   define SWIGUNUSED __attribute__ ((__unused__))
51
51
# else
52
 
#   define SWIGUNUSED 
 
52
#   define SWIGUNUSED
53
53
# endif
54
54
#endif
55
55
 
56
56
#ifndef SWIG_MSC_UNSUPPRESS_4505
57
57
# if defined(_MSC_VER)
58
58
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
59
 
# endif 
 
59
# endif
60
60
#endif
61
61
 
62
62
#ifndef SWIGUNUSEDPARM
63
63
# ifdef __cplusplus
64
64
#   define SWIGUNUSEDPARM(p)
65
65
# else
66
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
66
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
67
67
# endif
68
68
#endif
69
69
 
106
106
#   define SWIGSTDCALL __stdcall
107
107
# else
108
108
#   define SWIGSTDCALL
109
 
# endif 
 
109
# endif
110
110
#endif
111
111
 
112
112
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
144
144
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
145
145
  creating a static or dynamic library from the SWIG runtime code.
146
146
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
147
 
  
 
147
 
148
148
  But only do this if strictly necessary, ie, if you have problems
149
149
  with your compiler or suchlike.
150
150
*/
170
170
#define SWIG_POINTER_OWN           0x1
171
171
 
172
172
 
173
 
/* 
 
173
/*
174
174
   Flags/methods for returning states.
175
 
   
176
 
   The SWIG conversion methods, as ConvertPtr, return an integer 
 
175
 
 
176
   The SWIG conversion methods, as ConvertPtr, return an integer
177
177
   that tells if the conversion was successful or not. And if not,
178
178
   an error code can be returned (see swigerrors.swg for the codes).
179
 
   
 
179
 
180
180
   Use the following macros/flags to set or process the returning
181
181
   states.
182
 
   
 
182
 
183
183
   In old versions of SWIG, code such as the following was usually written:
184
184
 
185
185
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
212
212
    } else {
213
213
      // fail code
214
214
    }
215
 
    
 
215
 
216
216
   I.e., now SWIG_ConvertPtr can return new objects and you can
217
217
   identify the case and take care of the deallocation. Of course that
218
218
   also requires SWIG_ConvertPtr to return new result values, such as
219
219
 
220
 
      int SWIG_ConvertPtr(obj, ptr,...) {         
221
 
        if (<obj is ok>) {                             
222
 
          if (<need new object>) {                     
223
 
            *ptr = <ptr to new allocated object>; 
224
 
            return SWIG_NEWOBJ;                
225
 
          } else {                                     
226
 
            *ptr = <ptr to old object>;        
227
 
            return SWIG_OLDOBJ;                
228
 
          }                                    
229
 
        } else {                                       
230
 
          return SWIG_BADOBJ;                  
231
 
        }                                              
 
220
      int SWIG_ConvertPtr(obj, ptr,...) {
 
221
        if (<obj is ok>) {
 
222
          if (<need new object>) {
 
223
            *ptr = <ptr to new allocated object>;
 
224
            return SWIG_NEWOBJ;
 
225
          } else {
 
226
            *ptr = <ptr to old object>;
 
227
            return SWIG_OLDOBJ;
 
228
          }
 
229
        } else {
 
230
          return SWIG_BADOBJ;
 
231
        }
232
232
      }
233
233
 
234
234
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242
242
       int fooi(int);
243
243
 
244
244
   and you call
245
 
 
 
245
 
246
246
      food(1)   // cast rank '1'  (1 -> 1.0)
247
247
      fooi(1)   // cast rank '0'
248
248
 
249
249
   just use the SWIG_AddCast()/SWIG_CheckState()
250
250
*/
251
251
 
252
 
#define SWIG_OK                    (0) 
 
252
#define SWIG_OK                    (0)
253
253
#define SWIG_ERROR                 (-1)
254
254
#define SWIG_IsOK(r)               (r >= 0)
255
 
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
 
255
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
256
256
 
257
257
/* The CastRankLimit says how many bits are used for the cast rank */
258
258
#define SWIG_CASTRANKLIMIT         (1 << 8)
283
283
#  endif
284
284
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
285
285
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
286
 
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
 
286
SWIGINTERNINLINE int SWIG_AddCast(int r) {
287
287
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
288
288
}
289
 
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
290
 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
 
289
SWIGINTERNINLINE int SWIG_CheckState(int r) {
 
290
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
291
291
}
292
292
#else /* no cast-rank mode */
293
 
#  define SWIG_AddCast
 
293
#  define SWIG_AddCast(r) (r)
294
294
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
295
295
#endif
296
296
 
334
334
  void                    *clientdata;          /* Language specific module data */
335
335
} swig_module_info;
336
336
 
337
 
/* 
 
337
/*
338
338
  Compare two type names skipping the space characters, therefore
339
339
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
340
340
 
354
354
 
355
355
/*
356
356
  Check type equivalence in a name list like <name1>|<name2>|...
 
357
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 
358
*/
 
359
SWIGRUNTIME int
 
360
SWIG_TypeCmp(const char *nb, const char *tb) {
 
361
  int equiv = 1;
 
362
  const char* te = tb + strlen(tb);
 
363
  const char* ne = nb;
 
364
  while (equiv != 0 && *ne) {
 
365
    for (nb = ne; *ne; ++ne) {
 
366
      if (*ne == '|') break;
 
367
    }
 
368
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
 
369
    if (*ne) ++ne;
 
370
  }
 
371
  return equiv;
 
372
}
 
373
 
 
374
/*
 
375
  Check type equivalence in a name list like <name1>|<name2>|...
357
376
  Return 0 if not equal, 1 if equal
358
377
*/
359
378
SWIGRUNTIME int
360
379
SWIG_TypeEquiv(const char *nb, const char *tb) {
361
 
  int equiv = 0;
362
 
  const char* te = tb + strlen(tb);
363
 
  const char* ne = nb;
364
 
  while (!equiv && *ne) {
365
 
    for (nb = ne; *ne; ++ne) {
366
 
      if (*ne == '|') break;
367
 
    }
368
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
369
 
    if (*ne) ++ne;
370
 
  }
371
 
  return equiv;
372
 
}
373
 
 
374
 
/*
375
 
  Check type equivalence in a name list like <name1>|<name2>|...
376
 
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
377
 
*/
378
 
SWIGRUNTIME int
379
 
SWIG_TypeCompare(const char *nb, const char *tb) {
380
 
  int equiv = 0;
381
 
  const char* te = tb + strlen(tb);
382
 
  const char* ne = nb;
383
 
  while (!equiv && *ne) {
384
 
    for (nb = ne; *ne; ++ne) {
385
 
      if (*ne == '|') break;
386
 
    }
387
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
388
 
    if (*ne) ++ne;
389
 
  }
390
 
  return equiv;
391
 
}
392
 
 
 
380
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 
381
}
393
382
 
394
383
/*
395
384
  Check the typename
418
407
  return 0;
419
408
}
420
409
 
421
 
/* 
 
410
/*
422
411
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
423
412
*/
424
413
SWIGRUNTIME swig_cast_info *
453
442
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
454
443
}
455
444
 
456
 
/* 
 
445
/*
457
446
   Dynamic pointer casting. Down an inheritance hierarchy
458
447
*/
459
448
SWIGRUNTIME swig_type_info *
497
486
    return type->name;
498
487
}
499
488
 
500
 
/* 
 
489
/*
501
490
   Set the clientdata field for a type
502
491
*/
503
492
SWIGRUNTIME void
505
494
  swig_cast_info *cast = ti->cast;
506
495
  /* if (ti->clientdata == clientdata) return; */
507
496
  ti->clientdata = clientdata;
508
 
  
 
497
 
509
498
  while (cast) {
510
499
    if (!cast->converter) {
511
500
      swig_type_info *tc = cast->type;
512
501
      if (!tc->clientdata) {
513
502
        SWIG_TypeClientData(tc, clientdata);
514
503
      }
515
 
    }    
 
504
    }
516
505
    cast = cast->next;
517
506
  }
518
507
}
521
510
  SWIG_TypeClientData(ti, clientdata);
522
511
  ti->owndata = 1;
523
512
}
524
 
  
 
513
 
525
514
/*
526
515
  Search for a swig_type_info structure only by mangled name
527
516
  Search is a O(log #types)
528
 
  
529
 
  We start searching at module start, and finish searching when start == end.  
 
517
 
 
518
  We start searching at module start, and finish searching when start == end.
530
519
  Note: if start == end at the beginning of the function, we go all the way around
531
520
  the circular list.
532
521
*/
533
522
SWIGRUNTIME swig_type_info *
534
 
SWIG_MangledTypeQueryModule(swig_module_info *start, 
535
 
                            swig_module_info *end, 
 
523
SWIG_MangledTypeQueryModule(swig_module_info *start,
 
524
                            swig_module_info *end,
536
525
                            const char *name) {
537
526
  swig_module_info *iter = start;
538
527
  do {
541
530
      register size_t r = iter->size - 1;
542
531
      do {
543
532
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
544
 
        register size_t i = (l + r) >> 1; 
 
533
        register size_t i = (l + r) >> 1;
545
534
        const char *iname = iter->types[i]->name;
546
535
        if (iname) {
547
536
          register int compare = strcmp(name, iname);
548
 
          if (compare == 0) {       
 
537
          if (compare == 0) {
549
538
            return iter->types[i];
550
539
          } else if (compare < 0) {
551
540
            if (i) {
570
559
  Search for a swig_type_info structure for either a mangled name or a human readable name.
571
560
  It first searches the mangled names of the types, which is a O(log #types)
572
561
  If a type is not found it then searches the human readable names, which is O(#types).
573
 
  
574
 
  We start searching at module start, and finish searching when start == end.  
 
562
 
 
563
  We start searching at module start, and finish searching when start == end.
575
564
  Note: if start == end at the beginning of the function, we go all the way around
576
565
  the circular list.
577
566
*/
578
567
SWIGRUNTIME swig_type_info *
579
 
SWIG_TypeQueryModule(swig_module_info *start, 
580
 
                     swig_module_info *end, 
 
568
SWIG_TypeQueryModule(swig_module_info *start,
 
569
                     swig_module_info *end,
581
570
                     const char *name) {
582
571
  /* STEP 1: Search the name field using binary search */
583
572
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
596
585
      iter = iter->next;
597
586
    } while (iter != end);
598
587
  }
599
 
  
 
588
 
600
589
  /* neither found a match */
601
590
  return 0;
602
591
}
603
592
 
604
 
/* 
 
593
/*
605
594
   Pack binary data into a string
606
595
*/
607
596
SWIGRUNTIME char *
617
606
  return c;
618
607
}
619
608
 
620
 
/* 
 
609
/*
621
610
   Unpack binary data from a string
622
611
*/
623
612
SWIGRUNTIME const char *
631
620
      uu = ((d - '0') << 4);
632
621
    else if ((d >= 'a') && (d <= 'f'))
633
622
      uu = ((d - ('a'-10)) << 4);
634
 
    else 
 
623
    else
635
624
      return (char *) 0;
636
625
    d = *(c++);
637
626
    if ((d >= '0') && (d <= '9'))
638
627
      uu |= (d - '0');
639
628
    else if ((d >= 'a') && (d <= 'f'))
640
629
      uu |= (d - ('a'-10));
641
 
    else 
 
630
    else
642
631
      return (char *) 0;
643
632
    *u = uu;
644
633
  }
645
634
  return c;
646
635
}
647
636
 
648
 
/* 
 
637
/*
649
638
   Pack 'void *' into a string buffer.
650
639
*/
651
640
SWIGRUNTIME char *
705
694
#endif
706
695
 
707
696
/*  Errors in SWIG */
708
 
#define  SWIG_UnknownError         -1 
709
 
#define  SWIG_IOError              -2 
710
 
#define  SWIG_RuntimeError         -3 
711
 
#define  SWIG_IndexError           -4 
712
 
#define  SWIG_TypeError            -5 
713
 
#define  SWIG_DivisionByZero       -6 
714
 
#define  SWIG_OverflowError        -7 
715
 
#define  SWIG_SyntaxError          -8 
716
 
#define  SWIG_ValueError           -9 
 
697
#define  SWIG_UnknownError         -1
 
698
#define  SWIG_IOError              -2
 
699
#define  SWIG_RuntimeError         -3
 
700
#define  SWIG_IndexError           -4
 
701
#define  SWIG_TypeError            -5
 
702
#define  SWIG_DivisionByZero       -6
 
703
#define  SWIG_OverflowError        -7
 
704
#define  SWIG_SyntaxError          -8
 
705
#define  SWIG_ValueError           -9
717
706
#define  SWIG_SystemError          -10
718
707
#define  SWIG_AttributeError       -11
719
 
#define  SWIG_MemoryError          -12 
 
708
#define  SWIG_MemoryError          -12
720
709
#define  SWIG_NullReferenceError   -13
721
710
 
722
711
 
1505
1494
#define SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[9]
1506
1495
#define SWIGTYPE_p_f_p_void__p_svn_error_t swig_types[10]
1507
1496
#define SWIGTYPE_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[11]
1508
 
#define SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[12]
1509
 
#define SWIGTYPE_p_f_p_void_p_struct_svn_error_t__void swig_types[13]
1510
 
#define SWIGTYPE_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t swig_types[14]
1511
 
#define SWIGTYPE_p_int swig_types[15]
1512
 
#define SWIGTYPE_p_long swig_types[16]
1513
 
#define SWIGTYPE_p_p_apr_array_header_t swig_types[17]
1514
 
#define SWIGTYPE_p_p_apr_hash_t swig_types[18]
1515
 
#define SWIGTYPE_p_p_char swig_types[19]
1516
 
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[20]
1517
 
#define SWIGTYPE_p_p_svn_checksum_t swig_types[21]
1518
 
#define SWIGTYPE_p_p_svn_fs_access_t swig_types[22]
1519
 
#define SWIGTYPE_p_p_svn_fs_history_t swig_types[23]
1520
 
#define SWIGTYPE_p_p_svn_fs_id_t swig_types[24]
1521
 
#define SWIGTYPE_p_p_svn_fs_root_t swig_types[25]
1522
 
#define SWIGTYPE_p_p_svn_fs_t swig_types[26]
1523
 
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[27]
1524
 
#define SWIGTYPE_p_p_svn_lock_t swig_types[28]
1525
 
#define SWIGTYPE_p_p_svn_stream_t swig_types[29]
1526
 
#define SWIGTYPE_p_p_svn_string_t swig_types[30]
1527
 
#define SWIGTYPE_p_p_svn_txdelta_stream_t swig_types[31]
1528
 
#define SWIGTYPE_p_p_void swig_types[32]
1529
 
#define SWIGTYPE_p_svn_auth_baton_t swig_types[33]
1530
 
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[34]
1531
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[35]
1532
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[36]
1533
 
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[37]
1534
 
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[38]
1535
 
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[39]
1536
 
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[40]
1537
 
#define SWIGTYPE_p_svn_auth_provider_t swig_types[41]
1538
 
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[42]
1539
 
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[43]
1540
 
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[44]
1541
 
#define SWIGTYPE_p_svn_checksum_t swig_types[45]
1542
 
#define SWIGTYPE_p_svn_commit_info_t swig_types[46]
1543
 
#define SWIGTYPE_p_svn_config_t swig_types[47]
1544
 
#define SWIGTYPE_p_svn_delta_editor_t swig_types[48]
1545
 
#define SWIGTYPE_p_svn_depth_t swig_types[49]
1546
 
#define SWIGTYPE_p_svn_diff_conflict_display_style_t swig_types[50]
1547
 
#define SWIGTYPE_p_svn_diff_datasource_e swig_types[51]
1548
 
#define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[52]
1549
 
#define SWIGTYPE_p_svn_diff_file_options_t swig_types[53]
1550
 
#define SWIGTYPE_p_svn_diff_fns2_t swig_types[54]
1551
 
#define SWIGTYPE_p_svn_diff_fns_t swig_types[55]
1552
 
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[56]
1553
 
#define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[57]
1554
 
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[58]
1555
 
#define SWIGTYPE_p_svn_diff_t swig_types[59]
1556
 
#define SWIGTYPE_p_svn_dirent_t swig_types[60]
1557
 
#define SWIGTYPE_p_svn_errno_t swig_types[61]
1558
 
#define SWIGTYPE_p_svn_error_t swig_types[62]
1559
 
#define SWIGTYPE_p_svn_fs_access_t swig_types[63]
1560
 
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[64]
1561
 
#define SWIGTYPE_p_svn_fs_history_t swig_types[65]
1562
 
#define SWIGTYPE_p_svn_fs_id_t swig_types[66]
1563
 
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[67]
1564
 
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[68]
1565
 
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[69]
1566
 
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[70]
1567
 
#define SWIGTYPE_p_svn_fs_root_t swig_types[71]
1568
 
#define SWIGTYPE_p_svn_fs_t swig_types[72]
1569
 
#define SWIGTYPE_p_svn_fs_txn_t swig_types[73]
1570
 
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[74]
1571
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[75]
1572
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[76]
1573
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[77]
1574
 
#define SWIGTYPE_p_svn_lock_t swig_types[78]
1575
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[79]
1576
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[80]
1577
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[81]
1578
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[82]
1579
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[83]
1580
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[84]
1581
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[85]
1582
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[86]
1583
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[87]
1584
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[88]
1585
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[89]
1586
 
#define SWIGTYPE_p_svn_patch_file_t swig_types[90]
1587
 
#define SWIGTYPE_p_svn_patch_t swig_types[91]
1588
 
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[92]
1589
 
#define SWIGTYPE_p_svn_prop_kind swig_types[93]
1590
 
#define SWIGTYPE_p_svn_prop_patch_t swig_types[94]
1591
 
#define SWIGTYPE_p_svn_stream_mark_t swig_types[95]
1592
 
#define SWIGTYPE_p_svn_stream_t swig_types[96]
1593
 
#define SWIGTYPE_p_svn_string_t swig_types[97]
1594
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[98]
1595
 
#define SWIGTYPE_p_svn_tristate_t swig_types[99]
1596
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[100]
1597
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[101]
1598
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[102]
1599
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[103]
1600
 
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[104]
1601
 
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[105]
1602
 
#define SWIGTYPE_p_svn_version_extended_t swig_types[106]
1603
 
#define SWIGTYPE_p_svn_version_t swig_types[107]
1604
 
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[108]
1605
 
#define SWIGTYPE_p_unsigned_char swig_types[109]
1606
 
#define SWIGTYPE_p_unsigned_long swig_types[110]
1607
 
#define SWIGTYPE_p_void swig_types[111]
1608
 
static swig_type_info *swig_types[113];
1609
 
static swig_module_info swig_module = {swig_types, 112, 0, 0, 0, 0};
 
1497
#define SWIGTYPE_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[12]
 
1498
#define SWIGTYPE_p_f_p_void_long_long_p_apr_pool_t__void swig_types[13]
 
1499
#define SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[14]
 
1500
#define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t swig_types[15]
 
1501
#define SWIGTYPE_p_f_p_void_p_struct_svn_error_t__void swig_types[16]
 
1502
#define SWIGTYPE_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t swig_types[17]
 
1503
#define SWIGTYPE_p_int swig_types[18]
 
1504
#define SWIGTYPE_p_long swig_types[19]
 
1505
#define SWIGTYPE_p_p_apr_array_header_t swig_types[20]
 
1506
#define SWIGTYPE_p_p_apr_hash_t swig_types[21]
 
1507
#define SWIGTYPE_p_p_char swig_types[22]
 
1508
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[23]
 
1509
#define SWIGTYPE_p_p_svn_checksum_t swig_types[24]
 
1510
#define SWIGTYPE_p_p_svn_fs_access_t swig_types[25]
 
1511
#define SWIGTYPE_p_p_svn_fs_history_t swig_types[26]
 
1512
#define SWIGTYPE_p_p_svn_fs_id_t swig_types[27]
 
1513
#define SWIGTYPE_p_p_svn_fs_info_placeholder_t swig_types[28]
 
1514
#define SWIGTYPE_p_p_svn_fs_root_t swig_types[29]
 
1515
#define SWIGTYPE_p_p_svn_fs_t swig_types[30]
 
1516
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[31]
 
1517
#define SWIGTYPE_p_p_svn_lock_t swig_types[32]
 
1518
#define SWIGTYPE_p_p_svn_stream_t swig_types[33]
 
1519
#define SWIGTYPE_p_p_svn_string_t swig_types[34]
 
1520
#define SWIGTYPE_p_p_svn_txdelta_stream_t swig_types[35]
 
1521
#define SWIGTYPE_p_p_svn_version_t swig_types[36]
 
1522
#define SWIGTYPE_p_p_void swig_types[37]
 
1523
#define SWIGTYPE_p_svn_auth_baton_t swig_types[38]
 
1524
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[39]
 
1525
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[40]
 
1526
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[41]
 
1527
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[42]
 
1528
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[43]
 
1529
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[44]
 
1530
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[45]
 
1531
#define SWIGTYPE_p_svn_auth_provider_t swig_types[46]
 
1532
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[47]
 
1533
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[48]
 
1534
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[49]
 
1535
#define SWIGTYPE_p_svn_checksum_t swig_types[50]
 
1536
#define SWIGTYPE_p_svn_commit_info_t swig_types[51]
 
1537
#define SWIGTYPE_p_svn_config_t swig_types[52]
 
1538
#define SWIGTYPE_p_svn_delta_editor_t swig_types[53]
 
1539
#define SWIGTYPE_p_svn_depth_t swig_types[54]
 
1540
#define SWIGTYPE_p_svn_diff_conflict_display_style_t swig_types[55]
 
1541
#define SWIGTYPE_p_svn_diff_datasource_e swig_types[56]
 
1542
#define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[57]
 
1543
#define SWIGTYPE_p_svn_diff_file_options_t swig_types[58]
 
1544
#define SWIGTYPE_p_svn_diff_fns2_t swig_types[59]
 
1545
#define SWIGTYPE_p_svn_diff_fns_t swig_types[60]
 
1546
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[61]
 
1547
#define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[62]
 
1548
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[63]
 
1549
#define SWIGTYPE_p_svn_diff_t swig_types[64]
 
1550
#define SWIGTYPE_p_svn_dirent_t swig_types[65]
 
1551
#define SWIGTYPE_p_svn_errno_t swig_types[66]
 
1552
#define SWIGTYPE_p_svn_error_t swig_types[67]
 
1553
#define SWIGTYPE_p_svn_fs_access_t swig_types[68]
 
1554
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[69]
 
1555
#define SWIGTYPE_p_svn_fs_fsfs_info_t swig_types[70]
 
1556
#define SWIGTYPE_p_svn_fs_fsx_info_t swig_types[71]
 
1557
#define SWIGTYPE_p_svn_fs_history_t swig_types[72]
 
1558
#define SWIGTYPE_p_svn_fs_id_t swig_types[73]
 
1559
#define SWIGTYPE_p_svn_fs_info_placeholder_t swig_types[74]
 
1560
#define SWIGTYPE_p_svn_fs_lock_target_t swig_types[75]
 
1561
#define SWIGTYPE_p_svn_fs_node_relation_t swig_types[76]
 
1562
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[77]
 
1563
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[78]
 
1564
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[79]
 
1565
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[80]
 
1566
#define SWIGTYPE_p_svn_fs_root_t swig_types[81]
 
1567
#define SWIGTYPE_p_svn_fs_t swig_types[82]
 
1568
#define SWIGTYPE_p_svn_fs_txn_t swig_types[83]
 
1569
#define SWIGTYPE_p_svn_fs_upgrade_notify_action_t swig_types[84]
 
1570
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[85]
 
1571
#define SWIGTYPE_p_svn_io_dirent_t swig_types[86]
 
1572
#define SWIGTYPE_p_svn_io_file_del_t swig_types[87]
 
1573
#define SWIGTYPE_p_svn_location_segment_t swig_types[88]
 
1574
#define SWIGTYPE_p_svn_lock_t swig_types[89]
 
1575
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[90]
 
1576
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[91]
 
1577
#define SWIGTYPE_p_svn_log_entry_t swig_types[92]
 
1578
#define SWIGTYPE_p_svn_merge_range_t swig_types[93]
 
1579
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[94]
 
1580
#define SWIGTYPE_p_svn_node_kind_t swig_types[95]
 
1581
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[96]
 
1582
#define SWIGTYPE_p_svn_opt_revision_t swig_types[97]
 
1583
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[98]
 
1584
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[99]
 
1585
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[100]
 
1586
#define SWIGTYPE_p_svn_patch_file_t swig_types[101]
 
1587
#define SWIGTYPE_p_svn_patch_t swig_types[102]
 
1588
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[103]
 
1589
#define SWIGTYPE_p_svn_prop_kind swig_types[104]
 
1590
#define SWIGTYPE_p_svn_prop_patch_t swig_types[105]
 
1591
#define SWIGTYPE_p_svn_stream_mark_t swig_types[106]
 
1592
#define SWIGTYPE_p_svn_stream_t swig_types[107]
 
1593
#define SWIGTYPE_p_svn_string_t swig_types[108]
 
1594
#define SWIGTYPE_p_svn_stringbuf_t swig_types[109]
 
1595
#define SWIGTYPE_p_svn_tristate_t swig_types[110]
 
1596
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[111]
 
1597
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[112]
 
1598
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[113]
 
1599
#define SWIGTYPE_p_svn_version_checklist_t swig_types[114]
 
1600
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[115]
 
1601
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[116]
 
1602
#define SWIGTYPE_p_svn_version_extended_t swig_types[117]
 
1603
#define SWIGTYPE_p_svn_version_t swig_types[118]
 
1604
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[119]
 
1605
#define SWIGTYPE_p_unsigned_char swig_types[120]
 
1606
#define SWIGTYPE_p_unsigned_long swig_types[121]
 
1607
#define SWIGTYPE_p_void swig_types[122]
 
1608
static swig_type_info *swig_types[124];
 
1609
static swig_module_info swig_module = {swig_types, 123, 0, 0, 0, 0};
1610
1610
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1611
1611
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1612
1612
 
1617
1617
#define SWIG_name   "SVN::_Fs::boot_SVN___Fs"
1618
1618
#define SWIG_prefix "SVN::_Fs::"
1619
1619
 
1620
 
#define SWIGVERSION 0x020009 
 
1620
#define SWIGVERSION 0x020012 
1621
1621
#define SWIG_VERSION SWIGVERSION
1622
1622
 
1623
1623
 
1729
1729
 
1730
1730
 
1731
1731
 
 
1732
SWIGINTERNINLINE SV *
 
1733
SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
 
1734
{
 
1735
  SV *sv;
 
1736
  if (value >= IV_MIN && value <= IV_MAX)
 
1737
    sv = newSViv(value);
 
1738
  else
 
1739
    sv = newSVpvf("%ld", value);
 
1740
  return sv_2mortal(sv);
 
1741
}
 
1742
 
 
1743
 
 
1744
SWIGINTERNINLINE SV *
 
1745
SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
 
1746
{    
 
1747
  return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
 
1748
}
 
1749
 
 
1750
 
1732
1751
#include <limits.h>
1733
1752
#if !defined(SWIG_NO_LLONG_MAX)
1734
1753
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1870
1889
}
1871
1890
 
1872
1891
 
1873
 
SWIGINTERNINLINE SV *
1874
 
SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1875
 
{
1876
 
  SV *sv;
1877
 
  if (value >= IV_MIN && value <= IV_MAX)
1878
 
    sv = newSViv(value);
1879
 
  else
1880
 
    sv = newSVpvf("%ld", value);
1881
 
  return sv_2mortal(sv);
1882
 
}
1883
 
 
1884
 
 
1885
 
SWIGINTERNINLINE SV *
1886
 
SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1887
 
{    
1888
 
  return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1889
 
}
1890
 
 
1891
 
 
1892
1892
SWIGINTERN int
1893
1893
SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val) 
1894
1894
{
2004
2004
  _obj(baton, err);
2005
2005
}
2006
2006
 
 
2007
static svn_error_t * svn_fs_invoke_upgrade_notify(
 
2008
  svn_fs_upgrade_notify_t _obj, void *baton, apr_uint64_t number, svn_fs_upgrade_notify_action_t action, apr_pool_t *scratch_pool) {
 
2009
  return _obj(baton, number, action, scratch_pool);
 
2010
}
 
2011
 
2007
2012
static void svn_fs_invoke_progress_notify_func(
2008
2013
  svn_fs_progress_notify_func_t _obj, svn_revnum_t revision, void *baton, apr_pool_t *pool) {
2009
2014
  _obj(revision, baton, pool);
2010
2015
}
2011
2016
 
 
2017
static void svn_fs_invoke_hotcopy_notify(
 
2018
  svn_fs_hotcopy_notify_t _obj, void *baton, svn_revnum_t start_revision, svn_revnum_t end_revision, apr_pool_t *scratch_pool) {
 
2019
  _obj(baton, start_revision, end_revision, scratch_pool);
 
2020
}
 
2021
 
2012
2022
static svn_error_t * svn_fs_invoke_freeze_func(
2013
2023
  svn_fs_freeze_func_t _obj, void *baton, apr_pool_t *pool) {
2014
2024
  return _obj(baton, pool);
2019
2029
  return _obj(contents, len, baton, scratch_pool);
2020
2030
}
2021
2031
 
 
2032
static svn_error_t * svn_fs_invoke_lock_callback(
 
2033
  svn_fs_lock_callback_t _obj, void *baton, const char *path, const svn_lock_t *lock, svn_error_t *fs_err, apr_pool_t *scratch_pool) {
 
2034
  return _obj(baton, path, lock, fs_err, scratch_pool);
 
2035
}
 
2036
 
2022
2037
static svn_error_t * svn_fs_invoke_get_locks_callback(
2023
2038
  svn_fs_get_locks_callback_t _obj, void *baton, svn_lock_t *lock, apr_pool_t *pool) {
2024
2039
  return _obj(baton, lock, pool);
2030
2045
}
2031
2046
 
2032
2047
 
 
2048
 
 
2049
SWIGINTERN int
 
2050
SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long long *val)
 
2051
{
 
2052
  if (SvUOK(obj)) {
 
2053
    if (val) *val = SvUV(obj);
 
2054
    return SWIG_OK;
 
2055
  } else  if (SvIOK(obj)) {
 
2056
    IV v = SvIV(obj);
 
2057
    if (v >= 0 && v <= ULLONG_MAX) {
 
2058
      if (val) *val = v;
 
2059
      return SWIG_OK;
 
2060
    } else {
 
2061
      return SWIG_OverflowError;
 
2062
    }
 
2063
  } else {
 
2064
    int dispatch = 0;
 
2065
    const char *nptr = SvPV_nolen(obj);
 
2066
    if (nptr) {
 
2067
      char *endptr;
 
2068
      unsigned long long v;
 
2069
      errno = 0;
 
2070
      v = strtoull(nptr, &endptr,0);
 
2071
      if (errno == ERANGE) {
 
2072
        errno = 0;
 
2073
        return SWIG_OverflowError;
 
2074
      } else {
 
2075
        if (*endptr == '\0') {
 
2076
          if (val) *val = v;
 
2077
          return SWIG_Str2NumCast(SWIG_OK);
 
2078
        }
 
2079
      }
 
2080
    }
 
2081
    if (!dispatch) {
 
2082
      const double mant_max = 1LL << DBL_MANT_DIG;
 
2083
      double d;
 
2084
      int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
 
2085
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
 
2086
        if (val) *val = (unsigned long long)(d);
 
2087
        return res;
 
2088
      }
 
2089
    }
 
2090
  }
 
2091
  return SWIG_TypeError;
 
2092
}
 
2093
 
2033
2094
#ifdef __cplusplus
2034
2095
extern "C" {
2035
2096
#endif
2204
2265
}
2205
2266
 
2206
2267
 
 
2268
XS(_wrap_svn_fs_open2) {
 
2269
  {
 
2270
    svn_fs_t **arg1 = (svn_fs_t **) 0 ;
 
2271
    char *arg2 = (char *) 0 ;
 
2272
    apr_hash_t *arg3 = (apr_hash_t *) 0 ;
 
2273
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
2274
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
2275
    apr_pool_t *_global_pool ;
 
2276
    svn_fs_t *temp1 ;
 
2277
    int res2 ;
 
2278
    char *buf2 = 0 ;
 
2279
    int alloc2 = 0 ;
 
2280
    int argvi = 0;
 
2281
    svn_error_t *result = 0 ;
 
2282
    dXSARGS;
 
2283
    
 
2284
    {
 
2285
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
2286
    }
 
2287
    {
 
2288
      _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
 
2289
    }
 
2290
    arg1 = &temp1;
 
2291
    if ((items < 2) || (items > 4)) {
 
2292
      SWIG_croak("Usage: svn_fs_open2(path,fs_config,result_pool,scratch_pool);");
 
2293
    }
 
2294
    res2 = SWIG_AsCharPtrAndSize(ST(0), &buf2, NULL, &alloc2);
 
2295
    if (!SWIG_IsOK(res2)) {
 
2296
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_open2" "', argument " "2"" of type '" "char const *""'");
 
2297
    }
 
2298
    arg2 = (char *)(buf2);
 
2299
    {
 
2300
      /* PERL-FIXME: Handle undef -> NULL. */
 
2301
      arg3 = svn_swig_pl_strings_to_hash(ST(1), _global_pool);
 
2302
    }
 
2303
    if (items > 2) {
 
2304
      
 
2305
    }
 
2306
    if (items > 3) {
 
2307
      
 
2308
    }
 
2309
    {
 
2310
      result = (svn_error_t *)svn_fs_open2(arg1,(char const *)arg2,arg3,arg4,arg5);
 
2311
      
 
2312
      
 
2313
      
 
2314
    }
 
2315
    {
 
2316
      if (result) {
 
2317
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
2318
        
 
2319
        if (SvOK(exception_handler)) {
 
2320
          SV *callback_result;
 
2321
          
 
2322
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
2323
            &callback_result, "S", result,
 
2324
            SWIGTYPE_p_svn_error_t);
 
2325
        } else {
 
2326
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
2327
          argvi++;
 
2328
        }
 
2329
      }
 
2330
    }
 
2331
    {
 
2332
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_t, 0); argvi++  ;
 
2333
    }
 
2334
    
 
2335
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
2336
    
 
2337
    
 
2338
    
 
2339
    XSRETURN(argvi);
 
2340
  fail:
 
2341
    
 
2342
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
2343
    
 
2344
    
 
2345
    
 
2346
    SWIG_croak_null();
 
2347
  }
 
2348
}
 
2349
 
 
2350
 
2207
2351
XS(_wrap_svn_fs_open) {
2208
2352
  {
2209
2353
    svn_fs_t **arg1 = (svn_fs_t **) 0 ;
2278
2422
}
2279
2423
 
2280
2424
 
 
2425
XS(_wrap_svn_fs_upgrade2) {
 
2426
  {
 
2427
    char *arg1 = (char *) 0 ;
 
2428
    svn_fs_upgrade_notify_t arg2 = (svn_fs_upgrade_notify_t) 0 ;
 
2429
    void *arg3 = (void *) 0 ;
 
2430
    svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
 
2431
    void *arg5 = (void *) 0 ;
 
2432
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
2433
    apr_pool_t *_global_pool ;
 
2434
    int res1 ;
 
2435
    char *buf1 = 0 ;
 
2436
    int alloc1 = 0 ;
 
2437
    int res3 ;
 
2438
    int argvi = 0;
 
2439
    svn_error_t *result = 0 ;
 
2440
    dXSARGS;
 
2441
    
 
2442
    {
 
2443
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
 
2444
    }
 
2445
    if ((items < 4) || (items > 5)) {
 
2446
      SWIG_croak("Usage: svn_fs_upgrade2(path,notify_func,notify_baton,cancel_func,cancel_baton,scratch_pool);");
 
2447
    }
 
2448
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
 
2449
    if (!SWIG_IsOK(res1)) {
 
2450
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_upgrade2" "', argument " "1"" of type '" "char const *""'");
 
2451
    }
 
2452
    arg1 = (char *)(buf1);
 
2453
    {
 
2454
      int res = SWIG_ConvertFunctionPtr(ST(1), (void**)(&arg2), SWIGTYPE_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t);
 
2455
      if (!SWIG_IsOK(res)) {
 
2456
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_upgrade2" "', argument " "2"" of type '" "svn_fs_upgrade_notify_t""'"); 
 
2457
      }
 
2458
    }
 
2459
    res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
 
2460
    if (!SWIG_IsOK(res3)) {
 
2461
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_upgrade2" "', argument " "3"" of type '" "void *""'"); 
 
2462
    }
 
2463
    {
 
2464
      arg4 = (svn_cancel_func_t) svn_swig_pl_cancel_func;
 
2465
      arg5 = ST(3);
 
2466
    }
 
2467
    if (items > 4) {
 
2468
      
 
2469
    }
 
2470
    {
 
2471
      result = (svn_error_t *)svn_fs_upgrade2((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
 
2472
      
 
2473
      
 
2474
      
 
2475
    }
 
2476
    {
 
2477
      if (result) {
 
2478
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
2479
        
 
2480
        if (SvOK(exception_handler)) {
 
2481
          SV *callback_result;
 
2482
          
 
2483
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
2484
            &callback_result, "S", result,
 
2485
            SWIGTYPE_p_svn_error_t);
 
2486
        } else {
 
2487
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
2488
          argvi++;
 
2489
        }
 
2490
      }
 
2491
    }
 
2492
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
 
2493
    
 
2494
    
 
2495
    
 
2496
    XSRETURN(argvi);
 
2497
  fail:
 
2498
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
 
2499
    
 
2500
    
 
2501
    
 
2502
    SWIG_croak_null();
 
2503
  }
 
2504
}
 
2505
 
 
2506
 
2281
2507
XS(_wrap_svn_fs_upgrade) {
2282
2508
  {
2283
2509
    char *arg1 = (char *) 0 ;
2553
2779
}
2554
2780
 
2555
2781
 
 
2782
XS(_wrap_svn_fs_hotcopy3) {
 
2783
  {
 
2784
    char *arg1 = (char *) 0 ;
 
2785
    char *arg2 = (char *) 0 ;
 
2786
    svn_boolean_t arg3 ;
 
2787
    svn_boolean_t arg4 ;
 
2788
    svn_fs_hotcopy_notify_t arg5 = (svn_fs_hotcopy_notify_t) 0 ;
 
2789
    void *arg6 = (void *) 0 ;
 
2790
    svn_cancel_func_t arg7 = (svn_cancel_func_t) 0 ;
 
2791
    void *arg8 = (void *) 0 ;
 
2792
    apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
2793
    apr_pool_t *_global_pool ;
 
2794
    int res1 ;
 
2795
    char *buf1 = 0 ;
 
2796
    int alloc1 = 0 ;
 
2797
    int res2 ;
 
2798
    char *buf2 = 0 ;
 
2799
    int alloc2 = 0 ;
 
2800
    int val3 ;
 
2801
    int ecode3 = 0 ;
 
2802
    int val4 ;
 
2803
    int ecode4 = 0 ;
 
2804
    int res6 ;
 
2805
    int argvi = 0;
 
2806
    svn_error_t *result = 0 ;
 
2807
    dXSARGS;
 
2808
    
 
2809
    {
 
2810
      _global_pool = arg9 = svn_swig_pl_make_pool (ST(items-1));
 
2811
    }
 
2812
    if ((items < 7) || (items > 8)) {
 
2813
      SWIG_croak("Usage: svn_fs_hotcopy3(src_path,dest_path,clean,incremental,notify_func,notify_baton,cancel_func,cancel_baton,scratch_pool);");
 
2814
    }
 
2815
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
 
2816
    if (!SWIG_IsOK(res1)) {
 
2817
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_hotcopy3" "', argument " "1"" of type '" "char const *""'");
 
2818
    }
 
2819
    arg1 = (char *)(buf1);
 
2820
    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
 
2821
    if (!SWIG_IsOK(res2)) {
 
2822
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_hotcopy3" "', argument " "2"" of type '" "char const *""'");
 
2823
    }
 
2824
    arg2 = (char *)(buf2);
 
2825
    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
 
2826
    if (!SWIG_IsOK(ecode3)) {
 
2827
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svn_fs_hotcopy3" "', argument " "3"" of type '" "svn_boolean_t""'");
 
2828
    } 
 
2829
    arg3 = (svn_boolean_t)(val3);
 
2830
    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
 
2831
    if (!SWIG_IsOK(ecode4)) {
 
2832
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "svn_fs_hotcopy3" "', argument " "4"" of type '" "svn_boolean_t""'");
 
2833
    } 
 
2834
    arg4 = (svn_boolean_t)(val4);
 
2835
    {
 
2836
      int res = SWIG_ConvertFunctionPtr(ST(4), (void**)(&arg5), SWIGTYPE_p_f_p_void_long_long_p_apr_pool_t__void);
 
2837
      if (!SWIG_IsOK(res)) {
 
2838
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_hotcopy3" "', argument " "5"" of type '" "svn_fs_hotcopy_notify_t""'"); 
 
2839
      }
 
2840
    }
 
2841
    res6 = SWIG_ConvertPtr(ST(5),SWIG_as_voidptrptr(&arg6), 0, 0);
 
2842
    if (!SWIG_IsOK(res6)) {
 
2843
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svn_fs_hotcopy3" "', argument " "6"" of type '" "void *""'"); 
 
2844
    }
 
2845
    {
 
2846
      arg7 = (svn_cancel_func_t) svn_swig_pl_cancel_func;
 
2847
      arg8 = ST(6);
 
2848
    }
 
2849
    if (items > 7) {
 
2850
      
 
2851
    }
 
2852
    {
 
2853
      result = (svn_error_t *)svn_fs_hotcopy3((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
2854
      
 
2855
      
 
2856
      
 
2857
    }
 
2858
    {
 
2859
      if (result) {
 
2860
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
2861
        
 
2862
        if (SvOK(exception_handler)) {
 
2863
          SV *callback_result;
 
2864
          
 
2865
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
2866
            &callback_result, "S", result,
 
2867
            SWIGTYPE_p_svn_error_t);
 
2868
        } else {
 
2869
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
2870
          argvi++;
 
2871
        }
 
2872
      }
 
2873
    }
 
2874
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
 
2875
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
2876
    
 
2877
    
 
2878
    
 
2879
    
 
2880
    
 
2881
    XSRETURN(argvi);
 
2882
  fail:
 
2883
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
 
2884
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
2885
    
 
2886
    
 
2887
    
 
2888
    
 
2889
    
 
2890
    SWIG_croak_null();
 
2891
  }
 
2892
}
 
2893
 
 
2894
 
2556
2895
XS(_wrap_svn_fs_hotcopy2) {
2557
2896
  {
2558
2897
    char *arg1 = (char *) 0 ;
2573
2912
    int ecode3 = 0 ;
2574
2913
    int val4 ;
2575
2914
    int ecode4 = 0 ;
2576
 
    int res6 ;
2577
2915
    int argvi = 0;
2578
2916
    svn_error_t *result = 0 ;
2579
2917
    dXSARGS;
2581
2919
    {
2582
2920
      _global_pool = arg7 = svn_swig_pl_make_pool (ST(items-1));
2583
2921
    }
2584
 
    if ((items < 6) || (items > 7)) {
 
2922
    if ((items < 5) || (items > 6)) {
2585
2923
      SWIG_croak("Usage: svn_fs_hotcopy2(src_path,dest_path,clean,incremental,cancel_func,cancel_baton,scratch_pool);");
2586
2924
    }
2587
2925
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2605
2943
    } 
2606
2944
    arg4 = (svn_boolean_t)(val4);
2607
2945
    {
2608
 
      int res = SWIG_ConvertFunctionPtr(ST(4), (void**)(&arg5), SWIGTYPE_p_f_p_void__p_svn_error_t);
2609
 
      if (!SWIG_IsOK(res)) {
2610
 
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_hotcopy2" "', argument " "5"" of type '" "svn_cancel_func_t""'"); 
2611
 
      }
2612
 
    }
2613
 
    res6 = SWIG_ConvertPtr(ST(5),SWIG_as_voidptrptr(&arg6), 0, 0);
2614
 
    if (!SWIG_IsOK(res6)) {
2615
 
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svn_fs_hotcopy2" "', argument " "6"" of type '" "void *""'"); 
2616
 
    }
2617
 
    if (items > 6) {
 
2946
      arg5 = (svn_cancel_func_t) svn_swig_pl_cancel_func;
 
2947
      arg6 = ST(4);
 
2948
    }
 
2949
    if (items > 5) {
2618
2950
      
2619
2951
    }
2620
2952
    {
2644
2976
    
2645
2977
    
2646
2978
    
2647
 
    
2648
 
    
2649
2979
    XSRETURN(argvi);
2650
2980
  fail:
2651
2981
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2653
2983
    
2654
2984
    
2655
2985
    
2656
 
    
2657
 
    
2658
2986
    SWIG_croak_null();
2659
2987
  }
2660
2988
}
2750
3078
    int res1 ;
2751
3079
    char *buf1 = 0 ;
2752
3080
    int alloc1 = 0 ;
2753
 
    int res3 ;
2754
3081
    int argvi = 0;
2755
3082
    svn_error_t *result = 0 ;
2756
3083
    dXSARGS;
2758
3085
    {
2759
3086
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
2760
3087
    }
2761
 
    if ((items < 3) || (items > 4)) {
 
3088
    if ((items < 2) || (items > 3)) {
2762
3089
      SWIG_croak("Usage: svn_fs_recover(path,cancel_func,cancel_baton,pool);");
2763
3090
    }
2764
3091
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2767
3094
    }
2768
3095
    arg1 = (char *)(buf1);
2769
3096
    {
2770
 
      int res = SWIG_ConvertFunctionPtr(ST(1), (void**)(&arg2), SWIGTYPE_p_f_p_void__p_svn_error_t);
2771
 
      if (!SWIG_IsOK(res)) {
2772
 
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_recover" "', argument " "2"" of type '" "svn_cancel_func_t""'"); 
2773
 
      }
2774
 
    }
2775
 
    res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
2776
 
    if (!SWIG_IsOK(res3)) {
2777
 
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_recover" "', argument " "3"" of type '" "void *""'"); 
2778
 
    }
2779
 
    if (items > 3) {
 
3097
      arg2 = (svn_cancel_func_t) svn_swig_pl_cancel_func;
 
3098
      arg3 = ST(1);
 
3099
    }
 
3100
    if (items > 2) {
2780
3101
      
2781
3102
    }
2782
3103
    {
2803
3124
    }
2804
3125
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2805
3126
    
2806
 
    
2807
 
    
2808
3127
    XSRETURN(argvi);
2809
3128
  fail:
2810
3129
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2811
3130
    
2812
 
    
2813
 
    
2814
3131
    SWIG_croak_null();
2815
3132
  }
2816
3133
}
5738
6055
}
5739
6056
 
5740
6057
 
 
6058
XS(_wrap_svn_fs_path_change2_t_mergeinfo_mod_set) {
 
6059
  {
 
6060
    struct svn_fs_path_change2_t *arg1 = (struct svn_fs_path_change2_t *) 0 ;
 
6061
    svn_tristate_t arg2 ;
 
6062
    void *argp1 = 0 ;
 
6063
    int res1 = 0 ;
 
6064
    int val2 ;
 
6065
    int ecode2 = 0 ;
 
6066
    int argvi = 0;
 
6067
    dXSARGS;
 
6068
    
 
6069
    if ((items < 2) || (items > 2)) {
 
6070
      SWIG_croak("Usage: svn_fs_path_change2_t_mergeinfo_mod_set(self,mergeinfo_mod);");
 
6071
    }
 
6072
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_path_change2_t, 0 |  0 );
 
6073
    if (!SWIG_IsOK(res1)) {
 
6074
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_path_change2_t_mergeinfo_mod_set" "', argument " "1"" of type '" "struct svn_fs_path_change2_t *""'"); 
 
6075
    }
 
6076
    arg1 = (struct svn_fs_path_change2_t *)(argp1);
 
6077
    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
 
6078
    if (!SWIG_IsOK(ecode2)) {
 
6079
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svn_fs_path_change2_t_mergeinfo_mod_set" "', argument " "2"" of type '" "svn_tristate_t""'");
 
6080
    } 
 
6081
    arg2 = (svn_tristate_t)(val2);
 
6082
    if (arg1) (arg1)->mergeinfo_mod = arg2;
 
6083
    ST(argvi) = sv_newmortal();
 
6084
    
 
6085
    
 
6086
    XSRETURN(argvi);
 
6087
  fail:
 
6088
    
 
6089
    
 
6090
    SWIG_croak_null();
 
6091
  }
 
6092
}
 
6093
 
 
6094
 
 
6095
XS(_wrap_svn_fs_path_change2_t_mergeinfo_mod_get) {
 
6096
  {
 
6097
    struct svn_fs_path_change2_t *arg1 = (struct svn_fs_path_change2_t *) 0 ;
 
6098
    void *argp1 = 0 ;
 
6099
    int res1 = 0 ;
 
6100
    int argvi = 0;
 
6101
    svn_tristate_t result;
 
6102
    dXSARGS;
 
6103
    
 
6104
    if ((items < 1) || (items > 1)) {
 
6105
      SWIG_croak("Usage: svn_fs_path_change2_t_mergeinfo_mod_get(self);");
 
6106
    }
 
6107
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_path_change2_t, 0 |  0 );
 
6108
    if (!SWIG_IsOK(res1)) {
 
6109
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_path_change2_t_mergeinfo_mod_get" "', argument " "1"" of type '" "struct svn_fs_path_change2_t *""'"); 
 
6110
    }
 
6111
    arg1 = (struct svn_fs_path_change2_t *)(argp1);
 
6112
    result = (svn_tristate_t) ((arg1)->mergeinfo_mod);
 
6113
    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
 
6114
    
 
6115
    XSRETURN(argvi);
 
6116
  fail:
 
6117
    
 
6118
    SWIG_croak_null();
 
6119
  }
 
6120
}
 
6121
 
 
6122
 
5741
6123
XS(_wrap_svn_fs_path_change_t_node_rev_id_set) {
5742
6124
  {
5743
6125
    struct svn_fs_path_change_t *arg1 = (struct svn_fs_path_change_t *) 0 ;
6264
6646
}
6265
6647
 
6266
6648
 
 
6649
XS(_wrap_svn_fs_node_history2) {
 
6650
  {
 
6651
    svn_fs_history_t **arg1 = (svn_fs_history_t **) 0 ;
 
6652
    svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
6653
    char *arg3 = (char *) 0 ;
 
6654
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
6655
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
6656
    apr_pool_t *_global_pool ;
 
6657
    svn_fs_history_t *temp1 ;
 
6658
    void *argp2 = 0 ;
 
6659
    int res2 = 0 ;
 
6660
    int res3 ;
 
6661
    char *buf3 = 0 ;
 
6662
    int alloc3 = 0 ;
 
6663
    int argvi = 0;
 
6664
    svn_error_t *result = 0 ;
 
6665
    dXSARGS;
 
6666
    
 
6667
    {
 
6668
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
6669
    }
 
6670
    {
 
6671
      _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
 
6672
    }
 
6673
    arg1 = &temp1;
 
6674
    if ((items < 2) || (items > 4)) {
 
6675
      SWIG_croak("Usage: svn_fs_node_history2(root,path,result_pool,scratch_pool);");
 
6676
    }
 
6677
    res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
6678
    if (!SWIG_IsOK(res2)) {
 
6679
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_node_history2" "', argument " "2"" of type '" "svn_fs_root_t *""'"); 
 
6680
    }
 
6681
    arg2 = (svn_fs_root_t *)(argp2);
 
6682
    res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
 
6683
    if (!SWIG_IsOK(res3)) {
 
6684
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_node_history2" "', argument " "3"" of type '" "char const *""'");
 
6685
    }
 
6686
    arg3 = (char *)(buf3);
 
6687
    if (items > 2) {
 
6688
      
 
6689
    }
 
6690
    if (items > 3) {
 
6691
      
 
6692
    }
 
6693
    {
 
6694
      result = (svn_error_t *)svn_fs_node_history2(arg1,arg2,(char const *)arg3,arg4,arg5);
 
6695
      
 
6696
      
 
6697
      
 
6698
    }
 
6699
    {
 
6700
      if (result) {
 
6701
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
6702
        
 
6703
        if (SvOK(exception_handler)) {
 
6704
          SV *callback_result;
 
6705
          
 
6706
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
6707
            &callback_result, "S", result,
 
6708
            SWIGTYPE_p_svn_error_t);
 
6709
        } else {
 
6710
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
6711
          argvi++;
 
6712
        }
 
6713
      }
 
6714
    }
 
6715
    {
 
6716
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_history_t, 0); argvi++  ;
 
6717
    }
 
6718
    
 
6719
    
 
6720
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
6721
    
 
6722
    
 
6723
    XSRETURN(argvi);
 
6724
  fail:
 
6725
    
 
6726
    
 
6727
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
6728
    
 
6729
    
 
6730
    SWIG_croak_null();
 
6731
  }
 
6732
}
 
6733
 
 
6734
 
6267
6735
XS(_wrap_svn_fs_node_history) {
6268
6736
  {
6269
6737
    svn_fs_history_t **arg1 = (svn_fs_history_t **) 0 ;
6341
6809
}
6342
6810
 
6343
6811
 
 
6812
XS(_wrap_svn_fs_history_prev2) {
 
6813
  {
 
6814
    svn_fs_history_t **arg1 = (svn_fs_history_t **) 0 ;
 
6815
    svn_fs_history_t *arg2 = (svn_fs_history_t *) 0 ;
 
6816
    svn_boolean_t arg3 ;
 
6817
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
6818
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
6819
    apr_pool_t *_global_pool ;
 
6820
    svn_fs_history_t *temp1 ;
 
6821
    void *argp2 = 0 ;
 
6822
    int res2 = 0 ;
 
6823
    int val3 ;
 
6824
    int ecode3 = 0 ;
 
6825
    int argvi = 0;
 
6826
    svn_error_t *result = 0 ;
 
6827
    dXSARGS;
 
6828
    
 
6829
    {
 
6830
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
6831
    }
 
6832
    {
 
6833
      _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
 
6834
    }
 
6835
    arg1 = &temp1;
 
6836
    if ((items < 2) || (items > 4)) {
 
6837
      SWIG_croak("Usage: svn_fs_history_prev2(history,cross_copies,result_pool,scratch_pool);");
 
6838
    }
 
6839
    res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_fs_history_t, 0 |  0 );
 
6840
    if (!SWIG_IsOK(res2)) {
 
6841
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_history_prev2" "', argument " "2"" of type '" "svn_fs_history_t *""'"); 
 
6842
    }
 
6843
    arg2 = (svn_fs_history_t *)(argp2);
 
6844
    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val3);
 
6845
    if (!SWIG_IsOK(ecode3)) {
 
6846
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svn_fs_history_prev2" "', argument " "3"" of type '" "svn_boolean_t""'");
 
6847
    } 
 
6848
    arg3 = (svn_boolean_t)(val3);
 
6849
    if (items > 2) {
 
6850
      
 
6851
    }
 
6852
    if (items > 3) {
 
6853
      
 
6854
    }
 
6855
    {
 
6856
      result = (svn_error_t *)svn_fs_history_prev2(arg1,arg2,arg3,arg4,arg5);
 
6857
      
 
6858
      
 
6859
      
 
6860
    }
 
6861
    {
 
6862
      if (result) {
 
6863
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
6864
        
 
6865
        if (SvOK(exception_handler)) {
 
6866
          SV *callback_result;
 
6867
          
 
6868
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
6869
            &callback_result, "S", result,
 
6870
            SWIGTYPE_p_svn_error_t);
 
6871
        } else {
 
6872
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
6873
          argvi++;
 
6874
        }
 
6875
      }
 
6876
    }
 
6877
    {
 
6878
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_history_t, 0); argvi++  ;
 
6879
    }
 
6880
    
 
6881
    
 
6882
    
 
6883
    
 
6884
    
 
6885
    XSRETURN(argvi);
 
6886
  fail:
 
6887
    
 
6888
    
 
6889
    
 
6890
    
 
6891
    
 
6892
    SWIG_croak_null();
 
6893
  }
 
6894
}
 
6895
 
 
6896
 
6344
6897
XS(_wrap_svn_fs_history_prev) {
6345
6898
  {
6346
6899
    svn_fs_history_t **arg1 = (svn_fs_history_t **) 0 ;
6738
7291
}
6739
7292
 
6740
7293
 
 
7294
XS(_wrap_svn_fs_node_relation) {
 
7295
  {
 
7296
    svn_fs_node_relation_t *arg1 = (svn_fs_node_relation_t *) 0 ;
 
7297
    svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
7298
    char *arg3 = (char *) 0 ;
 
7299
    svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
 
7300
    char *arg5 = (char *) 0 ;
 
7301
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
7302
    apr_pool_t *_global_pool ;
 
7303
    void *argp1 = 0 ;
 
7304
    int res1 = 0 ;
 
7305
    void *argp2 = 0 ;
 
7306
    int res2 = 0 ;
 
7307
    int res3 ;
 
7308
    char *buf3 = 0 ;
 
7309
    int alloc3 = 0 ;
 
7310
    void *argp4 = 0 ;
 
7311
    int res4 = 0 ;
 
7312
    int res5 ;
 
7313
    char *buf5 = 0 ;
 
7314
    int alloc5 = 0 ;
 
7315
    int argvi = 0;
 
7316
    svn_error_t *result = 0 ;
 
7317
    dXSARGS;
 
7318
    
 
7319
    {
 
7320
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
 
7321
    }
 
7322
    if ((items < 5) || (items > 6)) {
 
7323
      SWIG_croak("Usage: svn_fs_node_relation(relation,root_a,path_a,root_b,path_b,scratch_pool);");
 
7324
    }
 
7325
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_node_relation_t, 0 |  0 );
 
7326
    if (!SWIG_IsOK(res1)) {
 
7327
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_node_relation" "', argument " "1"" of type '" "svn_fs_node_relation_t *""'"); 
 
7328
    }
 
7329
    arg1 = (svn_fs_node_relation_t *)(argp1);
 
7330
    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
7331
    if (!SWIG_IsOK(res2)) {
 
7332
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_node_relation" "', argument " "2"" of type '" "svn_fs_root_t *""'"); 
 
7333
    }
 
7334
    arg2 = (svn_fs_root_t *)(argp2);
 
7335
    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
 
7336
    if (!SWIG_IsOK(res3)) {
 
7337
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_node_relation" "', argument " "3"" of type '" "char const *""'");
 
7338
    }
 
7339
    arg3 = (char *)(buf3);
 
7340
    res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
7341
    if (!SWIG_IsOK(res4)) {
 
7342
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_fs_node_relation" "', argument " "4"" of type '" "svn_fs_root_t *""'"); 
 
7343
    }
 
7344
    arg4 = (svn_fs_root_t *)(argp4);
 
7345
    res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
 
7346
    if (!SWIG_IsOK(res5)) {
 
7347
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_fs_node_relation" "', argument " "5"" of type '" "char const *""'");
 
7348
    }
 
7349
    arg5 = (char *)(buf5);
 
7350
    if (items > 5) {
 
7351
      
 
7352
    }
 
7353
    {
 
7354
      result = (svn_error_t *)svn_fs_node_relation(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
 
7355
      
 
7356
      
 
7357
      
 
7358
    }
 
7359
    {
 
7360
      if (result) {
 
7361
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
7362
        
 
7363
        if (SvOK(exception_handler)) {
 
7364
          SV *callback_result;
 
7365
          
 
7366
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
7367
            &callback_result, "S", result,
 
7368
            SWIGTYPE_p_svn_error_t);
 
7369
        } else {
 
7370
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
7371
          argvi++;
 
7372
        }
 
7373
      }
 
7374
    }
 
7375
    
 
7376
    
 
7377
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
7378
    
 
7379
    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
 
7380
    
 
7381
    XSRETURN(argvi);
 
7382
  fail:
 
7383
    
 
7384
    
 
7385
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
7386
    
 
7387
    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
 
7388
    
 
7389
    SWIG_croak_null();
 
7390
  }
 
7391
}
 
7392
 
 
7393
 
6741
7394
XS(_wrap_svn_fs_node_created_rev) {
6742
7395
  {
6743
7396
    svn_revnum_t *arg1 = (svn_revnum_t *) 0 ;
7150
7803
}
7151
7804
 
7152
7805
 
 
7806
XS(_wrap_svn_fs_node_has_props) {
 
7807
  {
 
7808
    svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
 
7809
    svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
7810
    char *arg3 = (char *) 0 ;
 
7811
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
7812
    apr_pool_t *_global_pool ;
 
7813
    svn_boolean_t temp1 ;
 
7814
    int res1 = SWIG_TMPOBJ ;
 
7815
    void *argp2 = 0 ;
 
7816
    int res2 = 0 ;
 
7817
    int res3 ;
 
7818
    char *buf3 = 0 ;
 
7819
    int alloc3 = 0 ;
 
7820
    int argvi = 0;
 
7821
    svn_error_t *result = 0 ;
 
7822
    dXSARGS;
 
7823
    
 
7824
    {
 
7825
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
7826
    }
 
7827
    arg1 = &temp1;
 
7828
    if ((items < 2) || (items > 3)) {
 
7829
      SWIG_croak("Usage: svn_fs_node_has_props(root,path,scratch_pool);");
 
7830
    }
 
7831
    res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
7832
    if (!SWIG_IsOK(res2)) {
 
7833
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_node_has_props" "', argument " "2"" of type '" "svn_fs_root_t *""'"); 
 
7834
    }
 
7835
    arg2 = (svn_fs_root_t *)(argp2);
 
7836
    res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
 
7837
    if (!SWIG_IsOK(res3)) {
 
7838
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_node_has_props" "', argument " "3"" of type '" "char const *""'");
 
7839
    }
 
7840
    arg3 = (char *)(buf3);
 
7841
    if (items > 2) {
 
7842
      
 
7843
    }
 
7844
    {
 
7845
      result = (svn_error_t *)svn_fs_node_has_props(arg1,arg2,(char const *)arg3,arg4);
 
7846
      
 
7847
      
 
7848
      
 
7849
    }
 
7850
    {
 
7851
      if (result) {
 
7852
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
7853
        
 
7854
        if (SvOK(exception_handler)) {
 
7855
          SV *callback_result;
 
7856
          
 
7857
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
7858
            &callback_result, "S", result,
 
7859
            SWIGTYPE_p_svn_error_t);
 
7860
        } else {
 
7861
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
7862
          argvi++;
 
7863
        }
 
7864
      }
 
7865
    }
 
7866
    if (SWIG_IsTmpObj(res1)) {
 
7867
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((*arg1)); argvi++  ;
 
7868
    } else {
 
7869
      int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0) : 0;
 
7870
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags); argvi++  ;
 
7871
    }
 
7872
    
 
7873
    
 
7874
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
7875
    
 
7876
    XSRETURN(argvi);
 
7877
  fail:
 
7878
    
 
7879
    
 
7880
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
7881
    
 
7882
    SWIG_croak_null();
 
7883
  }
 
7884
}
 
7885
 
 
7886
 
7153
7887
XS(_wrap_svn_fs_change_node_prop) {
7154
7888
  {
7155
7889
    svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
7243
7977
}
7244
7978
 
7245
7979
 
 
7980
XS(_wrap_svn_fs_props_different) {
 
7981
  {
 
7982
    svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
 
7983
    svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
7984
    char *arg3 = (char *) 0 ;
 
7985
    svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
 
7986
    char *arg5 = (char *) 0 ;
 
7987
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
7988
    apr_pool_t *_global_pool ;
 
7989
    svn_boolean_t temp1 ;
 
7990
    int res1 = SWIG_TMPOBJ ;
 
7991
    void *argp2 = 0 ;
 
7992
    int res2 = 0 ;
 
7993
    int res3 ;
 
7994
    char *buf3 = 0 ;
 
7995
    int alloc3 = 0 ;
 
7996
    void *argp4 = 0 ;
 
7997
    int res4 = 0 ;
 
7998
    int res5 ;
 
7999
    char *buf5 = 0 ;
 
8000
    int alloc5 = 0 ;
 
8001
    int argvi = 0;
 
8002
    svn_error_t *result = 0 ;
 
8003
    dXSARGS;
 
8004
    
 
8005
    {
 
8006
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
 
8007
    }
 
8008
    arg1 = &temp1;
 
8009
    if ((items < 4) || (items > 5)) {
 
8010
      SWIG_croak("Usage: svn_fs_props_different(root1,path1,root2,path2,scratch_pool);");
 
8011
    }
 
8012
    res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
8013
    if (!SWIG_IsOK(res2)) {
 
8014
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_props_different" "', argument " "2"" of type '" "svn_fs_root_t *""'"); 
 
8015
    }
 
8016
    arg2 = (svn_fs_root_t *)(argp2);
 
8017
    res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
 
8018
    if (!SWIG_IsOK(res3)) {
 
8019
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_props_different" "', argument " "3"" of type '" "char const *""'");
 
8020
    }
 
8021
    arg3 = (char *)(buf3);
 
8022
    res4 = SWIG_ConvertPtr(ST(2), &argp4,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
8023
    if (!SWIG_IsOK(res4)) {
 
8024
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_fs_props_different" "', argument " "4"" of type '" "svn_fs_root_t *""'"); 
 
8025
    }
 
8026
    arg4 = (svn_fs_root_t *)(argp4);
 
8027
    res5 = SWIG_AsCharPtrAndSize(ST(3), &buf5, NULL, &alloc5);
 
8028
    if (!SWIG_IsOK(res5)) {
 
8029
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_fs_props_different" "', argument " "5"" of type '" "char const *""'");
 
8030
    }
 
8031
    arg5 = (char *)(buf5);
 
8032
    if (items > 4) {
 
8033
      
 
8034
    }
 
8035
    {
 
8036
      result = (svn_error_t *)svn_fs_props_different(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
 
8037
      
 
8038
      
 
8039
      
 
8040
    }
 
8041
    {
 
8042
      if (result) {
 
8043
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
8044
        
 
8045
        if (SvOK(exception_handler)) {
 
8046
          SV *callback_result;
 
8047
          
 
8048
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
8049
            &callback_result, "S", result,
 
8050
            SWIGTYPE_p_svn_error_t);
 
8051
        } else {
 
8052
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
8053
          argvi++;
 
8054
        }
 
8055
      }
 
8056
    }
 
8057
    if (SWIG_IsTmpObj(res1)) {
 
8058
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((*arg1)); argvi++  ;
 
8059
    } else {
 
8060
      int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0) : 0;
 
8061
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags); argvi++  ;
 
8062
    }
 
8063
    
 
8064
    
 
8065
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
8066
    
 
8067
    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
 
8068
    
 
8069
    XSRETURN(argvi);
 
8070
  fail:
 
8071
    
 
8072
    
 
8073
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
8074
    
 
8075
    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
 
8076
    
 
8077
    SWIG_croak_null();
 
8078
  }
 
8079
}
 
8080
 
 
8081
 
7246
8082
XS(_wrap_svn_fs_props_changed) {
7247
8083
  {
7248
8084
    svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
7567
8403
    }
7568
8404
    arg2 = (svn_fs_root_t *)(argp2);
7569
8405
    {
7570
 
      arg3 = (apr_array_header_t *) svn_swig_pl_strings_to_array(ST(1),
 
8406
      arg3 = svn_swig_pl_strings_to_array(ST(1),
7571
8407
        _global_pool);
7572
8408
    }
7573
8409
    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val4);
7678
8514
    }
7679
8515
    arg2 = (svn_fs_root_t *)(argp2);
7680
8516
    {
7681
 
      arg3 = (apr_array_header_t *) svn_swig_pl_strings_to_array(ST(1),
 
8517
      arg3 = svn_swig_pl_strings_to_array(ST(1),
7682
8518
        _global_pool);
7683
8519
    }
7684
8520
    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val4);
8147
8983
}
8148
8984
 
8149
8985
 
 
8986
XS(_wrap_svn_fs_dir_optimal_order) {
 
8987
  {
 
8988
    apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
 
8989
    svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
8990
    apr_hash_t *arg3 = (apr_hash_t *) 0 ;
 
8991
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
8992
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
8993
    apr_pool_t *_global_pool ;
 
8994
    apr_array_header_t *temp1 ;
 
8995
    void *argp2 = 0 ;
 
8996
    int res2 = 0 ;
 
8997
    void *argp3 = 0 ;
 
8998
    int res3 = 0 ;
 
8999
    int argvi = 0;
 
9000
    svn_error_t *result = 0 ;
 
9001
    dXSARGS;
 
9002
    
 
9003
    {
 
9004
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
9005
    }
 
9006
    {
 
9007
      _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
 
9008
    }
 
9009
    arg1 = &temp1;
 
9010
    if ((items < 2) || (items > 4)) {
 
9011
      SWIG_croak("Usage: svn_fs_dir_optimal_order(root,entries,result_pool,scratch_pool);");
 
9012
    }
 
9013
    res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
9014
    if (!SWIG_IsOK(res2)) {
 
9015
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_dir_optimal_order" "', argument " "2"" of type '" "svn_fs_root_t *""'"); 
 
9016
    }
 
9017
    arg2 = (svn_fs_root_t *)(argp2);
 
9018
    res3 = SWIG_ConvertPtr(ST(1), &argp3,SWIGTYPE_p_apr_hash_t, 0 |  0 );
 
9019
    if (!SWIG_IsOK(res3)) {
 
9020
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_dir_optimal_order" "', argument " "3"" of type '" "apr_hash_t *""'"); 
 
9021
    }
 
9022
    arg3 = (apr_hash_t *)(argp3);
 
9023
    if (items > 2) {
 
9024
      
 
9025
    }
 
9026
    if (items > 3) {
 
9027
      
 
9028
    }
 
9029
    {
 
9030
      result = (svn_error_t *)svn_fs_dir_optimal_order(arg1,arg2,arg3,arg4,arg5);
 
9031
      
 
9032
      
 
9033
      
 
9034
    }
 
9035
    {
 
9036
      if (result) {
 
9037
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
9038
        
 
9039
        if (SvOK(exception_handler)) {
 
9040
          SV *callback_result;
 
9041
          
 
9042
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
9043
            &callback_result, "S", result,
 
9044
            SWIGTYPE_p_svn_error_t);
 
9045
        } else {
 
9046
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
9047
          argvi++;
 
9048
        }
 
9049
      }
 
9050
    }
 
9051
    {
 
9052
      /* FIXME: Missing argout typemap: svn_fs_dir_optimal_order arg 1 (apr_array_header_t **) */
 
9053
      
 
9054
      
 
9055
      
 
9056
      
 
9057
      SWIG_exception(SWIG_ValueError, "svn_fs_dir_optimal_order is not implemented yet");
 
9058
      
 
9059
    }
 
9060
    
 
9061
    
 
9062
    
 
9063
    
 
9064
    
 
9065
    XSRETURN(argvi);
 
9066
  fail:
 
9067
    
 
9068
    
 
9069
    
 
9070
    
 
9071
    
 
9072
    SWIG_croak_null();
 
9073
  }
 
9074
}
 
9075
 
 
9076
 
8150
9077
XS(_wrap_svn_fs_make_dir) {
8151
9078
  {
8152
9079
    svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
8514
9441
      }
8515
9442
    }
8516
9443
    {
8517
 
      char temp[256];
 
9444
      char temp[30];
8518
9445
      sprintf(temp, "%" APR_INT64_T_FMT, (apr_int64_t)*(arg1));
8519
9446
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = sv_2mortal(newSVpv(temp, 0)); argvi++  ;
8520
9447
    }
8696
9623
      }
8697
9624
    }
8698
9625
    {
8699
 
      /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,59,%append_output@*/ if (argvi >= items) EXTEND(sp,1); /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,56,%set_output@*/ ST(argvi) = sv_2mortal(newSVpv(svn_md5_digest_to_cstring(arg1,
 
9626
      /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,59,%append_output@*/ if (argvi >= items) EXTEND(sp,1); /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,56,%set_output@*/ ST(argvi) = sv_2mortal(newSVpv(svn_md5_digest_to_cstring(arg1,
8700
9627
            _global_pool),
8701
9628
          0)); argvi++ /*@SWIG@*/
8702
9629
      
9158
10085
}
9159
10086
 
9160
10087
 
 
10088
XS(_wrap_svn_fs_contents_different) {
 
10089
  {
 
10090
    svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
 
10091
    svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
10092
    char *arg3 = (char *) 0 ;
 
10093
    svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
 
10094
    char *arg5 = (char *) 0 ;
 
10095
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
10096
    apr_pool_t *_global_pool ;
 
10097
    svn_boolean_t temp1 ;
 
10098
    int res1 = SWIG_TMPOBJ ;
 
10099
    void *argp2 = 0 ;
 
10100
    int res2 = 0 ;
 
10101
    int res3 ;
 
10102
    char *buf3 = 0 ;
 
10103
    int alloc3 = 0 ;
 
10104
    void *argp4 = 0 ;
 
10105
    int res4 = 0 ;
 
10106
    int res5 ;
 
10107
    char *buf5 = 0 ;
 
10108
    int alloc5 = 0 ;
 
10109
    int argvi = 0;
 
10110
    svn_error_t *result = 0 ;
 
10111
    dXSARGS;
 
10112
    
 
10113
    {
 
10114
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
 
10115
    }
 
10116
    arg1 = &temp1;
 
10117
    if ((items < 4) || (items > 5)) {
 
10118
      SWIG_croak("Usage: svn_fs_contents_different(root1,path1,root2,path2,scratch_pool);");
 
10119
    }
 
10120
    res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
10121
    if (!SWIG_IsOK(res2)) {
 
10122
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_contents_different" "', argument " "2"" of type '" "svn_fs_root_t *""'"); 
 
10123
    }
 
10124
    arg2 = (svn_fs_root_t *)(argp2);
 
10125
    res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
 
10126
    if (!SWIG_IsOK(res3)) {
 
10127
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_contents_different" "', argument " "3"" of type '" "char const *""'");
 
10128
    }
 
10129
    arg3 = (char *)(buf3);
 
10130
    res4 = SWIG_ConvertPtr(ST(2), &argp4,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
 
10131
    if (!SWIG_IsOK(res4)) {
 
10132
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_fs_contents_different" "', argument " "4"" of type '" "svn_fs_root_t *""'"); 
 
10133
    }
 
10134
    arg4 = (svn_fs_root_t *)(argp4);
 
10135
    res5 = SWIG_AsCharPtrAndSize(ST(3), &buf5, NULL, &alloc5);
 
10136
    if (!SWIG_IsOK(res5)) {
 
10137
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_fs_contents_different" "', argument " "5"" of type '" "char const *""'");
 
10138
    }
 
10139
    arg5 = (char *)(buf5);
 
10140
    if (items > 4) {
 
10141
      
 
10142
    }
 
10143
    {
 
10144
      result = (svn_error_t *)svn_fs_contents_different(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
 
10145
      
 
10146
      
 
10147
      
 
10148
    }
 
10149
    {
 
10150
      if (result) {
 
10151
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
10152
        
 
10153
        if (SvOK(exception_handler)) {
 
10154
          SV *callback_result;
 
10155
          
 
10156
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
10157
            &callback_result, "S", result,
 
10158
            SWIGTYPE_p_svn_error_t);
 
10159
        } else {
 
10160
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
10161
          argvi++;
 
10162
        }
 
10163
      }
 
10164
    }
 
10165
    if (SWIG_IsTmpObj(res1)) {
 
10166
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((*arg1)); argvi++  ;
 
10167
    } else {
 
10168
      int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0) : 0;
 
10169
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags); argvi++  ;
 
10170
    }
 
10171
    
 
10172
    
 
10173
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
10174
    
 
10175
    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
 
10176
    
 
10177
    XSRETURN(argvi);
 
10178
  fail:
 
10179
    
 
10180
    
 
10181
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
10182
    
 
10183
    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
 
10184
    
 
10185
    SWIG_croak_null();
 
10186
  }
 
10187
}
 
10188
 
 
10189
 
9161
10190
XS(_wrap_svn_fs_contents_changed) {
9162
10191
  {
9163
10192
    svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
9330
10359
}
9331
10360
 
9332
10361
 
 
10362
XS(_wrap_svn_fs_info_format) {
 
10363
  {
 
10364
    int *arg1 = (int *) 0 ;
 
10365
    svn_version_t **arg2 = (svn_version_t **) 0 ;
 
10366
    svn_fs_t *arg3 = (svn_fs_t *) 0 ;
 
10367
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
10368
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
10369
    apr_pool_t *_global_pool ;
 
10370
    int temp1 ;
 
10371
    int res1 = SWIG_TMPOBJ ;
 
10372
    svn_version_t *temp2 ;
 
10373
    void *argp3 = 0 ;
 
10374
    int res3 = 0 ;
 
10375
    int argvi = 0;
 
10376
    svn_error_t *result = 0 ;
 
10377
    dXSARGS;
 
10378
    
 
10379
    {
 
10380
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
10381
    }
 
10382
    {
 
10383
      _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
 
10384
    }
 
10385
    arg1 = &temp1;
 
10386
    arg2 = &temp2;
 
10387
    if ((items < 1) || (items > 3)) {
 
10388
      SWIG_croak("Usage: svn_fs_info_format(fs,result_pool,scratch_pool);");
 
10389
    }
 
10390
    res3 = SWIG_ConvertPtr(ST(0), &argp3,SWIGTYPE_p_svn_fs_t, 0 |  0 );
 
10391
    if (!SWIG_IsOK(res3)) {
 
10392
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_info_format" "', argument " "3"" of type '" "svn_fs_t *""'"); 
 
10393
    }
 
10394
    arg3 = (svn_fs_t *)(argp3);
 
10395
    if (items > 1) {
 
10396
      
 
10397
    }
 
10398
    if (items > 2) {
 
10399
      
 
10400
    }
 
10401
    {
 
10402
      result = (svn_error_t *)svn_fs_info_format(arg1,arg2,arg3,arg4,arg5);
 
10403
      
 
10404
      
 
10405
      
 
10406
    }
 
10407
    {
 
10408
      if (result) {
 
10409
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
10410
        
 
10411
        if (SvOK(exception_handler)) {
 
10412
          SV *callback_result;
 
10413
          
 
10414
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
10415
            &callback_result, "S", result,
 
10416
            SWIGTYPE_p_svn_error_t);
 
10417
        } else {
 
10418
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
10419
          argvi++;
 
10420
        }
 
10421
      }
 
10422
    }
 
10423
    if (SWIG_IsTmpObj(res1)) {
 
10424
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((*arg1)); argvi++  ;
 
10425
    } else {
 
10426
      int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0) : 0;
 
10427
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags); argvi++  ;
 
10428
    }
 
10429
    {
 
10430
      /* FIXME: Missing argout typemap: svn_fs_info_format arg 2 (svn_version_t **) */
 
10431
      
 
10432
      
 
10433
      
 
10434
      
 
10435
      SWIG_exception(SWIG_ValueError, "svn_fs_info_format is not implemented yet");
 
10436
      
 
10437
    }
 
10438
    
 
10439
    
 
10440
    
 
10441
    
 
10442
    
 
10443
    XSRETURN(argvi);
 
10444
  fail:
 
10445
    
 
10446
    
 
10447
    
 
10448
    
 
10449
    
 
10450
    SWIG_croak_null();
 
10451
  }
 
10452
}
 
10453
 
 
10454
 
 
10455
XS(_wrap_svn_fs_info_config_files) {
 
10456
  {
 
10457
    apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
 
10458
    svn_fs_t *arg2 = (svn_fs_t *) 0 ;
 
10459
    apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
10460
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
10461
    apr_pool_t *_global_pool ;
 
10462
    apr_array_header_t *temp1 ;
 
10463
    void *argp2 = 0 ;
 
10464
    int res2 = 0 ;
 
10465
    int argvi = 0;
 
10466
    svn_error_t *result = 0 ;
 
10467
    dXSARGS;
 
10468
    
 
10469
    {
 
10470
      _global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
 
10471
    }
 
10472
    {
 
10473
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
10474
    }
 
10475
    arg1 = &temp1;
 
10476
    if ((items < 1) || (items > 3)) {
 
10477
      SWIG_croak("Usage: svn_fs_info_config_files(fs,result_pool,scratch_pool);");
 
10478
    }
 
10479
    res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_fs_t, 0 |  0 );
 
10480
    if (!SWIG_IsOK(res2)) {
 
10481
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_info_config_files" "', argument " "2"" of type '" "svn_fs_t *""'"); 
 
10482
    }
 
10483
    arg2 = (svn_fs_t *)(argp2);
 
10484
    if (items > 1) {
 
10485
      
 
10486
    }
 
10487
    if (items > 2) {
 
10488
      
 
10489
    }
 
10490
    {
 
10491
      result = (svn_error_t *)svn_fs_info_config_files(arg1,arg2,arg3,arg4);
 
10492
      
 
10493
      
 
10494
      
 
10495
    }
 
10496
    {
 
10497
      if (result) {
 
10498
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
10499
        
 
10500
        if (SvOK(exception_handler)) {
 
10501
          SV *callback_result;
 
10502
          
 
10503
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
10504
            &callback_result, "S", result,
 
10505
            SWIGTYPE_p_svn_error_t);
 
10506
        } else {
 
10507
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
10508
          argvi++;
 
10509
        }
 
10510
      }
 
10511
    }
 
10512
    {
 
10513
      /* FIXME: Missing argout typemap: svn_fs_info_config_files arg 1 (apr_array_header_t **) */
 
10514
      
 
10515
      
 
10516
      
 
10517
      
 
10518
      SWIG_exception(SWIG_ValueError, "svn_fs_info_config_files is not implemented yet");
 
10519
      
 
10520
    }
 
10521
    
 
10522
    
 
10523
    
 
10524
    
 
10525
    XSRETURN(argvi);
 
10526
  fail:
 
10527
    
 
10528
    
 
10529
    
 
10530
    
 
10531
    SWIG_croak_null();
 
10532
  }
 
10533
}
 
10534
 
 
10535
 
9333
10536
XS(_wrap_svn_fs_deltify_revision) {
9334
10537
  {
9335
10538
    svn_fs_t *arg1 = (svn_fs_t *) 0 ;
10005
11208
}
10006
11209
 
10007
11210
 
 
11211
XS(_wrap_svn_fs_lock_target_create) {
 
11212
  {
 
11213
    char *arg1 = (char *) 0 ;
 
11214
    svn_revnum_t arg2 ;
 
11215
    apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
11216
    apr_pool_t *_global_pool ;
 
11217
    int res1 ;
 
11218
    char *buf1 = 0 ;
 
11219
    int alloc1 = 0 ;
 
11220
    long val2 ;
 
11221
    int ecode2 = 0 ;
 
11222
    int argvi = 0;
 
11223
    svn_fs_lock_target_t *result = 0 ;
 
11224
    dXSARGS;
 
11225
    
 
11226
    {
 
11227
      _global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
 
11228
    }
 
11229
    if ((items < 2) || (items > 3)) {
 
11230
      SWIG_croak("Usage: svn_fs_lock_target_create(token,current_rev,result_pool);");
 
11231
    }
 
11232
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
 
11233
    if (!SWIG_IsOK(res1)) {
 
11234
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_lock_target_create" "', argument " "1"" of type '" "char const *""'");
 
11235
    }
 
11236
    arg1 = (char *)(buf1);
 
11237
    ecode2 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
 
11238
    if (!SWIG_IsOK(ecode2)) {
 
11239
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svn_fs_lock_target_create" "', argument " "2"" of type '" "svn_revnum_t""'");
 
11240
    } 
 
11241
    arg2 = (svn_revnum_t)(val2);
 
11242
    if (items > 2) {
 
11243
      
 
11244
    }
 
11245
    {
 
11246
      result = (svn_fs_lock_target_t *)svn_fs_lock_target_create((char const *)arg1,arg2,arg3);
 
11247
      
 
11248
      
 
11249
      
 
11250
    }
 
11251
    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_fs_lock_target_t, 0 | 0); argvi++ ;
 
11252
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
 
11253
    
 
11254
    
 
11255
    XSRETURN(argvi);
 
11256
  fail:
 
11257
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
 
11258
    
 
11259
    
 
11260
    SWIG_croak_null();
 
11261
  }
 
11262
}
 
11263
 
 
11264
 
 
11265
XS(_wrap_svn_fs_lock_target_set_token) {
 
11266
  {
 
11267
    svn_fs_lock_target_t *arg1 = (svn_fs_lock_target_t *) 0 ;
 
11268
    char *arg2 = (char *) 0 ;
 
11269
    void *argp1 = 0 ;
 
11270
    int res1 = 0 ;
 
11271
    int res2 ;
 
11272
    char *buf2 = 0 ;
 
11273
    int alloc2 = 0 ;
 
11274
    int argvi = 0;
 
11275
    dXSARGS;
 
11276
    
 
11277
    if ((items < 2) || (items > 2)) {
 
11278
      SWIG_croak("Usage: svn_fs_lock_target_set_token(target,token);");
 
11279
    }
 
11280
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_lock_target_t, 0 |  0 );
 
11281
    if (!SWIG_IsOK(res1)) {
 
11282
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_lock_target_set_token" "', argument " "1"" of type '" "svn_fs_lock_target_t *""'"); 
 
11283
    }
 
11284
    arg1 = (svn_fs_lock_target_t *)(argp1);
 
11285
    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
 
11286
    if (!SWIG_IsOK(res2)) {
 
11287
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_lock_target_set_token" "', argument " "2"" of type '" "char const *""'");
 
11288
    }
 
11289
    arg2 = (char *)(buf2);
 
11290
    {
 
11291
      svn_fs_lock_target_set_token(arg1,(char const *)arg2);
 
11292
      
 
11293
      
 
11294
      
 
11295
    }
 
11296
    ST(argvi) = sv_newmortal();
 
11297
    
 
11298
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
11299
    XSRETURN(argvi);
 
11300
  fail:
 
11301
    
 
11302
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
11303
    SWIG_croak_null();
 
11304
  }
 
11305
}
 
11306
 
 
11307
 
 
11308
XS(_wrap_svn_fs_lock_many) {
 
11309
  {
 
11310
    svn_fs_t *arg1 = (svn_fs_t *) 0 ;
 
11311
    apr_hash_t *arg2 = (apr_hash_t *) 0 ;
 
11312
    char *arg3 = (char *) 0 ;
 
11313
    svn_boolean_t arg4 ;
 
11314
    apr_time_t arg5 ;
 
11315
    svn_boolean_t arg6 ;
 
11316
    svn_fs_lock_callback_t arg7 = (svn_fs_lock_callback_t) 0 ;
 
11317
    void *arg8 = (void *) 0 ;
 
11318
    apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
11319
    apr_pool_t *arg10 = (apr_pool_t *) 0 ;
 
11320
    apr_pool_t *_global_pool ;
 
11321
    void *argp1 = 0 ;
 
11322
    int res1 = 0 ;
 
11323
    void *argp2 = 0 ;
 
11324
    int res2 = 0 ;
 
11325
    int res3 ;
 
11326
    char *buf3 = 0 ;
 
11327
    int alloc3 = 0 ;
 
11328
    int val4 ;
 
11329
    int ecode4 = 0 ;
 
11330
    long long val5 ;
 
11331
    int ecode5 = 0 ;
 
11332
    int val6 ;
 
11333
    int ecode6 = 0 ;
 
11334
    int res8 ;
 
11335
    int argvi = 0;
 
11336
    svn_error_t *result = 0 ;
 
11337
    dXSARGS;
 
11338
    
 
11339
    {
 
11340
      _global_pool = arg9 = svn_swig_pl_make_pool (ST(items-1));
 
11341
    }
 
11342
    {
 
11343
      _global_pool = arg10 = svn_swig_pl_make_pool (ST(items-1));
 
11344
    }
 
11345
    if ((items < 8) || (items > 10)) {
 
11346
      SWIG_croak("Usage: svn_fs_lock_many(fs,lock_targets,comment,is_dav_comment,expiration_date,steal_lock,lock_callback,lock_baton,result_pool,scratch_pool);");
 
11347
    }
 
11348
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_t, 0 |  0 );
 
11349
    if (!SWIG_IsOK(res1)) {
 
11350
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_lock_many" "', argument " "1"" of type '" "svn_fs_t *""'"); 
 
11351
    }
 
11352
    arg1 = (svn_fs_t *)(argp1);
 
11353
    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_apr_hash_t, 0 |  0 );
 
11354
    if (!SWIG_IsOK(res2)) {
 
11355
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_lock_many" "', argument " "2"" of type '" "apr_hash_t *""'"); 
 
11356
    }
 
11357
    arg2 = (apr_hash_t *)(argp2);
 
11358
    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
 
11359
    if (!SWIG_IsOK(res3)) {
 
11360
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_lock_many" "', argument " "3"" of type '" "char const *""'");
 
11361
    }
 
11362
    arg3 = (char *)(buf3);
 
11363
    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
 
11364
    if (!SWIG_IsOK(ecode4)) {
 
11365
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "svn_fs_lock_many" "', argument " "4"" of type '" "svn_boolean_t""'");
 
11366
    } 
 
11367
    arg4 = (svn_boolean_t)(val4);
 
11368
    ecode5 = SWIG_AsVal_long_SS_long SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
 
11369
    if (!SWIG_IsOK(ecode5)) {
 
11370
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "svn_fs_lock_many" "', argument " "5"" of type '" "apr_time_t""'");
 
11371
    } 
 
11372
    arg5 = (apr_time_t)(val5);
 
11373
    ecode6 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
 
11374
    if (!SWIG_IsOK(ecode6)) {
 
11375
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "svn_fs_lock_many" "', argument " "6"" of type '" "svn_boolean_t""'");
 
11376
    } 
 
11377
    arg6 = (svn_boolean_t)(val6);
 
11378
    {
 
11379
      int res = SWIG_ConvertFunctionPtr(ST(6), (void**)(&arg7), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t);
 
11380
      if (!SWIG_IsOK(res)) {
 
11381
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_lock_many" "', argument " "7"" of type '" "svn_fs_lock_callback_t""'"); 
 
11382
      }
 
11383
    }
 
11384
    res8 = SWIG_ConvertPtr(ST(7),SWIG_as_voidptrptr(&arg8), 0, 0);
 
11385
    if (!SWIG_IsOK(res8)) {
 
11386
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "svn_fs_lock_many" "', argument " "8"" of type '" "void *""'"); 
 
11387
    }
 
11388
    if (items > 8) {
 
11389
      
 
11390
    }
 
11391
    if (items > 9) {
 
11392
      
 
11393
    }
 
11394
    {
 
11395
      result = (svn_error_t *)svn_fs_lock_many(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
 
11396
      
 
11397
      
 
11398
      
 
11399
    }
 
11400
    {
 
11401
      if (result) {
 
11402
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
11403
        
 
11404
        if (SvOK(exception_handler)) {
 
11405
          SV *callback_result;
 
11406
          
 
11407
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
11408
            &callback_result, "S", result,
 
11409
            SWIGTYPE_p_svn_error_t);
 
11410
        } else {
 
11411
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
11412
          argvi++;
 
11413
        }
 
11414
      }
 
11415
    }
 
11416
    
 
11417
    
 
11418
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
11419
    
 
11420
    
 
11421
    
 
11422
    
 
11423
    
 
11424
    
 
11425
    
 
11426
    XSRETURN(argvi);
 
11427
  fail:
 
11428
    
 
11429
    
 
11430
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
11431
    
 
11432
    
 
11433
    
 
11434
    
 
11435
    
 
11436
    
 
11437
    
 
11438
    SWIG_croak_null();
 
11439
  }
 
11440
}
 
11441
 
 
11442
 
10008
11443
XS(_wrap_svn_fs_lock) {
10009
11444
  {
10010
11445
    svn_lock_t **arg1 = (svn_lock_t **) 0 ;
10214
11649
}
10215
11650
 
10216
11651
 
 
11652
XS(_wrap_svn_fs_unlock_many) {
 
11653
  {
 
11654
    svn_fs_t *arg1 = (svn_fs_t *) 0 ;
 
11655
    apr_hash_t *arg2 = (apr_hash_t *) 0 ;
 
11656
    svn_boolean_t arg3 ;
 
11657
    svn_fs_lock_callback_t arg4 = (svn_fs_lock_callback_t) 0 ;
 
11658
    void *arg5 = (void *) 0 ;
 
11659
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
11660
    apr_pool_t *arg7 = (apr_pool_t *) 0 ;
 
11661
    apr_pool_t *_global_pool ;
 
11662
    void *argp1 = 0 ;
 
11663
    int res1 = 0 ;
 
11664
    void *argp2 = 0 ;
 
11665
    int res2 = 0 ;
 
11666
    int val3 ;
 
11667
    int ecode3 = 0 ;
 
11668
    int res5 ;
 
11669
    int argvi = 0;
 
11670
    svn_error_t *result = 0 ;
 
11671
    dXSARGS;
 
11672
    
 
11673
    {
 
11674
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
 
11675
    }
 
11676
    {
 
11677
      _global_pool = arg7 = svn_swig_pl_make_pool (ST(items-1));
 
11678
    }
 
11679
    if ((items < 5) || (items > 7)) {
 
11680
      SWIG_croak("Usage: svn_fs_unlock_many(fs,unlock_targets,break_lock,lock_callback,lock_baton,result_pool,scratch_pool);");
 
11681
    }
 
11682
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_t, 0 |  0 );
 
11683
    if (!SWIG_IsOK(res1)) {
 
11684
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_unlock_many" "', argument " "1"" of type '" "svn_fs_t *""'"); 
 
11685
    }
 
11686
    arg1 = (svn_fs_t *)(argp1);
 
11687
    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_apr_hash_t, 0 |  0 );
 
11688
    if (!SWIG_IsOK(res2)) {
 
11689
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_unlock_many" "', argument " "2"" of type '" "apr_hash_t *""'"); 
 
11690
    }
 
11691
    arg2 = (apr_hash_t *)(argp2);
 
11692
    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
 
11693
    if (!SWIG_IsOK(ecode3)) {
 
11694
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svn_fs_unlock_many" "', argument " "3"" of type '" "svn_boolean_t""'");
 
11695
    } 
 
11696
    arg3 = (svn_boolean_t)(val3);
 
11697
    {
 
11698
      int res = SWIG_ConvertFunctionPtr(ST(3), (void**)(&arg4), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t);
 
11699
      if (!SWIG_IsOK(res)) {
 
11700
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_unlock_many" "', argument " "4"" of type '" "svn_fs_lock_callback_t""'"); 
 
11701
      }
 
11702
    }
 
11703
    res5 = SWIG_ConvertPtr(ST(4),SWIG_as_voidptrptr(&arg5), 0, 0);
 
11704
    if (!SWIG_IsOK(res5)) {
 
11705
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_fs_unlock_many" "', argument " "5"" of type '" "void *""'"); 
 
11706
    }
 
11707
    if (items > 5) {
 
11708
      
 
11709
    }
 
11710
    if (items > 6) {
 
11711
      
 
11712
    }
 
11713
    {
 
11714
      result = (svn_error_t *)svn_fs_unlock_many(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
 
11715
      
 
11716
      
 
11717
      
 
11718
    }
 
11719
    {
 
11720
      if (result) {
 
11721
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
11722
        
 
11723
        if (SvOK(exception_handler)) {
 
11724
          SV *callback_result;
 
11725
          
 
11726
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
11727
            &callback_result, "S", result,
 
11728
            SWIGTYPE_p_svn_error_t);
 
11729
        } else {
 
11730
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
11731
          argvi++;
 
11732
        }
 
11733
      }
 
11734
    }
 
11735
    
 
11736
    
 
11737
    
 
11738
    
 
11739
    
 
11740
    
 
11741
    
 
11742
    XSRETURN(argvi);
 
11743
  fail:
 
11744
    
 
11745
    
 
11746
    
 
11747
    
 
11748
    
 
11749
    
 
11750
    
 
11751
    SWIG_croak_null();
 
11752
  }
 
11753
}
 
11754
 
 
11755
 
10217
11756
XS(_wrap_svn_fs_unlock) {
10218
11757
  {
10219
11758
    svn_fs_t *arg1 = (svn_fs_t *) 0 ;
10643
12182
    char *buf1 = 0 ;
10644
12183
    int alloc1 = 0 ;
10645
12184
    int res3 ;
10646
 
    int res5 ;
10647
12185
    int argvi = 0;
10648
12186
    svn_error_t *result = 0 ;
10649
12187
    dXSARGS;
10651
12189
    {
10652
12190
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
10653
12191
    }
10654
 
    if ((items < 5) || (items > 6)) {
 
12192
    if ((items < 4) || (items > 5)) {
10655
12193
      SWIG_croak("Usage: svn_fs_pack(db_path,notify_func,notify_baton,cancel_func,cancel_baton,pool);");
10656
12194
    }
10657
12195
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
10670
12208
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_pack" "', argument " "3"" of type '" "void *""'"); 
10671
12209
    }
10672
12210
    {
10673
 
      int res = SWIG_ConvertFunctionPtr(ST(3), (void**)(&arg4), SWIGTYPE_p_f_p_void__p_svn_error_t);
10674
 
      if (!SWIG_IsOK(res)) {
10675
 
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_pack" "', argument " "4"" of type '" "svn_cancel_func_t""'"); 
10676
 
      }
10677
 
    }
10678
 
    res5 = SWIG_ConvertPtr(ST(4),SWIG_as_voidptrptr(&arg5), 0, 0);
10679
 
    if (!SWIG_IsOK(res5)) {
10680
 
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_fs_pack" "', argument " "5"" of type '" "void *""'"); 
10681
 
    }
10682
 
    if (items > 5) {
 
12211
      arg4 = (svn_cancel_func_t) svn_swig_pl_cancel_func;
 
12212
      arg5 = ST(3);
 
12213
    }
 
12214
    if (items > 4) {
10683
12215
      
10684
12216
    }
10685
12217
    {
10708
12240
    
10709
12241
    
10710
12242
    
10711
 
    
10712
 
    
10713
12243
    XSRETURN(argvi);
10714
12244
  fail:
10715
12245
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10716
12246
    
10717
12247
    
10718
12248
    
10719
 
    
10720
 
    
10721
12249
    SWIG_croak_null();
10722
12250
  }
10723
12251
}
10743
12271
    long val4 ;
10744
12272
    int ecode4 = 0 ;
10745
12273
    int res6 ;
10746
 
    int res8 ;
10747
12274
    int argvi = 0;
10748
12275
    svn_error_t *result = 0 ;
10749
12276
    dXSARGS;
10751
12278
    {
10752
12279
      _global_pool = arg9 = svn_swig_pl_make_pool (ST(items-1));
10753
12280
    }
10754
 
    if ((items < 8) || (items > 9)) {
 
12281
    if ((items < 7) || (items > 8)) {
10755
12282
      SWIG_croak("Usage: svn_fs_verify(path,fs_config,start,end,notify_func,notify_baton,cancel_func,cancel_baton,scratch_pool);");
10756
12283
    }
10757
12284
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
10784
12311
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svn_fs_verify" "', argument " "6"" of type '" "void *""'"); 
10785
12312
    }
10786
12313
    {
10787
 
      int res = SWIG_ConvertFunctionPtr(ST(6), (void**)(&arg7), SWIGTYPE_p_f_p_void__p_svn_error_t);
10788
 
      if (!SWIG_IsOK(res)) {
10789
 
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_verify" "', argument " "7"" of type '" "svn_cancel_func_t""'"); 
10790
 
      }
10791
 
    }
10792
 
    res8 = SWIG_ConvertPtr(ST(7),SWIG_as_voidptrptr(&arg8), 0, 0);
10793
 
    if (!SWIG_IsOK(res8)) {
10794
 
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "svn_fs_verify" "', argument " "8"" of type '" "void *""'"); 
10795
 
    }
10796
 
    if (items > 8) {
 
12314
      arg7 = (svn_cancel_func_t) svn_swig_pl_cancel_func;
 
12315
      arg8 = ST(6);
 
12316
    }
 
12317
    if (items > 7) {
10797
12318
      
10798
12319
    }
10799
12320
    {
10825
12346
    
10826
12347
    
10827
12348
    
10828
 
    
10829
 
    
10830
12349
    XSRETURN(argvi);
10831
12350
  fail:
10832
12351
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10836
12355
    
10837
12356
    
10838
12357
    
10839
 
    
10840
 
    
10841
12358
    SWIG_croak_null();
10842
12359
  }
10843
12360
}
10901
12418
}
10902
12419
 
10903
12420
 
 
12421
XS(_wrap_svn_fs_fsfs_info_t_fs_type_set) {
 
12422
  {
 
12423
    struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12424
    char *arg2 = (char *) 0 ;
 
12425
    void *argp1 = 0 ;
 
12426
    int res1 = 0 ;
 
12427
    int res2 ;
 
12428
    char *buf2 = 0 ;
 
12429
    int alloc2 = 0 ;
 
12430
    int argvi = 0;
 
12431
    dXSARGS;
 
12432
    
 
12433
    if ((items < 2) || (items > 2)) {
 
12434
      SWIG_croak("Usage: svn_fs_fsfs_info_t_fs_type_set(self,fs_type);");
 
12435
    }
 
12436
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsfs_info_t, 0 |  0 );
 
12437
    if (!SWIG_IsOK(res1)) {
 
12438
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsfs_info_t_fs_type_set" "', argument " "1"" of type '" "struct svn_fs_fsfs_info_t *""'"); 
 
12439
    }
 
12440
    arg1 = (struct svn_fs_fsfs_info_t *)(argp1);
 
12441
    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
 
12442
    if (!SWIG_IsOK(res2)) {
 
12443
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_fsfs_info_t_fs_type_set" "', argument " "2"" of type '" "char const *""'");
 
12444
    }
 
12445
    arg2 = (char *)(buf2);
 
12446
    {
 
12447
      apr_size_t len = strlen(arg2) + 1;
 
12448
      char *copied;
 
12449
      if (arg1->fs_type) free((char *)arg1->fs_type);
 
12450
      copied = malloc(len);
 
12451
      memcpy(copied, arg2, len);
 
12452
      arg1->fs_type = copied;
 
12453
    }
 
12454
    ST(argvi) = sv_newmortal();
 
12455
    
 
12456
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
12457
    XSRETURN(argvi);
 
12458
  fail:
 
12459
    
 
12460
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
12461
    SWIG_croak_null();
 
12462
  }
 
12463
}
 
12464
 
 
12465
 
 
12466
XS(_wrap_svn_fs_fsfs_info_t_fs_type_get) {
 
12467
  {
 
12468
    struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12469
    void *argp1 = 0 ;
 
12470
    int res1 = 0 ;
 
12471
    int argvi = 0;
 
12472
    char *result = 0 ;
 
12473
    dXSARGS;
 
12474
    
 
12475
    if ((items < 1) || (items > 1)) {
 
12476
      SWIG_croak("Usage: svn_fs_fsfs_info_t_fs_type_get(self);");
 
12477
    }
 
12478
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsfs_info_t, 0 |  0 );
 
12479
    if (!SWIG_IsOK(res1)) {
 
12480
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsfs_info_t_fs_type_get" "', argument " "1"" of type '" "struct svn_fs_fsfs_info_t *""'"); 
 
12481
    }
 
12482
    arg1 = (struct svn_fs_fsfs_info_t *)(argp1);
 
12483
    result = (char *) ((arg1)->fs_type);
 
12484
    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
 
12485
    
 
12486
    XSRETURN(argvi);
 
12487
  fail:
 
12488
    
 
12489
    SWIG_croak_null();
 
12490
  }
 
12491
}
 
12492
 
 
12493
 
 
12494
XS(_wrap_svn_fs_fsfs_info_t_shard_size_set) {
 
12495
  {
 
12496
    struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12497
    int arg2 ;
 
12498
    void *argp1 = 0 ;
 
12499
    int res1 = 0 ;
 
12500
    int val2 ;
 
12501
    int ecode2 = 0 ;
 
12502
    int argvi = 0;
 
12503
    dXSARGS;
 
12504
    
 
12505
    if ((items < 2) || (items > 2)) {
 
12506
      SWIG_croak("Usage: svn_fs_fsfs_info_t_shard_size_set(self,shard_size);");
 
12507
    }
 
12508
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsfs_info_t, 0 |  0 );
 
12509
    if (!SWIG_IsOK(res1)) {
 
12510
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsfs_info_t_shard_size_set" "', argument " "1"" of type '" "struct svn_fs_fsfs_info_t *""'"); 
 
12511
    }
 
12512
    arg1 = (struct svn_fs_fsfs_info_t *)(argp1);
 
12513
    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
 
12514
    if (!SWIG_IsOK(ecode2)) {
 
12515
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svn_fs_fsfs_info_t_shard_size_set" "', argument " "2"" of type '" "int""'");
 
12516
    } 
 
12517
    arg2 = (int)(val2);
 
12518
    if (arg1) (arg1)->shard_size = arg2;
 
12519
    ST(argvi) = sv_newmortal();
 
12520
    
 
12521
    
 
12522
    XSRETURN(argvi);
 
12523
  fail:
 
12524
    
 
12525
    
 
12526
    SWIG_croak_null();
 
12527
  }
 
12528
}
 
12529
 
 
12530
 
 
12531
XS(_wrap_svn_fs_fsfs_info_t_shard_size_get) {
 
12532
  {
 
12533
    struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12534
    void *argp1 = 0 ;
 
12535
    int res1 = 0 ;
 
12536
    int argvi = 0;
 
12537
    int result;
 
12538
    dXSARGS;
 
12539
    
 
12540
    if ((items < 1) || (items > 1)) {
 
12541
      SWIG_croak("Usage: svn_fs_fsfs_info_t_shard_size_get(self);");
 
12542
    }
 
12543
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsfs_info_t, 0 |  0 );
 
12544
    if (!SWIG_IsOK(res1)) {
 
12545
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsfs_info_t_shard_size_get" "', argument " "1"" of type '" "struct svn_fs_fsfs_info_t *""'"); 
 
12546
    }
 
12547
    arg1 = (struct svn_fs_fsfs_info_t *)(argp1);
 
12548
    result = (int) ((arg1)->shard_size);
 
12549
    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
 
12550
    
 
12551
    XSRETURN(argvi);
 
12552
  fail:
 
12553
    
 
12554
    SWIG_croak_null();
 
12555
  }
 
12556
}
 
12557
 
 
12558
 
 
12559
XS(_wrap_svn_fs_fsfs_info_t_min_unpacked_rev_set) {
 
12560
  {
 
12561
    struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12562
    svn_revnum_t arg2 ;
 
12563
    void *argp1 = 0 ;
 
12564
    int res1 = 0 ;
 
12565
    long val2 ;
 
12566
    int ecode2 = 0 ;
 
12567
    int argvi = 0;
 
12568
    dXSARGS;
 
12569
    
 
12570
    if ((items < 2) || (items > 2)) {
 
12571
      SWIG_croak("Usage: svn_fs_fsfs_info_t_min_unpacked_rev_set(self,min_unpacked_rev);");
 
12572
    }
 
12573
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsfs_info_t, 0 |  0 );
 
12574
    if (!SWIG_IsOK(res1)) {
 
12575
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsfs_info_t_min_unpacked_rev_set" "', argument " "1"" of type '" "struct svn_fs_fsfs_info_t *""'"); 
 
12576
    }
 
12577
    arg1 = (struct svn_fs_fsfs_info_t *)(argp1);
 
12578
    ecode2 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
 
12579
    if (!SWIG_IsOK(ecode2)) {
 
12580
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svn_fs_fsfs_info_t_min_unpacked_rev_set" "', argument " "2"" of type '" "svn_revnum_t""'");
 
12581
    } 
 
12582
    arg2 = (svn_revnum_t)(val2);
 
12583
    if (arg1) (arg1)->min_unpacked_rev = arg2;
 
12584
    ST(argvi) = sv_newmortal();
 
12585
    
 
12586
    
 
12587
    XSRETURN(argvi);
 
12588
  fail:
 
12589
    
 
12590
    
 
12591
    SWIG_croak_null();
 
12592
  }
 
12593
}
 
12594
 
 
12595
 
 
12596
XS(_wrap_svn_fs_fsfs_info_t_min_unpacked_rev_get) {
 
12597
  {
 
12598
    struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12599
    void *argp1 = 0 ;
 
12600
    int res1 = 0 ;
 
12601
    int argvi = 0;
 
12602
    svn_revnum_t result;
 
12603
    dXSARGS;
 
12604
    
 
12605
    if ((items < 1) || (items > 1)) {
 
12606
      SWIG_croak("Usage: svn_fs_fsfs_info_t_min_unpacked_rev_get(self);");
 
12607
    }
 
12608
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsfs_info_t, 0 |  0 );
 
12609
    if (!SWIG_IsOK(res1)) {
 
12610
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsfs_info_t_min_unpacked_rev_get" "', argument " "1"" of type '" "struct svn_fs_fsfs_info_t *""'"); 
 
12611
    }
 
12612
    arg1 = (struct svn_fs_fsfs_info_t *)(argp1);
 
12613
    result = (svn_revnum_t) ((arg1)->min_unpacked_rev);
 
12614
    ST(argvi) = SWIG_From_long  SWIG_PERL_CALL_ARGS_1((long)(result)); argvi++ ;
 
12615
    
 
12616
    XSRETURN(argvi);
 
12617
  fail:
 
12618
    
 
12619
    SWIG_croak_null();
 
12620
  }
 
12621
}
 
12622
 
 
12623
 
 
12624
XS(_wrap_svn_fs_fsfs_info_t_log_addressing_set) {
 
12625
  {
 
12626
    struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12627
    svn_boolean_t arg2 ;
 
12628
    void *argp1 = 0 ;
 
12629
    int res1 = 0 ;
 
12630
    int val2 ;
 
12631
    int ecode2 = 0 ;
 
12632
    int argvi = 0;
 
12633
    dXSARGS;
 
12634
    
 
12635
    if ((items < 2) || (items > 2)) {
 
12636
      SWIG_croak("Usage: svn_fs_fsfs_info_t_log_addressing_set(self,log_addressing);");
 
12637
    }
 
12638
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsfs_info_t, 0 |  0 );
 
12639
    if (!SWIG_IsOK(res1)) {
 
12640
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsfs_info_t_log_addressing_set" "', argument " "1"" of type '" "struct svn_fs_fsfs_info_t *""'"); 
 
12641
    }
 
12642
    arg1 = (struct svn_fs_fsfs_info_t *)(argp1);
 
12643
    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
 
12644
    if (!SWIG_IsOK(ecode2)) {
 
12645
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svn_fs_fsfs_info_t_log_addressing_set" "', argument " "2"" of type '" "svn_boolean_t""'");
 
12646
    } 
 
12647
    arg2 = (svn_boolean_t)(val2);
 
12648
    if (arg1) (arg1)->log_addressing = arg2;
 
12649
    ST(argvi) = sv_newmortal();
 
12650
    
 
12651
    
 
12652
    XSRETURN(argvi);
 
12653
  fail:
 
12654
    
 
12655
    
 
12656
    SWIG_croak_null();
 
12657
  }
 
12658
}
 
12659
 
 
12660
 
 
12661
XS(_wrap_svn_fs_fsfs_info_t_log_addressing_get) {
 
12662
  {
 
12663
    struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12664
    void *argp1 = 0 ;
 
12665
    int res1 = 0 ;
 
12666
    int argvi = 0;
 
12667
    svn_boolean_t result;
 
12668
    dXSARGS;
 
12669
    
 
12670
    if ((items < 1) || (items > 1)) {
 
12671
      SWIG_croak("Usage: svn_fs_fsfs_info_t_log_addressing_get(self);");
 
12672
    }
 
12673
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsfs_info_t, 0 |  0 );
 
12674
    if (!SWIG_IsOK(res1)) {
 
12675
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsfs_info_t_log_addressing_get" "', argument " "1"" of type '" "struct svn_fs_fsfs_info_t *""'"); 
 
12676
    }
 
12677
    arg1 = (struct svn_fs_fsfs_info_t *)(argp1);
 
12678
    result = (svn_boolean_t) ((arg1)->log_addressing);
 
12679
    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
 
12680
    
 
12681
    XSRETURN(argvi);
 
12682
  fail:
 
12683
    
 
12684
    SWIG_croak_null();
 
12685
  }
 
12686
}
 
12687
 
 
12688
 
 
12689
XS(_wrap_svn_fs_fsx_info_t_fs_type_set) {
 
12690
  {
 
12691
    struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
12692
    char *arg2 = (char *) 0 ;
 
12693
    void *argp1 = 0 ;
 
12694
    int res1 = 0 ;
 
12695
    int res2 ;
 
12696
    char *buf2 = 0 ;
 
12697
    int alloc2 = 0 ;
 
12698
    int argvi = 0;
 
12699
    dXSARGS;
 
12700
    
 
12701
    if ((items < 2) || (items > 2)) {
 
12702
      SWIG_croak("Usage: svn_fs_fsx_info_t_fs_type_set(self,fs_type);");
 
12703
    }
 
12704
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsx_info_t, 0 |  0 );
 
12705
    if (!SWIG_IsOK(res1)) {
 
12706
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsx_info_t_fs_type_set" "', argument " "1"" of type '" "struct svn_fs_fsx_info_t *""'"); 
 
12707
    }
 
12708
    arg1 = (struct svn_fs_fsx_info_t *)(argp1);
 
12709
    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
 
12710
    if (!SWIG_IsOK(res2)) {
 
12711
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_fsx_info_t_fs_type_set" "', argument " "2"" of type '" "char const *""'");
 
12712
    }
 
12713
    arg2 = (char *)(buf2);
 
12714
    {
 
12715
      apr_size_t len = strlen(arg2) + 1;
 
12716
      char *copied;
 
12717
      if (arg1->fs_type) free((char *)arg1->fs_type);
 
12718
      copied = malloc(len);
 
12719
      memcpy(copied, arg2, len);
 
12720
      arg1->fs_type = copied;
 
12721
    }
 
12722
    ST(argvi) = sv_newmortal();
 
12723
    
 
12724
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
12725
    XSRETURN(argvi);
 
12726
  fail:
 
12727
    
 
12728
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
12729
    SWIG_croak_null();
 
12730
  }
 
12731
}
 
12732
 
 
12733
 
 
12734
XS(_wrap_svn_fs_fsx_info_t_fs_type_get) {
 
12735
  {
 
12736
    struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
12737
    void *argp1 = 0 ;
 
12738
    int res1 = 0 ;
 
12739
    int argvi = 0;
 
12740
    char *result = 0 ;
 
12741
    dXSARGS;
 
12742
    
 
12743
    if ((items < 1) || (items > 1)) {
 
12744
      SWIG_croak("Usage: svn_fs_fsx_info_t_fs_type_get(self);");
 
12745
    }
 
12746
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsx_info_t, 0 |  0 );
 
12747
    if (!SWIG_IsOK(res1)) {
 
12748
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsx_info_t_fs_type_get" "', argument " "1"" of type '" "struct svn_fs_fsx_info_t *""'"); 
 
12749
    }
 
12750
    arg1 = (struct svn_fs_fsx_info_t *)(argp1);
 
12751
    result = (char *) ((arg1)->fs_type);
 
12752
    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
 
12753
    
 
12754
    XSRETURN(argvi);
 
12755
  fail:
 
12756
    
 
12757
    SWIG_croak_null();
 
12758
  }
 
12759
}
 
12760
 
 
12761
 
 
12762
XS(_wrap_svn_fs_fsx_info_t_shard_size_set) {
 
12763
  {
 
12764
    struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
12765
    int arg2 ;
 
12766
    void *argp1 = 0 ;
 
12767
    int res1 = 0 ;
 
12768
    int val2 ;
 
12769
    int ecode2 = 0 ;
 
12770
    int argvi = 0;
 
12771
    dXSARGS;
 
12772
    
 
12773
    if ((items < 2) || (items > 2)) {
 
12774
      SWIG_croak("Usage: svn_fs_fsx_info_t_shard_size_set(self,shard_size);");
 
12775
    }
 
12776
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsx_info_t, 0 |  0 );
 
12777
    if (!SWIG_IsOK(res1)) {
 
12778
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsx_info_t_shard_size_set" "', argument " "1"" of type '" "struct svn_fs_fsx_info_t *""'"); 
 
12779
    }
 
12780
    arg1 = (struct svn_fs_fsx_info_t *)(argp1);
 
12781
    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
 
12782
    if (!SWIG_IsOK(ecode2)) {
 
12783
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svn_fs_fsx_info_t_shard_size_set" "', argument " "2"" of type '" "int""'");
 
12784
    } 
 
12785
    arg2 = (int)(val2);
 
12786
    if (arg1) (arg1)->shard_size = arg2;
 
12787
    ST(argvi) = sv_newmortal();
 
12788
    
 
12789
    
 
12790
    XSRETURN(argvi);
 
12791
  fail:
 
12792
    
 
12793
    
 
12794
    SWIG_croak_null();
 
12795
  }
 
12796
}
 
12797
 
 
12798
 
 
12799
XS(_wrap_svn_fs_fsx_info_t_shard_size_get) {
 
12800
  {
 
12801
    struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
12802
    void *argp1 = 0 ;
 
12803
    int res1 = 0 ;
 
12804
    int argvi = 0;
 
12805
    int result;
 
12806
    dXSARGS;
 
12807
    
 
12808
    if ((items < 1) || (items > 1)) {
 
12809
      SWIG_croak("Usage: svn_fs_fsx_info_t_shard_size_get(self);");
 
12810
    }
 
12811
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsx_info_t, 0 |  0 );
 
12812
    if (!SWIG_IsOK(res1)) {
 
12813
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsx_info_t_shard_size_get" "', argument " "1"" of type '" "struct svn_fs_fsx_info_t *""'"); 
 
12814
    }
 
12815
    arg1 = (struct svn_fs_fsx_info_t *)(argp1);
 
12816
    result = (int) ((arg1)->shard_size);
 
12817
    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
 
12818
    
 
12819
    XSRETURN(argvi);
 
12820
  fail:
 
12821
    
 
12822
    SWIG_croak_null();
 
12823
  }
 
12824
}
 
12825
 
 
12826
 
 
12827
XS(_wrap_svn_fs_fsx_info_t_min_unpacked_rev_set) {
 
12828
  {
 
12829
    struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
12830
    svn_revnum_t arg2 ;
 
12831
    void *argp1 = 0 ;
 
12832
    int res1 = 0 ;
 
12833
    long val2 ;
 
12834
    int ecode2 = 0 ;
 
12835
    int argvi = 0;
 
12836
    dXSARGS;
 
12837
    
 
12838
    if ((items < 2) || (items > 2)) {
 
12839
      SWIG_croak("Usage: svn_fs_fsx_info_t_min_unpacked_rev_set(self,min_unpacked_rev);");
 
12840
    }
 
12841
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsx_info_t, 0 |  0 );
 
12842
    if (!SWIG_IsOK(res1)) {
 
12843
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsx_info_t_min_unpacked_rev_set" "', argument " "1"" of type '" "struct svn_fs_fsx_info_t *""'"); 
 
12844
    }
 
12845
    arg1 = (struct svn_fs_fsx_info_t *)(argp1);
 
12846
    ecode2 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
 
12847
    if (!SWIG_IsOK(ecode2)) {
 
12848
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "svn_fs_fsx_info_t_min_unpacked_rev_set" "', argument " "2"" of type '" "svn_revnum_t""'");
 
12849
    } 
 
12850
    arg2 = (svn_revnum_t)(val2);
 
12851
    if (arg1) (arg1)->min_unpacked_rev = arg2;
 
12852
    ST(argvi) = sv_newmortal();
 
12853
    
 
12854
    
 
12855
    XSRETURN(argvi);
 
12856
  fail:
 
12857
    
 
12858
    
 
12859
    SWIG_croak_null();
 
12860
  }
 
12861
}
 
12862
 
 
12863
 
 
12864
XS(_wrap_svn_fs_fsx_info_t_min_unpacked_rev_get) {
 
12865
  {
 
12866
    struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
12867
    void *argp1 = 0 ;
 
12868
    int res1 = 0 ;
 
12869
    int argvi = 0;
 
12870
    svn_revnum_t result;
 
12871
    dXSARGS;
 
12872
    
 
12873
    if ((items < 1) || (items > 1)) {
 
12874
      SWIG_croak("Usage: svn_fs_fsx_info_t_min_unpacked_rev_get(self);");
 
12875
    }
 
12876
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_fsx_info_t, 0 |  0 );
 
12877
    if (!SWIG_IsOK(res1)) {
 
12878
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_fsx_info_t_min_unpacked_rev_get" "', argument " "1"" of type '" "struct svn_fs_fsx_info_t *""'"); 
 
12879
    }
 
12880
    arg1 = (struct svn_fs_fsx_info_t *)(argp1);
 
12881
    result = (svn_revnum_t) ((arg1)->min_unpacked_rev);
 
12882
    ST(argvi) = SWIG_From_long  SWIG_PERL_CALL_ARGS_1((long)(result)); argvi++ ;
 
12883
    
 
12884
    XSRETURN(argvi);
 
12885
  fail:
 
12886
    
 
12887
    SWIG_croak_null();
 
12888
  }
 
12889
}
 
12890
 
 
12891
 
 
12892
XS(_wrap_svn_fs_info_placeholder_t_fs_type_set) {
 
12893
  {
 
12894
    struct svn_fs_info_placeholder_t *arg1 = (struct svn_fs_info_placeholder_t *) 0 ;
 
12895
    char *arg2 = (char *) 0 ;
 
12896
    void *argp1 = 0 ;
 
12897
    int res1 = 0 ;
 
12898
    int res2 ;
 
12899
    char *buf2 = 0 ;
 
12900
    int alloc2 = 0 ;
 
12901
    int argvi = 0;
 
12902
    dXSARGS;
 
12903
    
 
12904
    if ((items < 2) || (items > 2)) {
 
12905
      SWIG_croak("Usage: svn_fs_info_placeholder_t_fs_type_set(self,fs_type);");
 
12906
    }
 
12907
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_info_placeholder_t, 0 |  0 );
 
12908
    if (!SWIG_IsOK(res1)) {
 
12909
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_info_placeholder_t_fs_type_set" "', argument " "1"" of type '" "struct svn_fs_info_placeholder_t *""'"); 
 
12910
    }
 
12911
    arg1 = (struct svn_fs_info_placeholder_t *)(argp1);
 
12912
    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
 
12913
    if (!SWIG_IsOK(res2)) {
 
12914
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_info_placeholder_t_fs_type_set" "', argument " "2"" of type '" "char const *""'");
 
12915
    }
 
12916
    arg2 = (char *)(buf2);
 
12917
    {
 
12918
      apr_size_t len = strlen(arg2) + 1;
 
12919
      char *copied;
 
12920
      if (arg1->fs_type) free((char *)arg1->fs_type);
 
12921
      copied = malloc(len);
 
12922
      memcpy(copied, arg2, len);
 
12923
      arg1->fs_type = copied;
 
12924
    }
 
12925
    ST(argvi) = sv_newmortal();
 
12926
    
 
12927
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
12928
    XSRETURN(argvi);
 
12929
  fail:
 
12930
    
 
12931
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
12932
    SWIG_croak_null();
 
12933
  }
 
12934
}
 
12935
 
 
12936
 
 
12937
XS(_wrap_svn_fs_info_placeholder_t_fs_type_get) {
 
12938
  {
 
12939
    struct svn_fs_info_placeholder_t *arg1 = (struct svn_fs_info_placeholder_t *) 0 ;
 
12940
    void *argp1 = 0 ;
 
12941
    int res1 = 0 ;
 
12942
    int argvi = 0;
 
12943
    char *result = 0 ;
 
12944
    dXSARGS;
 
12945
    
 
12946
    if ((items < 1) || (items > 1)) {
 
12947
      SWIG_croak("Usage: svn_fs_info_placeholder_t_fs_type_get(self);");
 
12948
    }
 
12949
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_info_placeholder_t, 0 |  0 );
 
12950
    if (!SWIG_IsOK(res1)) {
 
12951
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_info_placeholder_t_fs_type_get" "', argument " "1"" of type '" "struct svn_fs_info_placeholder_t *""'"); 
 
12952
    }
 
12953
    arg1 = (struct svn_fs_info_placeholder_t *)(argp1);
 
12954
    result = (char *) ((arg1)->fs_type);
 
12955
    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
 
12956
    
 
12957
    XSRETURN(argvi);
 
12958
  fail:
 
12959
    
 
12960
    SWIG_croak_null();
 
12961
  }
 
12962
}
 
12963
 
 
12964
 
 
12965
XS(_wrap_svn_fs_info) {
 
12966
  {
 
12967
    svn_fs_info_placeholder_t **arg1 = (svn_fs_info_placeholder_t **) 0 ;
 
12968
    svn_fs_t *arg2 = (svn_fs_t *) 0 ;
 
12969
    apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
12970
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
12971
    apr_pool_t *_global_pool ;
 
12972
    svn_fs_info_placeholder_t *temp1 ;
 
12973
    void *argp2 = 0 ;
 
12974
    int res2 = 0 ;
 
12975
    int argvi = 0;
 
12976
    svn_error_t *result = 0 ;
 
12977
    dXSARGS;
 
12978
    
 
12979
    {
 
12980
      _global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
 
12981
    }
 
12982
    {
 
12983
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
 
12984
    }
 
12985
    arg1 = &temp1;
 
12986
    if ((items < 1) || (items > 3)) {
 
12987
      SWIG_croak("Usage: svn_fs_info(fs,result_pool,scratch_pool);");
 
12988
    }
 
12989
    res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_fs_t, 0 |  0 );
 
12990
    if (!SWIG_IsOK(res2)) {
 
12991
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_info" "', argument " "2"" of type '" "svn_fs_t *""'"); 
 
12992
    }
 
12993
    arg2 = (svn_fs_t *)(argp2);
 
12994
    if (items > 1) {
 
12995
      
 
12996
    }
 
12997
    if (items > 2) {
 
12998
      
 
12999
    }
 
13000
    {
 
13001
      result = (svn_error_t *)svn_fs_info((struct svn_fs_info_placeholder_t const **)arg1,arg2,arg3,arg4);
 
13002
      
 
13003
      
 
13004
      
 
13005
    }
 
13006
    {
 
13007
      if (result) {
 
13008
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
13009
        
 
13010
        if (SvOK(exception_handler)) {
 
13011
          SV *callback_result;
 
13012
          
 
13013
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
13014
            &callback_result, "S", result,
 
13015
            SWIGTYPE_p_svn_error_t);
 
13016
        } else {
 
13017
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
13018
          argvi++;
 
13019
        }
 
13020
      }
 
13021
    }
 
13022
    {
 
13023
      /* FIXME: Missing argout typemap: svn_fs_info arg 1 (svn_fs_info_placeholder_t const **) */
 
13024
      
 
13025
      
 
13026
      
 
13027
      
 
13028
      SWIG_exception(SWIG_ValueError, "svn_fs_info is not implemented yet");
 
13029
      
 
13030
    }
 
13031
    
 
13032
    
 
13033
    
 
13034
    
 
13035
    XSRETURN(argvi);
 
13036
  fail:
 
13037
    
 
13038
    
 
13039
    
 
13040
    
 
13041
    SWIG_croak_null();
 
13042
  }
 
13043
}
 
13044
 
 
13045
 
 
13046
XS(_wrap_svn_fs_info_dup) {
 
13047
  {
 
13048
    void *arg1 = (void *) 0 ;
 
13049
    apr_pool_t *arg2 = (apr_pool_t *) 0 ;
 
13050
    apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
13051
    apr_pool_t *_global_pool ;
 
13052
    int res1 ;
 
13053
    int argvi = 0;
 
13054
    void *result = 0 ;
 
13055
    dXSARGS;
 
13056
    
 
13057
    {
 
13058
      _global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
 
13059
    }
 
13060
    {
 
13061
      _global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
 
13062
    }
 
13063
    if ((items < 1) || (items > 3)) {
 
13064
      SWIG_croak("Usage: svn_fs_info_dup(info,result_pool,scratch_pool);");
 
13065
    }
 
13066
    res1 = SWIG_ConvertPtr(ST(0),SWIG_as_voidptrptr(&arg1), 0, 0);
 
13067
    if (!SWIG_IsOK(res1)) {
 
13068
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_info_dup" "', argument " "1"" of type '" "void const *""'"); 
 
13069
    }
 
13070
    if (items > 1) {
 
13071
      
 
13072
    }
 
13073
    if (items > 2) {
 
13074
      
 
13075
    }
 
13076
    {
 
13077
      result = (void *)svn_fs_info_dup((void const *)arg1,arg2,arg3);
 
13078
      
 
13079
      
 
13080
      
 
13081
    }
 
13082
    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
 
13083
    
 
13084
    
 
13085
    
 
13086
    XSRETURN(argvi);
 
13087
  fail:
 
13088
    
 
13089
    
 
13090
    
 
13091
    SWIG_croak_null();
 
13092
  }
 
13093
}
 
13094
 
 
13095
 
10904
13096
XS(_wrap_svn_fs_invoke_warning_callback) {
10905
13097
  {
10906
13098
    svn_fs_warning_callback_t arg1 = (svn_fs_warning_callback_t) 0 ;
10950
13142
}
10951
13143
 
10952
13144
 
 
13145
XS(_wrap_svn_fs_invoke_upgrade_notify) {
 
13146
  {
 
13147
    svn_fs_upgrade_notify_t arg1 = (svn_fs_upgrade_notify_t) 0 ;
 
13148
    void *arg2 = (void *) 0 ;
 
13149
    apr_uint64_t arg3 ;
 
13150
    svn_fs_upgrade_notify_action_t arg4 ;
 
13151
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
13152
    apr_pool_t *_global_pool ;
 
13153
    int res2 ;
 
13154
    unsigned long long val3 ;
 
13155
    int ecode3 = 0 ;
 
13156
    int val4 ;
 
13157
    int ecode4 = 0 ;
 
13158
    int argvi = 0;
 
13159
    svn_error_t *result = 0 ;
 
13160
    dXSARGS;
 
13161
    
 
13162
    {
 
13163
      _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
 
13164
    }
 
13165
    if ((items < 4) || (items > 5)) {
 
13166
      SWIG_croak("Usage: svn_fs_invoke_upgrade_notify(_obj,baton,number,action,scratch_pool);");
 
13167
    }
 
13168
    {
 
13169
      int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t);
 
13170
      if (!SWIG_IsOK(res)) {
 
13171
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_invoke_upgrade_notify" "', argument " "1"" of type '" "svn_fs_upgrade_notify_t""'"); 
 
13172
      }
 
13173
    }
 
13174
    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
 
13175
    if (!SWIG_IsOK(res2)) {
 
13176
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_invoke_upgrade_notify" "', argument " "2"" of type '" "void *""'"); 
 
13177
    }
 
13178
    ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
 
13179
    if (!SWIG_IsOK(ecode3)) {
 
13180
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svn_fs_invoke_upgrade_notify" "', argument " "3"" of type '" "apr_uint64_t""'");
 
13181
    } 
 
13182
    arg3 = (apr_uint64_t)(val3);
 
13183
    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
 
13184
    if (!SWIG_IsOK(ecode4)) {
 
13185
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "svn_fs_invoke_upgrade_notify" "', argument " "4"" of type '" "svn_fs_upgrade_notify_action_t""'");
 
13186
    } 
 
13187
    arg4 = (svn_fs_upgrade_notify_action_t)(val4);
 
13188
    if (items > 4) {
 
13189
      
 
13190
    }
 
13191
    {
 
13192
      result = (svn_error_t *)svn_fs_invoke_upgrade_notify(arg1,arg2,arg3,arg4,arg5);
 
13193
      
 
13194
      
 
13195
      
 
13196
    }
 
13197
    {
 
13198
      if (result) {
 
13199
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
13200
        
 
13201
        if (SvOK(exception_handler)) {
 
13202
          SV *callback_result;
 
13203
          
 
13204
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
13205
            &callback_result, "S", result,
 
13206
            SWIGTYPE_p_svn_error_t);
 
13207
        } else {
 
13208
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
13209
          argvi++;
 
13210
        }
 
13211
      }
 
13212
    }
 
13213
    
 
13214
    
 
13215
    
 
13216
    
 
13217
    
 
13218
    XSRETURN(argvi);
 
13219
  fail:
 
13220
    
 
13221
    
 
13222
    
 
13223
    
 
13224
    
 
13225
    SWIG_croak_null();
 
13226
  }
 
13227
}
 
13228
 
 
13229
 
10953
13230
XS(_wrap_svn_fs_invoke_progress_notify_func) {
10954
13231
  {
10955
13232
    svn_fs_progress_notify_func_t arg1 = (svn_fs_progress_notify_func_t) 0 ;
11009
13286
}
11010
13287
 
11011
13288
 
 
13289
XS(_wrap_svn_fs_invoke_hotcopy_notify) {
 
13290
  {
 
13291
    svn_fs_hotcopy_notify_t arg1 = (svn_fs_hotcopy_notify_t) 0 ;
 
13292
    void *arg2 = (void *) 0 ;
 
13293
    svn_revnum_t arg3 ;
 
13294
    svn_revnum_t arg4 ;
 
13295
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
13296
    apr_pool_t *_global_pool ;
 
13297
    int res2 ;
 
13298
    long val3 ;
 
13299
    int ecode3 = 0 ;
 
13300
    long val4 ;
 
13301
    int ecode4 = 0 ;
 
13302
    int argvi = 0;
 
13303
    dXSARGS;
 
13304
    
 
13305
    {
 
13306
      _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
 
13307
    }
 
13308
    if ((items < 4) || (items > 5)) {
 
13309
      SWIG_croak("Usage: svn_fs_invoke_hotcopy_notify(_obj,baton,start_revision,end_revision,scratch_pool);");
 
13310
    }
 
13311
    {
 
13312
      int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_void_long_long_p_apr_pool_t__void);
 
13313
      if (!SWIG_IsOK(res)) {
 
13314
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_invoke_hotcopy_notify" "', argument " "1"" of type '" "svn_fs_hotcopy_notify_t""'"); 
 
13315
      }
 
13316
    }
 
13317
    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
 
13318
    if (!SWIG_IsOK(res2)) {
 
13319
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_invoke_hotcopy_notify" "', argument " "2"" of type '" "void *""'"); 
 
13320
    }
 
13321
    ecode3 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
 
13322
    if (!SWIG_IsOK(ecode3)) {
 
13323
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svn_fs_invoke_hotcopy_notify" "', argument " "3"" of type '" "svn_revnum_t""'");
 
13324
    } 
 
13325
    arg3 = (svn_revnum_t)(val3);
 
13326
    ecode4 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
 
13327
    if (!SWIG_IsOK(ecode4)) {
 
13328
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "svn_fs_invoke_hotcopy_notify" "', argument " "4"" of type '" "svn_revnum_t""'");
 
13329
    } 
 
13330
    arg4 = (svn_revnum_t)(val4);
 
13331
    if (items > 4) {
 
13332
      
 
13333
    }
 
13334
    {
 
13335
      svn_fs_invoke_hotcopy_notify(arg1,arg2,arg3,arg4,arg5);
 
13336
      
 
13337
      
 
13338
      
 
13339
    }
 
13340
    ST(argvi) = sv_newmortal();
 
13341
    
 
13342
    
 
13343
    
 
13344
    
 
13345
    
 
13346
    XSRETURN(argvi);
 
13347
  fail:
 
13348
    
 
13349
    
 
13350
    
 
13351
    
 
13352
    
 
13353
    SWIG_croak_null();
 
13354
  }
 
13355
}
 
13356
 
 
13357
 
11012
13358
XS(_wrap_svn_fs_invoke_freeze_func) {
11013
13359
  {
11014
13360
    svn_fs_freeze_func_t arg1 = (svn_fs_freeze_func_t) 0 ;
11159
13505
}
11160
13506
 
11161
13507
 
 
13508
XS(_wrap_svn_fs_invoke_lock_callback) {
 
13509
  {
 
13510
    svn_fs_lock_callback_t arg1 = (svn_fs_lock_callback_t) 0 ;
 
13511
    void *arg2 = (void *) 0 ;
 
13512
    char *arg3 = (char *) 0 ;
 
13513
    svn_lock_t *arg4 = (svn_lock_t *) 0 ;
 
13514
    svn_error_t *arg5 = (svn_error_t *) 0 ;
 
13515
    apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
13516
    apr_pool_t *_global_pool ;
 
13517
    int res2 ;
 
13518
    int res3 ;
 
13519
    char *buf3 = 0 ;
 
13520
    int alloc3 = 0 ;
 
13521
    void *argp4 = 0 ;
 
13522
    int res4 = 0 ;
 
13523
    void *argp5 = 0 ;
 
13524
    int res5 = 0 ;
 
13525
    int argvi = 0;
 
13526
    svn_error_t *result = 0 ;
 
13527
    dXSARGS;
 
13528
    
 
13529
    {
 
13530
      _global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
 
13531
    }
 
13532
    if ((items < 5) || (items > 6)) {
 
13533
      SWIG_croak("Usage: svn_fs_invoke_lock_callback(_obj,baton,path,lock,fs_err,scratch_pool);");
 
13534
    }
 
13535
    {
 
13536
      int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t);
 
13537
      if (!SWIG_IsOK(res)) {
 
13538
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_invoke_lock_callback" "', argument " "1"" of type '" "svn_fs_lock_callback_t""'"); 
 
13539
      }
 
13540
    }
 
13541
    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
 
13542
    if (!SWIG_IsOK(res2)) {
 
13543
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_invoke_lock_callback" "', argument " "2"" of type '" "void *""'"); 
 
13544
    }
 
13545
    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
 
13546
    if (!SWIG_IsOK(res3)) {
 
13547
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_invoke_lock_callback" "', argument " "3"" of type '" "char const *""'");
 
13548
    }
 
13549
    arg3 = (char *)(buf3);
 
13550
    res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_svn_lock_t, 0 |  0 );
 
13551
    if (!SWIG_IsOK(res4)) {
 
13552
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_fs_invoke_lock_callback" "', argument " "4"" of type '" "svn_lock_t const *""'"); 
 
13553
    }
 
13554
    arg4 = (svn_lock_t *)(argp4);
 
13555
    res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_svn_error_t, 0 |  0 );
 
13556
    if (!SWIG_IsOK(res5)) {
 
13557
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_fs_invoke_lock_callback" "', argument " "5"" of type '" "svn_error_t *""'"); 
 
13558
    }
 
13559
    arg5 = (svn_error_t *)(argp5);
 
13560
    if (items > 5) {
 
13561
      
 
13562
    }
 
13563
    {
 
13564
      result = (svn_error_t *)svn_fs_invoke_lock_callback(arg1,arg2,(char const *)arg3,(struct svn_lock_t const *)arg4,arg5,arg6);
 
13565
      
 
13566
      
 
13567
      
 
13568
    }
 
13569
    {
 
13570
      if (result) {
 
13571
        SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
13572
        
 
13573
        if (SvOK(exception_handler)) {
 
13574
          SV *callback_result;
 
13575
          
 
13576
          svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
 
13577
            &callback_result, "S", result,
 
13578
            SWIGTYPE_p_svn_error_t);
 
13579
        } else {
 
13580
          ST(argvi) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
 
13581
          argvi++;
 
13582
        }
 
13583
      }
 
13584
    }
 
13585
    
 
13586
    
 
13587
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
13588
    
 
13589
    
 
13590
    
 
13591
    XSRETURN(argvi);
 
13592
  fail:
 
13593
    
 
13594
    
 
13595
    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
13596
    
 
13597
    
 
13598
    
 
13599
    SWIG_croak_null();
 
13600
  }
 
13601
}
 
13602
 
 
13603
 
11162
13604
XS(_wrap_svn_fs_invoke_get_locks_callback) {
11163
13605
  {
11164
13606
    svn_fs_get_locks_callback_t arg1 = (svn_fs_get_locks_callback_t) 0 ;
11334
13776
static swig_type_info _swigt__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t = {"_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t", "struct svn_error_t *(*)(svn_txdelta_window_t *,void *)|svn_txdelta_window_handler_t", 0, 0, (void*)0, 0};
11335
13777
static swig_type_info _swigt__p_f_p_void__p_svn_error_t = {"_p_f_p_void__p_svn_error_t", "svn_cancel_func_t|struct svn_error_t *(*)(void *)", 0, 0, (void*)0, 0};
11336
13778
static swig_type_info _swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_int64_t,svn_fs_pack_notify_action_t,apr_pool_t *)|svn_fs_pack_notify_t", 0, 0, (void*)0, 0};
 
13779
static swig_type_info _swigt__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_uint64_t,svn_fs_upgrade_notify_action_t,apr_pool_t *)|svn_fs_upgrade_notify_t", 0, 0, (void*)0, 0};
 
13780
static swig_type_info _swigt__p_f_p_void_long_long_p_apr_pool_t__void = {"_p_f_p_void_long_long_p_apr_pool_t__void", "void (*)(void *,long,long,apr_pool_t *)|svn_fs_hotcopy_notify_t", 0, 0, (void*)0, 0};
11337
13781
static swig_type_info _swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_pool_t *)|svn_fs_freeze_func_t", 0, 0, (void*)0, 0};
 
13782
static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_lock_t const *,svn_error_t *,apr_pool_t *)|svn_fs_lock_callback_t", 0, 0, (void*)0, 0};
11338
13783
static swig_type_info _swigt__p_f_p_void_p_struct_svn_error_t__void = {"_p_f_p_void_p_struct_svn_error_t__void", "void (*)(void *,struct svn_error_t *)|svn_fs_warning_callback_t", 0, 0, (void*)0, 0};
11339
13784
static swig_type_info _swigt__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,svn_lock_t *,apr_pool_t *)|svn_fs_get_locks_callback_t", 0, 0, (void*)0, 0};
11340
13785
static swig_type_info _swigt__p_int = {"_p_int", "int *|svn_boolean_t *|apr_status_t *", 0, 0, (void*)0, 0};
11347
13792
static swig_type_info _swigt__p_p_svn_fs_access_t = {"_p_p_svn_fs_access_t", "struct svn_fs_access_t **|svn_fs_access_t **", 0, 0, (void*)0, 0};
11348
13793
static swig_type_info _swigt__p_p_svn_fs_history_t = {"_p_p_svn_fs_history_t", "struct svn_fs_history_t **|svn_fs_history_t **", 0, 0, (void*)0, 0};
11349
13794
static swig_type_info _swigt__p_p_svn_fs_id_t = {"_p_p_svn_fs_id_t", "struct svn_fs_id_t **|svn_fs_id_t **", 0, 0, (void*)0, 0};
 
13795
static swig_type_info _swigt__p_p_svn_fs_info_placeholder_t = {"_p_p_svn_fs_info_placeholder_t", "struct svn_fs_info_placeholder_t **|svn_fs_info_placeholder_t **", 0, 0, (void*)0, 0};
11350
13796
static swig_type_info _swigt__p_p_svn_fs_root_t = {"_p_p_svn_fs_root_t", "struct svn_fs_root_t **|svn_fs_root_t **", 0, 0, (void*)0, 0};
11351
13797
static swig_type_info _swigt__p_p_svn_fs_t = {"_p_p_svn_fs_t", "struct svn_fs_t **|svn_fs_t **", 0, 0, (void*)0, 0};
11352
13798
static swig_type_info _swigt__p_p_svn_fs_txn_t = {"_p_p_svn_fs_txn_t", "struct svn_fs_txn_t **|svn_fs_txn_t **", 0, 0, (void*)0, 0};
11354
13800
static swig_type_info _swigt__p_p_svn_stream_t = {"_p_p_svn_stream_t", "struct svn_stream_t **|svn_stream_t **", 0, 0, (void*)0, 0};
11355
13801
static swig_type_info _swigt__p_p_svn_string_t = {"_p_p_svn_string_t", "struct svn_string_t **|svn_string_t **", 0, 0, (void*)0, 0};
11356
13802
static swig_type_info _swigt__p_p_svn_txdelta_stream_t = {"_p_p_svn_txdelta_stream_t", "struct svn_txdelta_stream_t **|svn_txdelta_stream_t **", 0, 0, (void*)0, 0};
 
13803
static swig_type_info _swigt__p_p_svn_version_t = {"_p_p_svn_version_t", "struct svn_version_t **|svn_version_t **", 0, 0, (void*)0, 0};
11357
13804
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
11358
13805
static swig_type_info _swigt__p_svn_auth_baton_t = {"_p_svn_auth_baton_t", "struct svn_auth_baton_t *|svn_auth_baton_t *", 0, 0, (void*)0, 0};
11359
13806
static swig_type_info _swigt__p_svn_auth_cred_simple_t = {"_p_svn_auth_cred_simple_t", "struct svn_auth_cred_simple_t *|svn_auth_cred_simple_t *", 0, 0, (void*)0, 0};
11387
13834
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};
11388
13835
static swig_type_info _swigt__p_svn_fs_access_t = {"_p_svn_fs_access_t", "struct svn_fs_access_t *|svn_fs_access_t *", 0, 0, (void*)0, 0};
11389
13836
static swig_type_info _swigt__p_svn_fs_dirent_t = {"_p_svn_fs_dirent_t", "struct svn_fs_dirent_t *|svn_fs_dirent_t *", 0, 0, (void*)0, 0};
 
13837
static swig_type_info _swigt__p_svn_fs_fsfs_info_t = {"_p_svn_fs_fsfs_info_t", "struct svn_fs_fsfs_info_t *|svn_fs_fsfs_info_t *", 0, 0, (void*)0, 0};
 
13838
static swig_type_info _swigt__p_svn_fs_fsx_info_t = {"_p_svn_fs_fsx_info_t", "struct svn_fs_fsx_info_t *|svn_fs_fsx_info_t *", 0, 0, (void*)0, 0};
11390
13839
static swig_type_info _swigt__p_svn_fs_history_t = {"_p_svn_fs_history_t", "struct svn_fs_history_t *|svn_fs_history_t *", 0, 0, (void*)0, 0};
11391
13840
static swig_type_info _swigt__p_svn_fs_id_t = {"_p_svn_fs_id_t", "struct svn_fs_id_t *|svn_fs_id_t *", 0, 0, (void*)0, 0};
 
13841
static swig_type_info _swigt__p_svn_fs_info_placeholder_t = {"_p_svn_fs_info_placeholder_t", "struct svn_fs_info_placeholder_t *|svn_fs_info_placeholder_t *", 0, 0, (void*)0, 0};
 
13842
static swig_type_info _swigt__p_svn_fs_lock_target_t = {"_p_svn_fs_lock_target_t", "struct svn_fs_lock_target_t *|svn_fs_lock_target_t *", 0, 0, (void*)0, 0};
 
13843
static swig_type_info _swigt__p_svn_fs_node_relation_t = {"_p_svn_fs_node_relation_t", "enum svn_fs_node_relation_t *|svn_fs_node_relation_t *", 0, 0, (void*)0, 0};
11392
13844
static swig_type_info _swigt__p_svn_fs_pack_notify_action_t = {"_p_svn_fs_pack_notify_action_t", "enum svn_fs_pack_notify_action_t *|svn_fs_pack_notify_action_t *", 0, 0, (void*)0, 0};
11393
13845
static swig_type_info _swigt__p_svn_fs_path_change2_t = {"_p_svn_fs_path_change2_t", "struct svn_fs_path_change2_t *|svn_fs_path_change2_t *", 0, 0, (void*)0, 0};
11394
13846
static swig_type_info _swigt__p_svn_fs_path_change_kind_t = {"_p_svn_fs_path_change_kind_t", "enum svn_fs_path_change_kind_t *|svn_fs_path_change_kind_t *", 0, 0, (void*)0, 0};
11396
13848
static swig_type_info _swigt__p_svn_fs_root_t = {"_p_svn_fs_root_t", "struct svn_fs_root_t *|svn_fs_root_t *", 0, 0, (void*)0, 0};
11397
13849
static swig_type_info _swigt__p_svn_fs_t = {"_p_svn_fs_t", "struct svn_fs_t *|svn_fs_t *", 0, 0, (void*)0, 0};
11398
13850
static swig_type_info _swigt__p_svn_fs_txn_t = {"_p_svn_fs_txn_t", "struct svn_fs_txn_t *|svn_fs_txn_t *", 0, 0, (void*)0, 0};
 
13851
static swig_type_info _swigt__p_svn_fs_upgrade_notify_action_t = {"_p_svn_fs_upgrade_notify_action_t", "enum svn_fs_upgrade_notify_action_t *|svn_fs_upgrade_notify_action_t *", 0, 0, (void*)0, 0};
11399
13852
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};
11400
13853
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};
11401
13854
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};
11448
13901
  &_swigt__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
11449
13902
  &_swigt__p_f_p_void__p_svn_error_t,
11450
13903
  &_swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
13904
  &_swigt__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
13905
  &_swigt__p_f_p_void_long_long_p_apr_pool_t__void,
11451
13906
  &_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t,
 
13907
  &_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
11452
13908
  &_swigt__p_f_p_void_p_struct_svn_error_t__void,
11453
13909
  &_swigt__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t,
11454
13910
  &_swigt__p_int,
11461
13917
  &_swigt__p_p_svn_fs_access_t,
11462
13918
  &_swigt__p_p_svn_fs_history_t,
11463
13919
  &_swigt__p_p_svn_fs_id_t,
 
13920
  &_swigt__p_p_svn_fs_info_placeholder_t,
11464
13921
  &_swigt__p_p_svn_fs_root_t,
11465
13922
  &_swigt__p_p_svn_fs_t,
11466
13923
  &_swigt__p_p_svn_fs_txn_t,
11468
13925
  &_swigt__p_p_svn_stream_t,
11469
13926
  &_swigt__p_p_svn_string_t,
11470
13927
  &_swigt__p_p_svn_txdelta_stream_t,
 
13928
  &_swigt__p_p_svn_version_t,
11471
13929
  &_swigt__p_p_void,
11472
13930
  &_swigt__p_svn_auth_baton_t,
11473
13931
  &_swigt__p_svn_auth_cred_simple_t,
11501
13959
  &_swigt__p_svn_error_t,
11502
13960
  &_swigt__p_svn_fs_access_t,
11503
13961
  &_swigt__p_svn_fs_dirent_t,
 
13962
  &_swigt__p_svn_fs_fsfs_info_t,
 
13963
  &_swigt__p_svn_fs_fsx_info_t,
11504
13964
  &_swigt__p_svn_fs_history_t,
11505
13965
  &_swigt__p_svn_fs_id_t,
 
13966
  &_swigt__p_svn_fs_info_placeholder_t,
 
13967
  &_swigt__p_svn_fs_lock_target_t,
 
13968
  &_swigt__p_svn_fs_node_relation_t,
11506
13969
  &_swigt__p_svn_fs_pack_notify_action_t,
11507
13970
  &_swigt__p_svn_fs_path_change2_t,
11508
13971
  &_swigt__p_svn_fs_path_change_kind_t,
11510
13973
  &_swigt__p_svn_fs_root_t,
11511
13974
  &_swigt__p_svn_fs_t,
11512
13975
  &_swigt__p_svn_fs_txn_t,
 
13976
  &_swigt__p_svn_fs_upgrade_notify_action_t,
11513
13977
  &_swigt__p_svn_io_dirent2_t,
11514
13978
  &_swigt__p_svn_io_dirent_t,
11515
13979
  &_swigt__p_svn_io_file_del_t,
11562
14026
static swig_cast_info _swigc__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t[] = {  {&_swigt__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11563
14027
static swig_cast_info _swigc__p_f_p_void__p_svn_error_t[] = {  {&_swigt__p_f_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11564
14028
static swig_cast_info _swigc__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14029
static swig_cast_info _swigc__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14030
static swig_cast_info _swigc__p_f_p_void_long_long_p_apr_pool_t__void[] = {  {&_swigt__p_f_p_void_long_long_p_apr_pool_t__void, 0, 0, 0},{0, 0, 0, 0}};
11565
14031
static swig_cast_info _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14032
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11566
14033
static swig_cast_info _swigc__p_f_p_void_p_struct_svn_error_t__void[] = {  {&_swigt__p_f_p_void_p_struct_svn_error_t__void, 0, 0, 0},{0, 0, 0, 0}};
11567
14034
static swig_cast_info _swigc__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11568
14035
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
11575
14042
static swig_cast_info _swigc__p_p_svn_fs_access_t[] = {  {&_swigt__p_p_svn_fs_access_t, 0, 0, 0},{0, 0, 0, 0}};
11576
14043
static swig_cast_info _swigc__p_p_svn_fs_history_t[] = {  {&_swigt__p_p_svn_fs_history_t, 0, 0, 0},{0, 0, 0, 0}};
11577
14044
static swig_cast_info _swigc__p_p_svn_fs_id_t[] = {  {&_swigt__p_p_svn_fs_id_t, 0, 0, 0},{0, 0, 0, 0}};
 
14045
static swig_cast_info _swigc__p_p_svn_fs_info_placeholder_t[] = {  {&_swigt__p_p_svn_fs_info_placeholder_t, 0, 0, 0},{0, 0, 0, 0}};
11578
14046
static swig_cast_info _swigc__p_p_svn_fs_root_t[] = {  {&_swigt__p_p_svn_fs_root_t, 0, 0, 0},{0, 0, 0, 0}};
11579
14047
static swig_cast_info _swigc__p_p_svn_fs_t[] = {  {&_swigt__p_p_svn_fs_t, 0, 0, 0},{0, 0, 0, 0}};
11580
14048
static swig_cast_info _swigc__p_p_svn_fs_txn_t[] = {  {&_swigt__p_p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
11582
14050
static swig_cast_info _swigc__p_p_svn_stream_t[] = {  {&_swigt__p_p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
11583
14051
static swig_cast_info _swigc__p_p_svn_string_t[] = {  {&_swigt__p_p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
11584
14052
static swig_cast_info _swigc__p_p_svn_txdelta_stream_t[] = {  {&_swigt__p_p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
 
14053
static swig_cast_info _swigc__p_p_svn_version_t[] = {  {&_swigt__p_p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
11585
14054
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
11586
14055
static swig_cast_info _swigc__p_svn_auth_baton_t[] = {  {&_swigt__p_svn_auth_baton_t, 0, 0, 0},{0, 0, 0, 0}};
11587
14056
static swig_cast_info _swigc__p_svn_auth_cred_simple_t[] = {  {&_swigt__p_svn_auth_cred_simple_t, 0, 0, 0},{0, 0, 0, 0}};
11615
14084
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
11616
14085
static swig_cast_info _swigc__p_svn_fs_access_t[] = {  {&_swigt__p_svn_fs_access_t, 0, 0, 0},{0, 0, 0, 0}};
11617
14086
static swig_cast_info _swigc__p_svn_fs_dirent_t[] = {  {&_swigt__p_svn_fs_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
 
14087
static swig_cast_info _swigc__p_svn_fs_fsfs_info_t[] = {  {&_swigt__p_svn_fs_fsfs_info_t, 0, 0, 0},{0, 0, 0, 0}};
 
14088
static swig_cast_info _swigc__p_svn_fs_fsx_info_t[] = {  {&_swigt__p_svn_fs_fsx_info_t, 0, 0, 0},{0, 0, 0, 0}};
11618
14089
static swig_cast_info _swigc__p_svn_fs_history_t[] = {  {&_swigt__p_svn_fs_history_t, 0, 0, 0},{0, 0, 0, 0}};
11619
14090
static swig_cast_info _swigc__p_svn_fs_id_t[] = {  {&_swigt__p_svn_fs_id_t, 0, 0, 0},{0, 0, 0, 0}};
 
14091
static swig_cast_info _swigc__p_svn_fs_info_placeholder_t[] = {  {&_swigt__p_svn_fs_info_placeholder_t, 0, 0, 0},{0, 0, 0, 0}};
 
14092
static swig_cast_info _swigc__p_svn_fs_lock_target_t[] = {  {&_swigt__p_svn_fs_lock_target_t, 0, 0, 0},{0, 0, 0, 0}};
 
14093
static swig_cast_info _swigc__p_svn_fs_node_relation_t[] = {  {&_swigt__p_svn_fs_node_relation_t, 0, 0, 0},{0, 0, 0, 0}};
11620
14094
static swig_cast_info _swigc__p_svn_fs_pack_notify_action_t[] = {  {&_swigt__p_svn_fs_pack_notify_action_t, 0, 0, 0},{0, 0, 0, 0}};
11621
14095
static swig_cast_info _swigc__p_svn_fs_path_change2_t[] = {  {&_swigt__p_svn_fs_path_change2_t, 0, 0, 0},{0, 0, 0, 0}};
11622
14096
static swig_cast_info _swigc__p_svn_fs_path_change_kind_t[] = {  {&_swigt__p_svn_fs_path_change_kind_t, 0, 0, 0},{0, 0, 0, 0}};
11624
14098
static swig_cast_info _swigc__p_svn_fs_root_t[] = {  {&_swigt__p_svn_fs_root_t, 0, 0, 0},{0, 0, 0, 0}};
11625
14099
static swig_cast_info _swigc__p_svn_fs_t[] = {  {&_swigt__p_svn_fs_t, 0, 0, 0},{0, 0, 0, 0}};
11626
14100
static swig_cast_info _swigc__p_svn_fs_txn_t[] = {  {&_swigt__p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
 
14101
static swig_cast_info _swigc__p_svn_fs_upgrade_notify_action_t[] = {  {&_swigt__p_svn_fs_upgrade_notify_action_t, 0, 0, 0},{0, 0, 0, 0}};
11627
14102
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
11628
14103
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
11629
14104
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}};
11676
14151
  _swigc__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
11677
14152
  _swigc__p_f_p_void__p_svn_error_t,
11678
14153
  _swigc__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14154
  _swigc__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14155
  _swigc__p_f_p_void_long_long_p_apr_pool_t__void,
11679
14156
  _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t,
 
14157
  _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
11680
14158
  _swigc__p_f_p_void_p_struct_svn_error_t__void,
11681
14159
  _swigc__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t,
11682
14160
  _swigc__p_int,
11689
14167
  _swigc__p_p_svn_fs_access_t,
11690
14168
  _swigc__p_p_svn_fs_history_t,
11691
14169
  _swigc__p_p_svn_fs_id_t,
 
14170
  _swigc__p_p_svn_fs_info_placeholder_t,
11692
14171
  _swigc__p_p_svn_fs_root_t,
11693
14172
  _swigc__p_p_svn_fs_t,
11694
14173
  _swigc__p_p_svn_fs_txn_t,
11696
14175
  _swigc__p_p_svn_stream_t,
11697
14176
  _swigc__p_p_svn_string_t,
11698
14177
  _swigc__p_p_svn_txdelta_stream_t,
 
14178
  _swigc__p_p_svn_version_t,
11699
14179
  _swigc__p_p_void,
11700
14180
  _swigc__p_svn_auth_baton_t,
11701
14181
  _swigc__p_svn_auth_cred_simple_t,
11729
14209
  _swigc__p_svn_error_t,
11730
14210
  _swigc__p_svn_fs_access_t,
11731
14211
  _swigc__p_svn_fs_dirent_t,
 
14212
  _swigc__p_svn_fs_fsfs_info_t,
 
14213
  _swigc__p_svn_fs_fsx_info_t,
11732
14214
  _swigc__p_svn_fs_history_t,
11733
14215
  _swigc__p_svn_fs_id_t,
 
14216
  _swigc__p_svn_fs_info_placeholder_t,
 
14217
  _swigc__p_svn_fs_lock_target_t,
 
14218
  _swigc__p_svn_fs_node_relation_t,
11734
14219
  _swigc__p_svn_fs_pack_notify_action_t,
11735
14220
  _swigc__p_svn_fs_path_change2_t,
11736
14221
  _swigc__p_svn_fs_path_change_kind_t,
11738
14223
  _swigc__p_svn_fs_root_t,
11739
14224
  _swigc__p_svn_fs_t,
11740
14225
  _swigc__p_svn_fs_txn_t,
 
14226
  _swigc__p_svn_fs_upgrade_notify_action_t,
11741
14227
  _swigc__p_svn_io_dirent2_t,
11742
14228
  _swigc__p_svn_io_dirent_t,
11743
14229
  _swigc__p_svn_io_file_del_t,
11794
14280
{"SVN::_Fs::svn_fs_version", _wrap_svn_fs_version},
11795
14281
{"SVN::_Fs::svn_fs_initialize", _wrap_svn_fs_initialize},
11796
14282
{"SVN::_Fs::svn_fs_create", _wrap_svn_fs_create},
 
14283
{"SVN::_Fs::svn_fs_open2", _wrap_svn_fs_open2},
11797
14284
{"SVN::_Fs::svn_fs_open", _wrap_svn_fs_open},
 
14285
{"SVN::_Fs::svn_fs_upgrade2", _wrap_svn_fs_upgrade2},
11798
14286
{"SVN::_Fs::svn_fs_upgrade", _wrap_svn_fs_upgrade},
11799
14287
{"SVN::_Fs::svn_fs_type", _wrap_svn_fs_type},
11800
14288
{"SVN::_Fs::svn_fs_path", _wrap_svn_fs_path},
11801
14289
{"SVN::_Fs::svn_fs_config", _wrap_svn_fs_config},
11802
14290
{"SVN::_Fs::svn_fs_delete_fs", _wrap_svn_fs_delete_fs},
 
14291
{"SVN::_Fs::svn_fs_hotcopy3", _wrap_svn_fs_hotcopy3},
11803
14292
{"SVN::_Fs::svn_fs_hotcopy2", _wrap_svn_fs_hotcopy2},
11804
14293
{"SVN::_Fs::svn_fs_hotcopy", _wrap_svn_fs_hotcopy},
11805
14294
{"SVN::_Fs::svn_fs_recover", _wrap_svn_fs_recover},
11860
14349
{"SVN::_Fs::svn_fs_path_change2_t_copyfrom_rev_get", _wrap_svn_fs_path_change2_t_copyfrom_rev_get},
11861
14350
{"SVN::_Fs::svn_fs_path_change2_t_copyfrom_path_set", _wrap_svn_fs_path_change2_t_copyfrom_path_set},
11862
14351
{"SVN::_Fs::svn_fs_path_change2_t_copyfrom_path_get", _wrap_svn_fs_path_change2_t_copyfrom_path_get},
 
14352
{"SVN::_Fs::svn_fs_path_change2_t_mergeinfo_mod_set", _wrap_svn_fs_path_change2_t_mergeinfo_mod_set},
 
14353
{"SVN::_Fs::svn_fs_path_change2_t_mergeinfo_mod_get", _wrap_svn_fs_path_change2_t_mergeinfo_mod_get},
11863
14354
{"SVN::_Fs::svn_fs_path_change_t_node_rev_id_set", _wrap_svn_fs_path_change_t_node_rev_id_set},
11864
14355
{"SVN::_Fs::svn_fs_path_change_t_node_rev_id_get", _wrap_svn_fs_path_change_t_node_rev_id_get},
11865
14356
{"SVN::_Fs::svn_fs_path_change_t_change_kind_set", _wrap_svn_fs_path_change_t_change_kind_set},
11872
14363
{"SVN::_Fs::svn_fs_paths_changed2", _wrap_svn_fs_paths_changed2},
11873
14364
{"SVN::_Fs::svn_fs_paths_changed", _wrap_svn_fs_paths_changed},
11874
14365
{"SVN::_Fs::svn_fs_check_path", _wrap_svn_fs_check_path},
 
14366
{"SVN::_Fs::svn_fs_node_history2", _wrap_svn_fs_node_history2},
11875
14367
{"SVN::_Fs::svn_fs_node_history", _wrap_svn_fs_node_history},
 
14368
{"SVN::_Fs::svn_fs_history_prev2", _wrap_svn_fs_history_prev2},
11876
14369
{"SVN::_Fs::svn_fs_history_prev", _wrap_svn_fs_history_prev},
11877
14370
{"SVN::_Fs::svn_fs_history_location", _wrap_svn_fs_history_location},
11878
14371
{"SVN::_Fs::svn_fs_is_dir", _wrap_svn_fs_is_dir},
11879
14372
{"SVN::_Fs::svn_fs_is_file", _wrap_svn_fs_is_file},
11880
14373
{"SVN::_Fs::svn_fs_node_id", _wrap_svn_fs_node_id},
 
14374
{"SVN::_Fs::svn_fs_node_relation", _wrap_svn_fs_node_relation},
11881
14375
{"SVN::_Fs::svn_fs_node_created_rev", _wrap_svn_fs_node_created_rev},
11882
14376
{"SVN::_Fs::svn_fs_node_origin_rev", _wrap_svn_fs_node_origin_rev},
11883
14377
{"SVN::_Fs::svn_fs_node_created_path", _wrap_svn_fs_node_created_path},
11884
14378
{"SVN::_Fs::svn_fs_node_prop", _wrap_svn_fs_node_prop},
11885
14379
{"SVN::_Fs::svn_fs_node_proplist", _wrap_svn_fs_node_proplist},
 
14380
{"SVN::_Fs::svn_fs_node_has_props", _wrap_svn_fs_node_has_props},
11886
14381
{"SVN::_Fs::svn_fs_change_node_prop", _wrap_svn_fs_change_node_prop},
 
14382
{"SVN::_Fs::svn_fs_props_different", _wrap_svn_fs_props_different},
11887
14383
{"SVN::_Fs::svn_fs_props_changed", _wrap_svn_fs_props_changed},
11888
14384
{"SVN::_Fs::svn_fs_copied_from", _wrap_svn_fs_copied_from},
11889
14385
{"SVN::_Fs::svn_fs_closest_copy", _wrap_svn_fs_closest_copy},
11897
14393
{"SVN::_Fs::svn_fs_dirent_t_kind_set", _wrap_svn_fs_dirent_t_kind_set},
11898
14394
{"SVN::_Fs::svn_fs_dirent_t_kind_get", _wrap_svn_fs_dirent_t_kind_get},
11899
14395
{"SVN::_Fs::svn_fs_dir_entries", _wrap_svn_fs_dir_entries},
 
14396
{"SVN::_Fs::svn_fs_dir_optimal_order", _wrap_svn_fs_dir_optimal_order},
11900
14397
{"SVN::_Fs::svn_fs_make_dir", _wrap_svn_fs_make_dir},
11901
14398
{"SVN::_Fs::svn_fs_delete", _wrap_svn_fs_delete},
11902
14399
{"SVN::_Fs::svn_fs_copy", _wrap_svn_fs_copy},
11909
14406
{"SVN::_Fs::svn_fs_make_file", _wrap_svn_fs_make_file},
11910
14407
{"SVN::_Fs::svn_fs_apply_textdelta", _wrap_svn_fs_apply_textdelta},
11911
14408
{"SVN::_Fs::svn_fs_apply_text", _wrap_svn_fs_apply_text},
 
14409
{"SVN::_Fs::svn_fs_contents_different", _wrap_svn_fs_contents_different},
11912
14410
{"SVN::_Fs::svn_fs_contents_changed", _wrap_svn_fs_contents_changed},
11913
14411
{"SVN::_Fs::svn_fs_youngest_rev", _wrap_svn_fs_youngest_rev},
 
14412
{"SVN::_Fs::svn_fs_info_format", _wrap_svn_fs_info_format},
 
14413
{"SVN::_Fs::svn_fs_info_config_files", _wrap_svn_fs_info_config_files},
11914
14414
{"SVN::_Fs::svn_fs_deltify_revision", _wrap_svn_fs_deltify_revision},
11915
14415
{"SVN::_Fs::svn_fs_revision_prop", _wrap_svn_fs_revision_prop},
11916
14416
{"SVN::_Fs::svn_fs_revision_proplist", _wrap_svn_fs_revision_proplist},
11919
14419
{"SVN::_Fs::svn_fs_get_file_delta_stream", _wrap_svn_fs_get_file_delta_stream},
11920
14420
{"SVN::_Fs::svn_fs_get_uuid", _wrap_svn_fs_get_uuid},
11921
14421
{"SVN::_Fs::svn_fs_set_uuid", _wrap_svn_fs_set_uuid},
 
14422
{"SVN::_Fs::svn_fs_lock_target_create", _wrap_svn_fs_lock_target_create},
 
14423
{"SVN::_Fs::svn_fs_lock_target_set_token", _wrap_svn_fs_lock_target_set_token},
 
14424
{"SVN::_Fs::svn_fs_lock_many", _wrap_svn_fs_lock_many},
11922
14425
{"SVN::_Fs::svn_fs_lock", _wrap_svn_fs_lock},
11923
14426
{"SVN::_Fs::svn_fs_generate_lock_token", _wrap_svn_fs_generate_lock_token},
 
14427
{"SVN::_Fs::svn_fs_unlock_many", _wrap_svn_fs_unlock_many},
11924
14428
{"SVN::_Fs::svn_fs_unlock", _wrap_svn_fs_unlock},
11925
14429
{"SVN::_Fs::svn_fs_get_lock", _wrap_svn_fs_get_lock},
11926
14430
{"SVN::_Fs::svn_fs_get_locks2", _wrap_svn_fs_get_locks2},
11929
14433
{"SVN::_Fs::svn_fs_pack", _wrap_svn_fs_pack},
11930
14434
{"SVN::_Fs::svn_fs_verify", _wrap_svn_fs_verify},
11931
14435
{"SVN::_Fs::svn_fs_verify_root", _wrap_svn_fs_verify_root},
 
14436
{"SVN::_Fs::svn_fs_fsfs_info_t_fs_type_set", _wrap_svn_fs_fsfs_info_t_fs_type_set},
 
14437
{"SVN::_Fs::svn_fs_fsfs_info_t_fs_type_get", _wrap_svn_fs_fsfs_info_t_fs_type_get},
 
14438
{"SVN::_Fs::svn_fs_fsfs_info_t_shard_size_set", _wrap_svn_fs_fsfs_info_t_shard_size_set},
 
14439
{"SVN::_Fs::svn_fs_fsfs_info_t_shard_size_get", _wrap_svn_fs_fsfs_info_t_shard_size_get},
 
14440
{"SVN::_Fs::svn_fs_fsfs_info_t_min_unpacked_rev_set", _wrap_svn_fs_fsfs_info_t_min_unpacked_rev_set},
 
14441
{"SVN::_Fs::svn_fs_fsfs_info_t_min_unpacked_rev_get", _wrap_svn_fs_fsfs_info_t_min_unpacked_rev_get},
 
14442
{"SVN::_Fs::svn_fs_fsfs_info_t_log_addressing_set", _wrap_svn_fs_fsfs_info_t_log_addressing_set},
 
14443
{"SVN::_Fs::svn_fs_fsfs_info_t_log_addressing_get", _wrap_svn_fs_fsfs_info_t_log_addressing_get},
 
14444
{"SVN::_Fs::svn_fs_fsx_info_t_fs_type_set", _wrap_svn_fs_fsx_info_t_fs_type_set},
 
14445
{"SVN::_Fs::svn_fs_fsx_info_t_fs_type_get", _wrap_svn_fs_fsx_info_t_fs_type_get},
 
14446
{"SVN::_Fs::svn_fs_fsx_info_t_shard_size_set", _wrap_svn_fs_fsx_info_t_shard_size_set},
 
14447
{"SVN::_Fs::svn_fs_fsx_info_t_shard_size_get", _wrap_svn_fs_fsx_info_t_shard_size_get},
 
14448
{"SVN::_Fs::svn_fs_fsx_info_t_min_unpacked_rev_set", _wrap_svn_fs_fsx_info_t_min_unpacked_rev_set},
 
14449
{"SVN::_Fs::svn_fs_fsx_info_t_min_unpacked_rev_get", _wrap_svn_fs_fsx_info_t_min_unpacked_rev_get},
 
14450
{"SVN::_Fs::svn_fs_info_placeholder_t_fs_type_set", _wrap_svn_fs_info_placeholder_t_fs_type_set},
 
14451
{"SVN::_Fs::svn_fs_info_placeholder_t_fs_type_get", _wrap_svn_fs_info_placeholder_t_fs_type_get},
 
14452
{"SVN::_Fs::svn_fs_info", _wrap_svn_fs_info},
 
14453
{"SVN::_Fs::svn_fs_info_dup", _wrap_svn_fs_info_dup},
11932
14454
{"SVN::_Fs::svn_fs_invoke_warning_callback", _wrap_svn_fs_invoke_warning_callback},
 
14455
{"SVN::_Fs::svn_fs_invoke_upgrade_notify", _wrap_svn_fs_invoke_upgrade_notify},
11933
14456
{"SVN::_Fs::svn_fs_invoke_progress_notify_func", _wrap_svn_fs_invoke_progress_notify_func},
 
14457
{"SVN::_Fs::svn_fs_invoke_hotcopy_notify", _wrap_svn_fs_invoke_hotcopy_notify},
11934
14458
{"SVN::_Fs::svn_fs_invoke_freeze_func", _wrap_svn_fs_invoke_freeze_func},
11935
14459
{"SVN::_Fs::svn_fs_invoke_process_contents_func", _wrap_svn_fs_invoke_process_contents_func},
 
14460
{"SVN::_Fs::svn_fs_invoke_lock_callback", _wrap_svn_fs_invoke_lock_callback},
11936
14461
{"SVN::_Fs::svn_fs_invoke_get_locks_callback", _wrap_svn_fs_invoke_get_locks_callback},
11937
14462
{"SVN::_Fs::svn_fs_invoke_pack_notify", _wrap_svn_fs_invoke_pack_notify},
11938
14463
{0,0}
11939
14464
};
11940
14465
/* -----------------------------------------------------------------------------
11941
14466
 * Type initialization:
11942
 
 * This problem is tough by the requirement that no dynamic 
11943
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
14467
 * This problem is tough by the requirement that no dynamic
 
14468
 * memory is used. Also, since swig_type_info structures store pointers to
11944
14469
 * swig_cast_info structures and swig_cast_info structures store pointers back
11945
 
 * to swig_type_info structures, we need some lookup code at initialization. 
11946
 
 * The idea is that swig generates all the structures that are needed. 
11947
 
 * The runtime then collects these partially filled structures. 
11948
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
14470
 * to swig_type_info structures, we need some lookup code at initialization.
 
14471
 * The idea is that swig generates all the structures that are needed.
 
14472
 * The runtime then collects these partially filled structures.
 
14473
 * The SWIG_InitializeModule function takes these initial arrays out of
11949
14474
 * swig_module, and does all the lookup, filling in the swig_module.types
11950
14475
 * array with the correct data and linking the correct swig_cast_info
11951
14476
 * structures together.
11952
14477
 *
11953
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
14478
 * The generated swig_type_info structures are assigned staticly to an initial
11954
14479
 * array. We just loop through that array, and handle each type individually.
11955
14480
 * First we lookup if this type has been already loaded, and if so, use the
11956
14481
 * loaded structure instead of the generated one. Then we have to fill in the
11960
14485
 * a column is one of the swig_cast_info structures for that type.
11961
14486
 * The cast_initial array is actually an array of arrays, because each row has
11962
14487
 * a variable number of columns. So to actually build the cast linked list,
11963
 
 * we find the array of casts associated with the type, and loop through it 
 
14488
 * we find the array of casts associated with the type, and loop through it
11964
14489
 * adding the casts to the list. The one last trick we need to do is making
11965
14490
 * sure the type pointer in the swig_cast_info struct is correct.
11966
14491
 *
11967
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
14492
 * First off, we lookup the cast->type name to see if it is already loaded.
11968
14493
 * There are three cases to handle:
11969
14494
 *  1) If the cast->type has already been loaded AND the type we are adding
11970
14495
 *     casting info to has not been loaded (it is in this module), THEN we
11971
14496
 *     replace the cast->type pointer with the type pointer that has already
11972
14497
 *     been loaded.
11973
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
14498
 *  2) If BOTH types (the one we are adding casting info to, and the
11974
14499
 *     cast->type) are loaded, THEN the cast info has already been loaded by
11975
14500
 *     the previous module so we just ignore it.
11976
14501
 *  3) Finally, if cast->type has not already been loaded, then we add that
12033
14558
    module_head->next = &swig_module;
12034
14559
  }
12035
14560
  
12036
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
14561
  /* When multiple interpreters are used, a module could have already been initialized in
12037
14562
       a different interpreter, but not yet have a pointer in this interpreter.
12038
14563
       In this case, we do not want to continue adding types... everything should be
12039
14564
       set up already */
12232
14757
    SvREADONLY_on(sv);
12233
14758
  }
12234
14759
  
12235
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14760
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14761
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_TYPE_BDB", TRUE | 0x2 | GV_ADDMULTI);
 
14762
    sv_setsv(sv, SWIG_FromCharPtr("bdb"));
 
14763
    SvREADONLY_on(sv);
 
14764
  } while(0) /*@SWIG@*/;
 
14765
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14766
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_TYPE_FSFS", TRUE | 0x2 | GV_ADDMULTI);
 
14767
    sv_setsv(sv, SWIG_FromCharPtr("fsfs"));
 
14768
    SvREADONLY_on(sv);
 
14769
  } while(0) /*@SWIG@*/;
 
14770
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14771
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_TYPE_FSX", TRUE | 0x2 | GV_ADDMULTI);
 
14772
    sv_setsv(sv, SWIG_FromCharPtr("fsx"));
 
14773
    SvREADONLY_on(sv);
 
14774
  } while(0) /*@SWIG@*/;
 
14775
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12236
14776
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_BDB_TXN_NOSYNC", TRUE | 0x2 | GV_ADDMULTI);
12237
14777
    sv_setsv(sv, SWIG_FromCharPtr("bdb-txn-nosync"));
12238
14778
    SvREADONLY_on(sv);
12239
14779
  } while(0) /*@SWIG@*/;
12240
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14780
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12241
14781
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_BDB_LOG_AUTOREMOVE", TRUE | 0x2 | GV_ADDMULTI);
12242
14782
    sv_setsv(sv, SWIG_FromCharPtr("bdb-log-autoremove"));
12243
14783
    SvREADONLY_on(sv);
12244
14784
  } while(0) /*@SWIG@*/;
12245
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14785
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12246
14786
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_FSFS_CACHE_DELTAS", TRUE | 0x2 | GV_ADDMULTI);
12247
14787
    sv_setsv(sv, SWIG_FromCharPtr("fsfs-cache-deltas"));
12248
14788
    SvREADONLY_on(sv);
12249
14789
  } while(0) /*@SWIG@*/;
12250
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14790
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12251
14791
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_FSFS_CACHE_FULLTEXTS", TRUE | 0x2 | GV_ADDMULTI);
12252
14792
    sv_setsv(sv, SWIG_FromCharPtr("fsfs-cache-fulltexts"));
12253
14793
    SvREADONLY_on(sv);
12254
14794
  } while(0) /*@SWIG@*/;
12255
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14795
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12256
14796
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_FSFS_CACHE_REVPROPS", TRUE | 0x2 | GV_ADDMULTI);
12257
14797
    sv_setsv(sv, SWIG_FromCharPtr("fsfs-cache-revprops"));
12258
14798
    SvREADONLY_on(sv);
12259
14799
  } while(0) /*@SWIG@*/;
12260
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14800
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12261
14801
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_FSFS_CACHE_NS", TRUE | 0x2 | GV_ADDMULTI);
12262
14802
    sv_setsv(sv, SWIG_FromCharPtr("fsfs-cache-namespace"));
12263
14803
    SvREADONLY_on(sv);
12264
14804
  } while(0) /*@SWIG@*/;
12265
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14805
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14806
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_FSFS_BLOCK_READ", TRUE | 0x2 | GV_ADDMULTI);
 
14807
    sv_setsv(sv, SWIG_FromCharPtr("fsfs-block-read"));
 
14808
    SvREADONLY_on(sv);
 
14809
  } while(0) /*@SWIG@*/;
 
14810
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14811
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_FSFS_SHARD_SIZE", TRUE | 0x2 | GV_ADDMULTI);
 
14812
    sv_setsv(sv, SWIG_FromCharPtr("fsfs-shard-size"));
 
14813
    SvREADONLY_on(sv);
 
14814
  } while(0) /*@SWIG@*/;
 
14815
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14816
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_FSFS_LOG_ADDRESSING", TRUE | 0x2 | GV_ADDMULTI);
 
14817
    sv_setsv(sv, SWIG_FromCharPtr("fsfs-log-addressing"));
 
14818
    SvREADONLY_on(sv);
 
14819
  } while(0) /*@SWIG@*/;
 
14820
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12266
14821
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_FS_TYPE", TRUE | 0x2 | GV_ADDMULTI);
12267
14822
    sv_setsv(sv, SWIG_FromCharPtr("fs-type"));
12268
14823
    SvREADONLY_on(sv);
12269
14824
  } while(0) /*@SWIG@*/;
12270
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12271
 
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_TYPE_BDB", TRUE | 0x2 | GV_ADDMULTI);
12272
 
    sv_setsv(sv, SWIG_FromCharPtr("bdb"));
12273
 
    SvREADONLY_on(sv);
12274
 
  } while(0) /*@SWIG@*/;
12275
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12276
 
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_TYPE_FSFS", TRUE | 0x2 | GV_ADDMULTI);
12277
 
    sv_setsv(sv, SWIG_FromCharPtr("fsfs"));
12278
 
    SvREADONLY_on(sv);
12279
 
  } while(0) /*@SWIG@*/;
12280
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14825
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12281
14826
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_PRE_1_4_COMPATIBLE", TRUE | 0x2 | GV_ADDMULTI);
12282
14827
    sv_setsv(sv, SWIG_FromCharPtr("pre-1.4-compatible"));
12283
14828
    SvREADONLY_on(sv);
12284
14829
  } while(0) /*@SWIG@*/;
12285
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14830
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12286
14831
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_PRE_1_5_COMPATIBLE", TRUE | 0x2 | GV_ADDMULTI);
12287
14832
    sv_setsv(sv, SWIG_FromCharPtr("pre-1.5-compatible"));
12288
14833
    SvREADONLY_on(sv);
12289
14834
  } while(0) /*@SWIG@*/;
12290
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14835
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12291
14836
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_PRE_1_6_COMPATIBLE", TRUE | 0x2 | GV_ADDMULTI);
12292
14837
    sv_setsv(sv, SWIG_FromCharPtr("pre-1.6-compatible"));
12293
14838
    SvREADONLY_on(sv);
12294
14839
  } while(0) /*@SWIG@*/;
12295
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14840
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12296
14841
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_PRE_1_8_COMPATIBLE", TRUE | 0x2 | GV_ADDMULTI);
12297
14842
    sv_setsv(sv, SWIG_FromCharPtr("pre-1.8-compatible"));
12298
14843
    SvREADONLY_on(sv);
12299
14844
  } while(0) /*@SWIG@*/;
12300
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14845
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14846
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_CONFIG_COMPATIBLE_VERSION", TRUE | 0x2 | GV_ADDMULTI);
 
14847
    sv_setsv(sv, SWIG_FromCharPtr("compatible-version"));
 
14848
    SvREADONLY_on(sv);
 
14849
  } while(0) /*@SWIG@*/;
 
14850
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14851
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_upgrade_pack_revprops", TRUE | 0x2 | GV_ADDMULTI);
 
14852
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_upgrade_pack_revprops)));
 
14853
    SvREADONLY_on(sv);
 
14854
  } while(0) /*@SWIG@*/;
 
14855
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14856
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_upgrade_cleanup_revprops", TRUE | 0x2 | GV_ADDMULTI);
 
14857
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_upgrade_cleanup_revprops)));
 
14858
    SvREADONLY_on(sv);
 
14859
  } while(0) /*@SWIG@*/;
 
14860
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14861
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_upgrade_format_bumped", TRUE | 0x2 | GV_ADDMULTI);
 
14862
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_upgrade_format_bumped)));
 
14863
    SvREADONLY_on(sv);
 
14864
  } while(0) /*@SWIG@*/;
 
14865
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14866
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_node_unrelated", TRUE | 0x2 | GV_ADDMULTI);
 
14867
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_node_unrelated)));
 
14868
    SvREADONLY_on(sv);
 
14869
  } while(0) /*@SWIG@*/;
 
14870
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14871
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_node_unchanged", TRUE | 0x2 | GV_ADDMULTI);
 
14872
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_node_unchanged)));
 
14873
    SvREADONLY_on(sv);
 
14874
  } while(0) /*@SWIG@*/;
 
14875
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14876
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_node_common_ancestor", TRUE | 0x2 | GV_ADDMULTI);
 
14877
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_node_common_ancestor)));
 
14878
    SvREADONLY_on(sv);
 
14879
  } while(0) /*@SWIG@*/;
 
14880
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12301
14881
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_TXN_CHECK_OOD", TRUE | 0x2 | GV_ADDMULTI);
12302
14882
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(0x00001)));
12303
14883
    SvREADONLY_on(sv);
12304
14884
  } while(0) /*@SWIG@*/;
12305
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14885
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12306
14886
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_TXN_CHECK_LOCKS", TRUE | 0x2 | GV_ADDMULTI);
12307
14887
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(0x00002)));
12308
14888
    SvREADONLY_on(sv);
12309
14889
  } while(0) /*@SWIG@*/;
12310
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14890
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14891
    SV *sv = get_sv((char*) SWIG_prefix "SVN_FS_TXN_CLIENT_DATE", TRUE | 0x2 | GV_ADDMULTI);
 
14892
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(0x00004)));
 
14893
    SvREADONLY_on(sv);
 
14894
  } while(0) /*@SWIG@*/;
 
14895
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12311
14896
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_path_change_modify", TRUE | 0x2 | GV_ADDMULTI);
12312
14897
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_path_change_modify)));
12313
14898
    SvREADONLY_on(sv);
12314
14899
  } while(0) /*@SWIG@*/;
12315
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14900
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12316
14901
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_path_change_add", TRUE | 0x2 | GV_ADDMULTI);
12317
14902
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_path_change_add)));
12318
14903
    SvREADONLY_on(sv);
12319
14904
  } while(0) /*@SWIG@*/;
12320
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14905
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12321
14906
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_path_change_delete", TRUE | 0x2 | GV_ADDMULTI);
12322
14907
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_path_change_delete)));
12323
14908
    SvREADONLY_on(sv);
12324
14909
  } while(0) /*@SWIG@*/;
12325
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14910
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12326
14911
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_path_change_replace", TRUE | 0x2 | GV_ADDMULTI);
12327
14912
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_path_change_replace)));
12328
14913
    SvREADONLY_on(sv);
12329
14914
  } while(0) /*@SWIG@*/;
12330
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14915
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12331
14916
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_path_change_reset", TRUE | 0x2 | GV_ADDMULTI);
12332
14917
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_path_change_reset)));
12333
14918
    SvREADONLY_on(sv);
12334
14919
  } while(0) /*@SWIG@*/;
12335
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14920
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12336
14921
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_pack_notify_start", TRUE | 0x2 | GV_ADDMULTI);
12337
14922
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_pack_notify_start)));
12338
14923
    SvREADONLY_on(sv);
12339
14924
  } while(0) /*@SWIG@*/;
12340
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14925
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12341
14926
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_pack_notify_end", TRUE | 0x2 | GV_ADDMULTI);
12342
14927
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_pack_notify_end)));
12343
14928
    SvREADONLY_on(sv);
12344
14929
  } while(0) /*@SWIG@*/;
12345
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14930
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12346
14931
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_pack_notify_start_revprop", TRUE | 0x2 | GV_ADDMULTI);
12347
14932
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_pack_notify_start_revprop)));
12348
14933
    SvREADONLY_on(sv);
12349
14934
  } while(0) /*@SWIG@*/;
12350
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
14935
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
12351
14936
    SV *sv = get_sv((char*) SWIG_prefix "svn_fs_pack_notify_end_revprop", TRUE | 0x2 | GV_ADDMULTI);
12352
14937
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_fs_pack_notify_end_revprop)));
12353
14938
    SvREADONLY_on(sv);