(module svn-client
  *

(import chicken scheme foreign)

(declare (foreign-declare #<<EOF
#include <apr.h>
#include <apr_hash.h>
#include <apr_file_io.h>
#include <apr_pools.h>
#include <svn_auth.h>
#include <svn_client.h>
#include <svn_path.h>
#include <svn_pools.h>
#include <svn_config.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>

static svn_opt_revision_t revision_head;
static svn_opt_revision_t revision_unspecified;

char *svnwiki_user, *svnwiki_pass;
apr_pool_t *svn_pool;
svn_client_ctx_t *svn_ctx;

svn_error_t *
svnwiki_simple_first_credentials (void **credentials, void **iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool)
{
  svn_auth_cred_simple_t *cred;
  *credentials = cred = apr_pcalloc(pool, sizeof(svn_auth_cred_simple_t));
  cred->username = apr_pstrdup (pool, svnwiki_user);
  cred->password = apr_pstrdup (pool, svnwiki_pass);
  cred->may_save = 0;
  return 0;
}

svn_error_t *
svnwiki_username_first_credentials (void **credentials, void **iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool)
{
  svn_auth_cred_username_t *cred;
  *credentials = cred = apr_pcalloc(pool, sizeof(svn_auth_cred_simple_t));
  cred->username = apr_pstrdup (pool, svnwiki_user);
  cred->may_save = 0;
  return 0;
}

svn_error_t *
svnwiki_log_callback (const char **log_msg, const char **tmp_file, apr_array_header_t *commit_items, void *baton, apr_pool_t *pool)
{
  *tmp_file = NULL;
  *log_msg = baton;
  return SVN_NO_ERROR;
}

svn_auth_provider_t svnwiki_auth_simple   = { SVN_AUTH_CRED_SIMPLE, svnwiki_simple_first_credentials, NULL, NULL };
svn_auth_provider_object_t svnwiki_auth_simple_obj = { &svnwiki_auth_simple, NULL };

svn_auth_provider_t svnwiki_auth_username = { SVN_AUTH_CRED_USERNAME, svnwiki_username_first_credentials, NULL, NULL };
svn_auth_provider_object_t svnwiki_auth_username_obj = { &svnwiki_auth_username, NULL };
EOF
))

;;; Pools

(define-record apr-pool ptr)

(define-foreign-type
  apr-pool-type
  (pointer "apr_pool_t")
  apr-pool-ptr
  make-apr-pool)

(define svn-pool-create
  (foreign-lambda apr-pool-type "svn_pool_create" apr-pool-type))

;;; Hashes

(define-record apr-hash ptr)

(define-foreign-type
  apr-hash-type
  (pointer "apr_hash_t")
  apr-hash-ptr
  make-apr-hash)

(define-record apr-hash-index ptr)

(define-foreign-type
  apr-hash-index-type
  (pointer "apr_hash_index_t")
  apr-hash-index-ptr
  make-apr-hash-index)

(define apr-hash-first
  (foreign-lambda* apr-hash-index-type ((apr-hash-type hash))
  "return(apr_hash_first(svn_pool, hash));"))

(define apr-hash-next
  (foreign-lambda* apr-hash-index-type ((apr-hash-index-type index)) #<<EOF
  return(apr_hash_next(index));
EOF
))
  ;(foreign-lambda apr-hash-index-type "apr_hash_next" apr-hash-index-type))

(define-external (apr_hash_this_inner ((pointer void) key) (long len) ((pointer void) value)) scheme-object
  (list key len value))

(define apr-hash-this
  (foreign-lambda* void ((apr-hash-index-type index)) #<<EOF
  const void *key;
  apr_ssize_t keylen;
  void *value;
  apr_hash_this(index, &key, &keylen, &value);
  return(apr_hash_this_inner(key, keylen, value));
EOF
))

;;; Errors

(define-record svn-error ptr)

(define-foreign-type
  svn-error-type
  (pointer "svn_error_t")
  svn-error-ptr
  make-svn-error)

(define svn-no-error
  (foreign-value "SVN_NO_ERROR" svn-error-type))

;;; Init

((foreign-lambda* c-pointer () #<<EOF
  apr_array_header_t *providers;

  apr_initialize();
  svn_pool = svn_pool_create(NULL);
  svn_config_ensure(NULL, svn_pool);

  svn_client_create_context(&svn_ctx, svn_pool);
  svn_config_get_config(&svn_ctx->config, NULL, svn_pool);

  providers = apr_array_make(svn_pool, 2, sizeof(svn_auth_provider_object_t *));

  *(svn_auth_provider_object_t **)apr_array_push(providers) = &svnwiki_auth_simple_obj;
  *(svn_auth_provider_object_t **)apr_array_push(providers) = &svnwiki_auth_username_obj;

  svn_auth_open(&svn_ctx->auth_baton, providers, svn_pool);

  revision_head.kind = svn_opt_revision_head;
  revision_unspecified.kind = svn_opt_revision_unspecified;

  return(NULL);
EOF
))

;;; Info

(define-record svn-info ptr)

;(define (make-svn-info-with-finalizer x)
;  (set-finalizer! x (foreign-lambda void "free" (pointer "svn_info_t")))
;  (make-svn-info x))

(define-foreign-type
  svn-info-type
  (pointer "svn_info_t")
  svn-info-ptr
  ;make-svn-info-with-finalizer)
  make-svn-info)

(define svn-info-url
  (foreign-lambda* c-string ((svn-info-type info))
#<<EOF
  return(info->URL);
EOF
))

(define svn-info-repos-root-url
  (foreign-lambda* c-string ((svn-info-type info))
#<<EOF
  return(info->repos_root_URL);
EOF
))

(define svn-info-rev
  (foreign-lambda* long ((svn-info-type info))
#<<EOF
  return(info->rev);
EOF
))

;;; Revisions

(define-record svn-opt-revision ptr)

(define (make-svn-opt-revision-with-finalizer x)
  (set-finalizer! x (foreign-lambda void "free" (pointer "svn_opt_revision_t")))
  (make-svn-opt-revision x))

(define-foreign-type
  svn-opt-revision-type
  (pointer "svn_opt_revision_t")
  svn-opt-revision-ptr
  make-svn-opt-revision-with-finalizer)

(define make-svn-opt-revision-number
  (foreign-lambda* svn-opt-revision-type ((long num))
#<<EOF
  svn_opt_revision_t *rev = malloc(sizeof(svn_opt_revision_t));
  if (rev)
    {
      rev->kind = svn_opt_revision_number;
      rev->value.number = num;
    }
  return(rev);
EOF
))

(define svn-opt-revision-head
  (make-svn-opt-revision (foreign-value "&revision_head" (pointer "svn_opt_revision_t"))))

(define svn-opt-revision-unspecified
  (make-svn-opt-revision (foreign-value "&revision_unspecified" (pointer "svn_opt_revision_t"))))

(define svn-opt-revision-number
  (foreign-lambda* long ((svn-opt-revision-type rev))
#<<EOF
  return(rev->kind == svn_opt_revision_number ? rev->value.number : -1);
EOF
))

(define svn-opt-revision-kind
  (foreign-lambda* unsigned-int ((svn-opt-revision-type rev))
#<<EOF
  return(rev->kind);
EOF
))

(define-foreign-type svn-revnum-type long)

;;; svn_log_changed_path_t

(define-record svn-log-changed-path ptr)

(define (make-svn-log-changed-path-with-finalizer x)
  (set-finalizer! x
    (foreign-lambda* void (((pointer "svn_log_changed_path_t") obj))
      "if (obj) free(obj->copyfrom_path); free(obj);"))
  (make-svn-log-changed-path x))

(define-foreign-type
  svn-log-changed-path-type
  (pointer "svn_log_changed_path_t")
  svn-log-changed-path-ptr
  make-svn-log-changed-path-with-finalizer)

(define svn-log-changed-path-action
  (foreign-lambda* char ((svn-log-changed-path-type info))
#<<EOF
    return(info->action);
EOF
))

(define svn-log-changed-path-copy-from-path
  (foreign-lambda* c-string ((svn-log-changed-path-type info))
#<<EOF
    return(info->copyfrom_path);
EOF
))

(define svn-log-changed-path-copy-from-rev
  (foreign-lambda* long ((svn-log-changed-path-type info))
#<<EOF
    return(info->copyfrom_rev);
EOF
))

;;; Other stuff

(define svn-commit
  (foreign-lambda* scheme-object ((c-string path) (c-string user) (c-string pass) (c-string changes))
#<<EOF
  svn_client_commit_info_t *commit_info = NULL;
  apr_array_header_t *targets = apr_array_make(svn_pool, 1, sizeof(char *));
  svn_error_t *err;

  (*((const char **) apr_array_push (targets))) = path;

  svnwiki_user = user;
  svnwiki_pass = pass;

  svn_ctx->log_msg_func = svnwiki_log_callback;
  svn_ctx->log_msg_baton = changes;

  err = svn_client_commit(&commit_info, targets, FALSE, svn_ctx, svn_pool);
  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  if (!commit_info || commit_info->revision == SVN_INVALID_REVNUM)
    return(C_SCHEME_TRUE);
  return(C_fix(commit_info->revision));
EOF
))

(define svn-update
  (foreign-lambda* scheme-object ((c-string url) (c-string path) (svn-opt-revision-type rev) (c-string user) (c-string pass))
#<<EOF
  svn_revnum_t revnum;
  svn_error_t *err;

  svnwiki_user = user;
  svnwiki_pass = pass;

  err = svn_client_checkout(&revnum, url, path, rev, TRUE, svn_ctx, svn_pool);
  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  return(C_fix(revnum));
EOF
))

(define svn-diff
  (foreign-lambda* c-string* ((c-string path) (c-string user) (c-string pass))
#<<EOF
  apr_array_header_t *diff_opts = apr_array_make(svn_pool, 0, sizeof (char *));
  char template[] = "/tmp/svnwiki-diff-XXXXXX";
  svn_opt_revision_t rev1, rev2;
  apr_file_t *outfile;
  svn_error_t *err;

  svnwiki_user = user;
  svnwiki_pass = pass;

  rev1.kind = svn_opt_revision_head;
  rev2.kind = svn_opt_revision_working;

  mkstemp(template);
  apr_file_open(&outfile, template, APR_WRITE, APR_OS_DEFAULT, svn_pool);
  err = svn_client_diff(diff_opts, path, &rev1, path, &rev2, TRUE, FALSE, TRUE, outfile, NULL, svn_ctx, svn_pool);
  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(NULL);
    }
  apr_file_close(outfile);
  return(strdup(template));
EOF
))

(define svn-ls
  (foreign-safe-lambda* scheme-object ((c-string path) (scheme-object result) (c-string user) (c-string pass))
#<<EOF
  svn_error_t *err;
  apr_hash_t *dirents;
  apr_hash_index_t *tmp;
  svn_opt_revision_t head;
  const char *can_path = svn_path_internal_style(path, svn_pool);

  head.kind = svn_opt_revision_head;

  svnwiki_user = user;
  svnwiki_pass = pass;

  err = svn_client_ls(&dirents, can_path, &head, FALSE, svn_ctx, svn_pool);
  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  for (tmp = apr_hash_first(svn_pool, dirents); tmp; tmp = apr_hash_next(tmp))
    {
      const void *key;
      apr_ssize_t keylen;
      svn_dirent_t *value;

      apr_hash_this(tmp, &key, &keylen, (void **) &value);
      result = svn_ls_add(key,
                          value->kind == svn_node_file ? C_fix(value->size) : C_SCHEME_FALSE,
                          value->created_rev,
                          result);
    }

  return(result);
EOF
))

(define-external (svn_ls_add (c-string key) (scheme-object size) (long rev) (scheme-object result)) scheme-object
  (cons (list key size rev) result))

; Currently returns a list of all property values for a given file.

(define svn-propget
  (foreign-safe-lambda* scheme-object ((c-string propname) (c-string target) (c-string user) (c-string pass) (scheme-object result))
#<<EOF
  apr_hash_t *props;
  apr_pool_t *pool;
  svn_opt_revision_t head;
  apr_hash_index_t *tmp;
  svn_error_t *err;
  void *resultroot;

  head.kind = svn_opt_revision_unspecified;

  svnwiki_user = user;
  svnwiki_pass = pass;

  pool = svn_pool_create(NULL);

  resultroot = CHICKEN_new_gc_root();

  CHICKEN_gc_root_set(resultroot, result);

  err = svn_client_propget(&props, propname, target, &head, FALSE, svn_ctx, pool);
  if (err)
    {
      apr_pool_destroy(pool);
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  for (tmp = apr_hash_first(pool, props); tmp; tmp = apr_hash_next(tmp))
    {
      const void *key;
      apr_ssize_t keylen;
      svn_string_t *value;

      apr_hash_this(tmp, &key, &keylen, (void **) &value);
      CHICKEN_gc_root_set(resultroot, svn_propget_add(key, value->data, resultroot));
    }

  apr_pool_destroy(pool);

  result = CHICKEN_gc_root_ref(resultroot);
  CHICKEN_delete_gc_root(resultroot);

  return(result);
EOF
))

(define-external (svn_propget_add (c-string key) (c-string value) ((pointer void) result)) scheme-object
  (cons (list key value) (gc-root-ref result)))

(define svn-propset
  (foreign-safe-lambda* scheme-object ((c-string propname)
                                       (c-string propval)
                                       (c-string target)
                                       (bool recurse)
                                       (bool skip_checks))
#<<EOF
  svn_error_t *err;
  apr_pool_t *pool;

  pool = svn_pool_create(NULL);
  err = svn_client_propset2(propname, svn_string_create(propval, pool), target, recurse, skip_checks, svn_ctx, pool);
  apr_pool_destroy(pool);
  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }
  return(C_SCHEME_TRUE);
EOF
))

(define svn-add
  (foreign-safe-lambda* scheme-object ((c-string path) (c-string user) (c-string pass))
#<<EOF
  svn_error_t *err;
  svnwiki_user = user;
  svnwiki_pass = pass;

  err = svn_client_add(path, 0, svn_ctx, svn_pool);
  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }
  return(C_SCHEME_TRUE);
EOF
))

;;; History

(define gc-root-ref
  (foreign-lambda* void (((pointer "void") root)) "return(CHICKEN_gc_root_ref(root));"))

(define-external (svn_history_add ((pointer void) root) (apr-hash-type changed-paths) (svn-revnum-type rev) (c-string author) (c-string date) (c-string message) (apr-pool-type pool)) svn-error-type
  (let ((paths (changed-paths-fix changed-paths '())))
    ((gc-root-ref root) paths rev author date message))
  svn-no-error)

(define-external (changed_paths_fix_one (c-string key) (svn-log-changed-path-type log-cp) ((pointer void) root)) scheme-object
  (cons (cons key log-cp) (gc-root-ref root)))

(define changed-paths-fix
  (foreign-safe-lambda* scheme-object ((apr-hash-type paths) (scheme-object result)) #<<EOF
  apr_pool_t *pool;
  void *resultroot;
  apr_hash_index_t *tmp;

  if (!paths)
    return(result);

  resultroot = CHICKEN_new_gc_root();

  CHICKEN_gc_root_set(resultroot, result);

  pool = svn_pool_create(NULL);

  for (tmp = apr_hash_first(pool, paths); tmp; tmp = apr_hash_next(tmp))
    {
      const void *key;
      void *old;
      apr_ssize_t keylen;
      svn_log_changed_path_t *new = malloc(sizeof(svn_log_changed_path_t));

      apr_hash_this(tmp, &key, &keylen, &old);

      *new = * (svn_log_changed_path_t *) old;

      if (new->copyfrom_path)
        new->copyfrom_path = strdup(new->copyfrom_path);

      CHICKEN_gc_root_set(resultroot, changed_paths_fix_one(key, new, resultroot));
    }
  apr_pool_destroy(pool);
  result = CHICKEN_gc_root_ref(resultroot);
  CHICKEN_delete_gc_root(resultroot);

  return(result);
EOF
))

(define svn-client-log2
  (foreign-safe-lambda* bool ((c-string path) (svn-opt-revision-type start) (svn-opt-revision-type end) (int limit) (bool discover_changed_paths) (bool strict_node_history) (c-string user) (c-string pass) (scheme-object func))
#<<EOF
  apr_array_header_t *targets;
  apr_pool_t *pool;
  svn_error_t *err;
  void *funcroot = CHICKEN_new_gc_root();

  CHICKEN_gc_root_set(funcroot, func);

  pool = svn_pool_create(NULL);

  targets = apr_array_make(pool, 1, sizeof(char *));

  *(char **)apr_array_push(targets) = path;

  svnwiki_user = user;
  svnwiki_pass = pass;

  err = svn_client_log2(targets, start, end, limit, discover_changed_paths, strict_node_history, svn_history_add, (void *) funcroot, svn_ctx, pool);

  apr_pool_destroy(pool);
  CHICKEN_delete_gc_root(funcroot);

  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  return(C_SCHEME_TRUE);
EOF
))

; Currently returns a list with an entry for each commit between start and end.
; Each entry is itself a list with the commit message, the number of the
; revision that was created as the result of the commit, the author, the date
; of the commit (a string) and the list of changed files.

(define svn-client-log
  (foreign-safe-lambda* bool ((c-string path) (svn-opt-revision-type start) (svn-opt-revision-type end) (bool discover_changed_paths) (bool strict_node_history) (c-string user) (c-string pass) (scheme-object func))
#<<EOF
  apr_array_header_t *targets;
  apr_pool_t *pool;
  svn_error_t *err;
  void *funcroot = CHICKEN_new_gc_root();

  CHICKEN_gc_root_set(funcroot, func);

  pool = svn_pool_create(NULL);

  targets = apr_array_make(pool, 1, sizeof(char *));

  *(char **)apr_array_push(targets) = path;

  svnwiki_user = user;
  svnwiki_pass = pass;

  err = svn_client_log(targets, start, end, discover_changed_paths, strict_node_history, svn_history_add, (void *) funcroot, svn_ctx, pool);

  apr_pool_destroy(pool);
  CHICKEN_delete_gc_root(funcroot);

  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  return(C_SCHEME_TRUE);
EOF
))

(define get-lock
  (foreign-lambda* scheme-object ((c-string path))
#<<EOF
  int fd;
  mkdir(path, S_IRWXU);
  if ((fd = open(path, O_RDONLY)) == -1 || flock(fd, LOCK_EX) == -1)
    {
      fprintf(stderr, "%s: %s\n", path, strerror(errno));
      exit(EXIT_FAILURE);
    }
  return C_SCHEME_TRUE;
EOF
))

(define svn-time-from-cstring
  (foreign-lambda* number ((c-string data))
#<<EOF
  apr_time_t when;
  apr_pool_t *pool;
  pool = svn_pool_create(NULL);
  svn_time_from_cstring(&when, data, pool);
  apr_pool_destroy(pool);
  return((double) when);
EOF
))

(define svn-client-revert
  (foreign-safe-lambda* bool ((scheme-object paths) (bool recursive) (c-string user) (c-string pass))
#<<EOF
  apr_pool_t *pool;
  apr_array_header_t *paths_array;
  svn_error_t *err;
  C_word tmp;
  int len = 0;

  pool = svn_pool_create(NULL);

  for (tmp = paths; C_i_pairp(tmp) && tmp != C_SCHEME_END_OF_LIST; tmp = C_u_i_cdr(tmp))
    len ++;

  paths_array = apr_array_make(pool, len, sizeof(char *));

  for (tmp = paths; C_i_pairp(tmp) && tmp != C_SCHEME_END_OF_LIST; tmp = C_u_i_cdr(tmp))
    {
      int len = C_header_size(C_u_i_car(tmp));
      char *buffer = apr_palloc(svn_pool, len + 1);

      strncpy(buffer, C_c_string(C_u_i_car(tmp)), len);
      buffer[len] = 0;

      (*((const char **) apr_array_push(paths_array))) = buffer;
    }

  err = svn_client_revert(paths_array, recursive, svn_ctx, pool);

  apr_pool_destroy(pool);

  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  return(C_SCHEME_TRUE);
EOF
))

(define svn-client-resolved
  (foreign-safe-lambda* bool ((c-string path) (bool recursive))
#<<EOF
  apr_pool_t *pool;
  svn_error_t *err;

  pool = svn_pool_create(NULL);

  err = svn_client_resolved(path, recursive, svn_ctx, pool);

  apr_pool_destroy(pool);

  if (err)
    {
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  return(C_SCHEME_TRUE);
  
EOF
))

(define svn-path-canonicalize
  (foreign-safe-lambda* c-string ((c-string old))
#<<EOF
  apr_pool_t *pool;
  char *new;

  pool = svn_pool_create(NULL);

  new = strdup(svn_path_canonicalize(old, pool));

  apr_pool_destroy(pool);

  return(new);
EOF
))

(define svn-client-cat
  (foreign-safe-lambda* c-string* ((c-string path_or_url) (svn-opt-revision-type revision) (c-string user) (c-string pass))
#<<EOF
  apr_array_header_t *diff_opts = apr_array_make(svn_pool, 0, sizeof (char *));
  char template[] = "/tmp/svnwiki-cat-XXXXXX";
  apr_file_t *outfile;
  svn_stream_t *out;
  apr_pool_t *pool;

  apr_file_t *stdout_file;
  svn_error_t *err;

  svnwiki_user = user;
  svnwiki_pass = pass;

  pool = svn_pool_create(NULL);

  mkstemp(template);

  apr_file_open(&outfile, template, APR_WRITE, APR_OS_DEFAULT, pool);
  out = svn_stream_from_aprfile(outfile, pool);

  err = svn_client_cat(out, path_or_url, revision, svn_ctx, pool);
  if (err)
    {
      apr_pool_destroy(pool);
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(NULL);
    }

  svn_stream_close(out);
  apr_pool_destroy(pool);

  return(strdup(template));
EOF
))

(define svn-client-info
  (foreign-safe-lambda* void ((c-string path_or_url) (svn-opt-revision-type peg_revision) (svn-opt-revision-type revision) (scheme-object receiver) (bool recurse) (c-string user) (c-string pass))
#<<EOF
  void *receiverroot;

  apr_hash_t *props;
  apr_pool_t *pool;
  svn_opt_revision_t head;
  apr_hash_index_t *tmp;
  svn_error_t *err;

  svnwiki_user = user;
  svnwiki_pass = pass;

  pool = svn_pool_create(NULL);

  receiverroot = CHICKEN_new_gc_root();

  CHICKEN_gc_root_set(receiverroot, receiver);

  err = svn_client_info(path_or_url, peg_revision, revision, svn_client_info_receiver, receiverroot, recurse, svn_ctx, pool);
  if (err)
    {
      apr_pool_destroy(pool);
      svn_handle_error(err, stderr, FALSE);
      svn_error_clear(err);
      return(C_SCHEME_FALSE);
    }

  apr_pool_destroy(pool);

  CHICKEN_delete_gc_root(receiverroot);

  return(C_SCHEME_TRUE);
EOF
))

(define-external (svn_client_info_receiver ((pointer void) baton) (c-string path) (svn-info-type info) (apr-pool-type pool)) svn-error-type
  ((gc-root-ref baton) path info)
  svn-no-error)
)