Alien-SVN

 view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/swig/ruby/core.c  view on Meta::CPAN

#include "svn_props.h"




#include "svn_opt.h"

typedef struct {
  int optch; const char *desc; 
} svn_opt_subcommand_desc2_t_desc_overrides;





#include "svn_cmdline.h"




#include "svn_auth.h"


/*@SWIG:/home/breser/wandisco/rm/1.8.11/prefix/share/swig/2.0.9/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  unsigned long *res = (unsigned long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
{
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    unsigned long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return ULONG2NUM(value); 
}


static svn_error_t * svn_auth_provider_invoke_first_credentials(
  svn_auth_provider_t * _obj, void **credentials, void **iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
  return (_obj->first_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}

static svn_error_t * svn_auth_provider_invoke_next_credentials(
  svn_auth_provider_t * _obj, void **credentials, void *iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
  return (_obj->next_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}

static svn_error_t * svn_auth_provider_invoke_save_credentials(
  svn_auth_provider_t * _obj, svn_boolean_t *saved, void *credentials, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
  return (_obj->save_credentials)(saved, credentials, provider_baton, parameters, realmstring, pool);
}

static void svn_auth_invoke_simple_provider_func(
  svn_auth_simple_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
  _obj(provider, pool);
}

static void svn_auth_invoke_ssl_client_cert_pw_provider_func(
  svn_auth_ssl_client_cert_pw_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
  _obj(provider, pool);
}

static svn_error_t * svn_auth_invoke_simple_prompt_func(
  svn_auth_simple_prompt_func_t _obj, svn_auth_cred_simple_t **cred, void *baton, const char *realm, const char *username, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, username, may_save, pool);
}

static svn_error_t * svn_auth_invoke_username_prompt_func(
  svn_auth_username_prompt_func_t _obj, svn_auth_cred_username_t **cred, void *baton, const char *realm, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, may_save, pool);
}

static svn_error_t * svn_auth_invoke_ssl_server_trust_prompt_func(
  svn_auth_ssl_server_trust_prompt_func_t _obj, svn_auth_cred_ssl_server_trust_t **cred, void *baton, const char *realm, apr_uint32_t failures, const svn_auth_ssl_server_cert_info_t *cert_info, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, failures, cert_info, may_save, pool);
}

static svn_error_t * svn_auth_invoke_ssl_client_cert_prompt_func(
  svn_auth_ssl_client_cert_prompt_func_t _obj, svn_auth_cred_ssl_client_cert_t **cred, void *baton, const char *realm, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, may_save, pool);
}

static svn_error_t * svn_auth_invoke_ssl_client_cert_pw_prompt_func(
  svn_auth_ssl_client_cert_pw_prompt_func_t _obj, svn_auth_cred_ssl_client_cert_pw_t **cred, void *baton, const char *realm, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, may_save, pool);
}

static svn_error_t * svn_auth_invoke_plaintext_prompt_func(
  svn_auth_plaintext_prompt_func_t _obj, svn_boolean_t *may_save_plaintext, const char *realmstring, void *baton, apr_pool_t *pool) {
  return _obj(may_save_plaintext, realmstring, baton, pool);
}

static svn_error_t * svn_auth_invoke_plaintext_passphrase_prompt_func(
  svn_auth_plaintext_passphrase_prompt_func_t _obj, svn_boolean_t *may_save_plaintext, const char *realmstring, void *baton, apr_pool_t *pool) {
  return _obj(may_save_plaintext, realmstring, baton, pool);
}



#include "svn_config.h"


static svn_boolean_t svn_config_invoke_section_enumerator(
  svn_config_section_enumerator_t _obj, const char *name, void *baton) {
  return _obj(name, baton);
}

static svn_boolean_t svn_config_invoke_section_enumerator2(
  svn_config_section_enumerator2_t _obj, const char *name, void *baton, apr_pool_t *pool) {
  return _obj(name, baton, pool);

src/subversion/subversion/bindings/swig/ruby/core.c  view on Meta::CPAN

  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","cred_kind", 1, self )); 
  }
  arg1 = (struct svn_auth_provider_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cred_kind", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  {
    apr_size_t len = strlen(arg2) + 1;
    char *copied;
    if (arg1->cred_kind) free((char *)arg1->cred_kind);
    copied = malloc(len);
    memcpy(copied, arg2, len);
    arg1->cred_kind = copied;
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_t_cred_kind_get(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","cred_kind", 1, self )); 
  }
  arg1 = (struct svn_auth_provider_t *)(argp1);
  result = (char *) ((arg1)->cred_kind);
  {
    if (result) {
      vresult = rb_str_new2(result);
    } else {
      vresult = Qnil;
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_t_first_credentials_set(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  svn_error_t *(*arg2)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","first_credentials", 1, self )); 
  }
  arg1 = (struct svn_auth_provider_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)","first_credentials", 2, argv[0] )); 
    }
  }
  if (arg1) (arg1)->first_credentials = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_t_first_credentials_get(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  svn_error_t *(*result)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","first_credentials", 1, self )); 
  }
  arg1 = (struct svn_auth_provider_t *)(argp1);
  result = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->first_credentials);
  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_t_next_credentials_set(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  svn_error_t *(*arg2)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","next_credentials", 1, self )); 
  }
  arg1 = (struct svn_auth_provider_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)","next_credentials", 2, argv[0] )); 
    }
  }
  if (arg1) (arg1)->next_credentials = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_t_next_credentials_get(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  svn_error_t *(*result)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","next_credentials", 1, self )); 
  }
  arg1 = (struct svn_auth_provider_t *)(argp1);
  result = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->next_credentials);
  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_t_save_credentials_set(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  svn_error_t *(*arg2)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","save_credentials", 1, self )); 
  }
  arg1 = (struct svn_auth_provider_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)","save_credentials", 2, argv[0] )); 
    }
  }
  if (arg1) (arg1)->save_credentials = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_t_save_credentials_get(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  svn_error_t *(*result)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","save_credentials", 1, self )); 
  }
  arg1 = (struct svn_auth_provider_t *)(argp1);
  result = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->save_credentials);
  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_svn_auth_provider_t_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_svn_auth_provider_t_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_svn_auth_provider_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_svn_auth_provider_t(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_t *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    result = (struct svn_auth_provider_t *)calloc(1, sizeof(struct svn_auth_provider_t));
    DATA_PTR(self) = result;
    
    
    
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_svn_auth_provider_t(struct svn_auth_provider_t *arg1) {
    free((char *) arg1);
}

static swig_class SwigClassSvn_auth_provider_object_t;

SWIGINTERN VALUE
_wrap_svn_auth_provider_object_t_vtable_set(int argc, VALUE *argv, VALUE self) {
  struct svn_auth_provider_object_t *arg1 = (struct svn_auth_provider_object_t *) 0 ;
  svn_auth_provider_t *arg2 = (svn_auth_provider_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  

src/subversion/subversion/bindings/swig/ruby/core.c  view on Meta::CPAN

    
    
    
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_get_parameter(int argc, VALUE *argv, VALUE self) {
  svn_auth_baton_t *arg1 = (svn_auth_baton_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_baton_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_baton_t *","svn_auth_get_parameter", 1, argv[0] )); 
  }
  arg1 = (svn_auth_baton_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_auth_get_parameter", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  {
    result = (void *)svn_auth_get_parameter(arg1,(char const *)arg2);
    
    
    
  }
  {
    char *value = result;
    if (value) {
      vresult = rb_str_new2(value);
    } else {
      vresult = Qnil;
    }
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_first_credentials(int argc, VALUE *argv, VALUE self) {
  void **arg1 = (void **) 0 ;
  svn_auth_iterstate_t **arg2 = (svn_auth_iterstate_t **) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  svn_auth_baton_t *arg5 = (svn_auth_baton_t *) 0 ;
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  void *temp1 ;
  svn_auth_iterstate_t *temp2 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  svn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
    _global_pool = arg6;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  arg1 = &temp1;
  arg2 = &temp2;
  if ((argc < 3) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res3 = SWIG_AsCharPtrAndSize(argv[0], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_auth_first_credentials", 3, argv[0] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[1], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","svn_auth_first_credentials", 4, argv[1] ));
  }
  arg4 = (char *)(buf4);
  res5 = SWIG_ConvertPtr(argv[2], &argp5,SWIGTYPE_p_svn_auth_baton_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "svn_auth_baton_t *","svn_auth_first_credentials", 5, argv[2] )); 
  }
  arg5 = (svn_auth_baton_t *)(argp5);
  if (argc > 3) {
    
  }
  {
    result = (svn_error_t *)svn_auth_first_credentials(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
    
    
    
  }
  {
    if (result) {
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_handle_svn_error(result);
    }
    vresult = Qnil;
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_void, 0));
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_svn_auth_iterstate_t, 0));
  }
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_next_credentials(int argc, VALUE *argv, VALUE self) {
  void **arg1 = (void **) 0 ;
  svn_auth_iterstate_t *arg2 = (svn_auth_iterstate_t *) 0 ;
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  void *temp1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  svn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
    _global_pool = arg3;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  arg1 = &temp1;
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_svn_auth_iterstate_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_auth_iterstate_t *","svn_auth_next_credentials", 2, argv[0] )); 
  }
  arg2 = (svn_auth_iterstate_t *)(argp2);
  if (argc > 1) {
    
  }
  {
    result = (svn_error_t *)svn_auth_next_credentials(arg1,arg2,arg3);
    
    
    
  }
  {
    if (result) {
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_handle_svn_error(result);
    }
    vresult = Qnil;
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_void, 0));
  }
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return vresult;
fail:
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_save_credentials(int argc, VALUE *argv, VALUE self) {
  svn_auth_iterstate_t *arg1 = (svn_auth_iterstate_t *) 0 ;
  apr_pool_t *arg2 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  svn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
    _global_pool = arg2;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_iterstate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_iterstate_t *","svn_auth_save_credentials", 1, argv[0] )); 
  }
  arg1 = (svn_auth_iterstate_t *)(argp1);
  if (argc > 1) {
    
  }
  {
    result = (svn_error_t *)svn_auth_save_credentials(arg1,arg2);
    
    
    
  }
  {
    if (result) {
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_handle_svn_error(result);
    }
    vresult = Qnil;
  }
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return vresult;
fail:
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_forget_credentials(int argc, VALUE *argv, VALUE self) {
  svn_auth_baton_t *arg1 = (svn_auth_baton_t *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  svn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
    _global_pool = arg4;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  if ((argc < 3) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_baton_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_baton_t *","svn_auth_forget_credentials", 1, argv[0] )); 
  }
  arg1 = (svn_auth_baton_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_auth_forget_credentials", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_auth_forget_credentials", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  if (argc > 3) {
    
  }
  {
    result = (svn_error_t *)svn_auth_forget_credentials(arg1,(char const *)arg2,(char const *)arg3,arg4);
    
    
    
  }
  {
    if (result) {
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_handle_svn_error(result);
    }
    vresult = Qnil;
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_get_simple_prompt_provider(int argc, VALUE *argv, VALUE self) {
  svn_auth_provider_object_t **arg1 = (svn_auth_provider_object_t **) 0 ;
  svn_auth_simple_prompt_func_t arg2 = (svn_auth_simple_prompt_func_t) 0 ;
  void *arg3 = (void *) 0 ;
  int arg4 ;
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  svn_auth_provider_object_t *temp1 ;
  int val4 ;
  int ecode4 = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
    _global_pool = arg5;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  arg1 = &temp1;
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {

src/subversion/subversion/bindings/swig/ruby/core.c  view on Meta::CPAN

  int arg4 ;
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  svn_auth_provider_object_t *temp1 ;
  int val4 ;
  int ecode4 = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
    _global_pool = arg5;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  arg1 = &temp1;
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    arg2 = svn_swig_rb_auth_ssl_client_cert_pw_prompt_func;
    arg3 = (void *)svn_swig_rb_make_baton(argv[0], _global_svn_swig_rb_pool);
  }
  ecode4 = SWIG_AsVal_int(argv[1], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","svn_auth_get_ssl_client_cert_pw_prompt_provider", 4, argv[1] ));
  } 
  arg4 = (int)(val4);
  if (argc > 2) {
    
  }
  {
    svn_auth_get_ssl_client_cert_pw_prompt_provider(arg1,arg2,arg3,arg4,arg5);
    
    
    
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_auth_provider_object_t, 0));
  }
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return vresult;
fail:
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_invoke_first_credentials(int argc, VALUE *argv, VALUE self) {
  svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
  void **arg2 = (void **) 0 ;
  void **arg3 = (void **) 0 ;
  void *arg4 = (void *) 0 ;
  apr_hash_t *arg5 = (apr_hash_t *) 0 ;
  char *arg6 = (char *) 0 ;
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *temp2 ;
  void *temp3 ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  svn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
    _global_pool = arg7;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  arg2 = &temp2;
  arg3 = &temp3;
  if ((argc < 4) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_provider_t *","svn_auth_provider_invoke_first_credentials", 1, argv[0] )); 
  }
  arg1 = (svn_auth_provider_t *)(argp1);
  res4 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_first_credentials", 4, argv[1] )); 
  }
  res5 = SWIG_ConvertPtr(argv[2], &argp5,SWIGTYPE_p_apr_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_hash_t *","svn_auth_provider_invoke_first_credentials", 5, argv[2] )); 
  }
  arg5 = (apr_hash_t *)(argp5);
  res6 = SWIG_AsCharPtrAndSize(argv[3], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","svn_auth_provider_invoke_first_credentials", 6, argv[3] ));
  }
  arg6 = (char *)(buf6);
  if (argc > 4) {
    
  }
  {
    result = (svn_error_t *)svn_auth_provider_invoke_first_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
    
    
    
  }
  {
    if (result) {
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_handle_svn_error(result);
    }
    vresult = Qnil;
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_void, 0));
  }
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return vresult;
fail:
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_invoke_next_credentials(int argc, VALUE *argv, VALUE self) {
  svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
  void **arg2 = (void **) 0 ;
  void *arg3 = (void *) 0 ;
  void *arg4 = (void *) 0 ;
  apr_hash_t *arg5 = (apr_hash_t *) 0 ;
  char *arg6 = (char *) 0 ;
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *temp2 ;
  int res3 ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  svn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
    _global_pool = arg7;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  arg2 = &temp2;
  if ((argc < 5) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_provider_t *","svn_auth_provider_invoke_next_credentials", 1, argv[0] )); 
  }
  arg1 = (svn_auth_provider_t *)(argp1);
  res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_next_credentials", 3, argv[1] )); 
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_next_credentials", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_apr_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_hash_t *","svn_auth_provider_invoke_next_credentials", 5, argv[3] )); 
  }
  arg5 = (apr_hash_t *)(argp5);
  res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","svn_auth_provider_invoke_next_credentials", 6, argv[4] ));
  }
  arg6 = (char *)(buf6);
  if (argc > 5) {
    
  }
  {
    result = (svn_error_t *)svn_auth_provider_invoke_next_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
    
    
    
  }
  {
    if (result) {
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_handle_svn_error(result);
    }
    vresult = Qnil;
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
  }
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return vresult;
fail:
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_provider_invoke_save_credentials(int argc, VALUE *argv, VALUE self) {
  svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
  svn_boolean_t *arg2 = (svn_boolean_t *) 0 ;
  void *arg3 = (void *) 0 ;
  void *arg4 = (void *) 0 ;
  apr_hash_t *arg5 = (apr_hash_t *) 0 ;
  char *arg6 = (char *) 0 ;
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  svn_boolean_t temp2 ;
  int res3 ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  svn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
    _global_pool = arg7;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  arg2 = &temp2;
  if ((argc < 5) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_provider_t *","svn_auth_provider_invoke_save_credentials", 1, argv[0] )); 
  }
  arg1 = (svn_auth_provider_t *)(argp1);
  res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_save_credentials", 3, argv[1] )); 
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_save_credentials", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_apr_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_hash_t *","svn_auth_provider_invoke_save_credentials", 5, argv[3] )); 
  }
  arg5 = (apr_hash_t *)(argp5);
  res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","svn_auth_provider_invoke_save_credentials", 6, argv[4] ));
  }
  arg6 = (char *)(buf6);
  if (argc > 5) {
    
  }
  {
    result = (svn_error_t *)svn_auth_provider_invoke_save_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
    
    
    
  }
  {
    if (result) {
      svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
      svn_swig_rb_handle_svn_error(result);
    }
    vresult = Qnil;
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, *arg2 ? Qtrue : Qfalse);
  }
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return vresult;
fail:
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  {
    VALUE target;
    target = _global_vresult_address == &vresult ? self : vresult;
    if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
    svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
    svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
  }
  return Qnil;
}


SWIGINTERN VALUE
_wrap_svn_auth_invoke_simple_provider_func(int argc, VALUE *argv, VALUE self) {
  svn_auth_simple_provider_func_t arg1 = (svn_auth_simple_provider_func_t) 0 ;
  svn_auth_provider_object_t **arg2 = (svn_auth_provider_object_t **) 0 ;
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
  VALUE _global_svn_swig_rb_pool ;
  apr_pool_t *_global_pool ;
  svn_auth_provider_object_t *temp2 ;
  VALUE vresult = Qnil;
  
  {
    svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
    _global_pool = arg3;
    svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
  }
  arg2 = &temp2;
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_p_struct_svn_auth_provider_object_t_p_apr_pool_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_auth_simple_provider_func_t","svn_auth_invoke_simple_provider_func", 1, argv[0] )); 

src/subversion/subversion/bindings/swig/ruby/core.c  view on Meta::CPAN

  rb_define_const(mCore, "Svn_opt_revision_committed", SWIG_From_int((int)(svn_opt_revision_committed)));
  rb_define_const(mCore, "Svn_opt_revision_previous", SWIG_From_int((int)(svn_opt_revision_previous)));
  rb_define_const(mCore, "Svn_opt_revision_base", SWIG_From_int((int)(svn_opt_revision_base)));
  rb_define_const(mCore, "Svn_opt_revision_working", SWIG_From_int((int)(svn_opt_revision_working)));
  rb_define_const(mCore, "Svn_opt_revision_head", SWIG_From_int((int)(svn_opt_revision_head)));
  
  SwigClassSvn_opt_revision_value_t.klass = rb_define_class_under(mCore, "Svn_opt_revision_value_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_opt_revision_value_t, (void *) &SwigClassSvn_opt_revision_value_t);
  rb_define_alloc_func(SwigClassSvn_opt_revision_value_t.klass, _wrap_svn_opt_revision_value_t_allocate);
  rb_define_method(SwigClassSvn_opt_revision_value_t.klass, "initialize", _wrap_new_svn_opt_revision_value_t, -1);
  rb_define_method(SwigClassSvn_opt_revision_value_t.klass, "number=", _wrap_svn_opt_revision_value_t_number_set, -1);
  rb_define_method(SwigClassSvn_opt_revision_value_t.klass, "number", _wrap_svn_opt_revision_value_t_number_get, -1);
  rb_define_method(SwigClassSvn_opt_revision_value_t.klass, "date=", _wrap_svn_opt_revision_value_t_date_set, -1);
  rb_define_method(SwigClassSvn_opt_revision_value_t.klass, "date", _wrap_svn_opt_revision_value_t_date_get, -1);
  SwigClassSvn_opt_revision_value_t.mark = 0;
  SwigClassSvn_opt_revision_value_t.destroy = (void (*)(void *)) free_svn_opt_revision_value_t;
  SwigClassSvn_opt_revision_value_t.trackObjects = 0;
  
  SwigClassSvn_opt_revision_t.klass = rb_define_class_under(mCore, "Svn_opt_revision_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_opt_revision_t, (void *) &SwigClassSvn_opt_revision_t);
  rb_define_alloc_func(SwigClassSvn_opt_revision_t.klass, _wrap_svn_opt_revision_t_allocate);
  rb_define_method(SwigClassSvn_opt_revision_t.klass, "initialize", _wrap_new_svn_opt_revision_t, -1);
  rb_define_method(SwigClassSvn_opt_revision_t.klass, "kind=", _wrap_svn_opt_revision_t_kind_set, -1);
  rb_define_method(SwigClassSvn_opt_revision_t.klass, "kind", _wrap_svn_opt_revision_t_kind_get, -1);
  rb_define_method(SwigClassSvn_opt_revision_t.klass, "value=", _wrap_svn_opt_revision_t_value_set, -1);
  rb_define_method(SwigClassSvn_opt_revision_t.klass, "value", _wrap_svn_opt_revision_t_value_get, -1);
  SwigClassSvn_opt_revision_t.mark = 0;
  SwigClassSvn_opt_revision_t.destroy = (void (*)(void *)) free_svn_opt_revision_t;
  SwigClassSvn_opt_revision_t.trackObjects = 0;
  
  SwigClassSvn_opt_revision_range_t.klass = rb_define_class_under(mCore, "Svn_opt_revision_range_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_opt_revision_range_t, (void *) &SwigClassSvn_opt_revision_range_t);
  rb_define_alloc_func(SwigClassSvn_opt_revision_range_t.klass, _wrap_svn_opt_revision_range_t_allocate);
  rb_define_method(SwigClassSvn_opt_revision_range_t.klass, "initialize", _wrap_new_svn_opt_revision_range_t, -1);
  rb_define_method(SwigClassSvn_opt_revision_range_t.klass, "start=", _wrap_svn_opt_revision_range_t_start_set, -1);
  rb_define_method(SwigClassSvn_opt_revision_range_t.klass, "start", _wrap_svn_opt_revision_range_t_start_get, -1);
  rb_define_method(SwigClassSvn_opt_revision_range_t.klass, "end=", _wrap_svn_opt_revision_range_t_end_set, -1);
  rb_define_method(SwigClassSvn_opt_revision_range_t.klass, "end", _wrap_svn_opt_revision_range_t_end_get, -1);
  SwigClassSvn_opt_revision_range_t.mark = 0;
  SwigClassSvn_opt_revision_range_t.destroy = (void (*)(void *)) free_svn_opt_revision_range_t;
  SwigClassSvn_opt_revision_range_t.trackObjects = 0;
  rb_define_module_function(mCore, "svn_opt_parse_revision", _wrap_svn_opt_parse_revision, -1);
  rb_define_module_function(mCore, "svn_opt_parse_revision_to_range", _wrap_svn_opt_parse_revision_to_range, -1);
  rb_define_module_function(mCore, "svn_opt_resolve_revisions", _wrap_svn_opt_resolve_revisions, -1);
  rb_define_module_function(mCore, "svn_opt_parse_revprop", _wrap_svn_opt_parse_revprop, -1);
  rb_define_module_function(mCore, "svn_opt_push_implicit_dot_target", _wrap_svn_opt_push_implicit_dot_target, -1);
  rb_define_module_function(mCore, "svn_opt_parse_path", _wrap_svn_opt_parse_path, -1);
  rb_define_module_function(mCore, "svn_opt_print_help4", _wrap_svn_opt_print_help4, -1);
  rb_define_module_function(mCore, "svn_opt_print_help3", _wrap_svn_opt_print_help3, -1);
  rb_define_module_function(mCore, "svn_opt_print_help2", _wrap_svn_opt_print_help2, -1);
  rb_define_module_function(mCore, "svn_opt_print_help", _wrap_svn_opt_print_help, -1);
  rb_define_module_function(mCore, "svn_cmdline_init", _wrap_svn_cmdline_init, -1);
  rb_define_module_function(mCore, "svn_cmdline_create_auth_baton", _wrap_svn_cmdline_create_auth_baton, -1);
  
  SwigClassSvn_auth_provider_t.klass = rb_define_class_under(mCore, "Svn_auth_provider_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_auth_provider_t, (void *) &SwigClassSvn_auth_provider_t);
  rb_define_alloc_func(SwigClassSvn_auth_provider_t.klass, _wrap_svn_auth_provider_t_allocate);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "initialize", _wrap_new_svn_auth_provider_t, -1);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "cred_kind=", _wrap_svn_auth_provider_t_cred_kind_set, -1);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "cred_kind", _wrap_svn_auth_provider_t_cred_kind_get, -1);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "first_credentials=", _wrap_svn_auth_provider_t_first_credentials_set, -1);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "first_credentials", _wrap_svn_auth_provider_t_first_credentials_get, -1);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "next_credentials=", _wrap_svn_auth_provider_t_next_credentials_set, -1);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "next_credentials", _wrap_svn_auth_provider_t_next_credentials_get, -1);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "save_credentials=", _wrap_svn_auth_provider_t_save_credentials_set, -1);
  rb_define_method(SwigClassSvn_auth_provider_t.klass, "save_credentials", _wrap_svn_auth_provider_t_save_credentials_get, -1);
  SwigClassSvn_auth_provider_t.mark = 0;
  SwigClassSvn_auth_provider_t.destroy = (void (*)(void *)) free_svn_auth_provider_t;
  SwigClassSvn_auth_provider_t.trackObjects = 0;
  
  SwigClassSvn_auth_provider_object_t.klass = rb_define_class_under(mCore, "Svn_auth_provider_object_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_auth_provider_object_t, (void *) &SwigClassSvn_auth_provider_object_t);
  rb_define_alloc_func(SwigClassSvn_auth_provider_object_t.klass, _wrap_svn_auth_provider_object_t_allocate);
  rb_define_method(SwigClassSvn_auth_provider_object_t.klass, "initialize", _wrap_new_svn_auth_provider_object_t, -1);
  rb_define_method(SwigClassSvn_auth_provider_object_t.klass, "vtable=", _wrap_svn_auth_provider_object_t_vtable_set, -1);
  rb_define_method(SwigClassSvn_auth_provider_object_t.klass, "vtable", _wrap_svn_auth_provider_object_t_vtable_get, -1);
  rb_define_method(SwigClassSvn_auth_provider_object_t.klass, "provider_baton=", _wrap_svn_auth_provider_object_t_provider_baton_set, -1);
  rb_define_method(SwigClassSvn_auth_provider_object_t.klass, "provider_baton", _wrap_svn_auth_provider_object_t_provider_baton_get, -1);
  SwigClassSvn_auth_provider_object_t.mark = 0;
  SwigClassSvn_auth_provider_object_t.destroy = (void (*)(void *)) free_svn_auth_provider_object_t;
  SwigClassSvn_auth_provider_object_t.trackObjects = 0;
  rb_define_const(mCore, "SVN_AUTH_CRED_SIMPLE", SWIG_FromCharPtr("svn.simple"));
  
  SwigClassSvn_auth_cred_simple_t.klass = rb_define_class_under(mCore, "Svn_auth_cred_simple_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_auth_cred_simple_t, (void *) &SwigClassSvn_auth_cred_simple_t);
  rb_define_alloc_func(SwigClassSvn_auth_cred_simple_t.klass, _wrap_svn_auth_cred_simple_t_allocate);
  rb_define_method(SwigClassSvn_auth_cred_simple_t.klass, "initialize", _wrap_new_svn_auth_cred_simple_t, -1);
  rb_define_method(SwigClassSvn_auth_cred_simple_t.klass, "username=", _wrap_svn_auth_cred_simple_t_username_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_simple_t.klass, "username", _wrap_svn_auth_cred_simple_t_username_get, -1);
  rb_define_method(SwigClassSvn_auth_cred_simple_t.klass, "password=", _wrap_svn_auth_cred_simple_t_password_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_simple_t.klass, "password", _wrap_svn_auth_cred_simple_t_password_get, -1);
  rb_define_method(SwigClassSvn_auth_cred_simple_t.klass, "may_save=", _wrap_svn_auth_cred_simple_t_may_save_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_simple_t.klass, "may_save", _wrap_svn_auth_cred_simple_t_may_save_get, -1);
  SwigClassSvn_auth_cred_simple_t.mark = 0;
  SwigClassSvn_auth_cred_simple_t.destroy = (void (*)(void *)) free_svn_auth_cred_simple_t;
  SwigClassSvn_auth_cred_simple_t.trackObjects = 0;
  rb_define_const(mCore, "SVN_AUTH_CRED_USERNAME", SWIG_FromCharPtr("svn.username"));
  
  SwigClassSvn_auth_cred_username_t.klass = rb_define_class_under(mCore, "Svn_auth_cred_username_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_auth_cred_username_t, (void *) &SwigClassSvn_auth_cred_username_t);
  rb_define_alloc_func(SwigClassSvn_auth_cred_username_t.klass, _wrap_svn_auth_cred_username_t_allocate);
  rb_define_method(SwigClassSvn_auth_cred_username_t.klass, "initialize", _wrap_new_svn_auth_cred_username_t, -1);
  rb_define_method(SwigClassSvn_auth_cred_username_t.klass, "username=", _wrap_svn_auth_cred_username_t_username_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_username_t.klass, "username", _wrap_svn_auth_cred_username_t_username_get, -1);
  rb_define_method(SwigClassSvn_auth_cred_username_t.klass, "may_save=", _wrap_svn_auth_cred_username_t_may_save_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_username_t.klass, "may_save", _wrap_svn_auth_cred_username_t_may_save_get, -1);
  SwigClassSvn_auth_cred_username_t.mark = 0;
  SwigClassSvn_auth_cred_username_t.destroy = (void (*)(void *)) free_svn_auth_cred_username_t;
  SwigClassSvn_auth_cred_username_t.trackObjects = 0;
  rb_define_const(mCore, "SVN_AUTH_CRED_SSL_CLIENT_CERT", SWIG_FromCharPtr("svn.ssl.client-cert"));
  
  SwigClassSvn_auth_cred_ssl_client_cert_t.klass = rb_define_class_under(mCore, "Svn_auth_cred_ssl_client_cert_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t, (void *) &SwigClassSvn_auth_cred_ssl_client_cert_t);
  rb_define_alloc_func(SwigClassSvn_auth_cred_ssl_client_cert_t.klass, _wrap_svn_auth_cred_ssl_client_cert_t_allocate);
  rb_define_method(SwigClassSvn_auth_cred_ssl_client_cert_t.klass, "initialize", _wrap_new_svn_auth_cred_ssl_client_cert_t, -1);
  rb_define_method(SwigClassSvn_auth_cred_ssl_client_cert_t.klass, "cert_file=", _wrap_svn_auth_cred_ssl_client_cert_t_cert_file_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_ssl_client_cert_t.klass, "cert_file", _wrap_svn_auth_cred_ssl_client_cert_t_cert_file_get, -1);
  rb_define_method(SwigClassSvn_auth_cred_ssl_client_cert_t.klass, "may_save=", _wrap_svn_auth_cred_ssl_client_cert_t_may_save_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_ssl_client_cert_t.klass, "may_save", _wrap_svn_auth_cred_ssl_client_cert_t_may_save_get, -1);
  SwigClassSvn_auth_cred_ssl_client_cert_t.mark = 0;
  SwigClassSvn_auth_cred_ssl_client_cert_t.destroy = (void (*)(void *)) free_svn_auth_cred_ssl_client_cert_t;
  SwigClassSvn_auth_cred_ssl_client_cert_t.trackObjects = 0;
  rb_define_const(mCore, "SVN_AUTH_CRED_SSL_CLIENT_CERT_PW", SWIG_FromCharPtr("svn.ssl.client-passphrase"));
  
  SwigClassSvn_auth_cred_ssl_client_cert_pw_t.klass = rb_define_class_under(mCore, "Svn_auth_cred_ssl_client_cert_pw_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t, (void *) &SwigClassSvn_auth_cred_ssl_client_cert_pw_t);

src/subversion/subversion/bindings/swig/ruby/core.c  view on Meta::CPAN

  SwigClassSvn_auth_cred_ssl_client_cert_pw_t.mark = 0;
  SwigClassSvn_auth_cred_ssl_client_cert_pw_t.destroy = (void (*)(void *)) free_svn_auth_cred_ssl_client_cert_pw_t;
  SwigClassSvn_auth_cred_ssl_client_cert_pw_t.trackObjects = 0;
  rb_define_const(mCore, "SVN_AUTH_CRED_SSL_SERVER_TRUST", SWIG_FromCharPtr("svn.ssl.server"));
  
  SwigClassSvn_auth_ssl_server_cert_info_t.klass = rb_define_class_under(mCore, "Svn_auth_ssl_server_cert_info_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_auth_ssl_server_cert_info_t, (void *) &SwigClassSvn_auth_ssl_server_cert_info_t);
  rb_define_alloc_func(SwigClassSvn_auth_ssl_server_cert_info_t.klass, _wrap_svn_auth_ssl_server_cert_info_t_allocate);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "initialize", _wrap_new_svn_auth_ssl_server_cert_info_t, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "hostname=", _wrap_svn_auth_ssl_server_cert_info_t_hostname_set, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "hostname", _wrap_svn_auth_ssl_server_cert_info_t_hostname_get, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "fingerprint=", _wrap_svn_auth_ssl_server_cert_info_t_fingerprint_set, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "fingerprint", _wrap_svn_auth_ssl_server_cert_info_t_fingerprint_get, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "valid_from=", _wrap_svn_auth_ssl_server_cert_info_t_valid_from_set, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "valid_from", _wrap_svn_auth_ssl_server_cert_info_t_valid_from_get, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "valid_until=", _wrap_svn_auth_ssl_server_cert_info_t_valid_until_set, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "valid_until", _wrap_svn_auth_ssl_server_cert_info_t_valid_until_get, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "issuer_dname=", _wrap_svn_auth_ssl_server_cert_info_t_issuer_dname_set, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "issuer_dname", _wrap_svn_auth_ssl_server_cert_info_t_issuer_dname_get, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "ascii_cert=", _wrap_svn_auth_ssl_server_cert_info_t_ascii_cert_set, -1);
  rb_define_method(SwigClassSvn_auth_ssl_server_cert_info_t.klass, "ascii_cert", _wrap_svn_auth_ssl_server_cert_info_t_ascii_cert_get, -1);
  SwigClassSvn_auth_ssl_server_cert_info_t.mark = 0;
  SwigClassSvn_auth_ssl_server_cert_info_t.destroy = (void (*)(void *)) free_svn_auth_ssl_server_cert_info_t;
  SwigClassSvn_auth_ssl_server_cert_info_t.trackObjects = 0;
  rb_define_module_function(mCore, "svn_auth_ssl_server_cert_info_dup", _wrap_svn_auth_ssl_server_cert_info_dup, -1);
  
  SwigClassSvn_auth_cred_ssl_server_trust_t.klass = rb_define_class_under(mCore, "Svn_auth_cred_ssl_server_trust_t", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t, (void *) &SwigClassSvn_auth_cred_ssl_server_trust_t);
  rb_define_alloc_func(SwigClassSvn_auth_cred_ssl_server_trust_t.klass, _wrap_svn_auth_cred_ssl_server_trust_t_allocate);
  rb_define_method(SwigClassSvn_auth_cred_ssl_server_trust_t.klass, "initialize", _wrap_new_svn_auth_cred_ssl_server_trust_t, -1);
  rb_define_method(SwigClassSvn_auth_cred_ssl_server_trust_t.klass, "may_save=", _wrap_svn_auth_cred_ssl_server_trust_t_may_save_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_ssl_server_trust_t.klass, "may_save", _wrap_svn_auth_cred_ssl_server_trust_t_may_save_get, -1);
  rb_define_method(SwigClassSvn_auth_cred_ssl_server_trust_t.klass, "accepted_failures=", _wrap_svn_auth_cred_ssl_server_trust_t_accepted_failures_set, -1);
  rb_define_method(SwigClassSvn_auth_cred_ssl_server_trust_t.klass, "accepted_failures", _wrap_svn_auth_cred_ssl_server_trust_t_accepted_failures_get, -1);
  SwigClassSvn_auth_cred_ssl_server_trust_t.mark = 0;
  SwigClassSvn_auth_cred_ssl_server_trust_t.destroy = (void (*)(void *)) free_svn_auth_cred_ssl_server_trust_t;
  SwigClassSvn_auth_cred_ssl_server_trust_t.trackObjects = 0;
  rb_define_const(mCore, "SVN_AUTH_SSL_NOTYETVALID", SWIG_From_int((int)(0x00000001)));
  rb_define_const(mCore, "SVN_AUTH_SSL_EXPIRED", SWIG_From_int((int)(0x00000002)));
  rb_define_const(mCore, "SVN_AUTH_SSL_CNMISMATCH", SWIG_From_int((int)(0x00000004)));
  rb_define_const(mCore, "SVN_AUTH_SSL_UNKNOWNCA", SWIG_From_int((int)(0x00000008)));
  rb_define_const(mCore, "SVN_AUTH_SSL_OTHER", SWIG_From_int((int)(0x40000000)));
  rb_define_module_function(mCore, "svn_auth_set_parameter", _wrap_svn_auth_set_parameter, -1);
  rb_define_module_function(mCore, "svn_auth_get_parameter", _wrap_svn_auth_get_parameter, -1);
  rb_define_const(mCore, "SVN_AUTH_PARAM_PREFIX", SWIG_FromCharPtr("svn:auth:"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_DEFAULT_USERNAME", SWIG_FromCharPtr("svn:auth:username"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_DEFAULT_PASSWORD", SWIG_FromCharPtr("svn:auth:password"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_NON_INTERACTIVE", SWIG_FromCharPtr("svn:auth:non-interactive"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_DONT_STORE_PASSWORDS", SWIG_FromCharPtr("svn:auth:dont-store-passwords"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_STORE_PLAINTEXT_PASSWORDS", SWIG_FromCharPtr("svn:auth:store-plaintext-passwords"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_DONT_STORE_SSL_CLIENT_CERT_PP", SWIG_FromCharPtr("svn:auth:dont-store-ssl-client-cert-pp"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT", SWIG_FromCharPtr("svn:auth:store-ssl-client-cert-pp-plaintext"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_NO_AUTH_CACHE", SWIG_FromCharPtr("svn:auth:no-auth-cache"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_SSL_SERVER_FAILURES", SWIG_FromCharPtr("svn:auth:ssl:failures"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO", SWIG_FromCharPtr("svn:auth:ssl:cert-info"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_CONFIG_CATEGORY_CONFIG", SWIG_FromCharPtr("svn:auth:config-category-config"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS", SWIG_FromCharPtr("svn:auth:config-category-servers"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_CONFIG", SWIG_FromCharPtr("svn:auth:config-category-servers"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_SERVER_GROUP", SWIG_FromCharPtr("svn:auth:server-group"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_CONFIG_DIR", SWIG_FromCharPtr("svn:auth:config-dir"));
  rb_define_module_function(mCore, "svn_auth_first_credentials", _wrap_svn_auth_first_credentials, -1);
  rb_define_module_function(mCore, "svn_auth_next_credentials", _wrap_svn_auth_next_credentials, -1);
  rb_define_module_function(mCore, "svn_auth_save_credentials", _wrap_svn_auth_save_credentials, -1);
  rb_define_module_function(mCore, "svn_auth_forget_credentials", _wrap_svn_auth_forget_credentials, -1);
  rb_define_module_function(mCore, "svn_auth_get_simple_prompt_provider", _wrap_svn_auth_get_simple_prompt_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_username_prompt_provider", _wrap_svn_auth_get_username_prompt_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_simple_provider2", _wrap_svn_auth_get_simple_provider2, -1);
  rb_define_module_function(mCore, "svn_auth_get_simple_provider", _wrap_svn_auth_get_simple_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_platform_specific_provider", _wrap_svn_auth_get_platform_specific_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_platform_specific_client_providers", _wrap_svn_auth_get_platform_specific_client_providers, -1);
  rb_define_const(mCore, "SVN_AUTH_PARAM_GNOME_KEYRING_UNLOCK_PROMPT_FUNC", SWIG_FromCharPtr("gnome-keyring-unlock-prompt-func"));
  rb_define_const(mCore, "SVN_AUTH_PARAM_GNOME_KEYRING_UNLOCK_PROMPT_BATON", SWIG_FromCharPtr("gnome-keyring-unlock-prompt-baton"));
  rb_define_module_function(mCore, "svn_auth_get_username_provider", _wrap_svn_auth_get_username_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_ssl_server_trust_file_provider", _wrap_svn_auth_get_ssl_server_trust_file_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_file_provider", _wrap_svn_auth_get_ssl_client_cert_file_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_pw_file_provider2", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider2, -1);
  rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_pw_file_provider", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_ssl_server_trust_prompt_provider", _wrap_svn_auth_get_ssl_server_trust_prompt_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_prompt_provider, -1);
  rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_pw_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_pw_prompt_provider, -1);
  rb_define_module_function(mCore, "svn_auth_provider_invoke_first_credentials", _wrap_svn_auth_provider_invoke_first_credentials, -1);
  rb_define_module_function(mCore, "svn_auth_provider_invoke_next_credentials", _wrap_svn_auth_provider_invoke_next_credentials, -1);
  rb_define_module_function(mCore, "svn_auth_provider_invoke_save_credentials", _wrap_svn_auth_provider_invoke_save_credentials, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_simple_provider_func", _wrap_svn_auth_invoke_simple_provider_func, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_ssl_client_cert_pw_provider_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_provider_func, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_simple_prompt_func", _wrap_svn_auth_invoke_simple_prompt_func, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_username_prompt_func", _wrap_svn_auth_invoke_username_prompt_func, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_ssl_server_trust_prompt_func", _wrap_svn_auth_invoke_ssl_server_trust_prompt_func, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_ssl_client_cert_prompt_func", _wrap_svn_auth_invoke_ssl_client_cert_prompt_func, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_ssl_client_cert_pw_prompt_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_prompt_func, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_plaintext_prompt_func", _wrap_svn_auth_invoke_plaintext_prompt_func, -1);
  rb_define_module_function(mCore, "svn_auth_invoke_plaintext_passphrase_prompt_func", _wrap_svn_auth_invoke_plaintext_passphrase_prompt_func, -1);
  rb_define_const(mCore, "SVN_CONFIG_CATEGORY_SERVERS", SWIG_FromCharPtr("servers"));
  rb_define_const(mCore, "SVN_CONFIG_SECTION_GROUPS", SWIG_FromCharPtr("groups"));
  rb_define_const(mCore, "SVN_CONFIG_SECTION_GLOBAL", SWIG_FromCharPtr("global"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_PROXY_HOST", SWIG_FromCharPtr("http-proxy-host"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_PROXY_PORT", SWIG_FromCharPtr("http-proxy-port"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_PROXY_USERNAME", SWIG_FromCharPtr("http-proxy-username"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_PROXY_PASSWORD", SWIG_FromCharPtr("http-proxy-password"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_PROXY_EXCEPTIONS", SWIG_FromCharPtr("http-proxy-exceptions"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_TIMEOUT", SWIG_FromCharPtr("http-timeout"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_COMPRESSION", SWIG_FromCharPtr("http-compression"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_NEON_DEBUG_MASK", SWIG_FromCharPtr("neon-debug-mask"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_AUTH_TYPES", SWIG_FromCharPtr("http-auth-types"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_SSL_AUTHORITY_FILES", SWIG_FromCharPtr("ssl-authority-files"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_SSL_TRUST_DEFAULT_CA", SWIG_FromCharPtr("ssl-trust-default-ca"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_SSL_CLIENT_CERT_FILE", SWIG_FromCharPtr("ssl-client-cert-file"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_SSL_CLIENT_CERT_PASSWORD", SWIG_FromCharPtr("ssl-client-cert-password"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_SSL_PKCS11_PROVIDER", SWIG_FromCharPtr("ssl-pkcs11-provider"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_LIBRARY", SWIG_FromCharPtr("http-library"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_STORE_PASSWORDS", SWIG_FromCharPtr("store-passwords"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_STORE_PLAINTEXT_PASSWORDS", SWIG_FromCharPtr("store-plaintext-passwords"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_STORE_AUTH_CREDS", SWIG_FromCharPtr("store-auth-creds"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_STORE_SSL_CLIENT_CERT_PP", SWIG_FromCharPtr("store-ssl-client-cert-pp"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT", SWIG_FromCharPtr("store-ssl-client-cert-pp-plaintext"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_USERNAME", SWIG_FromCharPtr("username"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_BULK_UPDATES", SWIG_FromCharPtr("http-bulk-updates"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_HTTP_MAX_CONNECTIONS", SWIG_FromCharPtr("http-max-connections"));
  rb_define_const(mCore, "SVN_CONFIG_CATEGORY_CONFIG", SWIG_FromCharPtr("config"));
  rb_define_const(mCore, "SVN_CONFIG_SECTION_AUTH", SWIG_FromCharPtr("auth"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_PASSWORD_STORES", SWIG_FromCharPtr("password-stores"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_KWALLET_WALLET", SWIG_FromCharPtr("kwallet-wallet"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_KWALLET_SVN_APPLICATION_NAME_WITH_PID", SWIG_FromCharPtr("kwallet-svn-application-name-with-pid"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_SSL_CLIENT_CERT_FILE_PROMPT", SWIG_FromCharPtr("ssl-client-cert-file-prompt"));
  rb_define_const(mCore, "SVN_CONFIG_SECTION_HELPERS", SWIG_FromCharPtr("helpers"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_EDITOR_CMD", SWIG_FromCharPtr("editor-cmd"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_DIFF_CMD", SWIG_FromCharPtr("diff-cmd"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_DIFF_EXTENSIONS", SWIG_FromCharPtr("diff-extensions"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_DIFF3_CMD", SWIG_FromCharPtr("diff3-cmd"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_DIFF3_HAS_PROGRAM_ARG", SWIG_FromCharPtr("diff3-has-program-arg"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_MERGE_TOOL_CMD", SWIG_FromCharPtr("merge-tool-cmd"));
  rb_define_const(mCore, "SVN_CONFIG_SECTION_MISCELLANY", SWIG_FromCharPtr("miscellany"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_GLOBAL_IGNORES", SWIG_FromCharPtr("global-ignores"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_LOG_ENCODING", SWIG_FromCharPtr("log-encoding"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_USE_COMMIT_TIMES", SWIG_FromCharPtr("use-commit-times"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_TEMPLATE_ROOT", SWIG_FromCharPtr("template-root"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_ENABLE_AUTO_PROPS", SWIG_FromCharPtr("enable-auto-props"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_NO_UNLOCK", SWIG_FromCharPtr("no-unlock"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_MIMETYPES_FILE", SWIG_FromCharPtr("mime-types-file"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_PRESERVED_CF_EXTS", SWIG_FromCharPtr("preserved-conflict-file-exts"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_INTERACTIVE_CONFLICTS", SWIG_FromCharPtr("interactive-conflicts"));
  rb_define_const(mCore, "SVN_CONFIG_OPTION_MEMORY_CACHE_SIZE", SWIG_FromCharPtr("memory-cache-size"));
  rb_define_const(mCore, "SVN_CONFIG_SECTION_TUNNELS", SWIG_FromCharPtr("tunnels"));