core.c

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

            
        }
        {
            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++;
                }
            }
        }
        {
            char temp[256];
            if (argvi >= items) {
                EXTEND(sp,1);
            }
            sprintf(temp, "%" APR_INT64_T_FMT, (apr_int64_t)*(arg1));
            ST(argvi) = sv_newmortal();
            sv_setpv(ST(argvi),temp);
            argvi++;
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_time_to_human_cstring) {
    {
        apr_time_t arg1 ;
        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_time_to_human_cstring(when,pool);");
        }
        arg1 = (apr_time_t) strtoll(SvPV(ST(0), PL_na), 0, 0);
        if (items > 1) {
            
        }
        {
            result = (char *)svn_time_to_human_cstring(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_parse_date) {
    {
        svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
        apr_time_t *arg2 = (apr_time_t *) 0 ;
        char *arg3 = (char *) 0 ;
        apr_time_t arg4 ;
        apr_pool_t *arg5 = (apr_pool_t *) 0 ;
        svn_error_t *result;
        apr_pool_t *_global_pool ;
        int temp1 ;
        apr_int64_t temp2 ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
        }
        arg1 = &temp1;
        arg2 = &temp2;
        if ((items < 2) || (items > 3)) {
            SWIG_croak("Usage: svn_parse_date(text,now,pool);");
        }
        if (!SvOK((SV*) ST(0))) arg3 = 0;
        else arg3 = (char *) SvPV(ST(0), PL_na);
        arg4 = (apr_time_t) strtoll(SvPV(ST(1), PL_na), 0, 0);
        if (items > 2) {
            
        }
        {
            result = (svn_error_t *)svn_parse_date(arg1,arg2,(char const *)arg3,arg4,arg5);
            
            
            
            
        }
        {
            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 (argvi >= items) {
                EXTEND(sp,1);
            }
            ST(argvi) = sv_newmortal();
            sv_setiv(ST(argvi),(IV) *(arg1));
            argvi++;
        }
        {
            char temp[256];
            if (argvi >= items) {
                EXTEND(sp,1);
            }
            sprintf(temp, "%" APR_INT64_T_FMT, (apr_int64_t)*(arg2));
            ST(argvi) = sv_newmortal();
            sv_setpv(ST(argvi),temp);
            argvi++;
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_sleep_for_timestamps) {
    {
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 0)) {
            SWIG_croak("Usage: svn_sleep_for_timestamps();");
        }
        {
            svn_sleep_for_timestamps();
            
            
            
            
        }
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_error_t_apr_err_set) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        apr_status_t arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: svn_error_t_apr_err_set(self,apr_err);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_apr_err_set. Expected _p_svn_error_t");
            }
        }
        arg2 = (apr_status_t) SvIV(ST(1));
        if (arg1) (arg1)->apr_err = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_error_t_apr_err_get) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        apr_status_t result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_error_t_apr_err_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_apr_err_get. Expected _p_svn_error_t");
            }
        }
        result = (apr_status_t) ((arg1)->apr_err);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_error_t_message_get) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_error_t_message_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_message_get. Expected _p_svn_error_t");
            }
        }
        result = (char *) ((arg1)->message);
        
        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_error_t_child_set) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        struct svn_error_t *arg2 = (struct svn_error_t *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: svn_error_t_child_set(self,child);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_child_set. Expected _p_svn_error_t");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 2 of svn_error_t_child_set. Expected _p_svn_error_t");
            }
        }
        if (arg1) (arg1)->child = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_error_t_child_get) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        struct svn_error_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_error_t_child_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_child_get. Expected _p_svn_error_t");
            }
        }
        result = (struct svn_error_t *) ((arg1)->child);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_svn_error_t, SWIG_SHADOW|0);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_error_t_pool_set) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        apr_pool_t *arg2 = (apr_pool_t *) 0 ;
        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_error_t_pool_set(self,pool);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_pool_set. Expected _p_svn_error_t");
            }
        }
        if (items > 1) {
            
        }
        if (arg1) (arg1)->pool = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_error_t_pool_get) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        apr_pool_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_error_t_pool_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_pool_get. Expected _p_svn_error_t");
            }
        }
        result = (apr_pool_t *) ((arg1)->pool);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_apr_pool_t, 0|0);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_error_t_file_get) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_error_t_file_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_file_get. Expected _p_svn_error_t");
            }
        }
        result = (char *) ((arg1)->file);
        
        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_error_t_line_set) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        long arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: svn_error_t_line_set(self,line);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_line_set. Expected _p_svn_error_t");
            }
        }
        arg2 = (long) SvIV(ST(1));
        if (arg1) (arg1)->line = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_error_t_line_get) {
    {
        svn_error_t *arg1 = (svn_error_t *) 0 ;
        long result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_error_t_line_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_error_t_line_get. Expected _p_svn_error_t");
            }
        }
        result = (long) ((arg1)->line);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_new_svn_error_t) {
    {
        svn_error_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 0)) {
            SWIG_croak("Usage: new_svn_error_t();");