swigutil_rb.c

subversion-1.4.3-1.tar.gz 配置svn的源码

    if (changed_paths) {
      rb_changed_paths = c2r_hash(changed_paths,
                                  c2r_log_changed_path_dup,
                                  NULL);
    }

    args = rb_ary_new3(7,
                       proc,
                       rb_id_call(),
                       rb_changed_paths,
                       c2r_long(&revision, NULL),
                       c2r_string2(author),
                       c2r_string2(date),
                       c2r_string2(message));
    invoke_callback_handle_error(args, rb_pool, &err);
  }
  return err;
}


svn_error_t *
svn_swig_rb_repos_authz_func(svn_boolean_t *allowed,
                             svn_fs_root_t *root,
                             const char *path,
                             void *baton,
                             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);

  *allowed = TRUE;
  
  if (!NIL_P(proc)) {
    VALUE args;
    VALUE result;

    args = rb_ary_new3(4,
                       proc,
                       rb_id_call(),
                       c2r_swig_type((void *)root, (void *)"svn_fs_root_t *"),
                       c2r_string2(path));
    result = invoke_callback_handle_error(args, rb_pool, &err);

    *allowed = RTEST(result);
  }
  return err;
}

svn_error_t *
svn_swig_rb_repos_authz_callback(svn_repos_authz_access_t required,
                                 svn_boolean_t *allowed,
                                 svn_fs_root_t *root,
                                 const char *path,
                                 void *baton,
                                 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);

  *allowed = TRUE;
  
  if (!NIL_P(proc)) {
    VALUE args;
    VALUE result;

    args = rb_ary_new3(5,
                       proc,
                       rb_id_call(),
                       INT2NUM(required),
                       c2r_swig_type((void *)root, (void *)"svn_fs_root_t *"),
                       c2r_string2(path));
    result = invoke_callback_handle_error(args, rb_pool, &err);

    *allowed = RTEST(result);
  }
  return err;
}

svn_error_t *
svn_swig_rb_get_commit_log_func2(const char **log_msg,
                                 const char **tmp_file,
                                 const apr_array_header_t *commit_items,
                                 void *baton,
                                 apr_pool_t *pool)
{
  svn_error_t *err = SVN_NO_ERROR;
  VALUE proc, rb_pool;

  *log_msg = NULL;
  *tmp_file = NULL;

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

  if (!NIL_P(proc)) {
    VALUE args;
    VALUE result;
    VALUE is_message;
    VALUE value;
    char *ret;

    args = rb_ary_new3(3,
                       proc,
                       rb_id_call(),
                       c2r_commit_item2_array(commit_items));
    result = invoke_callback_handle_error(args, rb_pool, &err);

    if (!err) {
      is_message = rb_ary_entry(result, 0);
      value = rb_ary_entry(result, 1);

      Check_Type(value, T_STRING);
      ret = (char *)r2c_string(value, NULL, pool);
      if (RTEST(is_message)) {
        *log_msg = ret;
      } else {
        *tmp_file = ret;
      }
    }
  }
  return err;
}


void
svn_swig_rb_notify_func2(void *baton,
                         const svn_wc_notify_t *notify,
                         apr_pool_t *pool)
{
  VALUE proc, rb_pool;

  svn_swig_rb_from_baton((VALUE)baton, &proc, &rb_pool);
  
  if (!NIL_P(proc)) {
    VALUE args;

    args = rb_ary_new3(3,
                       proc,
                       rb_id_call(),
                       c2r_wc_notify__dup(notify));
    invoke_callback(args, rb_pool);
  }
}

svn_error_t *
svn_swig_rb_commit_callback(svn_revnum_t new_revision,
                            const char *date,
                            const char *author,
                            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)) {
    VALUE args;

    args = rb_ary_new3(5,
                       proc,
                       rb_id_call(),
                       INT2NUM(new_revision),
                       c2r_string2(date),
                       c2r_string2(author));
    invoke_callback_handle_error(args, rb_pool, &err);
  }
  
  return err;
}

svn_error_t *
svn_swig_rb_commit_callback2(const svn_commit_info_t *commit_info,
                             void *baton, 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)) {
    VALUE args;

    args = rb_ary_new3(3,
                       proc,
                       rb_id_call(),
                       c2r_commit_info__dup(commit_info));
    invoke_callback_handle_error(args, rb_pool, &err);
  }
  
  return err;
}

svn_error_t *
svn_swig_rb_cancel_func(void *cancel_baton)
{
  svn_error_t *err = SVN_NO_ERROR;
  VALUE proc, rb_pool;

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

  if (!NIL_P(proc)) {
    VALUE args;

    args = rb_ary_new3(2,
                       proc,
                       rb_id_call());
    invoke_callback_handle_error(args, rb_pool, &err);
  }
  
  return err;
}

svn_error_t *
svn_swig_rb_info_receiver(void *baton,
                          const char *path,
                          const svn_info_t *info,
                          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)) {
    VALUE args;

    args = rb_ary_new3(4,
                       proc,
                       rb_id_call(),
                       c2r_string2(path),
                       c2r_info__dup(info));
    invoke_callback_handle_error(args, rb_pool, &err);
  }
  
  return err;
}

svn_boolean_t
svn_swig_rb_config_enumerator(const char *name,
                              const char *value,
                              void *baton,
                              apr_pool_t *pool)
{
  svn_boolean_t result = FALSE;
  VALUE proc, rb_pool;

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

  if (!NIL_P(proc)) {
    VALUE args;

    args = rb_ary_new3(4,
                       proc,
                       rb_id_call(),
                       c2r_string2(name),
                       c2r_string2(value));
    result = RTEST(invoke_callback(args, rb_pool));
  }
  
  return result;
}

svn_boolean_t
svn_swig_rb_config_section_enumerator(const char *name,
                                      void *baton,
                                      apr_pool_t *pool)
{
  svn_boolean_t result = FALSE;
  VALUE proc, rb_pool;

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

  if (!NIL_P(proc)) {
    VALUE args;

    args = rb_ary_new3(3,
                       proc,
                       rb_id_call(),
                       c2r_string2(name));
    result = RTEST(invoke_callback(args, rb_pool));
  }
  
  return result;
}

svn_error_t *
svn_swig_rb_delta_path_driver_cb_func(void **dir_baton,
                                      void *parent_baton,
                                      void *callback_baton,
                                      const char *path,
                                      apr_pool_t *pool)
{
  svn_error_t *err = SVN_NO_ERROR;
  VALUE proc, rb_pool;

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

  if (!NIL_P(proc)) {
    VALUE args, result;

    args = rb_ary_new3(4,
                       proc,
                       rb_id_call(),
                       parent_baton ? (VALUE)parent_baton : Qnil,
                       c2r_string2(path));
    result = invoke_callback_handle_error(args, rb_pool, &err);
    if (path[0] != '\0' && path[strlen(path) - 1] == '/') {
      *dir_baton = (void *)result;
    } else {
      *dir_baton = NULL;
    }
  }
  
  return err;
}

svn_error_t *
svn_swig_rb_txdelta_window_handler(svn_txdelta_window_t *window,
                                   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)) {
    VALUE args;

    args = rb_ary_new3(3,
                       proc,
                       rb_id_call(),
                       c2r_txdelta_window__dup(window));
    invoke_callback_handle_error(args, rb_pool, &err);
  }
  
  return err;
}

void
svn_swig_rb_fs_warning_callback(void *baton, svn_error_t *err)
{
  VALUE proc, rb_pool;

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

  if (!NIL_P(proc)) {
    VALUE args;

    args = rb_ary_new3(3,
                       proc,
                       rb_id_call(),
                       svn_swig_rb_svn_error_to_rb_error(err));
    invoke_callback(args, rb_pool);
  }
}

static apr_status_t
cleanup_fs_warning_callback_baton(void *baton)
{
  rb_holder_pop(rb_svn_fs_warning_callback_baton_holder(), (VALUE)baton);
  return APR_SUCCESS;
}

void
svn_swig_rb_fs_warning_callback_baton_register(VALUE baton, apr_pool_t *pool)
{
  rb_holder_push(rb_svn_fs_warning_callback_baton_holder(), (VALUE)baton);
  apr_pool_cleanup_register(pool, (void *)baton,
                            cleanup_fs_warning_callback_baton,
                            apr_pool_cleanup_null);
}

svn_error_t *
svn_swig_rb_fs_get_locks_callback(void *baton,
                                  svn_lock_t *lock,
                                  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)) {
    VALUE args;

    args = rb_ary_new3(3,
                       proc,
                       rb_id_call(),
                       c2r_lock__dup(lock));
    invoke_callback_handle_error(args, rb_pool, &err);
  }
  
  return err;
}


/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_open_tmp_file(apr_file_t **fp,
                           void *callback_baton,
                           apr_pool_t *pool)
{
  VALUE callbacks = (VALUE)callback_baton;
  svn_error_t *err = SVN_NO_ERROR;

  if (!NIL_P(callbacks)) {
    VALUE args, result;

    args = rb_ary_new3(2,
                       callbacks,
                       rb_id_open_tmp_file());
    
    result = invoke_callback_handle_error(args, Qnil, &err);
    *fp = svn_swig_rb_make_file(result, pool);
  }
  
  return err;
}

static svn_error_t *
ra_callbacks_get_wc_prop(void *baton,
                         const char *relpath,
                         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)) {
    VALUE args, result;

    args = rb_ary_new3(4,
                       callbacks,
                       rb_id_get_wc_prop(),
                       c2r_string2(relpath),
                       c2r_string2(name));
    
    result = invoke_callback_handle_error(args, Qnil, &err);
    if (NIL_P(result)) {
      *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)) {
    VALUE args;

    args = rb_ary_new3(5,
                       callbacks,
                       rb_id_set_wc_prop(),
                       c2r_string2(path),
                       c2r_string2(name),
                       c2r_svn_string((void *)value, NULL));
    
    invoke_callback_handle_error(args, Qnil, &err);
  }
  
  return err;
}

static svn_error_t *
ra_callbacks_push_wc_prop(void *baton,
                          const char *path,