view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/swig/perl/native/svn_fs.c  view on Meta::CPAN

      }
    }
    res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_pack" "', argument " "3"" of type '" "void *""'"); 
    }
    {
      int res = SWIG_ConvertFunctionPtr(ST(3), (void**)(&arg4), SWIGTYPE_p_f_p_void__p_svn_error_t);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_pack" "', argument " "4"" of type '" "svn_cancel_func_t""'"); 
      }
    }
    res5 = SWIG_ConvertPtr(ST(4),SWIG_as_voidptrptr(&arg5), 0, 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_fs_pack" "', argument " "5"" of type '" "void *""'"); 
    }
    if (items > 5) {
      
    }
    {
      result = (svn_error_t *)svn_fs_pack((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
      
      
      
    }
    {
      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) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
          argvi++;
        }
      }
    }
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
    
    
    
    
    
    XSRETURN(argvi);
  fail:
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
    
    
    
    
    
    SWIG_croak_null();
  }
}


XS(_wrap_svn_fs_verify) {
  {
    char *arg1 = (char *) 0 ;
    apr_hash_t *arg2 = (apr_hash_t *) 0 ;
    svn_revnum_t arg3 ;
    svn_revnum_t arg4 ;
    svn_fs_progress_notify_func_t arg5 = (svn_fs_progress_notify_func_t) 0 ;
    void *arg6 = (void *) 0 ;
    svn_cancel_func_t arg7 = (svn_cancel_func_t) 0 ;
    void *arg8 = (void *) 0 ;
    apr_pool_t *arg9 = (apr_pool_t *) 0 ;
    apr_pool_t *_global_pool ;
    int res1 ;
    char *buf1 = 0 ;
    int alloc1 = 0 ;
    long val3 ;
    int ecode3 = 0 ;
    long val4 ;
    int ecode4 = 0 ;
    int res6 ;
    int res8 ;
    int argvi = 0;
    svn_error_t *result = 0 ;
    dXSARGS;
    
    {
      _global_pool = arg9 = svn_swig_pl_make_pool (ST(items-1));
    }
    if ((items < 8) || (items > 9)) {
      SWIG_croak("Usage: svn_fs_verify(path,fs_config,start,end,notify_func,notify_baton,cancel_func,cancel_baton,scratch_pool);");
    }
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_verify" "', argument " "1"" of type '" "char const *""'");
    }
    arg1 = (char *)(buf1);
    {
      /* PERL-FIXME: Handle undef -> NULL. */
      arg2 = svn_swig_pl_strings_to_hash(ST(1), _global_pool);
    }
    ecode3 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "svn_fs_verify" "', argument " "3"" of type '" "svn_revnum_t""'");
    } 
    arg3 = (svn_revnum_t)(val3);
    ecode4 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "svn_fs_verify" "', argument " "4"" of type '" "svn_revnum_t""'");
    } 
    arg4 = (svn_revnum_t)(val4);
    {
      int res = SWIG_ConvertFunctionPtr(ST(4), (void**)(&arg5), SWIGTYPE_p_f_long_p_void_p_apr_pool_t__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_verify" "', argument " "5"" of type '" "svn_fs_progress_notify_func_t""'"); 
      }
    }
    res6 = SWIG_ConvertPtr(ST(5),SWIG_as_voidptrptr(&arg6), 0, 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svn_fs_verify" "', argument " "6"" of type '" "void *""'"); 
    }
    {
      int res = SWIG_ConvertFunctionPtr(ST(6), (void**)(&arg7), SWIGTYPE_p_f_p_void__p_svn_error_t);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_verify" "', argument " "7"" of type '" "svn_cancel_func_t""'"); 
      }
    }
    res8 = SWIG_ConvertPtr(ST(7),SWIG_as_voidptrptr(&arg8), 0, 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "svn_fs_verify" "', argument " "8"" of type '" "void *""'"); 
    }
    if (items > 8) {
      
    }
    {
      result = (svn_error_t *)svn_fs_verify((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
      
      
      
    }
    {
      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) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
          argvi++;
        }
      }
    }
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
    
    
    
    
    
    
    
    
    XSRETURN(argvi);
  fail:
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
    
    
    
    
    
    
    
    
    SWIG_croak_null();
  }
}


XS(_wrap_svn_fs_verify_root) {
  {
    svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
    apr_pool_t *arg2 = (apr_pool_t *) 0 ;
    apr_pool_t *_global_pool ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int argvi = 0;
    svn_error_t *result = 0 ;
    dXSARGS;
    
    {
      _global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
    }
    if ((items < 1) || (items > 2)) {
      SWIG_croak("Usage: svn_fs_verify_root(root,scratch_pool);");
    }
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_fs_root_t, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_fs_verify_root" "', argument " "1"" of type '" "svn_fs_root_t *""'"); 
    }
    arg1 = (svn_fs_root_t *)(argp1);
    if (items > 1) {
      
    }
    {
      result = (svn_error_t *)svn_fs_verify_root(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) = SWIG_NewPointerObj(result, SWIGTYPE_p_svn_error_t, 0);
          argvi++;
        }
      }
    }
    
    
    XSRETURN(argvi);
  fail:
    
    
    SWIG_croak_null();
  }
}


XS(_wrap_svn_fs_invoke_warning_callback) {
  {
    svn_fs_warning_callback_t arg1 = (svn_fs_warning_callback_t) 0 ;
    void *arg2 = (void *) 0 ;
    svn_error_t *arg3 = (svn_error_t *) 0 ;
    int res2 ;
    void *argp3 = 0 ;
    int res3 = 0 ;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 3) || (items > 3)) {
      SWIG_croak("Usage: svn_fs_invoke_warning_callback(_obj,baton,err);");
    }
    {
      int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_void_p_struct_svn_error_t__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_fs_invoke_warning_callback" "', argument " "1"" of type '" "svn_fs_warning_callback_t""'"); 
      }
    }
    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_fs_invoke_warning_callback" "', argument " "2"" of type '" "void *""'"); 
    }
    res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_svn_error_t, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_fs_invoke_warning_callback" "', argument " "3"" of type '" "svn_error_t *""'"); 
    }
    arg3 = (svn_error_t *)(argp3);

src/subversion/subversion/bindings/swig/perl/native/svn_fs.c  view on Meta::CPAN

{"SVN::_Fs::svn_fs_path_change_t_prop_mod_get", _wrap_svn_fs_path_change_t_prop_mod_get},
{"SVN::_Fs::svn_fs_path_change2_create", _wrap_svn_fs_path_change2_create},
{"SVN::_Fs::svn_fs_paths_changed2", _wrap_svn_fs_paths_changed2},
{"SVN::_Fs::svn_fs_paths_changed", _wrap_svn_fs_paths_changed},
{"SVN::_Fs::svn_fs_check_path", _wrap_svn_fs_check_path},
{"SVN::_Fs::svn_fs_node_history", _wrap_svn_fs_node_history},
{"SVN::_Fs::svn_fs_history_prev", _wrap_svn_fs_history_prev},
{"SVN::_Fs::svn_fs_history_location", _wrap_svn_fs_history_location},
{"SVN::_Fs::svn_fs_is_dir", _wrap_svn_fs_is_dir},
{"SVN::_Fs::svn_fs_is_file", _wrap_svn_fs_is_file},
{"SVN::_Fs::svn_fs_node_id", _wrap_svn_fs_node_id},
{"SVN::_Fs::svn_fs_node_created_rev", _wrap_svn_fs_node_created_rev},
{"SVN::_Fs::svn_fs_node_origin_rev", _wrap_svn_fs_node_origin_rev},
{"SVN::_Fs::svn_fs_node_created_path", _wrap_svn_fs_node_created_path},
{"SVN::_Fs::svn_fs_node_prop", _wrap_svn_fs_node_prop},
{"SVN::_Fs::svn_fs_node_proplist", _wrap_svn_fs_node_proplist},
{"SVN::_Fs::svn_fs_change_node_prop", _wrap_svn_fs_change_node_prop},
{"SVN::_Fs::svn_fs_props_changed", _wrap_svn_fs_props_changed},
{"SVN::_Fs::svn_fs_copied_from", _wrap_svn_fs_copied_from},
{"SVN::_Fs::svn_fs_closest_copy", _wrap_svn_fs_closest_copy},
{"SVN::_Fs::svn_fs_get_mergeinfo2", _wrap_svn_fs_get_mergeinfo2},
{"SVN::_Fs::svn_fs_get_mergeinfo", _wrap_svn_fs_get_mergeinfo},
{"SVN::_Fs::svn_fs_merge", _wrap_svn_fs_merge},
{"SVN::_Fs::svn_fs_dirent_t_name_set", _wrap_svn_fs_dirent_t_name_set},
{"SVN::_Fs::svn_fs_dirent_t_name_get", _wrap_svn_fs_dirent_t_name_get},
{"SVN::_Fs::svn_fs_dirent_t_id_set", _wrap_svn_fs_dirent_t_id_set},
{"SVN::_Fs::svn_fs_dirent_t_id_get", _wrap_svn_fs_dirent_t_id_get},
{"SVN::_Fs::svn_fs_dirent_t_kind_set", _wrap_svn_fs_dirent_t_kind_set},
{"SVN::_Fs::svn_fs_dirent_t_kind_get", _wrap_svn_fs_dirent_t_kind_get},
{"SVN::_Fs::svn_fs_dir_entries", _wrap_svn_fs_dir_entries},
{"SVN::_Fs::svn_fs_make_dir", _wrap_svn_fs_make_dir},
{"SVN::_Fs::svn_fs_delete", _wrap_svn_fs_delete},
{"SVN::_Fs::svn_fs_copy", _wrap_svn_fs_copy},
{"SVN::_Fs::svn_fs_revision_link", _wrap_svn_fs_revision_link},
{"SVN::_Fs::svn_fs_file_length", _wrap_svn_fs_file_length},
{"SVN::_Fs::svn_fs_file_checksum", _wrap_svn_fs_file_checksum},
{"SVN::_Fs::svn_fs_file_md5_checksum", _wrap_svn_fs_file_md5_checksum},
{"SVN::_Fs::svn_fs_file_contents", _wrap_svn_fs_file_contents},
{"SVN::_Fs::svn_fs_try_process_file_contents", _wrap_svn_fs_try_process_file_contents},
{"SVN::_Fs::svn_fs_make_file", _wrap_svn_fs_make_file},
{"SVN::_Fs::svn_fs_apply_textdelta", _wrap_svn_fs_apply_textdelta},
{"SVN::_Fs::svn_fs_apply_text", _wrap_svn_fs_apply_text},
{"SVN::_Fs::svn_fs_contents_changed", _wrap_svn_fs_contents_changed},
{"SVN::_Fs::svn_fs_youngest_rev", _wrap_svn_fs_youngest_rev},
{"SVN::_Fs::svn_fs_deltify_revision", _wrap_svn_fs_deltify_revision},
{"SVN::_Fs::svn_fs_revision_prop", _wrap_svn_fs_revision_prop},
{"SVN::_Fs::svn_fs_revision_proplist", _wrap_svn_fs_revision_proplist},
{"SVN::_Fs::svn_fs_change_rev_prop2", _wrap_svn_fs_change_rev_prop2},
{"SVN::_Fs::svn_fs_change_rev_prop", _wrap_svn_fs_change_rev_prop},
{"SVN::_Fs::svn_fs_get_file_delta_stream", _wrap_svn_fs_get_file_delta_stream},
{"SVN::_Fs::svn_fs_get_uuid", _wrap_svn_fs_get_uuid},
{"SVN::_Fs::svn_fs_set_uuid", _wrap_svn_fs_set_uuid},
{"SVN::_Fs::svn_fs_lock", _wrap_svn_fs_lock},
{"SVN::_Fs::svn_fs_generate_lock_token", _wrap_svn_fs_generate_lock_token},
{"SVN::_Fs::svn_fs_unlock", _wrap_svn_fs_unlock},
{"SVN::_Fs::svn_fs_get_lock", _wrap_svn_fs_get_lock},
{"SVN::_Fs::svn_fs_get_locks2", _wrap_svn_fs_get_locks2},
{"SVN::_Fs::svn_fs_get_locks", _wrap_svn_fs_get_locks},
{"SVN::_Fs::svn_fs_print_modules", _wrap_svn_fs_print_modules},
{"SVN::_Fs::svn_fs_pack", _wrap_svn_fs_pack},
{"SVN::_Fs::svn_fs_verify", _wrap_svn_fs_verify},
{"SVN::_Fs::svn_fs_verify_root", _wrap_svn_fs_verify_root},
{"SVN::_Fs::svn_fs_invoke_warning_callback", _wrap_svn_fs_invoke_warning_callback},
{"SVN::_Fs::svn_fs_invoke_progress_notify_func", _wrap_svn_fs_invoke_progress_notify_func},
{"SVN::_Fs::svn_fs_invoke_freeze_func", _wrap_svn_fs_invoke_freeze_func},
{"SVN::_Fs::svn_fs_invoke_process_contents_func", _wrap_svn_fs_invoke_process_contents_func},
{"SVN::_Fs::svn_fs_invoke_get_locks_callback", _wrap_svn_fs_invoke_get_locks_callback},
{"SVN::_Fs::svn_fs_invoke_pack_notify", _wrap_svn_fs_invoke_pack_notify},
{0,0}
};
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic 
 * memory is used. Also, since swig_type_info structures store pointers to 
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization. 
 * The idea is that swig generates all the structures that are needed. 
 * The runtime then collects these partially filled structures. 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned staticly to an initial 
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it 
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded. 
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the 
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif