svn_fs.c

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

        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_berkeley_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_berkeley_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_berkeley_path. Expected _p_svn_fs_t");
            }
        }
        if (items > 1) {
            
        }
        {
            result = (char *)svn_fs_berkeley_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_berkeley) {
    {
        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_berkeley(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_berkeley((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_berkeley) {
    {
        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_berkeley(src_path,dest_path,clean_logs,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_berkeley((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_create_access) {
    {
        svn_fs_access_t **arg1 = (svn_fs_access_t **) 0 ;
        char *arg2 = (char *) 0 ;
        apr_pool_t *arg3 = (apr_pool_t *) 0 ;
        svn_error_t *result;
        apr_pool_t *_global_pool ;
        svn_fs_access_t *temp1 ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
        }
        {
            arg1 = (svn_fs_access_t **)&temp1;
        }
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_create_access(username,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_create_access(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++;
                }
            }
        }
        {
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *)*arg1, SWIGTYPE_p_svn_fs_access_t,0);
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_set_access) {
    {
        svn_fs_t *arg1 = (svn_fs_t *) 0 ;
        svn_fs_access_t *arg2 = (svn_fs_access_t *) 0 ;
        svn_error_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_set_access(fs,access_ctx);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_fs_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_fs_set_access. Expected _p_svn_fs_t");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_svn_fs_access_t,0) < 0) {
                SWIG_croak("Type error in argument 2 of svn_fs_set_access. Expected _p_svn_fs_access_t");
            }
        }
        {
            result = (svn_error_t *)svn_fs_set_access(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_get_access) {
    {
        svn_fs_access_t **arg1 = (svn_fs_access_t **) 0 ;
        svn_fs_t *arg2 = (svn_fs_t *) 0 ;
        svn_error_t *result;
        svn_fs_access_t *temp1 ;
        int argvi = 0;
        dXSARGS;
        
        {
            arg1 = (svn_fs_access_t **)&temp1;
        }
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_fs_get_access(fs);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg2, SWIGTYPE_p_svn_fs_t,0) < 0) {
                SWIG_croak("Type error in argument 2 of svn_fs_get_access. Expected _p_svn_fs_t");
            }
        }
        {
            result = (svn_error_t *)svn_fs_get_access(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++;
                }
            }
        }
        {
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *)*arg1, SWIGTYPE_p_svn_fs_access_t,0);
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_fs_access_get_username) {
    {
        char **arg1 = (char **) 0 ;
        svn_fs_access_t *arg2 = (svn_fs_access_t *) 0 ;
        svn_error_t *result;
        char const *temp1 = NULL ;
        int argvi = 0;
        dXSARGS;
        
        arg1 = (char **)&temp1;
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_fs_access_get_username(access_ctx);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg2, SWIGTYPE_p_svn_fs_access_t,0) < 0) {
                SWIG_croak("Type error in argument 2 of svn_fs_access_get_username. Expected _p_svn_fs_access_t");
            }
        }
        {
            result = (svn_error_t *)svn_fs_access_get_username((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++;
                }
            }
        }
        {
            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_access_add_lock_token) {
    {
        svn_fs_access_t *arg1 = (svn_fs_access_t *) 0 ;
        char *arg2 = (char *) 0 ;
        svn_error_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_access_add_lock_token(access_ctx,token);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_fs_access_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_fs_access_add_lock_token. Expected _p_svn_fs_access_t");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        {
            result = (svn_error_t *)svn_fs_access_add_lock_token(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_compare_ids) {
    {
        svn_fs_id_t *arg1 = (svn_fs_id_t *) 0 ;
        svn_fs_id_t *arg2 = (svn_fs_id_t *) 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: svn_fs_compare_ids(a,b);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_fs_id_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_fs_compare_ids. Expected _p_svn_fs_id_t");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_svn_fs_id_t,0) < 0) {
                SWIG_croak("Type error in argument 2 of svn_fs_compare_ids. Expected _p_svn_fs_id_t");
            }
        }
        {