svn_fs.c

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

XS(_wrap_svn_fs_type) {
    {
        char **arg1 = (char **) 0 ;
        char *arg2 = (char *) 0 ;
        apr_pool_t *arg3 = (apr_pool_t *) 0 ;
        svn_error_t *result;
        apr_pool_t *_global_pool ;
        char const *temp1 = NULL ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
        }
        arg1 = (char **)&temp1;
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_type(path,pool);");
        }
        if (!SvOK((SV*) ST(0))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            
        }
        {
            result = (svn_error_t *)svn_fs_type((char const **)arg1,(char const *)arg2,arg3);
            
            
            
            
        }
        {
            if (result) {
                SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
                
                if (SvOK(exception_handler)) {
                    SV *callback_result;
                    
                    svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
                    &callback_result, "S", result,
                    SWIGTYPE_p_svn_error_t);
                } else {
                    ST(argvi) = sv_newmortal();
                    SWIG_MakePtr (ST(argvi), (void *)result, SWIGTYPE_p_svn_error_t ,0);
                    argvi++;
                }
            }
        }
        {
            if (*arg1 == NULL)
            ST(argvi) = &PL_sv_undef;
            else
            ST(argvi) = sv_2mortal(newSVpv(*arg1, 0));
            ++argvi;
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_path) {
    {
        svn_fs_t *arg1 = (svn_fs_t *) 0 ;
        apr_pool_t *arg2 = (apr_pool_t *) 0 ;
        char *result;
        apr_pool_t *_global_pool ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
        }
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_path(fs,pool);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_fs_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_fs_path. Expected _p_svn_fs_t");
            }
        }
        if (items > 1) {
            
        }
        {
            result = (char *)svn_fs_path(arg1,arg2);
            
            
            
            
        }
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        } else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_delete_fs) {
    {
        char *arg1 = (char *) 0 ;
        apr_pool_t *arg2 = (apr_pool_t *) 0 ;
        svn_error_t *result;
        apr_pool_t *_global_pool ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
        }
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_delete_fs(path,pool);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            
        }
        {
            result = (svn_error_t *)svn_fs_delete_fs((char const *)arg1,arg2);
            
            
            
            
        }
        {
            if (result) {
                SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
                
                if (SvOK(exception_handler)) {
                    SV *callback_result;
                    
                    svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
                    &callback_result, "S", result,
                    SWIGTYPE_p_svn_error_t);
                } else {
                    ST(argvi) = sv_newmortal();
                    SWIG_MakePtr (ST(argvi), (void *)result, SWIGTYPE_p_svn_error_t ,0);
                    argvi++;
                }
            }
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_hotcopy) {
    {
        char *arg1 = (char *) 0 ;
        char *arg2 = (char *) 0 ;
        svn_boolean_t arg3 ;
        apr_pool_t *arg4 = (apr_pool_t *) 0 ;
        svn_error_t *result;
        apr_pool_t *_global_pool ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
        }
        if ((items < 3) || (items > 4)) {
            SWIG_croak("Usage: svn_fs_hotcopy(src_path,dest_path,clean,pool);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        arg3 = (svn_boolean_t) SvIV(ST(2));
        if (items > 3) {
            
        }
        {
            result = (svn_error_t *)svn_fs_hotcopy((char const *)arg1,(char const *)arg2,arg3,arg4);
            
            
            
            
        }
        {
            if (result) {
                SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
                
                if (SvOK(exception_handler)) {
                    SV *callback_result;
                    
                    svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
                    &callback_result, "S", result,
                    SWIGTYPE_p_svn_error_t);
                } else {
                    ST(argvi) = sv_newmortal();
                    SWIG_MakePtr (ST(argvi), (void *)result, SWIGTYPE_p_svn_error_t ,0);
                    argvi++;
                }
            }
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_berkeley_recover) {
    {
        char *arg1 = (char *) 0 ;
        apr_pool_t *arg2 = (apr_pool_t *) 0 ;
        svn_error_t *result;
        apr_pool_t *_global_pool ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
        }
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_berkeley_recover(path,pool);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            
        }
        {
            result = (svn_error_t *)svn_fs_berkeley_recover((char const *)arg1,arg2);
            
            
            
            
        }
        {
            if (result) {
                SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
                
                if (SvOK(exception_handler)) {
                    SV *callback_result;
                    
                    svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
                    &callback_result, "S", result,
                    SWIGTYPE_p_svn_error_t);
                } else {
                    ST(argvi) = sv_newmortal();
                    SWIG_MakePtr (ST(argvi), (void *)result, SWIGTYPE_p_svn_error_t ,0);
                    argvi++;
                }
            }
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_berkeley_logfiles) {
    {
        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;
        apr_pool_t *_global_pool ;
        apr_array_header_t *temp1 ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
        }
        {
            arg1 = &temp1;
        }
        if ((items < 2) || (items > 3)) {
            SWIG_croak("Usage: svn_fs_berkeley_logfiles(path,only_unused,pool);");
        }
        if (!SvOK((SV*) ST(0))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(0), PL_na);
        arg3 = (svn_boolean_t) SvIV(ST(1));
        if (items > 2) {
            
        }
        {
            result = (svn_error_t *)svn_fs_berkeley_logfiles(arg1,(char const *)arg2,arg3,arg4);
            
            
            
            
        }
        {
            if (result) {
                SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
                
                if (SvOK(exception_handler)) {
                    SV *callback_result;
                    
                    svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
                    &callback_result, "S", result,
                    SWIGTYPE_p_svn_error_t);
                } else {
                    ST(argvi) = sv_newmortal();
                    SWIG_MakePtr (ST(argvi), (void *)result, SWIGTYPE_p_svn_error_t ,0);
                    argvi++;
                }
            }
        }
        {
            ST(argvi) = svn_swig_pl_array_to_list(*arg1);
            ++argvi;
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_new) {
    {
        apr_hash_t *arg1 = (apr_hash_t *) 0 ;
        apr_pool_t *arg2 = (apr_pool_t *) 0 ;
        svn_fs_t *result;
        apr_pool_t *_global_pool ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
        }
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_new(fs_config,pool);");
        }
        {
            arg1 = svn_swig_pl_strings_to_hash (ST(0), _global_pool);
        }
        if (items > 1) {
            
        }
        {
            result = (svn_fs_t *)svn_fs_new(arg1,arg2);
            
            
            
            
        }
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_svn_fs_t, 0|0);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_create_berkeley) {
    {
        svn_fs_t *arg1 = (svn_fs_t *) 0 ;
        char *arg2 = (char *) 0 ;
        svn_error_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_create_berkeley(fs,path);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_fs_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_fs_create_berkeley. Expected _p_svn_fs_t");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        {
            result = (svn_error_t *)svn_fs_create_berkeley(arg1,(char const *)arg2);
            
            
            
            
        }
        {
            if (result) {
                SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
                
                if (SvOK(exception_handler)) {
                    SV *callback_result;
                    
                    svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
                    &callback_result, "S", result,
                    SWIGTYPE_p_svn_error_t);
                } else {
                    ST(argvi) = sv_newmortal();
                    SWIG_MakePtr (ST(argvi), (void *)result, SWIGTYPE_p_svn_error_t ,0);
                    argvi++;
                }
            }
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_open_berkeley) {
    {
        svn_fs_t *arg1 = (svn_fs_t *) 0 ;
        char *arg2 = (char *) 0 ;
        svn_error_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_open_berkeley(fs,path);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_fs_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_fs_open_berkeley. Expected _p_svn_fs_t");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        {
            result = (svn_error_t *)svn_fs_open_berkeley(arg1,(char const *)arg2);
            
            
            
            
        }
        {
            if (result) {
                SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
                
                if (SvOK(exception_handler)) {
                    SV *callback_result;
                    
                    svn_swig_pl_callback_thunk (CALL_SV, exception_handler,
                    &callback_result, "S", result,
                    SWIGTYPE_p_svn_error_t);
                } else {
                    ST(argvi) = sv_newmortal();
                    SWIG_MakePtr (ST(argvi), (void *)result, SWIGTYPE_p_svn_error_t ,0);
                    argvi++;
                }
            }
        }
        XSRETURN(argvi);
        fail: