Alien-SVN

 view release on metacpan or  search on metacpan

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

#define SVN_ERR_P(obj) (RTEST(rb_obj_is_kind_of(obj, rb_svn_error())))

static VALUE mSvn = Qnil;
static VALUE mSvnClient = Qnil;
static VALUE mSvnUtil = Qnil;
static VALUE cSvnClientContext = Qnil;
static VALUE mSvnCore = Qnil;
static VALUE cSvnCorePool = Qnil;
static VALUE cSvnCoreStream = Qnil;
static VALUE cSvnDelta = Qnil;
static VALUE cSvnDeltaEditor = Qnil;
static VALUE cSvnDeltaTextDeltaWindowHandler = Qnil;
static VALUE cSvnError = Qnil;
static VALUE cSvnErrorSvnError = Qnil;
static VALUE cSvnFs = Qnil;
static VALUE cSvnFsFileSystem = Qnil;
static VALUE cSvnRa = Qnil;
static VALUE cSvnRaReporter3 = Qnil;

static apr_pool_t *swig_rb_pool;
static apr_allocator_t *swig_rb_allocator;

#define DECLARE_ID(key) static ID id_ ## key
#define DEFINE_ID(key) DEFINE_ID_WITH_NAME(key, #key)
#define DEFINE_ID_WITH_NAME(key, name) id_ ## key = rb_intern(name)

DECLARE_ID(code);
DECLARE_ID(message);
DECLARE_ID(call);
DECLARE_ID(read);
DECLARE_ID(write);
DECLARE_ID(eqq);
DECLARE_ID(baton);
DECLARE_ID(new);
DECLARE_ID(new_corresponding_error);
DECLARE_ID(set_target_revision);
DECLARE_ID(open_root);
DECLARE_ID(delete_entry);
DECLARE_ID(add_directory);
DECLARE_ID(open_directory);
DECLARE_ID(change_dir_prop);
DECLARE_ID(close_directory);
DECLARE_ID(absent_directory);
DECLARE_ID(add_file);
DECLARE_ID(open_file);
DECLARE_ID(apply_textdelta);
DECLARE_ID(change_file_prop);
DECLARE_ID(absent_file);
DECLARE_ID(close_file);
DECLARE_ID(close_edit);
DECLARE_ID(abort_edit);
DECLARE_ID(__pool__);
DECLARE_ID(__pools__);
DECLARE_ID(name);
DECLARE_ID(value);
DECLARE_ID(swig_type_regex);
DECLARE_ID(open_tmp_file);
DECLARE_ID(get_wc_prop);
DECLARE_ID(set_wc_prop);
DECLARE_ID(push_wc_prop);
DECLARE_ID(invalidate_wc_props);
DECLARE_ID(progress_func);
DECLARE_ID(auth_baton);
DECLARE_ID(found_entry);
DECLARE_ID(file_changed);
DECLARE_ID(file_added);
DECLARE_ID(file_deleted);
DECLARE_ID(dir_added);
DECLARE_ID(dir_deleted);
DECLARE_ID(dir_props_changed);
DECLARE_ID(handler);
DECLARE_ID(handler_baton);
DECLARE_ID(__batons__);
DECLARE_ID(destroy);
DECLARE_ID(filename_to_temp_file);
DECLARE_ID(inspect);
DECLARE_ID(handle_error);
DECLARE_ID(set_path);
DECLARE_ID(delete_path);
DECLARE_ID(link_path);
DECLARE_ID(finish_report);
DECLARE_ID(abort_report);
DECLARE_ID(to_s);
DECLARE_ID(upcase);


typedef void *(*r2c_func)(VALUE value, void *ctx, apr_pool_t *pool);
typedef VALUE (*c2r_func)(void *value, void *ctx);
typedef struct hash_to_apr_hash_data_t
{
  apr_hash_t *apr_hash;
  r2c_func func;
  void *ctx;
  apr_pool_t *pool;
} hash_to_apr_hash_data_t;

static void r2c_swig_type2(VALUE value, const char *type_name, void **result);
static const char *r2c_inspect(VALUE object);



/* constant getter */
static VALUE
rb_svn(void)
{
  if (NIL_P(mSvn)) {
    mSvn = rb_const_get(rb_cObject, rb_intern("Svn"));
  }
  return mSvn;
}

static VALUE
rb_svn_util(void)
{
  if (NIL_P(mSvnUtil)) {
    mSvnUtil = rb_const_get(rb_svn(), rb_intern("Util"));
  }
  return mSvnUtil;
}

static VALUE

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

  return result ? rb_str_new2(result) : Qnil;
}

static VALUE
svn_swig_rb_gettext_bindtextdomain(VALUE self, VALUE path)
{
#ifdef ENABLE_NLS
  bindtextdomain(PACKAGE_NAME, StringValueCStr(path));
#endif
  return Qnil;
}

static VALUE
svn_swig_rb_gettext__(VALUE self, VALUE message)
{
#ifdef ENABLE_NLS
  return rb_str_new2(_(StringValueCStr(message)));
#else
  return message;
#endif
}

static void
svn_swig_rb_initialize_ids(void)
{
  DEFINE_ID(code);
  DEFINE_ID(message);
  DEFINE_ID(call);
  DEFINE_ID(read);
  DEFINE_ID(write);
  DEFINE_ID_WITH_NAME(eqq, "===");
  DEFINE_ID(baton);
  DEFINE_ID(new);
  DEFINE_ID(new_corresponding_error);
  DEFINE_ID(set_target_revision);
  DEFINE_ID(open_root);
  DEFINE_ID(delete_entry);
  DEFINE_ID(add_directory);
  DEFINE_ID(open_directory);
  DEFINE_ID(change_dir_prop);
  DEFINE_ID(close_directory);
  DEFINE_ID(absent_directory);
  DEFINE_ID(add_file);
  DEFINE_ID(open_file);
  DEFINE_ID(apply_textdelta);
  DEFINE_ID(change_file_prop);
  DEFINE_ID(absent_file);
  DEFINE_ID(close_file);
  DEFINE_ID(close_edit);
  DEFINE_ID(abort_edit);
  DEFINE_ID(__pool__);
  DEFINE_ID(__pools__);
  DEFINE_ID(name);
  DEFINE_ID(value);
  DEFINE_ID(swig_type_regex);
  DEFINE_ID(open_tmp_file);
  DEFINE_ID(get_wc_prop);
  DEFINE_ID(set_wc_prop);
  DEFINE_ID(push_wc_prop);
  DEFINE_ID(invalidate_wc_props);
  DEFINE_ID(progress_func);
  DEFINE_ID(auth_baton);
  DEFINE_ID(found_entry);
  DEFINE_ID(file_changed);
  DEFINE_ID(file_added);
  DEFINE_ID(file_deleted);
  DEFINE_ID(dir_added);
  DEFINE_ID(dir_deleted);
  DEFINE_ID(dir_props_changed);
  DEFINE_ID(handler);
  DEFINE_ID(handler_baton);
  DEFINE_ID(__batons__);
  DEFINE_ID(destroy);
  DEFINE_ID(filename_to_temp_file);
  DEFINE_ID(inspect);
  DEFINE_ID(handle_error);
  DEFINE_ID(set_path);
  DEFINE_ID(delete_path);
  DEFINE_ID(link_path);
  DEFINE_ID(finish_report);
  DEFINE_ID(abort_report);
  DEFINE_ID(to_s);
  DEFINE_ID(upcase);
}

static void
check_apr_status(apr_status_t status, VALUE exception_class, const char *format)
{
    if (status != APR_SUCCESS) {
	char buffer[1024];
	apr_strerror(status, buffer, sizeof(buffer) - 1);
	rb_raise(exception_class, format, buffer);
    }
}

static VALUE swig_type_re = Qnil;

static VALUE
swig_type_regex(void)
{
  if (NIL_P(swig_type_re)) {
    char reg_str[] = "\\A(?:SWIG|Svn::Ext)::";
    swig_type_re = rb_reg_new(reg_str, strlen(reg_str), 0);
    rb_ivar_set(rb_svn(), id_swig_type_regex, swig_type_re);
  }
  return swig_type_re;
}

static VALUE
find_swig_type_object(int num, VALUE *objects)
{
  VALUE re;
  int i;

  re = swig_type_regex();
  for (i = 0; i < num; i++) {
    if (RTEST(rb_reg_match(re,
                           rb_funcall(rb_obj_class(objects[i]),
                                      id_name,
                                      0)))) {

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

      *value = NULL;
    } else {
      *value = r2c_svn_string(result, NULL, pool);
    }
  }

  return err;
}

static svn_error_t *
ra_callbacks_set_wc_prop(void *baton,
                         const char *path,
                         const char *name,
                         const svn_string_t *value,
                         apr_pool_t *pool)
{
  VALUE callbacks = (VALUE)baton;
  svn_error_t *err = SVN_NO_ERROR;

  if (!NIL_P(callbacks)) {
    callback_baton_t cbb;

    cbb.receiver = callbacks;
    cbb.message = id_set_wc_prop;
    cbb.args = rb_ary_new3(3,
                           c2r_string2(path),
                           c2r_string2(name),
                           c2r_svn_string((void *)value, NULL));
    invoke_callback_handle_error((VALUE)(&cbb), Qnil, &err);
  }

  return err;
}

static svn_error_t *
ra_callbacks_push_wc_prop(void *baton,
                          const char *path,
                          const char *name,
                          const svn_string_t *value,
                          apr_pool_t *pool)
{
  VALUE callbacks = (VALUE)baton;
  svn_error_t *err = SVN_NO_ERROR;

  if (!NIL_P(callbacks)) {
    callback_baton_t cbb;

    cbb.receiver = callbacks;
    cbb.message = id_push_wc_prop;
    cbb.args = rb_ary_new3(3,
                           c2r_string2(path),
                           c2r_string2(name),
                           c2r_svn_string((void *)value, NULL));
    invoke_callback_handle_error((VALUE)(&cbb), Qnil, &err);
  }

  return err;
}

static svn_error_t *
ra_callbacks_invalidate_wc_props(void *baton,
                                 const char *path,
                                 const char *name,
                                 apr_pool_t *pool)
{
  VALUE callbacks = (VALUE)baton;
  svn_error_t *err = SVN_NO_ERROR;

  if (!NIL_P(callbacks)) {
    callback_baton_t cbb;

    cbb.receiver = callbacks;
    cbb.message = id_invalidate_wc_props;
    cbb.args = rb_ary_new3(2, c2r_string2(path), c2r_string2(name));
    invoke_callback_handle_error((VALUE)(&cbb), Qnil, &err);
  }

  return err;
}


static void
ra_callbacks_progress_func(apr_off_t progress,
                           apr_off_t total,
                           void *baton,
                           apr_pool_t *pool)
{
  VALUE callbacks = (VALUE)baton;
  if (!NIL_P(callbacks)) {
    callback_baton_t cbb;

    cbb.receiver = callbacks;
    cbb.message = id_progress_func;
    cbb.args = rb_ary_new3(2, AOFF2NUM(progress), AOFF2NUM(total));
    invoke_callback((VALUE)(&cbb), Qnil);
  }
}

void
svn_swig_rb_setup_ra_callbacks(svn_ra_callbacks2_t **callbacks,
                               void **baton,
                               VALUE rb_callbacks,
                               apr_pool_t *pool)
{
  void *auth_baton = NULL;

  if (!NIL_P(rb_callbacks)) {
    VALUE rb_auth_baton = Qnil;
    rb_auth_baton = rb_funcall(rb_callbacks, id_auth_baton, 0);
    auth_baton = r2c_swig_type(rb_auth_baton,
                               (void *)"svn_auth_baton_t *",
                               pool);
  }

  *callbacks = apr_pcalloc(pool, sizeof(**callbacks));
  *baton = (void *)rb_callbacks;

  (*callbacks)->open_tmp_file = ra_callbacks_open_tmp_file;
  (*callbacks)->auth_baton = auth_baton;
  (*callbacks)->get_wc_prop = ra_callbacks_get_wc_prop;
  (*callbacks)->set_wc_prop = ra_callbacks_set_wc_prop;
  (*callbacks)->push_wc_prop = ra_callbacks_push_wc_prop;
  (*callbacks)->invalidate_wc_props = ra_callbacks_invalidate_wc_props;
  (*callbacks)->progress_func = ra_callbacks_progress_func;
  (*callbacks)->progress_baton = (void *)rb_callbacks;
}


svn_error_t *
svn_swig_rb_ra_lock_callback(void *baton,
                             const char *path,
                             svn_boolean_t do_lock,
                             const svn_lock_t *lock,
                             svn_error_t *ra_err,
                             apr_pool_t *pool)
{
  svn_error_t *err = SVN_NO_ERROR;
  VALUE proc, rb_pool;

  svn_swig_rb_from_baton((VALUE)baton, &proc, &rb_pool);

  if (!NIL_P(proc)) {
    callback_baton_t cbb;

    cbb.receiver = proc;
    cbb.message = id_call;
    cbb.args = rb_ary_new3(4,
                           c2r_string2(path),
                           do_lock ? Qtrue : Qfalse,
                           c2r_lock__dup(lock),
                           ra_err ?
                             svn_swig_rb_svn_error_to_rb_error(ra_err) :
                             Qnil);
    invoke_callback_handle_error((VALUE)(&cbb), rb_pool, &err);
  }

  return err;
}

svn_error_t *
svn_swig_rb_just_call(void *baton)
{
  svn_error_t *err = SVN_NO_ERROR;
  VALUE proc, rb_pool;

  svn_swig_rb_from_baton((VALUE)baton, &proc, &rb_pool);

  if (!NIL_P(proc)) {
    callback_baton_t cbb;

    cbb.receiver = proc;
    cbb.message = id_call;
    cbb.args = rb_ary_new3(0);
    invoke_callback_handle_error((VALUE)(&cbb), rb_pool, &err);
  }

  return err;
}

svn_error_t *
svn_swig_rb_ra_file_rev_handler(void *baton,
                                const char *path,
                                svn_revnum_t rev,