svn_delta.c

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

    croak(Nullch);
}


XS(_wrap_svn_txdelta_window_t_new_data_get) {
    {
        svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
        svn_string_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_txdelta_window_t_new_data_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_txdelta_window_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_txdelta_window_t_new_data_get. Expected _p_svn_txdelta_window_t");
            }
        }
        result = (svn_string_t *) ((arg1)->new_data);
        
        {
            ST(argvi) = sv_2mortal(newSVpv(result->data, result->len));
            ++argvi;
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_new_svn_txdelta_window_t) {
    {
        svn_txdelta_window_t *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 0)) {
            SWIG_croak("Usage: new_svn_txdelta_window_t();");
        }
        {
            result = (svn_txdelta_window_t *)(svn_txdelta_window_t *) calloc(1, sizeof(svn_txdelta_window_t));
            
            
            
            
        }
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_svn_txdelta_window_t, SWIG_SHADOW|SWIG_OWNER);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_delete_svn_txdelta_window_t) {
    {
        svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_svn_txdelta_window_t(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_txdelta_window_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_svn_txdelta_window_t. Expected _p_svn_txdelta_window_t");
            }
        }
        {
            free((char *) arg1);
            
            
            
            
        }
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_txdelta_window_dup) {
    {
        svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
        apr_pool_t *arg2 = (apr_pool_t *) 0 ;
        svn_txdelta_window_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_txdelta_window_dup(window,pool);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_txdelta_window_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_txdelta_window_dup. Expected _p_svn_txdelta_window_t");
            }
        }
        if (items > 1) {
            
        }
        {
            result = (svn_txdelta_window_t *)svn_txdelta_window_dup((struct svn_txdelta_window_t const *)arg1,arg2);
            
            
            
            
        }
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_svn_txdelta_window_t, SWIG_SHADOW|0);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_txdelta_compose_windows) {
    {
        svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
        svn_txdelta_window_t *arg2 = (svn_txdelta_window_t *) 0 ;
        apr_pool_t *arg3 = (apr_pool_t *) 0 ;
        svn_txdelta_window_t *result;
        apr_pool_t *_global_pool ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
        }
        if ((items < 2) || (items > 3)) {
            SWIG_croak("Usage: svn_txdelta_compose_windows(window_A,window_B,pool);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_txdelta_window_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_txdelta_compose_windows. Expected _p_svn_txdelta_window_t");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_svn_txdelta_window_t,0) < 0) {
                SWIG_croak("Type error in argument 2 of svn_txdelta_compose_windows. Expected _p_svn_txdelta_window_t");
            }
        }
        if (items > 2) {
            
        }
        {
            result = (svn_txdelta_window_t *)svn_txdelta_compose_windows((struct svn_txdelta_window_t const *)arg1,(struct svn_txdelta_window_t const *)arg2,arg3);
            
            
            
            
        }
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_svn_txdelta_window_t, SWIG_SHADOW|0);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_txdelta_apply_instructions) {
    {
        svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        apr_size_t *arg4 = (apr_size_t *) 0 ;
        unsigned long temp4 ;
        int argvi = 0;
        dXSARGS;
        
        arg4 = &temp4;
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: svn_txdelta_apply_instructions(window,sbuf,tbuf);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_txdelta_window_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_txdelta_apply_instructions. Expected _p_svn_txdelta_window_t");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (!SvOK((SV*) ST(2))) arg3 = 0;
        else arg3 = (char *) SvPV(ST(2), PL_na);
        {
            svn_txdelta_apply_instructions(arg1,(char const *)arg2,arg3,arg4);
            
            
            
            
        }
        
        {
            if (argvi >= items) {
                EXTEND(sp,1);
            }
            ST(argvi) = sv_newmortal();
            sv_setuv(ST(argvi),(UV) *(arg4));
            argvi++;
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_txdelta_stream_create) {
    {
        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;
        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_txdelta_stream_create(baton,next_window,md5_digest,pool);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, 0,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_txdelta_stream_create. Expected _p_void");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 2 of svn_txdelta_stream_create. Expected _p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_f_p_void__p_unsigned_char,0) < 0) {
                SWIG_croak("Type error in argument 3 of svn_txdelta_stream_create. Expected _p_f_p_void__p_unsigned_char");
            }
        }
        if (items > 3) {
            
        }
        {
            result = (svn_txdelta_stream_t *)svn_txdelta_stream_create(arg1,arg2,(unsigned char const *(*)(void *))arg3,arg4);
            
            
            
            
        }
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_svn_txdelta_stream_t, 0|0);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_txdelta_next_window) {
    {
        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;
        apr_pool_t *_global_pool ;
        svn_txdelta_window_t *temp1 ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
        }
        {
            arg1 = (svn_txdelta_window_t **)&temp1;
        }
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: svn_txdelta_next_window(stream,pool);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg2, SWIGTYPE_p_svn_txdelta_stream_t,0) < 0) {
                SWIG_croak("Type error in argument 2 of svn_txdelta_next_window. Expected _p_svn_txdelta_stream_t");
            }
        }
        if (items > 1) {
            
        }
        {
            result = (svn_error_t *)svn_txdelta_next_window(arg1,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_txdelta_window_t,0);
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_txdelta_md5_digest) {
    {
        svn_txdelta_stream_t *arg1 = (svn_txdelta_stream_t *) 0 ;
        unsigned char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: svn_txdelta_md5_digest(stream);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_svn_txdelta_stream_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_txdelta_md5_digest. Expected _p_svn_txdelta_stream_t");
            }
        }
        {
            result = (unsigned char *)svn_txdelta_md5_digest(arg1);
            
            
            
            
        }
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_unsigned_char, 0|0);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_txdelta) {
    {
        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 ;
        apr_pool_t *_global_pool ;
        svn_txdelta_stream_t *temp1 ;
        int argvi = 0;
        dXSARGS;
        
        {
            _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
        }
        {
            arg1 = (svn_txdelta_stream_t **)&temp1;
        }
        if ((items < 2) || (items > 3)) {
            SWIG_croak("Usage: svn_txdelta(source,target,pool);");
        }
        {
            svn_swig_pl_make_stream (&arg2, ST(0));
        }
        {
            svn_swig_pl_make_stream (&arg3, ST(1));
        }
        if (items > 2) {
            
        }
        {
            svn_txdelta(arg1,arg2,arg3,arg4);
            
            
            
            
        }
        
        {
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *)*arg1, SWIGTYPE_p_svn_txdelta_stream_t,0);
        }
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_svn_txdelta_target_push) {
    {
        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;
        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_txdelta_target_push(handler,handler_baton,source,pool);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,0) < 0) {
                SWIG_croak("Type error in argument 1 of svn_txdelta_target_push. Expected _p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t");
            }
        }
        {
            if (SWIG_ConvertPtr(