svn_delta.c

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

    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    {
        SWIG_ConvertPtr(argv[0], &temp1, SWIGTYPE_p_svn_txdelta_window_t, 1);
        
        
        
        arg1 = (svn_txdelta_window_t *)temp1;
    }
    arg2 = StringValuePtr(argv[1]);
    arg3 = StringValuePtr(argv[2]);
    {
        svn_txdelta_apply_instructions(arg1,(char const *)arg2,arg3,arg4);
        
        
        
        
    }
    {
        VALUE o = UINT2NUM((unsigned long) (*arg4));
        vresult = output_helper(vresult, o);
    }
    return vresult;
}


static VALUE
_wrap_svn_txdelta_stream_create(int argc, VALUE *argv, VALUE self) {
    void *arg1 = (void *) 0 ;
    svn_txdelta_next_window_fn_t arg2 = (svn_txdelta_next_window_fn_t) 0 ;
    svn_txdelta_md5_digest_fn_t arg3 = (svn_txdelta_md5_digest_fn_t) 0 ;
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
    svn_txdelta_stream_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    void *temp2 ;
    void *temp3 ;
    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);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
    {
        SWIG_ConvertPtr(argv[1], &temp2, SWIGTYPE_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t, 1);
        
        
        
        arg2 = (svn_txdelta_next_window_fn_t)temp2;
    }
    {
        SWIG_ConvertPtr(argv[2], &temp3, SWIGTYPE_p_f_p_void__p_unsigned_char, 1);
        
        
        
        arg3 = (svn_txdelta_md5_digest_fn_t)temp3;
    }
    if (argc > 3) {
        
    }
    {
        result = (svn_txdelta_stream_t *)svn_txdelta_stream_create(arg1,arg2,(unsigned char const *(*)(void *))arg3,arg4);
        
        
        
        
    }
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_svn_txdelta_stream_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_txdelta_next_window(int argc, VALUE *argv, VALUE self) {
    svn_txdelta_window_t **arg1 = (svn_txdelta_window_t **) 0 ;
    svn_txdelta_stream_t *arg2 = (svn_txdelta_stream_t *) 0 ;
    apr_pool_t *arg3 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    svn_txdelta_window_t *temp1 ;
    void *temp2 ;
    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);
    }
    {
        temp1 = NULL;
        arg1 = (svn_txdelta_window_t **)&temp1;
    }
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        SWIG_ConvertPtr(argv[0], &temp2, SWIGTYPE_p_svn_txdelta_stream_t, 1);
        
        
        
        arg2 = (svn_txdelta_stream_t *)temp2;
    }
    if (argc > 1) {
        
    }
    {
        result = (svn_error_t *)svn_txdelta_next_window(arg1,arg2,arg3);
        
        
        
        
    }
    {
        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_txdelta_window_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_txdelta_md5_digest(int argc, VALUE *argv, VALUE self) {
    svn_txdelta_stream_t *arg1 = (svn_txdelta_stream_t *) 0 ;
    unsigned char *result;
    void *temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        SWIG_ConvertPtr(argv[0], &temp1, SWIGTYPE_p_svn_txdelta_stream_t, 1);
        
        
        
        arg1 = (svn_txdelta_stream_t *)temp1;
    }
    {
        result = (unsigned char *)svn_txdelta_md5_digest(arg1);
        
        
        
        
    }
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_unsigned_char,0);
    return vresult;
}


static VALUE
_wrap_svn_txdelta(int argc, VALUE *argv, VALUE self) {
    svn_txdelta_stream_t **arg1 = (svn_txdelta_stream_t **) 0 ;
    svn_stream_t *arg2 = (svn_stream_t *) 0 ;
    svn_stream_t *arg3 = (svn_stream_t *) 0 ;
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    svn_txdelta_stream_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_txdelta_stream_t **)&temp1;
    }
    if ((argc < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        arg2 = svn_swig_rb_make_stream(argv[0]);
    }
    {
        arg3 = svn_swig_rb_make_stream(argv[1]);
    }
    if (argc > 2) {
        
    }
    {
        svn_txdelta(arg1,arg2,arg3,arg4);
        
        
        
        
    }
    {
        vresult = output_helper(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_stream_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_txdelta_target_push(int argc, VALUE *argv, VALUE self) {
    svn_txdelta_window_handler_t arg1 = (svn_txdelta_window_handler_t) 0 ;
    void *arg2 = (void *) 0 ;
    svn_stream_t *arg3 = (svn_stream_t *) 0 ;
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
    svn_stream_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 < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        if (RTEST(rb_obj_is_kind_of(argv[0],
        svn_swig_rb_svn_delta_text_delta_window_handler()))) {
            arg1 = svn_swig_rb_to_swig_type(argv[0],
            "svn_txdelta_window_handler_t",
            _global_pool);
            arg2 = svn_swig_rb_to_swig_type(rb_funcall(argv[0], rb_intern("baton"), 0),
            "void *", _global_pool);
        } else {
            arg1 = svn_swig_rb_txdelta_window_handler;
            arg2 = (void *)svn_swig_rb_make_baton(argv[0], _global_svn_swig_rb_pool);
        }
    }
    {
        arg3 = svn_swig_rb_make_stream(argv[1]);
    }
    if (argc > 2) {
        
    }
    {
        result = (svn_stream_t *)svn_txdelta_target_push(arg1,arg2,arg3,arg4);
        
        
        
        
    }
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_svn_stream_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_txdelta_send_string(int argc, VALUE *argv, VALUE self) {
    svn_string_t *arg1 = (svn_string_t *) 0 ;
    svn_txdelta_window_handler_t arg2 = (svn_txdelta_window_handler_t) 0 ;
    void *arg3 = (void *) 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_string_t value1 ;
    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 < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        if (NIL_P(argv[0])) {
            arg1 = NULL;
        } else {
            value1.data = StringValuePtr(argv[0]);
            value1.len = RSTRING(argv[0])->len;
            arg1 = &value1;
        }
    }
    {
        if (RTEST(rb_obj_is_kind_of(argv[1],
        svn_swig_rb_svn_delta_text_delta_window_handler()))) {
            arg2 = svn_swig_rb_to_swig_type(argv[1],
            "svn_txdelta_window_handler_t",
            _global_pool);
            arg3 = svn_swig_rb_to_swig_type(rb_funcall(argv[1], rb_intern("baton"), 0),
            "void *", _global_pool);
        } else {
            arg2 = svn_swig_rb_txdelta_window_handler;
            arg3 = (void *)svn_swig_rb_make_baton(argv[1], _global_svn_swig_rb_pool);
        }
    }
    if (argc > 2) {
        
    }
    {
        result = (svn_error_t *)svn_txdelta_send_string((struct svn_string_t const *)arg1,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_txdelta_send_stream(int argc, VALUE *argv, VALUE self) {
    svn_stream_t *arg1 = (svn_stream_t *) 0 ;
    svn_txdelta_window_handler_t arg2 = (svn_txdelta_window_handler_t) 0 ;
    void *arg3 = (void *) 0 ;
    unsigned char *arg4 = (unsigned char *) 0 ;
    apr_pool_t *arg5 = (apr_pool_t *) 0 ;
    svn_error_t *result;
    VALUE _global_svn_swig_rb_pool ;
    apr_pool_t *_global_pool ;
    unsigned char temp4[APR_MD5_DIGESTSIZE] ;
    VALUE vresult = Qnil;
    
    {
        svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
        _global_pool = arg5;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    {
        arg4 = (unsigned char *)temp4;
    }
    if ((argc < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        arg1 = svn_swig_rb_make_stream(argv[0]);
    }
    {
        if (RTEST(rb_obj_is_kind_of(argv[1],
        svn_swig_rb_svn_delta_text_delta_window_handler()))) {
            arg2 = svn_swig_rb_to_swig_type(argv[1],
            "svn_txdelta_window_handler_t",
            _global_pool);
            arg3 = svn_swig_rb_to_swig_type(rb_funcall(argv[1], rb_intern("baton"), 0),
            "void *", _global_pool);
        } else {
            arg2 = svn_swig_rb_txdelta_window_handler;
            arg3 = (void *)svn_swig_rb_make_baton(argv[1], _global_svn_swig_rb_pool);
        }
    }
    if (argc > 2) {
        
    }
    {
        result = (svn_error_t *)svn_txdelta_send_stream(arg1,arg2,arg3,arg4,arg5);
        
        
        
        
    }
    {
        if (result) {
            svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
            svn_swig_rb_handle_svn_error(result);
        }
        vresult = Qnil;
    }
    {
        char *digest_string = (char *)svn_md5_digest_to_cstring(arg4, _global_pool);
        vresult = output_helper(vresult, rb_str_new2(digest_string));
    }
    {
        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_txdelta_send_txstream(int argc, VALUE *argv, VALUE self) {
    svn_txdelta_stream_t *arg1 = (svn_txdelta_stream_t *) 0 ;
    svn_txdelta_window_handler_t arg2 = (svn_txdelta_window_handler_t) 0 ;
    void *arg3 = (void *) 0 ;
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
    svn_error_t *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, &arg4);
        _global_pool = arg4;
        svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
    }
    if ((argc < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        SWIG_ConvertPtr(argv[0], &temp1, SWIGTYPE_p_svn_txdelta_stream_t, 1);
        
        
        
        arg1 = (svn_txdelta_stream_t *)temp1;
    }
    {
        if (RTEST(rb_obj_is_kind_of(argv[1],
        svn_swig_rb_svn_delta_text_delta_window_handler()))) {
            arg2 = svn_swig_rb_to_swig_type(argv[1],
            "svn_txdelta_window_handler_t",
            _global_pool);
            arg3 = svn_swig_rb_to_swig_type(rb_funcall(argv[1], rb_intern("baton"), 0),
            "void *", _global_pool);
        } else {
            arg2 = svn_swig_rb_txdelta_window_handler;
            arg3 = (void *)svn_swig_rb_make_baton(argv[1], _global_svn_swig_rb_pool);
        }
    }
    if (argc > 2) {
        
    }
    {
        result = (svn_error_t *)svn_txdelta_send_txstream(arg1,arg2