svn_fs.c

subversion-1.4.5.tar.gz 配置svn的源码

static VALUE _global_svn_swig_rb_pool = Qnil;


#include "svn_time.h"
#include "svn_pools.h"


#include "svn_md5.h"

#ifdef SWIGPYTHON
#include "swigutil_py.h"
#endif

#ifdef SWIGPERL
#include "swigutil_pl.h"
#endif

#ifdef SWIGRUBY
#include "swigutil_rb.h"
#endif


#include "svn_fs.h"


static VALUE output_helper(VALUE target, VALUE o) {
    if (NIL_P(target)) {
	target = o;
    } else {
	if (TYPE(target) != T_ARRAY) {
	    VALUE o2 = target;
	    target = rb_ary_new();
	    rb_ary_push(target, o2);
	}
	rb_ary_push(target, o);
    }
    return target;
}




static void
svn_fs_set_warning_func_wrapper(svn_fs_t *fs,
                                svn_fs_warning_callback_t warning,
                                void *warning_baton,
                                apr_pool_t *pool)
{
  svn_fs_set_warning_func(fs, warning, warning_baton);
}

static svn_fs_t *
svn_fs_root_fs_wrapper(svn_fs_root_t *root, apr_pool_t *pool)
{
  return svn_fs_root_fs(root);
}

static VALUE
_wrap_svn_fs_version(int argc, VALUE *argv, VALUE self) {
    svn_version_t *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        result = (svn_version_t *)svn_fs_version();
        
        
        
        
    }
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_svn_version_t,0);
    return vresult;
}


static VALUE
_wrap_svn_fs_initialize(int argc, VALUE *argv, VALUE self) {
    apr_pool_t *arg1 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg1);
        _global_pool = arg1;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    if ((argc < 0) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    if (argc > 0) {
        
    }
    {
        result = (svn_error_t *)svn_fs_initialize(arg1);
        
        
        
        
    }
    {
        if (result) {
            svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
            svn_swig_rb_handle_svn_error(result);
        }
        vresult = Qnil;
    }
    {
        svn_swig_rb_set_pool(vresult, _global_svn_swig_rb_pool);
        svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
    }
    return vresult;
}


static VALUE
_wrap_svn_fs_create(int argc, VALUE *argv, VALUE self) {
    svn_fs_t **arg1 = (svn_fs_t **) 0 ;
    char *arg2 = (char *) 0 ;
    apr_hash_t *arg3 = (apr_hash_t *) 0 ;
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    svn_fs_t *temp1 ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
        _global_pool = arg4;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    {
        temp1 = NULL;
        arg1 = (svn_fs_t **)&temp1;
    }
    if ((argc < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg2 = StringValuePtr(argv[0]);
    {
        arg3 = svn_swig_rb_hash_to_apr_hash_string(argv[1], _global_pool);
    }
    if (argc > 2) {
        
    }
    {
        result = (svn_error_t *)svn_fs_create(arg1,(char const *)arg2,arg3,arg4);
        
        
        
        
    }
    {
        if (result) {
            svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
            svn_swig_rb_handle_svn_error(result);
        }
        vresult = Qnil;
    }
    {
        vresult = output_helper(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_t, 0));
    }
    {
        svn_swig_rb_set_pool(vresult, _global_svn_swig_rb_pool);
        svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
    }
    return vresult;
}


static VALUE
_wrap_svn_fs_open(int argc, VALUE *argv, VALUE self) {
    svn_fs_t **arg1 = (svn_fs_t **) 0 ;
    char *arg2 = (char *) 0 ;
    apr_hash_t *arg3 = (apr_hash_t *) 0 ;
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    svn_fs_t *temp1 ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
        _global_pool = arg4;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    {
        temp1 = NULL;
        arg1 = (svn_fs_t **)&temp1;
    }
    if ((argc < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg2 = StringValuePtr(argv[0]);
    {
        if (NIL_P(argv[1])) {
            arg3 = NULL;
        } else {
            arg3 = svn_swig_rb_hash_to_apr_hash_swig_type(argv[1], "svn_config_t *", _global_pool);
        }
    }
    if (argc > 2) {
        
    }
    {
        result = (svn_error_t *)svn_fs_open(arg1,(char const *)arg2,arg3,arg4);
        
        
        
        
    }
    {
        if (result) {
            svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
            svn_swig_rb_handle_svn_error(result);
        }
        vresult = Qnil;
    }
    {
        vresult = output_helper(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_t, 0));
    }
    {
        svn_swig_rb_set_pool(vresult, _global_svn_swig_rb_pool);
        svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
    }
    return vresult;
}


static VALUE
_wrap_svn_fs_type(int argc, VALUE *argv, VALUE self) {
    char **arg1 = (char **) 0 ;
    char *arg2 = (char *) 0 ;
    apr_pool_t *arg3 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    char const *temp1 = NULL ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
        _global_pool = arg3;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    arg1 = (char **)&temp1;
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg2 = StringValuePtr(argv[0]);
    if (argc > 1) {
        
    }
    {
        result = (svn_error_t *)svn_fs_type((char const **)arg1,(char const *)arg2,arg3);
        
        
        
        
    }
    {
        if (result) {
            svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
            svn_swig_rb_handle_svn_error(result);
        }
        vresult = Qnil;
    }
    {
        if (*arg1) {
            vresult = output_helper(vresult, rb_str_new2(*arg1));
        } else {
            vresult = output_helper(vresult, Qnil);
        }
    }
    {
        svn_swig_rb_set_pool(vresult, _global_svn_swig_rb_pool);
        svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
    }
    return vresult;
}


static VALUE
_wrap_svn_fs_path(int argc, VALUE *argv, VALUE self) {
    svn_fs_t *arg1 = (svn_fs_t *) 0 ;
    apr_pool_t *arg2 = (apr_pool_t *) 0 ;
    char *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    void *temp1 ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
        _global_pool = arg2;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        SWIG_ConvertPtr(argv[0], &temp1, SWIGTYPE_p_svn_fs_t, 1);
        
        
        
        arg1 = (svn_fs_t *)temp1;
    }
    if (argc > 1) {
        
    }
    {
        result = (char *)svn_fs_path(arg1,arg2);
        
        
        
        
    }
    {
        if (result) {
            vresult = rb_str_new2(result);
        } else {
            vresult = Qnil;
        }
    }
    {
        svn_swig_rb_set_pool(vresult, _global_svn_swig_rb_pool);
        svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
    }
    return vresult;
}


static VALUE
_wrap_svn_fs_delete_fs(int argc, VALUE *argv, VALUE self) {
    char *arg1 = (char *) 0 ;
    apr_pool_t *arg2 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
        _global_pool = arg2;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = StringValuePtr(argv[0]);
    if (argc > 1) {
        
    }
    {
        result = (svn_error_t *)svn_fs_delete_fs((char const *)arg1,arg2);
        
        
        
        
    }
    {
        if (result) {
            svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
            svn_swig_rb_handle_svn_error(result);
        }
        vresult = Qnil;
    }
    {
        svn_swig_rb_set_pool(vresult, _global_svn_swig_rb_pool);
        svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
    }
    return vresult;
}


static VALUE
_wrap_svn_fs_hotcopy(int argc, VALUE *argv, VALUE self) {
    char *arg1 = (char *) 0 ;
    char *arg2 = (char *) 0 ;
    svn_boolean_t arg3 ;
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
        _global_pool = arg4;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    if ((argc < 3) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    arg1 = StringValuePtr(argv[0]);
    arg2 = StringValuePtr(argv[1]);
    arg3 = RTEST(argv[2]);
    if (argc > 3) {
        
    }
    {
        result = (svn_error_t *)svn_fs_hotcopy((char const *)arg1,(char const *)arg2,arg3,arg4);
        
        
        
        
    }
    {
        if (result) {
            svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
            svn_swig_rb_handle_svn_error(result);
        }
        vresult = Qnil;
    }
    {
        svn_swig_rb_set_pool(vresult, _global_svn_swig_rb_pool);
        svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
    }
    return vresult;
}


static VALUE
_wrap_svn_fs_berkeley_recover(int argc, VALUE *argv, VALUE self) {
    char *arg1 = (char *) 0 ;
    apr_pool_t *arg2 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
        _global_pool = arg2;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = StringValuePtr(argv[0]);
    if (argc > 1) {
        
    }
    {
        result = (svn_error_t *)svn_fs_berkeley_recover((char const *)arg1,arg2);
        
        
        
        
    }
    {
        if (result) {
            svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
            svn_swig_rb_handle_svn_error(result);
        }
        vresult = Qnil;
    }
    {
        svn_swig_rb_set_pool(vresult, _global_svn_swig_rb_pool);
        svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
    }
    return vresult;
}


static VALUE
_wrap_svn_fs_berkeley_logfiles(int argc, VALUE *argv, VALUE self) {
    apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
    char *arg2 = (char *) 0 ;
    svn_boolean_t arg3 ;
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    apr_array_header_t *temp1 ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
        _global_pool = arg4;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    {
        arg1 = &temp1;
    }
    if ((argc < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg2 = StringValuePtr(argv[0]);