← Back to branch summary

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

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/ruby/svn_fs.c

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/bindings/swig/ruby/svn_fs.c
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.36
 
3
 * Version 2.0.4
4
4
 * 
5
5
 * This file is not intended to be easily readable and contains a number of 
6
6
 * coding conventions designed to improve portability and efficiency. Do not make
9
9
 * ----------------------------------------------------------------------------- */
10
10
 
11
11
#define SWIGRUBY
 
12
 
12
13
/* -----------------------------------------------------------------------------
13
14
 *  This section contains generic SWIG labels for method/variable
14
15
 *  declarations/attributes, and other compiler dependent labels.
230
231
/* -----------------------------------------------------------------------------
231
232
 * swigrun.swg
232
233
 *
233
 
 * This file contains generic CAPI SWIG runtime support for pointer
 
234
 * This file contains generic C API SWIG runtime support for pointer
234
235
 * type checking.
235
236
 * ----------------------------------------------------------------------------- */
236
237
 
249
250
 
250
251
/*
251
252
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
252
 
  creating a static or dynamic library from the swig runtime code.
253
 
  In 99.9% of the cases, swig just needs to declare them as 'static'.
 
253
  creating a static or dynamic library from the SWIG runtime code.
 
254
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
254
255
  
255
 
  But only do this if is strictly necessary, ie, if you have problems
256
 
  with your compiler or so.
 
256
  But only do this if strictly necessary, ie, if you have problems
 
257
  with your compiler or suchlike.
257
258
*/
258
259
 
259
260
#ifndef SWIGRUNTIME
280
281
/* 
281
282
   Flags/methods for returning states.
282
283
   
283
 
   The swig conversion methods, as ConvertPtr, return and integer 
 
284
   The SWIG conversion methods, as ConvertPtr, return an integer 
284
285
   that tells if the conversion was successful or not. And if not,
285
286
   an error code can be returned (see swigerrors.swg for the codes).
286
287
   
287
288
   Use the following macros/flags to set or process the returning
288
289
   states.
289
290
   
290
 
   In old swig versions, you usually write code as:
 
291
   In old versions of SWIG, code such as the following was usually written:
291
292
 
292
293
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
293
294
       // success code
295
296
       //fail code
296
297
     }
297
298
 
298
 
   Now you can be more explicit as:
 
299
   Now you can be more explicit:
299
300
 
300
301
    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
301
302
    if (SWIG_IsOK(res)) {
304
305
      // fail code
305
306
    }
306
307
 
307
 
   that seems to be the same, but now you can also do
 
308
   which is the same really, but now you can also do
308
309
 
309
310
    Type *ptr;
310
311
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
322
323
    
323
324
   I.e., now SWIG_ConvertPtr can return new objects and you can
324
325
   identify the case and take care of the deallocation. Of course that
325
 
   requires also to SWIG_ConvertPtr to return new result values, as
 
326
   also requires SWIG_ConvertPtr to return new result values, such as
326
327
 
327
328
      int SWIG_ConvertPtr(obj, ptr,...) {         
328
329
        if (<obj is ok>) {                             
340
341
 
341
342
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
342
343
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
343
 
   swig errors code.
 
344
   SWIG errors code.
344
345
 
345
346
   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
346
347
   allows to return the 'cast rank', for example, if you have this
354
355
      fooi(1)   // cast rank '0'
355
356
 
356
357
   just use the SWIG_AddCast()/SWIG_CheckState()
357
 
 
358
 
 
359
 
 */
 
358
*/
 
359
 
360
360
#define SWIG_OK                    (0) 
361
361
#define SWIG_ERROR                 (-1)
362
362
#define SWIG_IsOK(r)               (r >= 0)
381
381
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
382
382
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
383
383
 
384
 
 
385
384
/* Cast-Rank Mode */
386
385
#if defined(SWIG_CASTRANK_MODE)
387
386
#  ifndef SWIG_TypeRank
404
403
#endif
405
404
 
406
405
 
407
 
 
408
 
 
409
406
#include <string.h>
410
407
 
411
408
#ifdef __cplusplus
502
499
}
503
500
 
504
501
 
505
 
/* think of this as a c++ template<> or a scheme macro */
506
 
#define SWIG_TypeCheck_Template(comparison, ty)         \
507
 
  if (ty) {                                             \
508
 
    swig_cast_info *iter = ty->cast;                    \
509
 
    while (iter) {                                      \
510
 
      if (comparison) {                                 \
511
 
        if (iter == ty->cast) return iter;              \
512
 
        /* Move iter to the top of the linked list */   \
513
 
        iter->prev->next = iter->next;                  \
514
 
        if (iter->next)                                 \
515
 
          iter->next->prev = iter->prev;                \
516
 
        iter->next = ty->cast;                          \
517
 
        iter->prev = 0;                                 \
518
 
        if (ty->cast) ty->cast->prev = iter;            \
519
 
        ty->cast = iter;                                \
520
 
        return iter;                                    \
521
 
      }                                                 \
522
 
      iter = iter->next;                                \
523
 
    }                                                   \
524
 
  }                                                     \
525
 
  return 0
526
 
 
527
502
/*
528
503
  Check the typename
529
504
*/
530
505
SWIGRUNTIME swig_cast_info *
531
506
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
532
 
  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 
507
  if (ty) {
 
508
    swig_cast_info *iter = ty->cast;
 
509
    while (iter) {
 
510
      if (strcmp(iter->type->name, c) == 0) {
 
511
        if (iter == ty->cast)
 
512
          return iter;
 
513
        /* Move iter to the top of the linked list */
 
514
        iter->prev->next = iter->next;
 
515
        if (iter->next)
 
516
          iter->next->prev = iter->prev;
 
517
        iter->next = ty->cast;
 
518
        iter->prev = 0;
 
519
        if (ty->cast) ty->cast->prev = iter;
 
520
        ty->cast = iter;
 
521
        return iter;
 
522
      }
 
523
      iter = iter->next;
 
524
    }
 
525
  }
 
526
  return 0;
533
527
}
534
528
 
535
 
/* Same as previous function, except strcmp is replaced with a pointer comparison */
 
529
/* 
 
530
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 
531
*/
536
532
SWIGRUNTIME swig_cast_info *
537
 
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
538
 
  SWIG_TypeCheck_Template(iter->type == from, into);
 
533
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 
534
  if (ty) {
 
535
    swig_cast_info *iter = ty->cast;
 
536
    while (iter) {
 
537
      if (iter->type == from) {
 
538
        if (iter == ty->cast)
 
539
          return iter;
 
540
        /* Move iter to the top of the linked list */
 
541
        iter->prev->next = iter->next;
 
542
        if (iter->next)
 
543
          iter->next->prev = iter->prev;
 
544
        iter->next = ty->cast;
 
545
        iter->prev = 0;
 
546
        if (ty->cast) ty->cast->prev = iter;
 
547
        ty->cast = iter;
 
548
        return iter;
 
549
      }
 
550
      iter = iter->next;
 
551
    }
 
552
  }
 
553
  return 0;
539
554
}
540
555
 
541
556
/*
816
831
 
817
832
#include <ruby.h>
818
833
 
 
834
/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
 
835
 * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
 
836
 * issue for now by disabling this.
 
837
 * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
 
838
 */
 
839
#ifdef rb_intern
 
840
# undef rb_intern
 
841
#endif
 
842
 
819
843
/* Remove global macros defined in Ruby's win32.h */
820
844
#ifdef write
821
845
# undef write
823
847
#ifdef read
824
848
# undef read
825
849
#endif
 
850
#ifdef bind
 
851
# undef bind
 
852
#endif
 
853
#ifdef close
 
854
# undef close
 
855
#endif
 
856
#ifdef connect
 
857
# undef connect
 
858
#endif
826
859
 
827
860
 
828
861
/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
965
998
 
966
999
/* Define custom exceptions for errors that do not map to existing Ruby
967
1000
   exceptions.  Note this only works for C++ since a global cannot be
968
 
   initialized by a funtion in C.  For C, fallback to rb_eRuntimeError.*/
 
1001
   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
969
1002
 
970
1003
SWIGINTERN VALUE 
971
1004
getNullReferenceError(void) {
1110
1143
}
1111
1144
 
1112
1145
/* -----------------------------------------------------------------------------
1113
 
 * See the LICENSE file for information on copyright, usage and redistribution
1114
 
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1115
 
 *
1116
1146
 * rubytracking.swg
1117
1147
 *
1118
1148
 * This file contains support for tracking mappings from 
1308
1338
 
1309
1339
 
1310
1340
/* -----------------------------------------------------------------------------
1311
 
 * See the LICENSE file for information on copyright, usage and redistribution
1312
 
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1313
 
 *
1314
1341
 * rubyrun.swg
1315
1342
 *
1316
1343
 * This file contains the runtime support for Ruby modules
1354
1381
/* Error manipulation */
1355
1382
 
1356
1383
#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
1357
 
#define SWIG_Error(code, msg)                           rb_raise(SWIG_Ruby_ErrorType(code), msg)
 
1384
#define SWIG_Error(code, msg)                           rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
1358
1385
#define SWIG_fail                                       goto fail                                
1359
1386
 
1360
1387
 
1409
1436
      ++swig_virtual_calls;
1410
1437
#  define SWIG_RELEASE_STACK --swig_virtual_calls;
1411
1438
#  define Ruby_DirectorTypeMismatchException(x) \
1412
 
          rb_raise( rb_eTypeError, x ); return c_result;
 
1439
          rb_raise( rb_eTypeError, "%s", x ); return c_result;
1413
1440
 
1414
1441
      static unsigned int swig_virtual_calls = 0;
1415
1442
 
1814
1841
#define SWIGTYPE_p_svn_diff_datasource_e swig_types[46]
1815
1842
#define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[47]
1816
1843
#define SWIGTYPE_p_svn_diff_file_options_t swig_types[48]
1817
 
#define SWIGTYPE_p_svn_diff_fns_t swig_types[49]
1818
 
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[50]
1819
 
#define SWIGTYPE_p_svn_diff_t swig_types[51]
1820
 
#define SWIGTYPE_p_svn_dirent_t swig_types[52]
1821
 
#define SWIGTYPE_p_svn_errno_t swig_types[53]
1822
 
#define SWIGTYPE_p_svn_error_t swig_types[54]
1823
 
#define SWIGTYPE_p_svn_fs_access_t swig_types[55]
1824
 
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[56]
1825
 
#define SWIGTYPE_p_svn_fs_history_t swig_types[57]
1826
 
#define SWIGTYPE_p_svn_fs_id_t swig_types[58]
1827
 
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[59]
1828
 
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[60]
1829
 
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[61]
1830
 
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[62]
1831
 
#define SWIGTYPE_p_svn_fs_root_t swig_types[63]
1832
 
#define SWIGTYPE_p_svn_fs_t swig_types[64]
1833
 
#define SWIGTYPE_p_svn_fs_txn_t swig_types[65]
1834
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[66]
1835
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[67]
1836
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[68]
1837
 
#define SWIGTYPE_p_svn_lock_t swig_types[69]
1838
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[70]
1839
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[71]
1840
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[72]
1841
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[73]
1842
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[74]
1843
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[75]
1844
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[76]
1845
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[77]
1846
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[78]
1847
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[79]
1848
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[80]
1849
 
#define SWIGTYPE_p_svn_prop_kind swig_types[81]
1850
 
#define SWIGTYPE_p_svn_stream_t swig_types[82]
1851
 
#define SWIGTYPE_p_svn_string_t swig_types[83]
1852
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[84]
1853
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[85]
1854
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[86]
1855
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[87]
1856
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[88]
1857
 
#define SWIGTYPE_p_svn_version_t swig_types[89]
1858
 
#define SWIGTYPE_p_unsigned_char swig_types[90]
1859
 
#define SWIGTYPE_p_void swig_types[91]
1860
 
static swig_type_info *swig_types[93];
1861
 
static swig_module_info swig_module = {swig_types, 92, 0, 0, 0, 0};
 
1844
#define SWIGTYPE_p_svn_diff_fns2_t swig_types[49]
 
1845
#define SWIGTYPE_p_svn_diff_fns_t swig_types[50]
 
1846
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[51]
 
1847
#define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[52]
 
1848
#define SWIGTYPE_p_svn_diff_output_fns_t swig_types[53]
 
1849
#define SWIGTYPE_p_svn_diff_t swig_types[54]
 
1850
#define SWIGTYPE_p_svn_dirent_t swig_types[55]
 
1851
#define SWIGTYPE_p_svn_errno_t swig_types[56]
 
1852
#define SWIGTYPE_p_svn_error_t swig_types[57]
 
1853
#define SWIGTYPE_p_svn_fs_access_t swig_types[58]
 
1854
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[59]
 
1855
#define SWIGTYPE_p_svn_fs_history_t swig_types[60]
 
1856
#define SWIGTYPE_p_svn_fs_id_t swig_types[61]
 
1857
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[62]
 
1858
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[63]
 
1859
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[64]
 
1860
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[65]
 
1861
#define SWIGTYPE_p_svn_fs_root_t swig_types[66]
 
1862
#define SWIGTYPE_p_svn_fs_t swig_types[67]
 
1863
#define SWIGTYPE_p_svn_fs_txn_t swig_types[68]
 
1864
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[69]
 
1865
#define SWIGTYPE_p_svn_io_dirent_t swig_types[70]
 
1866
#define SWIGTYPE_p_svn_io_file_del_t swig_types[71]
 
1867
#define SWIGTYPE_p_svn_location_segment_t swig_types[72]
 
1868
#define SWIGTYPE_p_svn_lock_t swig_types[73]
 
1869
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[74]
 
1870
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[75]
 
1871
#define SWIGTYPE_p_svn_log_entry_t swig_types[76]
 
1872
#define SWIGTYPE_p_svn_merge_range_t swig_types[77]
 
1873
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[78]
 
1874
#define SWIGTYPE_p_svn_node_kind_t swig_types[79]
 
1875
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[80]
 
1876
#define SWIGTYPE_p_svn_opt_revision_t swig_types[81]
 
1877
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[82]
 
1878
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[83]
 
1879
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[84]
 
1880
#define SWIGTYPE_p_svn_patch_file_t swig_types[85]
 
1881
#define SWIGTYPE_p_svn_patch_t swig_types[86]
 
1882
#define SWIGTYPE_p_svn_prop_kind swig_types[87]
 
1883
#define SWIGTYPE_p_svn_prop_patch_t swig_types[88]
 
1884
#define SWIGTYPE_p_svn_stream_mark_t swig_types[89]
 
1885
#define SWIGTYPE_p_svn_stream_t swig_types[90]
 
1886
#define SWIGTYPE_p_svn_string_t swig_types[91]
 
1887
#define SWIGTYPE_p_svn_stringbuf_t swig_types[92]
 
1888
#define SWIGTYPE_p_svn_tristate_t swig_types[93]
 
1889
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[94]
 
1890
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[95]
 
1891
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[96]
 
1892
#define SWIGTYPE_p_svn_version_checklist_t swig_types[97]
 
1893
#define SWIGTYPE_p_svn_version_t swig_types[98]
 
1894
#define SWIGTYPE_p_unsigned_char swig_types[99]
 
1895
#define SWIGTYPE_p_unsigned_long swig_types[100]
 
1896
#define SWIGTYPE_p_void swig_types[101]
 
1897
static swig_type_info *swig_types[103];
 
1898
static swig_module_info swig_module = {swig_types, 102, 0, 0, 0, 0};
1862
1899
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1863
1900
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1864
1901
 
1873
1910
#define SWIG_RUBY_THREAD_END_BLOCK
1874
1911
 
1875
1912
 
1876
 
#define SWIGVERSION 0x010336 
 
1913
#define SWIGVERSION 0x020004 
1877
1914
#define SWIG_VERSION SWIGVERSION
1878
1915
 
1879
1916
 
1884
1921
#ifdef __cplusplus
1885
1922
extern "C" {
1886
1923
#endif
 
1924
 
 
1925
// Ruby 1.9 changed the file name of this header
 
1926
#ifdef HAVE_RUBY_IO_H
 
1927
#include "ruby/io.h"
 
1928
#else
1887
1929
#include "rubyio.h"
 
1930
#endif
 
1931
 
1888
1932
#ifdef __cplusplus
1889
1933
}
1890
1934
#endif
2033
2077
} 
2034
2078
 
2035
2079
 
2036
 
/*@SWIG:/home/hwright/dev/release/roll/prefix/share/swig/1.3.36/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 
2080
/*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
2037
2081
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
2038
2082
{
2039
2083
  VALUE obj = args[0];
2088
2132
}
2089
2133
 
2090
2134
 
2091
 
/*@SWIG:/home/hwright/dev/release/roll/prefix/share/swig/1.3.36/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 
2135
/*@SWIG:/home/pm/sw/subversion/release/prefix/share/swig/2.0.4/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
2092
2136
SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
2093
2137
{
2094
2138
  VALUE obj = args[0];
4870
4914
  arg1 = (svn_fs_txn_t *)(argp1);
4871
4915
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_apr_array_header_t, 0 |  0 );
4872
4916
  if (!SWIG_IsOK(res2)) {
4873
 
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "apr_array_header_t *","svn_fs_change_txn_props", 2, argv[1] )); 
 
4917
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "apr_array_header_t const *","svn_fs_change_txn_props", 2, argv[1] )); 
4874
4918
  }
4875
4919
  arg2 = (apr_array_header_t *)(argp2);
4876
4920
  if (argc > 2) {
4877
4921
    
4878
4922
  }
4879
4923
  {
4880
 
    result = (svn_error_t *)svn_fs_change_txn_props(arg1,arg2,arg3);
 
4924
    result = (svn_error_t *)svn_fs_change_txn_props(arg1,(apr_array_header_t const *)arg2,arg3);
4881
4925
    
4882
4926
    
4883
4927
    
5259
5303
}
5260
5304
 
5261
5305
 
5262
 
swig_class cSvn_fs_path_change2_t;
 
5306
swig_class SwigClassSvn_fs_path_change2_t;
5263
5307
 
5264
5308
SWIGINTERN VALUE
5265
5309
_wrap_svn_fs_path_change2_t_node_rev_id_set(int argc, VALUE *argv, VALUE self) {
5680
5724
}
5681
5725
 
5682
5726
 
5683
 
swig_class cSvn_fs_path_change_t;
 
5727
swig_class SwigClassSvn_fs_path_change_t;
5684
5728
 
5685
5729
SWIGINTERN VALUE
5686
5730
_wrap_svn_fs_path_change_t_node_rev_id_set(int argc, VALUE *argv, VALUE self) {
5990
6034
  }
5991
6035
  {
5992
6036
    vresult = SWIG_Ruby_AppendOutput(vresult, svn_swig_rb_apr_hash_to_hash_swig_type(*arg1,
5993
 
        "svn_fs_path_change2_t *"));
 
6037
        "svn_fs_path_change2_t *"))
 
6038
    
 
6039
    ;
5994
6040
  }
5995
6041
  {
5996
6042
    VALUE target;
6058
6104
  }
6059
6105
  {
6060
6106
    vresult = SWIG_Ruby_AppendOutput(vresult, svn_swig_rb_apr_hash_to_hash_swig_type(*arg1,
6061
 
        "svn_fs_path_change_t *"));
 
6107
        "svn_fs_path_change_t *"))
 
6108
    
 
6109
    ;
6062
6110
  }
6063
6111
  {
6064
6112
    VALUE target;
7609
7657
}
7610
7658
 
7611
7659
 
7612
 
swig_class cSvn_fs_dirent_t;
 
7660
swig_class SwigClassSvn_fs_dirent_t;
7613
7661
 
7614
7662
SWIGINTERN VALUE
7615
7663
_wrap_svn_fs_dirent_t_name_set(int argc, VALUE *argv, VALUE self) {
7841
7889
  }
7842
7890
  {
7843
7891
    vresult = SWIG_Ruby_AppendOutput(vresult, svn_swig_rb_apr_hash_to_hash_swig_type(*arg1,
7844
 
        "svn_fs_dirent_t *"));
 
7892
        "svn_fs_dirent_t *"))
 
7893
    
 
7894
    ;
7845
7895
  }
7846
7896
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7847
7897
  {
9197
9247
 
9198
9248
 
9199
9249
SWIGINTERN VALUE
 
9250
_wrap_svn_fs_change_rev_prop2(int argc, VALUE *argv, VALUE self) {
 
9251
  svn_fs_t *arg1 = (svn_fs_t *) 0 ;
 
9252
  svn_revnum_t arg2 ;
 
9253
  char *arg3 = (char *) 0 ;
 
9254
  svn_string_t **arg4 = (svn_string_t **) 0 ;
 
9255
  svn_string_t *arg5 = (svn_string_t *) 0 ;
 
9256
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
9257
  VALUE _global_svn_swig_rb_pool ;
 
9258
  apr_pool_t *_global_pool ;
 
9259
  void *argp1 = 0 ;
 
9260
  int res1 = 0 ;
 
9261
  long val2 ;
 
9262
  int ecode2 = 0 ;
 
9263
  int res3 ;
 
9264
  char *buf3 = 0 ;
 
9265
  int alloc3 = 0 ;
 
9266
  void *argp4 = 0 ;
 
9267
  int res4 = 0 ;
 
9268
  svn_string_t value5 ;
 
9269
  svn_error_t *result = 0 ;
 
9270
  VALUE vresult = Qnil;
 
9271
  
 
9272
  {
 
9273
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
 
9274
    _global_pool = arg6;
 
9275
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
9276
  }
 
9277
  if ((argc < 5) || (argc > 6)) {
 
9278
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
 
9279
  }
 
9280
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_fs_t, 0 |  0 );
 
9281
  if (!SWIG_IsOK(res1)) {
 
9282
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_fs_t *","svn_fs_change_rev_prop2", 1, argv[0] )); 
 
9283
  }
 
9284
  arg1 = (svn_fs_t *)(argp1);
 
9285
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
 
9286
  if (!SWIG_IsOK(ecode2)) {
 
9287
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "svn_revnum_t","svn_fs_change_rev_prop2", 2, argv[1] ));
 
9288
  } 
 
9289
  arg2 = (svn_revnum_t)(val2);
 
9290
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
 
9291
  if (!SWIG_IsOK(res3)) {
 
9292
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_fs_change_rev_prop2", 3, argv[2] ));
 
9293
  }
 
9294
  arg3 = (char *)(buf3);
 
9295
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_p_svn_string_t, 0 |  0 );
 
9296
  if (!SWIG_IsOK(res4)) {
 
9297
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "svn_string_t const *const *","svn_fs_change_rev_prop2", 4, argv[3] )); 
 
9298
  }
 
9299
  arg4 = (svn_string_t **)(argp4);
 
9300
  {
 
9301
    if (NIL_P(argv[4])) {
 
9302
      arg5 = NULL;
 
9303
    } else {
 
9304
      value5.data = StringValuePtr(argv[4]);
 
9305
      value5.len = RSTRING_LEN(argv[4]);
 
9306
      arg5 = &value5;
 
9307
    }
 
9308
  }
 
9309
  if (argc > 5) {
 
9310
    
 
9311
  }
 
9312
  {
 
9313
    if (!arg1) {
 
9314
      svn_swig_rb_raise_svn_fs_already_close();
 
9315
    }
 
9316
  }
 
9317
  {
 
9318
    result = (svn_error_t *)svn_fs_change_rev_prop2(arg1,arg2,(char const *)arg3,(struct svn_string_t const *const *)arg4,(struct svn_string_t const *)arg5,arg6);
 
9319
    
 
9320
    
 
9321
    
 
9322
  }
 
9323
  {
 
9324
    if (result) {
 
9325
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
9326
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
9327
      svn_swig_rb_handle_svn_error(result);
 
9328
    }
 
9329
    vresult = Qnil;
 
9330
  }
 
9331
  {
 
9332
    if (*arg4) {
 
9333
      vresult = SWIG_Ruby_AppendOutput(vresult, rb_str_new((*arg4)->data, (*arg4)->len));
 
9334
    } else {
 
9335
      vresult = SWIG_Ruby_AppendOutput(vresult, Qnil);
 
9336
    }
 
9337
  }
 
9338
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
9339
  {
 
9340
    VALUE target;
 
9341
    target = _global_vresult_address == &vresult ? self : vresult;
 
9342
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
9343
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
9344
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
9345
  }
 
9346
  return vresult;
 
9347
fail:
 
9348
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
 
9349
  {
 
9350
    VALUE target;
 
9351
    target = _global_vresult_address == &vresult ? self : vresult;
 
9352
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
9353
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
9354
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
9355
  }
 
9356
  return Qnil;
 
9357
}
 
9358
 
 
9359
 
 
9360
SWIGINTERN VALUE
9200
9361
_wrap_svn_fs_change_rev_prop(int argc, VALUE *argv, VALUE self) {
9201
9362
  svn_fs_t *arg1 = (svn_fs_t *) 0 ;
9202
9363
  svn_revnum_t arg2 ;
9901
10062
 
9902
10063
 
9903
10064
SWIGINTERN VALUE
 
10065
_wrap_svn_fs_get_locks2(int argc, VALUE *argv, VALUE self) {
 
10066
  svn_fs_t *arg1 = (svn_fs_t *) 0 ;
 
10067
  char *arg2 = (char *) 0 ;
 
10068
  svn_depth_t arg3 ;
 
10069
  svn_fs_get_locks_callback_t arg4 = (svn_fs_get_locks_callback_t) 0 ;
 
10070
  void *arg5 = (void *) 0 ;
 
10071
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
10072
  VALUE _global_svn_swig_rb_pool ;
 
10073
  apr_pool_t *_global_pool ;
 
10074
  void *argp1 = 0 ;
 
10075
  int res1 = 0 ;
 
10076
  int res2 ;
 
10077
  char *buf2 = 0 ;
 
10078
  int alloc2 = 0 ;
 
10079
  svn_error_t *result = 0 ;
 
10080
  VALUE vresult = Qnil;
 
10081
  
 
10082
  {
 
10083
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
 
10084
    _global_pool = arg6;
 
10085
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 
10086
  }
 
10087
  if ((argc < 4) || (argc > 5)) {
 
10088
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
 
10089
  }
 
10090
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_fs_t, 0 |  0 );
 
10091
  if (!SWIG_IsOK(res1)) {
 
10092
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_fs_t *","svn_fs_get_locks2", 1, argv[0] )); 
 
10093
  }
 
10094
  arg1 = (svn_fs_t *)(argp1);
 
10095
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
 
10096
  if (!SWIG_IsOK(res2)) {
 
10097
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_fs_get_locks2", 2, argv[1] ));
 
10098
  }
 
10099
  arg2 = (char *)(buf2);
 
10100
  {
 
10101
    arg3 = svn_swig_rb_to_depth(argv[2]);
 
10102
  }
 
10103
  {
 
10104
    arg4 = svn_swig_rb_fs_get_locks_callback;
 
10105
    arg5 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
 
10106
  }
 
10107
  if (argc > 4) {
 
10108
    
 
10109
  }
 
10110
  {
 
10111
    if (!arg1) {
 
10112
      svn_swig_rb_raise_svn_fs_already_close();
 
10113
    }
 
10114
  }
 
10115
  {
 
10116
    result = (svn_error_t *)svn_fs_get_locks2(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
 
10117
    
 
10118
    
 
10119
    
 
10120
  }
 
10121
  {
 
10122
    if (result) {
 
10123
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10124
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10125
      svn_swig_rb_handle_svn_error(result);
 
10126
    }
 
10127
    vresult = Qnil;
 
10128
  }
 
10129
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
10130
  {
 
10131
    VALUE target;
 
10132
    target = _global_vresult_address == &vresult ? self : vresult;
 
10133
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10134
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10135
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10136
  }
 
10137
  return vresult;
 
10138
fail:
 
10139
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
10140
  {
 
10141
    VALUE target;
 
10142
    target = _global_vresult_address == &vresult ? self : vresult;
 
10143
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
 
10144
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
 
10145
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 
10146
  }
 
10147
  return Qnil;
 
10148
}
 
10149
 
 
10150
 
 
10151
SWIGINTERN VALUE
9904
10152
_wrap_svn_fs_get_locks(int argc, VALUE *argv, VALUE self) {
9905
10153
  svn_fs_t *arg1 = (svn_fs_t *) 0 ;
9906
10154
  char *arg2 = (char *) 0 ;
10378
10626
static swig_type_info _swigt__p_svn_diff_datasource_e = {"_p_svn_diff_datasource_e", "enum svn_diff_datasource_e *|svn_diff_datasource_e *", 0, 0, (void*)0, 0};
10379
10627
static swig_type_info _swigt__p_svn_diff_file_ignore_space_t = {"_p_svn_diff_file_ignore_space_t", "enum svn_diff_file_ignore_space_t *|svn_diff_file_ignore_space_t *", 0, 0, (void*)0, 0};
10380
10628
static swig_type_info _swigt__p_svn_diff_file_options_t = {"_p_svn_diff_file_options_t", "struct svn_diff_file_options_t *|svn_diff_file_options_t *", 0, 0, (void*)0, 0};
 
10629
static swig_type_info _swigt__p_svn_diff_fns2_t = {"_p_svn_diff_fns2_t", "struct svn_diff_fns2_t *|svn_diff_fns2_t *", 0, 0, (void*)0, 0};
10381
10630
static swig_type_info _swigt__p_svn_diff_fns_t = {"_p_svn_diff_fns_t", "struct svn_diff_fns_t *|svn_diff_fns_t *", 0, 0, (void*)0, 0};
 
10631
static swig_type_info _swigt__p_svn_diff_hunk_t = {"_p_svn_diff_hunk_t", "struct svn_diff_hunk_t *|svn_diff_hunk_t *", 0, 0, (void*)0, 0};
 
10632
static swig_type_info _swigt__p_svn_diff_operation_kind_e = {"_p_svn_diff_operation_kind_e", "svn_diff_operation_kind_t *|enum svn_diff_operation_kind_e *", 0, 0, (void*)0, 0};
10382
10633
static swig_type_info _swigt__p_svn_diff_output_fns_t = {"_p_svn_diff_output_fns_t", "struct svn_diff_output_fns_t *|svn_diff_output_fns_t *", 0, 0, (void*)0, 0};
10383
10634
static swig_type_info _swigt__p_svn_diff_t = {"_p_svn_diff_t", "struct svn_diff_t *|svn_diff_t *", 0, 0, (void*)0, 0};
10384
10635
static swig_type_info _swigt__p_svn_dirent_t = {"_p_svn_dirent_t", "struct svn_dirent_t *|svn_dirent_t *", 0, 0, (void*)0, 0};
10395
10646
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};
10396
10647
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};
10397
10648
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};
 
10649
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};
10398
10650
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};
10399
10651
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};
10400
10652
static swig_type_info _swigt__p_svn_location_segment_t = {"_p_svn_location_segment_t", "struct svn_location_segment_t *|svn_location_segment_t *", 0, 0, (void*)0, 0};
10410
10662
static swig_type_info _swigt__p_svn_opt_revision_value_t = {"_p_svn_opt_revision_value_t", "union svn_opt_revision_value_t *|svn_opt_revision_value_t *", 0, 0, (void*)0, 0};
10411
10663
static swig_type_info _swigt__p_svn_opt_subcommand_desc2_t = {"_p_svn_opt_subcommand_desc2_t", "struct svn_opt_subcommand_desc2_t *|svn_opt_subcommand_desc2_t *", 0, 0, (void*)0, 0};
10412
10664
static swig_type_info _swigt__p_svn_opt_subcommand_desc_t = {"_p_svn_opt_subcommand_desc_t", "struct svn_opt_subcommand_desc_t *|svn_opt_subcommand_desc_t *", 0, 0, (void*)0, 0};
 
10665
static swig_type_info _swigt__p_svn_patch_file_t = {"_p_svn_patch_file_t", "struct svn_patch_file_t *|svn_patch_file_t *", 0, 0, (void*)0, 0};
 
10666
static swig_type_info _swigt__p_svn_patch_t = {"_p_svn_patch_t", "struct svn_patch_t *|svn_patch_t *", 0, 0, (void*)0, 0};
10413
10667
static swig_type_info _swigt__p_svn_prop_kind = {"_p_svn_prop_kind", "svn_prop_kind_t *|enum svn_prop_kind *", 0, 0, (void*)0, 0};
 
10668
static swig_type_info _swigt__p_svn_prop_patch_t = {"_p_svn_prop_patch_t", "struct svn_prop_patch_t *|svn_prop_patch_t *", 0, 0, (void*)0, 0};
 
10669
static swig_type_info _swigt__p_svn_stream_mark_t = {"_p_svn_stream_mark_t", "struct svn_stream_mark_t *|svn_stream_mark_t *", 0, 0, (void*)0, 0};
10414
10670
static swig_type_info _swigt__p_svn_stream_t = {"_p_svn_stream_t", "struct svn_stream_t *|svn_stream_t *", 0, 0, (void*)0, 0};
10415
10671
static swig_type_info _swigt__p_svn_string_t = {"_p_svn_string_t", "struct svn_string_t *|svn_string_t *", 0, 0, (void*)0, 0};
10416
10672
static swig_type_info _swigt__p_svn_stringbuf_t = {"_p_svn_stringbuf_t", "struct svn_stringbuf_t *|svn_stringbuf_t *", 0, 0, (void*)0, 0};
 
10673
static swig_type_info _swigt__p_svn_tristate_t = {"_p_svn_tristate_t", "enum svn_tristate_t *|svn_tristate_t *", 0, 0, (void*)0, 0};
10417
10674
static swig_type_info _swigt__p_svn_txdelta_op_t = {"_p_svn_txdelta_op_t", "struct svn_txdelta_op_t *|svn_txdelta_op_t *", 0, 0, (void*)0, 0};
10418
10675
static swig_type_info _swigt__p_svn_txdelta_stream_t = {"_p_svn_txdelta_stream_t", "struct svn_txdelta_stream_t *|svn_txdelta_stream_t *", 0, 0, (void*)0, 0};
10419
10676
static swig_type_info _swigt__p_svn_txdelta_window_t = {"_p_svn_txdelta_window_t", "struct svn_txdelta_window_t *|svn_txdelta_window_t *", 0, 0, (void*)0, 0};
10420
10677
static swig_type_info _swigt__p_svn_version_checklist_t = {"_p_svn_version_checklist_t", "struct svn_version_checklist_t *|svn_version_checklist_t *", 0, 0, (void*)0, 0};
10421
10678
static swig_type_info _swigt__p_svn_version_t = {"_p_svn_version_t", "struct svn_version_t *|svn_version_t *", 0, 0, (void*)0, 0};
10422
10679
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0};
 
10680
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|svn_linenum_t *", 0, 0, (void*)0, 0};
10423
10681
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
10424
10682
 
10425
10683
static swig_type_info *swig_type_initial[] = {
10472
10730
  &_swigt__p_svn_diff_datasource_e,
10473
10731
  &_swigt__p_svn_diff_file_ignore_space_t,
10474
10732
  &_swigt__p_svn_diff_file_options_t,
 
10733
  &_swigt__p_svn_diff_fns2_t,
10475
10734
  &_swigt__p_svn_diff_fns_t,
 
10735
  &_swigt__p_svn_diff_hunk_t,
 
10736
  &_swigt__p_svn_diff_operation_kind_e,
10476
10737
  &_swigt__p_svn_diff_output_fns_t,
10477
10738
  &_swigt__p_svn_diff_t,
10478
10739
  &_swigt__p_svn_dirent_t,
10489
10750
  &_swigt__p_svn_fs_root_t,
10490
10751
  &_swigt__p_svn_fs_t,
10491
10752
  &_swigt__p_svn_fs_txn_t,
 
10753
  &_swigt__p_svn_io_dirent2_t,
10492
10754
  &_swigt__p_svn_io_dirent_t,
10493
10755
  &_swigt__p_svn_io_file_del_t,
10494
10756
  &_swigt__p_svn_location_segment_t,
10504
10766
  &_swigt__p_svn_opt_revision_value_t,
10505
10767
  &_swigt__p_svn_opt_subcommand_desc2_t,
10506
10768
  &_swigt__p_svn_opt_subcommand_desc_t,
 
10769
  &_swigt__p_svn_patch_file_t,
 
10770
  &_swigt__p_svn_patch_t,
10507
10771
  &_swigt__p_svn_prop_kind,
 
10772
  &_swigt__p_svn_prop_patch_t,
 
10773
  &_swigt__p_svn_stream_mark_t,
10508
10774
  &_swigt__p_svn_stream_t,
10509
10775
  &_swigt__p_svn_string_t,
10510
10776
  &_swigt__p_svn_stringbuf_t,
 
10777
  &_swigt__p_svn_tristate_t,
10511
10778
  &_swigt__p_svn_txdelta_op_t,
10512
10779
  &_swigt__p_svn_txdelta_stream_t,
10513
10780
  &_swigt__p_svn_txdelta_window_t,
10514
10781
  &_swigt__p_svn_version_checklist_t,
10515
10782
  &_swigt__p_svn_version_t,
10516
10783
  &_swigt__p_unsigned_char,
 
10784
  &_swigt__p_unsigned_long,
10517
10785
  &_swigt__p_void,
10518
10786
};
10519
10787
 
10566
10834
static swig_cast_info _swigc__p_svn_diff_datasource_e[] = {  {&_swigt__p_svn_diff_datasource_e, 0, 0, 0},{0, 0, 0, 0}};
10567
10835
static swig_cast_info _swigc__p_svn_diff_file_ignore_space_t[] = {  {&_swigt__p_svn_diff_file_ignore_space_t, 0, 0, 0},{0, 0, 0, 0}};
10568
10836
static swig_cast_info _swigc__p_svn_diff_file_options_t[] = {  {&_swigt__p_svn_diff_file_options_t, 0, 0, 0},{0, 0, 0, 0}};
 
10837
static swig_cast_info _swigc__p_svn_diff_fns2_t[] = {  {&_swigt__p_svn_diff_fns2_t, 0, 0, 0},{0, 0, 0, 0}};
10569
10838
static swig_cast_info _swigc__p_svn_diff_fns_t[] = {  {&_swigt__p_svn_diff_fns_t, 0, 0, 0},{0, 0, 0, 0}};
 
10839
static swig_cast_info _swigc__p_svn_diff_hunk_t[] = {  {&_swigt__p_svn_diff_hunk_t, 0, 0, 0},{0, 0, 0, 0}};
 
10840
static swig_cast_info _swigc__p_svn_diff_operation_kind_e[] = {  {&_swigt__p_svn_diff_operation_kind_e, 0, 0, 0},{0, 0, 0, 0}};
10570
10841
static swig_cast_info _swigc__p_svn_diff_output_fns_t[] = {  {&_swigt__p_svn_diff_output_fns_t, 0, 0, 0},{0, 0, 0, 0}};
10571
10842
static swig_cast_info _swigc__p_svn_diff_t[] = {  {&_swigt__p_svn_diff_t, 0, 0, 0},{0, 0, 0, 0}};
10572
10843
static swig_cast_info _swigc__p_svn_dirent_t[] = {  {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
10583
10854
static swig_cast_info _swigc__p_svn_fs_root_t[] = {  {&_swigt__p_svn_fs_root_t, 0, 0, 0},{0, 0, 0, 0}};
10584
10855
static swig_cast_info _swigc__p_svn_fs_t[] = {  {&_swigt__p_svn_fs_t, 0, 0, 0},{0, 0, 0, 0}};
10585
10856
static swig_cast_info _swigc__p_svn_fs_txn_t[] = {  {&_swigt__p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
 
10857
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
10586
10858
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
10587
10859
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}};
10588
10860
static swig_cast_info _swigc__p_svn_location_segment_t[] = {  {&_swigt__p_svn_location_segment_t, 0, 0, 0},{0, 0, 0, 0}};
10598
10870
static swig_cast_info _swigc__p_svn_opt_revision_value_t[] = {  {&_swigt__p_svn_opt_revision_value_t, 0, 0, 0},{0, 0, 0, 0}};
10599
10871
static swig_cast_info _swigc__p_svn_opt_subcommand_desc2_t[] = {  {&_swigt__p_svn_opt_subcommand_desc2_t, 0, 0, 0},{0, 0, 0, 0}};
10600
10872
static swig_cast_info _swigc__p_svn_opt_subcommand_desc_t[] = {  {&_swigt__p_svn_opt_subcommand_desc_t, 0, 0, 0},{0, 0, 0, 0}};
 
10873
static swig_cast_info _swigc__p_svn_patch_file_t[] = {  {&_swigt__p_svn_patch_file_t, 0, 0, 0},{0, 0, 0, 0}};
 
10874
static swig_cast_info _swigc__p_svn_patch_t[] = {  {&_swigt__p_svn_patch_t, 0, 0, 0},{0, 0, 0, 0}};
10601
10875
static swig_cast_info _swigc__p_svn_prop_kind[] = {  {&_swigt__p_svn_prop_kind, 0, 0, 0},{0, 0, 0, 0}};
 
10876
static swig_cast_info _swigc__p_svn_prop_patch_t[] = {  {&_swigt__p_svn_prop_patch_t, 0, 0, 0},{0, 0, 0, 0}};
 
10877
static swig_cast_info _swigc__p_svn_stream_mark_t[] = {  {&_swigt__p_svn_stream_mark_t, 0, 0, 0},{0, 0, 0, 0}};
10602
10878
static swig_cast_info _swigc__p_svn_stream_t[] = {  {&_swigt__p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
10603
10879
static swig_cast_info _swigc__p_svn_string_t[] = {  {&_swigt__p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
10604
10880
static swig_cast_info _swigc__p_svn_stringbuf_t[] = {  {&_swigt__p_svn_stringbuf_t, 0, 0, 0},{0, 0, 0, 0}};
 
10881
static swig_cast_info _swigc__p_svn_tristate_t[] = {  {&_swigt__p_svn_tristate_t, 0, 0, 0},{0, 0, 0, 0}};
10605
10882
static swig_cast_info _swigc__p_svn_txdelta_op_t[] = {  {&_swigt__p_svn_txdelta_op_t, 0, 0, 0},{0, 0, 0, 0}};
10606
10883
static swig_cast_info _swigc__p_svn_txdelta_stream_t[] = {  {&_swigt__p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
10607
10884
static swig_cast_info _swigc__p_svn_txdelta_window_t[] = {  {&_swigt__p_svn_txdelta_window_t, 0, 0, 0},{0, 0, 0, 0}};
10608
10885
static swig_cast_info _swigc__p_svn_version_checklist_t[] = {  {&_swigt__p_svn_version_checklist_t, 0, 0, 0},{0, 0, 0, 0}};
10609
10886
static swig_cast_info _swigc__p_svn_version_t[] = {  {&_swigt__p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
10610
10887
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
 
10888
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
10611
10889
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
10612
10890
 
10613
10891
static swig_cast_info *swig_cast_initial[] = {
10660
10938
  _swigc__p_svn_diff_datasource_e,
10661
10939
  _swigc__p_svn_diff_file_ignore_space_t,
10662
10940
  _swigc__p_svn_diff_file_options_t,
 
10941
  _swigc__p_svn_diff_fns2_t,
10663
10942
  _swigc__p_svn_diff_fns_t,
 
10943
  _swigc__p_svn_diff_hunk_t,
 
10944
  _swigc__p_svn_diff_operation_kind_e,
10664
10945
  _swigc__p_svn_diff_output_fns_t,
10665
10946
  _swigc__p_svn_diff_t,
10666
10947
  _swigc__p_svn_dirent_t,
10677
10958
  _swigc__p_svn_fs_root_t,
10678
10959
  _swigc__p_svn_fs_t,
10679
10960
  _swigc__p_svn_fs_txn_t,
 
10961
  _swigc__p_svn_io_dirent2_t,
10680
10962
  _swigc__p_svn_io_dirent_t,
10681
10963
  _swigc__p_svn_io_file_del_t,
10682
10964
  _swigc__p_svn_location_segment_t,
10692
10974
  _swigc__p_svn_opt_revision_value_t,
10693
10975
  _swigc__p_svn_opt_subcommand_desc2_t,
10694
10976
  _swigc__p_svn_opt_subcommand_desc_t,
 
10977
  _swigc__p_svn_patch_file_t,
 
10978
  _swigc__p_svn_patch_t,
10695
10979
  _swigc__p_svn_prop_kind,
 
10980
  _swigc__p_svn_prop_patch_t,
 
10981
  _swigc__p_svn_stream_mark_t,
10696
10982
  _swigc__p_svn_stream_t,
10697
10983
  _swigc__p_svn_string_t,
10698
10984
  _swigc__p_svn_stringbuf_t,
 
10985
  _swigc__p_svn_tristate_t,
10699
10986
  _swigc__p_svn_txdelta_op_t,
10700
10987
  _swigc__p_svn_txdelta_stream_t,
10701
10988
  _swigc__p_svn_txdelta_window_t,
10702
10989
  _swigc__p_svn_version_checklist_t,
10703
10990
  _swigc__p_svn_version_t,
10704
10991
  _swigc__p_unsigned_char,
 
10992
  _swigc__p_unsigned_long,
10705
10993
  _swigc__p_void,
10706
10994
};
10707
10995
 
10972
11260
  rb_define_module_function(mFs, "svn_fs_version", _wrap_svn_fs_version, -1);
10973
11261
  rb_define_const(mFs, "SVN_FS_CONFIG_BDB_TXN_NOSYNC", SWIG_FromCharPtr("bdb-txn-nosync"));
10974
11262
  rb_define_const(mFs, "SVN_FS_CONFIG_BDB_LOG_AUTOREMOVE", SWIG_FromCharPtr("bdb-log-autoremove"));
 
11263
  rb_define_const(mFs, "SVN_FS_CONFIG_FSFS_CACHE_DELTAS", SWIG_FromCharPtr("fsfs-cache-deltas"));
 
11264
  rb_define_const(mFs, "SVN_FS_CONFIG_FSFS_CACHE_FULLTEXTS", SWIG_FromCharPtr("fsfs-cache-fulltexts"));
10975
11265
  rb_define_const(mFs, "SVN_FS_CONFIG_FS_TYPE", SWIG_FromCharPtr("fs-type"));
10976
11266
  rb_define_const(mFs, "SVN_FS_TYPE_BDB", SWIG_FromCharPtr("bdb"));
10977
11267
  rb_define_const(mFs, "SVN_FS_TYPE_FSFS", SWIG_FromCharPtr("fsfs"));
11034
11324
  rb_define_const(mFs, "Svn_fs_path_change_replace", SWIG_From_int((int)(svn_fs_path_change_replace)));
11035
11325
  rb_define_const(mFs, "Svn_fs_path_change_reset", SWIG_From_int((int)(svn_fs_path_change_reset)));
11036
11326
  
11037
 
  cSvn_fs_path_change2_t.klass = rb_define_class_under(mFs, "Svn_fs_path_change2_t", rb_cObject);
11038
 
  SWIG_TypeClientData(SWIGTYPE_p_svn_fs_path_change2_t, (void *) &cSvn_fs_path_change2_t);
11039
 
  rb_undef_alloc_func(cSvn_fs_path_change2_t.klass);
11040
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "node_rev_id=", _wrap_svn_fs_path_change2_t_node_rev_id_set, -1);
11041
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "node_rev_id", _wrap_svn_fs_path_change2_t_node_rev_id_get, -1);
11042
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "change_kind=", _wrap_svn_fs_path_change2_t_change_kind_set, -1);
11043
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "change_kind", _wrap_svn_fs_path_change2_t_change_kind_get, -1);
11044
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "text_mod=", _wrap_svn_fs_path_change2_t_text_mod_set, -1);
11045
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "text_mod", _wrap_svn_fs_path_change2_t_text_mod_get, -1);
11046
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "prop_mod=", _wrap_svn_fs_path_change2_t_prop_mod_set, -1);
11047
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "prop_mod", _wrap_svn_fs_path_change2_t_prop_mod_get, -1);
11048
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "node_kind=", _wrap_svn_fs_path_change2_t_node_kind_set, -1);
11049
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "node_kind", _wrap_svn_fs_path_change2_t_node_kind_get, -1);
11050
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "copyfrom_known=", _wrap_svn_fs_path_change2_t_copyfrom_known_set, -1);
11051
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "copyfrom_known", _wrap_svn_fs_path_change2_t_copyfrom_known_get, -1);
11052
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "copyfrom_rev=", _wrap_svn_fs_path_change2_t_copyfrom_rev_set, -1);
11053
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "copyfrom_rev", _wrap_svn_fs_path_change2_t_copyfrom_rev_get, -1);
11054
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "copyfrom_path=", _wrap_svn_fs_path_change2_t_copyfrom_path_set, -1);
11055
 
  rb_define_method(cSvn_fs_path_change2_t.klass, "copyfrom_path", _wrap_svn_fs_path_change2_t_copyfrom_path_get, -1);
11056
 
  cSvn_fs_path_change2_t.mark = 0;
11057
 
  cSvn_fs_path_change2_t.trackObjects = 0;
 
11327
  SwigClassSvn_fs_path_change2_t.klass = rb_define_class_under(mFs, "Svn_fs_path_change2_t", rb_cObject);
 
11328
  SWIG_TypeClientData(SWIGTYPE_p_svn_fs_path_change2_t, (void *) &SwigClassSvn_fs_path_change2_t);
 
11329
  rb_undef_alloc_func(SwigClassSvn_fs_path_change2_t.klass);
 
11330
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "node_rev_id=", _wrap_svn_fs_path_change2_t_node_rev_id_set, -1);
 
11331
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "node_rev_id", _wrap_svn_fs_path_change2_t_node_rev_id_get, -1);
 
11332
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "change_kind=", _wrap_svn_fs_path_change2_t_change_kind_set, -1);
 
11333
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "change_kind", _wrap_svn_fs_path_change2_t_change_kind_get, -1);
 
11334
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "text_mod=", _wrap_svn_fs_path_change2_t_text_mod_set, -1);
 
11335
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "text_mod", _wrap_svn_fs_path_change2_t_text_mod_get, -1);
 
11336
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "prop_mod=", _wrap_svn_fs_path_change2_t_prop_mod_set, -1);
 
11337
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "prop_mod", _wrap_svn_fs_path_change2_t_prop_mod_get, -1);
 
11338
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "node_kind=", _wrap_svn_fs_path_change2_t_node_kind_set, -1);
 
11339
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "node_kind", _wrap_svn_fs_path_change2_t_node_kind_get, -1);
 
11340
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "copyfrom_known=", _wrap_svn_fs_path_change2_t_copyfrom_known_set, -1);
 
11341
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "copyfrom_known", _wrap_svn_fs_path_change2_t_copyfrom_known_get, -1);
 
11342
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "copyfrom_rev=", _wrap_svn_fs_path_change2_t_copyfrom_rev_set, -1);
 
11343
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "copyfrom_rev", _wrap_svn_fs_path_change2_t_copyfrom_rev_get, -1);
 
11344
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "copyfrom_path=", _wrap_svn_fs_path_change2_t_copyfrom_path_set, -1);
 
11345
  rb_define_method(SwigClassSvn_fs_path_change2_t.klass, "copyfrom_path", _wrap_svn_fs_path_change2_t_copyfrom_path_get, -1);
 
11346
  SwigClassSvn_fs_path_change2_t.mark = 0;
 
11347
  SwigClassSvn_fs_path_change2_t.trackObjects = 0;
11058
11348
  
11059
 
  cSvn_fs_path_change_t.klass = rb_define_class_under(mFs, "Svn_fs_path_change_t", rb_cObject);
11060
 
  SWIG_TypeClientData(SWIGTYPE_p_svn_fs_path_change_t, (void *) &cSvn_fs_path_change_t);
11061
 
  rb_undef_alloc_func(cSvn_fs_path_change_t.klass);
11062
 
  rb_define_method(cSvn_fs_path_change_t.klass, "node_rev_id=", _wrap_svn_fs_path_change_t_node_rev_id_set, -1);
11063
 
  rb_define_method(cSvn_fs_path_change_t.klass, "node_rev_id", _wrap_svn_fs_path_change_t_node_rev_id_get, -1);
11064
 
  rb_define_method(cSvn_fs_path_change_t.klass, "change_kind=", _wrap_svn_fs_path_change_t_change_kind_set, -1);
11065
 
  rb_define_method(cSvn_fs_path_change_t.klass, "change_kind", _wrap_svn_fs_path_change_t_change_kind_get, -1);
11066
 
  rb_define_method(cSvn_fs_path_change_t.klass, "text_mod=", _wrap_svn_fs_path_change_t_text_mod_set, -1);
11067
 
  rb_define_method(cSvn_fs_path_change_t.klass, "text_mod", _wrap_svn_fs_path_change_t_text_mod_get, -1);
11068
 
  rb_define_method(cSvn_fs_path_change_t.klass, "prop_mod=", _wrap_svn_fs_path_change_t_prop_mod_set, -1);
11069
 
  rb_define_method(cSvn_fs_path_change_t.klass, "prop_mod", _wrap_svn_fs_path_change_t_prop_mod_get, -1);
11070
 
  cSvn_fs_path_change_t.mark = 0;
11071
 
  cSvn_fs_path_change_t.trackObjects = 0;
 
11349
  SwigClassSvn_fs_path_change_t.klass = rb_define_class_under(mFs, "Svn_fs_path_change_t", rb_cObject);
 
11350
  SWIG_TypeClientData(SWIGTYPE_p_svn_fs_path_change_t, (void *) &SwigClassSvn_fs_path_change_t);
 
11351
  rb_undef_alloc_func(SwigClassSvn_fs_path_change_t.klass);
 
11352
  rb_define_method(SwigClassSvn_fs_path_change_t.klass, "node_rev_id=", _wrap_svn_fs_path_change_t_node_rev_id_set, -1);
 
11353
  rb_define_method(SwigClassSvn_fs_path_change_t.klass, "node_rev_id", _wrap_svn_fs_path_change_t_node_rev_id_get, -1);
 
11354
  rb_define_method(SwigClassSvn_fs_path_change_t.klass, "change_kind=", _wrap_svn_fs_path_change_t_change_kind_set, -1);
 
11355
  rb_define_method(SwigClassSvn_fs_path_change_t.klass, "change_kind", _wrap_svn_fs_path_change_t_change_kind_get, -1);
 
11356
  rb_define_method(SwigClassSvn_fs_path_change_t.klass, "text_mod=", _wrap_svn_fs_path_change_t_text_mod_set, -1);
 
11357
  rb_define_method(SwigClassSvn_fs_path_change_t.klass, "text_mod", _wrap_svn_fs_path_change_t_text_mod_get, -1);
 
11358
  rb_define_method(SwigClassSvn_fs_path_change_t.klass, "prop_mod=", _wrap_svn_fs_path_change_t_prop_mod_set, -1);
 
11359
  rb_define_method(SwigClassSvn_fs_path_change_t.klass, "prop_mod", _wrap_svn_fs_path_change_t_prop_mod_get, -1);
 
11360
  SwigClassSvn_fs_path_change_t.mark = 0;
 
11361
  SwigClassSvn_fs_path_change_t.trackObjects = 0;
11072
11362
  rb_define_module_function(mFs, "svn_fs_path_change2_create", _wrap_svn_fs_path_change2_create, -1);
11073
11363
  rb_define_module_function(mFs, "svn_fs_paths_changed2", _wrap_svn_fs_paths_changed2, -1);
11074
11364
  rb_define_module_function(mFs, "svn_fs_paths_changed", _wrap_svn_fs_paths_changed, -1);
11091
11381
  rb_define_module_function(mFs, "svn_fs_get_mergeinfo", _wrap_svn_fs_get_mergeinfo, -1);
11092
11382
  rb_define_module_function(mFs, "svn_fs_merge", _wrap_svn_fs_merge, -1);
11093
11383
  
11094
 
  cSvn_fs_dirent_t.klass = rb_define_class_under(mFs, "Svn_fs_dirent_t", rb_cObject);
11095
 
  SWIG_TypeClientData(SWIGTYPE_p_svn_fs_dirent_t, (void *) &cSvn_fs_dirent_t);
11096
 
  rb_undef_alloc_func(cSvn_fs_dirent_t.klass);
11097
 
  rb_define_method(cSvn_fs_dirent_t.klass, "name=", _wrap_svn_fs_dirent_t_name_set, -1);
11098
 
  rb_define_method(cSvn_fs_dirent_t.klass, "name", _wrap_svn_fs_dirent_t_name_get, -1);
11099
 
  rb_define_method(cSvn_fs_dirent_t.klass, "id=", _wrap_svn_fs_dirent_t_id_set, -1);
11100
 
  rb_define_method(cSvn_fs_dirent_t.klass, "id", _wrap_svn_fs_dirent_t_id_get, -1);
11101
 
  rb_define_method(cSvn_fs_dirent_t.klass, "kind=", _wrap_svn_fs_dirent_t_kind_set, -1);
11102
 
  rb_define_method(cSvn_fs_dirent_t.klass, "kind", _wrap_svn_fs_dirent_t_kind_get, -1);
11103
 
  cSvn_fs_dirent_t.mark = 0;
11104
 
  cSvn_fs_dirent_t.trackObjects = 0;
 
11384
  SwigClassSvn_fs_dirent_t.klass = rb_define_class_under(mFs, "Svn_fs_dirent_t", rb_cObject);
 
11385
  SWIG_TypeClientData(SWIGTYPE_p_svn_fs_dirent_t, (void *) &SwigClassSvn_fs_dirent_t);
 
11386
  rb_undef_alloc_func(SwigClassSvn_fs_dirent_t.klass);
 
11387
  rb_define_method(SwigClassSvn_fs_dirent_t.klass, "name=", _wrap_svn_fs_dirent_t_name_set, -1);
 
11388
  rb_define_method(SwigClassSvn_fs_dirent_t.klass, "name", _wrap_svn_fs_dirent_t_name_get, -1);
 
11389
  rb_define_method(SwigClassSvn_fs_dirent_t.klass, "id=", _wrap_svn_fs_dirent_t_id_set, -1);
 
11390
  rb_define_method(SwigClassSvn_fs_dirent_t.klass, "id", _wrap_svn_fs_dirent_t_id_get, -1);
 
11391
  rb_define_method(SwigClassSvn_fs_dirent_t.klass, "kind=", _wrap_svn_fs_dirent_t_kind_set, -1);
 
11392
  rb_define_method(SwigClassSvn_fs_dirent_t.klass, "kind", _wrap_svn_fs_dirent_t_kind_get, -1);
 
11393
  SwigClassSvn_fs_dirent_t.mark = 0;
 
11394
  SwigClassSvn_fs_dirent_t.trackObjects = 0;
11105
11395
  rb_define_module_function(mFs, "svn_fs_dir_entries", _wrap_svn_fs_dir_entries, -1);
11106
11396
  rb_define_module_function(mFs, "svn_fs_make_dir", _wrap_svn_fs_make_dir, -1);
11107
11397
  rb_define_module_function(mFs, "svn_fs_delete", _wrap_svn_fs_delete, -1);
11119
11409
  rb_define_module_function(mFs, "svn_fs_deltify_revision", _wrap_svn_fs_deltify_revision, -1);
11120
11410
  rb_define_module_function(mFs, "svn_fs_revision_prop", _wrap_svn_fs_revision_prop, -1);
11121
11411
  rb_define_module_function(mFs, "svn_fs_revision_proplist", _wrap_svn_fs_revision_proplist, -1);
 
11412
  rb_define_module_function(mFs, "svn_fs_change_rev_prop2", _wrap_svn_fs_change_rev_prop2, -1);
11122
11413
  rb_define_module_function(mFs, "svn_fs_change_rev_prop", _wrap_svn_fs_change_rev_prop, -1);
11123
11414
  rb_define_module_function(mFs, "svn_fs_get_file_delta_stream", _wrap_svn_fs_get_file_delta_stream, -1);
11124
11415
  rb_define_module_function(mFs, "svn_fs_get_uuid", _wrap_svn_fs_get_uuid, -1);
11127
11418
  rb_define_module_function(mFs, "svn_fs_generate_lock_token", _wrap_svn_fs_generate_lock_token, -1);
11128
11419
  rb_define_module_function(mFs, "svn_fs_unlock", _wrap_svn_fs_unlock, -1);
11129
11420
  rb_define_module_function(mFs, "svn_fs_get_lock", _wrap_svn_fs_get_lock, -1);
 
11421
  rb_define_module_function(mFs, "svn_fs_get_locks2", _wrap_svn_fs_get_locks2, -1);
11130
11422
  rb_define_module_function(mFs, "svn_fs_get_locks", _wrap_svn_fs_get_locks, -1);
11131
11423
  rb_define_module_function(mFs, "svn_fs_print_modules", _wrap_svn_fs_print_modules, -1);
11132
11424
  rb_define_const(mFs, "Svn_fs_pack_notify_start", SWIG_From_int((int)(svn_fs_pack_notify_start)));
11133
11425
  rb_define_const(mFs, "Svn_fs_pack_notify_end", SWIG_From_int((int)(svn_fs_pack_notify_end)));
 
11426
  rb_define_const(mFs, "Svn_fs_pack_notify_start_revprop", SWIG_From_int((int)(svn_fs_pack_notify_start_revprop)));
 
11427
  rb_define_const(mFs, "Svn_fs_pack_notify_end_revprop", SWIG_From_int((int)(svn_fs_pack_notify_end_revprop)));
11134
11428
  rb_define_module_function(mFs, "svn_fs_pack", _wrap_svn_fs_pack, -1);
11135
11429
  rb_define_module_function(mFs, "svn_fs_invoke_warning_callback", _wrap_svn_fs_invoke_warning_callback, -1);
11136
11430
  rb_define_module_function(mFs, "svn_fs_invoke_get_locks_callback", _wrap_svn_fs_invoke_get_locks_callback, -1);