/* ================================================================
 * Copyright (c) 2000-2004 CollabNet.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * 
 * 3. The end-user documentation included with the redistribution, if
 * any, must include the following acknowledgment: "This product includes
 * software developed by CollabNet (http://www.Collab.Net/)."
 * Alternately, this acknowledgment may appear in the software itself, if
 * and wherever such third-party acknowledgments normally appear.
 * 
 * 4. The hosted project names must not be used to endorse or promote
 * products derived from this software without prior written
 * permission. For written permission, please contact info@collab.net.
 * 
 * 5. Products derived from this software may not use the "Tigris" name
 * nor may "Tigris" appear in their names without prior written
 * permission of CollabNet.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL COLLABNET OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by many
 * individuals on behalf of CollabNet.
 */


#include "svnmod.h"

#include 
#include 
#include 


/*! @module Subversion */


/*! @class Client
 *!
 *!  The Client class provides convenient access to most user-level
 *!  operations.
 */

/* Function indices for callbacks */
static int notify_function, log_msg_function, cancel_function;

/* Internal object structure */
struct client_obj {
  svn_client_ctx_t *ctx;
  apr_pool_t *pool;
  struct array *auth_providers;
  struct mapping *config;
  struct svalue notify_func, log_msg_func, cancel_func;
};
#define THIS ((struct client_obj *)(Pike_fp->current_storage))


/*! @decl void notify_func( string path, int action, int kind,	  @
 *!                         string mime_type, int content_state,  @
 *!                         int prop_state, int revision )
 *!
 *!  This function is called when the state of an entry in the wc
 *!  changes.  Override it if you are interrested in this information.
 *!
 *! @param path
 *!   Path to the affected file or directory.
 *! @param action
 *!   The action taken on the entry.
 *! @param kind
 *!   The kind of entry (file or directory), see @[RA.Library.Session.check_path()].
 *! @param mime_type
 *!   The media type for the entry, if available (otherwise 0).
 *! @param content_state
 *!   The new state of the entry contents.
 *! @param prop_state
 *!   The new state of the entry properties.
 *! @param revision
 *!   The new revision of the entry.
 */
static void f_notify_func (INT32 args)
{
  pop_n_elems (args);
}


/*! @decl string log_msg_func( array(array(string|int)) commit_items )
 *!
 *!  Override this function to provide log messages for commits.
 *!
 *! @param commit_items
 *!   A list of items being committed.  Each element has the following
 *!   format:
 *! @array
 *!   @elem string path
 *!     Absolute working-copy path of item.
 *!   @elem int kind
 *!     Node kind (dir, file).
 *!   @elem string URL
 *!     Commit URL for this item.
 *!   @elem int revision
 *!     Revision (copyfrom-rev if _IS_COPY).
 *!   @elem string copyfrom_url
 *!     copyfrom-url.
 *!   @elem int state_flags
 *!     State flags.
 *! @endarray
 *!
 *! @returns
 *!   The function should return a log message for the commit as a string.
 */
static void f_log_msg_func (INT32 args)
{
  pop_n_elems (args);
  push_int (0);
}


/*! @decl void cancel_func( )
 *!
 *!  Override this function to enable operations in progress to be aborted.
 *!  If the operation should continue, the function should do nothing.
 *!  If not, it should throw an error with apr_err of SVN_ERR_CANCELLED.
 *!
 */
static void f_cancel_func (INT32 args)
{
  pop_n_elems (args);
  push_int (0);
}


/* C stub for calling notify_func */

static void notify_func_stub (void *baton, const char *path,
			      svn_wc_notify_action_t action,
			      svn_node_kind_t kind,
			      const char *mime_type,
			      svn_wc_notify_state_t content_state,
			      svn_wc_notify_state_t prop_state,
			      svn_revnum_t revision)
{
  JMP_BUF recovery;

  do {
    struct thread_state *_tmp=thread_state_for_id (th_self ());
    HIDE_GLOBAL_VARIABLES ();
    THREADS_DISALLOW ();

    if (SETJMP (recovery))
      call_handle_error ();
    else {
      svn_pike_push_utf8 (path);
      push_int (action);
      push_int (kind);
      svn_pike_push_utf8 (mime_type);
      push_int (content_state);
      push_int (prop_state);
      push_int (revision);

      apply_svalue ((struct svalue *)baton, 7);
      pop_stack ();
    }
    UNSETJMP (recovery);

    THREADS_ALLOW ();
  } while (0);
}


/* C stub for calling log_msg_func */

static svn_error_t *log_msg_func_stub (const char **log_msg,
				       const char **tmp_file,
				       apr_array_header_t *commit_items,
				       void *baton, apr_pool_t *pool)
{
  JMP_BUF recovery;
  svn_error_t *err = SVN_NO_ERROR;

  if(tmp_file) *tmp_file = NULL;
  do {
    struct thread_state *_tmp=thread_state_for_id (th_self ());
    HIDE_GLOBAL_VARIABLES ();
    THREADS_DISALLOW ();

    if (SETJMP (recovery)) {
      err = svn_pike_make_svn_error (&throw_value);
    } else {
      if (commit_items && commit_items->elts) {
	int i;
	struct svn_client_commit_item_t **cis =
	  (struct svn_client_commit_item_t **) commit_items->elts;
	push_array (allocate_array (commit_items->nelts));
	for (i=0; inelts; i++) {
	  svn_pike_push_utf8 (cis[i]->path);
	  push_int (cis[i]->kind);
	  svn_pike_push_utf8 (cis[i]->url);
	  push_int (cis[i]->revision);
	  svn_pike_push_utf8 (cis[i]->copyfrom_url);
	  push_int (cis[i]->state_flags);
	  f_aggregate (6);
	  assign_svalue (&ITEM(Pike_sp[-2].u.array)[i], Pike_sp-1);
	  pop_stack ();
	}
      } else
	push_array (allocate_array (0));
      apply_svalue ((struct svalue *)baton, 1);
      if (Pike_sp[-1].type != PIKE_T_STRING)
	Pike_error ("log_msg_func must return a string\n");
      f_string_to_utf8 (1);
      *log_msg = apr_pstrdup (pool, APR_STR0 (Pike_sp[-1].u.string));
      pop_stack ();
    }
    UNSETJMP (recovery);

    THREADS_ALLOW ();
  } while (0);

  return err;
}


/* C stub for calling status_func */

static void status_func_stub (void *baton,
			      const char *path,
			      svn_wc_status_t *status)
{
  JMP_BUF recovery;

  do {
    struct thread_state *_tmp=thread_state_for_id (th_self ());
    HIDE_GLOBAL_VARIABLES ();
    THREADS_DISALLOW ();

    if (SETJMP (recovery)) {
      call_handle_error();
    } else {
      svn_pike_push_utf8 (path);
      if(status) {
	push_constant_text("text_status");
	push_int(status->text_status);
	push_constant_text("prop_status");
	push_int(status->prop_status);
	push_constant_text("locked");
	push_int(status->locked);
	push_constant_text("copied");
	push_int(status->copied);
	push_constant_text("switched");
	push_int(status->switched);
	push_constant_text("repos_text_status");
	push_int(status->repos_text_status);
	push_constant_text("repos_prop_status");
	push_int(status->repos_prop_status);
	if(status->entry) {
	  svn_wc_entry_t *entry = status->entry;
	  push_constant_text("name");
	  svn_pike_push_utf8(entry->name);
	  push_constant_text("revision");
	  push_int(entry->revision);
	  push_constant_text("url");
	  svn_pike_push_utf8(entry->url);
	  push_constant_text("repos");
	  svn_pike_push_utf8(entry->repos);
	  push_constant_text("kind");
	  push_int(entry->kind);	
	  push_constant_text("schedule");
	  push_int(entry->schedule);
	  push_constant_text("copied");
	  push_int(entry->copied);
	  push_constant_text("deleted");
	  push_int(entry->deleted);
	  push_constant_text("copyfrom_url");
	  svn_pike_push_utf8(entry->copyfrom_url);
	  push_constant_text("copyfrom_rev");
	  push_int(entry->copyfrom_rev);
	  push_constant_text("conflict_old");
	  svn_pike_push_utf8(entry->conflict_old);
	  push_constant_text("conflict_new");
	  svn_pike_push_utf8(entry->conflict_new);
	  push_constant_text("conflict_wrk");
	  svn_pike_push_utf8(entry->conflict_wrk);
	  push_constant_text("prejfile");
	  svn_pike_push_utf8(entry->prejfile);
	  push_constant_text("text_time");
	  svn_pike_push_time(entry->text_time);
	  push_constant_text("prop_time");
	  svn_pike_push_time(entry->prop_time);
	  push_constant_text("checksum");
	  if(entry->checksum)
	    push_text(entry->checksum);
	  else
	    push_int(0);
	  push_constant_text("cmt_rev");
	  push_int(entry->cmt_rev);
	  push_constant_text("cmt_date");
	  svn_pike_push_time(entry->cmt_date);
	  push_constant_text("cmt_author");
	  svn_pike_push_utf8(entry->cmt_author);
	  f_aggregate_mapping(54);
	} else
	  f_aggregate_mapping(14);
      } else
	push_int(0);
      apply_svalue ((struct svalue *)baton, 2);
      pop_stack ();
    }
    UNSETJMP (recovery);

    THREADS_ALLOW ();
  } while (0);
}


/* C stub for calling blame_receiver_func */

static svn_error_t *blame_receiver_func_stub (void *baton,
					      apr_int64_t line_no,
					      svn_revnum_t revision,
					      const char *author,
					      const char *date,
					      const char *line,
					      apr_pool_t *pool)
{
  JMP_BUF recovery;
  svn_error_t *err = SVN_NO_ERROR;

  do {
    struct thread_state *_tmp=thread_state_for_id (th_self ());
    HIDE_GLOBAL_VARIABLES ();
    THREADS_DISALLOW ();

    if (SETJMP (recovery)) {
      err = svn_pike_make_svn_error (&throw_value);
    } else {
      push_int64 (line_no);
      push_int (revision);
      svn_pike_push_utf8 (author);
      svn_pike_push_utf8 (date);
      svn_pike_push_utf8 (line);
      apply_svalue ((struct svalue *)baton, 5);
      pop_stack ();
    }
    UNSETJMP (recovery);

    THREADS_ALLOW ();
  } while (0);

  return err;
}


/* C stub for calling cancel_func */

static svn_error_t *cancel_func_stub (void *baton)
{
  JMP_BUF recovery;
  svn_error_t *err = SVN_NO_ERROR;

  do {
    struct thread_state *_tmp=thread_state_for_id (th_self ());
    HIDE_GLOBAL_VARIABLES ();
    THREADS_DISALLOW ();

    if (SETJMP (recovery)) {
      err = svn_pike_make_svn_error (&throw_value);
    } else {
      apply_svalue ((struct svalue *)baton, 0);
      pop_stack ();
    }
    UNSETJMP (recovery);

    THREADS_ALLOW ();
  } while (0);

  return err;
}


/* Convert a commit_info struct to a Pike svalue */

static void make_commit_info (struct svalue *ret,
			      struct svn_client_commit_info_t *commit_info)
{
  if (commit_info) {
    push_int (commit_info->revision);
    svn_pike_push_utf8 (commit_info->date);
    svn_pike_push_utf8 (commit_info->author);
    f_aggregate (3);
    *ret = *--Pike_sp;
  } else {
    ret->u.integer = 0;
    ret->type = PIKE_T_INT;
    ret->subtype = NUMBER_NUMBER;
  }
}


/* Convert an APR array of property hashes to a Pike mapping */
static void make_proplist (struct svalue *ret, apr_array_header_t *props)
{
  if(props) {
    svn_client_proplist_item_t **pis =
      (svn_client_proplist_item_t **) props->elts;
    int i;
    for (i=0; inelts; i++) {
      svn_stringbuf_t *name = pis[i]->node_name;
      push_string (make_shared_binary_string (name->data, name->len));
      f_utf8_to_string (1);
      svn_pike_make_propmap (Pike_sp, pis[i]->prop_hash, -1);
      Pike_sp ++;
    }
    f_aggregate_mapping(2*props->nelts);
    *ret = *--Pike_sp;  
  } else {
    ret->u.integer = 0;
    ret->type = PIKE_T_INT;
    ret->subtype = NUMBER_UNDEFINED;
  }
}


/*! @decl int checkout( string URL, string path, Revision|void revision,  @
 *!                     int|void non_recursive )
 *!
 *!  Checkout a working copy of a Subversion repository.
 *!
 *! @param URL
 *!   Repository URL to checkout.
 *! @param path
 *!   Root directory of the newly checked out working copy.
 *! @param revision
 *!   Revision number to checkout, or UNDEFINED for newset revision.
 *! @param non_recursive
 *!   If non-zero, don't checkout subdirectories.
 *!
 *! @returns
 *!   The actual revision number that was checked out.
 */
static void f_checkout (INT32 args)
{
  struct pike_string *url, *path;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_revnum_t ret_rev;
  svn_opt_revision_t revision;
  svn_boolean_t recurse;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("checkout", args, "%W%W", &url, &path);
  svn_pike_check_rev_arg ("checkout", args, 2, &revision);
  recurse = svn_pike_check_recurse_arg ("checkout", args, 3);

  url = svn_pike_to_utf8 (url);
  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_checkout (&ret_rev,
			     svn_path_canonicalize (APR_STR0 (url), pool),
			     svn_path_canonicalize (APR_STR0 (path), pool),
			     &revision, recurse, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path);
  do_free_string (url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (ret_rev);
  }
}


/*! @decl int update( string path, Revision|void revision,	@
 *!                   int|void nonrecursive )
 *!
 *!  Update a working copy to a new revision.
 *!
 *! @param path
 *!   The path of the working tree.
 *! @param revision
 *!   Revision to update to, or UNDEFINED for the latest revision.
 *! @param non_recursive
 *!   If non-zero, don't update subdirectories.
 *!
 *! @returns
 *!   The actual revision number that the working copy was updated to.
 */
static void f_update (INT32 args)
{
  struct pike_string *path;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_revnum_t ret_rev;
  svn_opt_revision_t revision;
  svn_boolean_t recurse;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("update", args, "%W", &path);
  svn_pike_check_rev_arg ("update", args, 1, &revision);
  recurse = svn_pike_check_recurse_arg ("update", args, 2);

  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_update (&ret_rev, svn_path_canonicalize (APR_STR0 (path), pool),
			   &revision, recurse,
			   ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (ret_rev);
  }
}


/*! @decl int switch( string path, string URL, Revision|void revision,	@
 *!                   int|void nonrecursive )
 *!
 *!  Switch a working tree to a different branch/tag.
 *!
 *! @param path
 *!   The path of the working tree.
 *! @param URL
 *!   New repository URL for this working tree.
 *! @param revision
 *!   Revision to switch to, or UNDEFINED for the latest revision.
 *! @param non_recursive
 *!   If non-zero, don't switch subdirectories.
 *!
 *! @returns
 *!   The actual revision number that the working tree was switched to.
 */
static void f_switch (INT32 args)
{
  struct pike_string *url, *path;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_revnum_t ret_rev;
  svn_opt_revision_t revision;
  svn_boolean_t recurse;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("switch", args, "%W%W", &path, &url);
  svn_pike_check_rev_arg ("switch", args, 2, &revision);
  recurse = svn_pike_check_recurse_arg ("switch", args, 3);

  path = svn_pike_to_utf8 (path);
  url = svn_pike_to_utf8 (url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_switch (&ret_rev, svn_path_canonicalize (APR_STR0 (path), pool),
			   svn_path_canonicalize (APR_STR0 (url), pool), &revision,
			   recurse, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (url);
  do_free_string (path);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (ret_rev);
  }
}


/*! @decl void add( string path, int|void non_recursive )
 *!
 *!  Schedule a working copy file or directory for addition to
 *!  the repository.  @[path]'s parent must be under revision control
 *!  already.
 *!
 *! @param path
 *!   The path of the file or directory to add.
 *! @param non_recursive
 *!   If non-zero, don't schedule the contents of @[path] for
 *!   addition if it's a directory.
 */
static void f_add_ (INT32 args)
{
  struct pike_string *path;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_boolean_t recurse;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("add", args, "%W", &path);
  recurse = svn_pike_check_recurse_arg ("add", args, 1);

  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_add (svn_path_canonicalize (APR_STR0 (path), pool), recurse,
			ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl array(int|string) mkdir( array(string) paths_or_urls )
 *!
 *!  If @[paths_or_urls] contains URLs, immediately attempt to commit the
 *!  creation of those directory URL in the repository.  Else, create
 *!  the directories on disk, and attempt to schedule it for addition.
 *!
 *! @param paths_or_urls
 *!   Paths of directories to schedule for addition, or URLs of directories
 *!   to create in the repository.
 *!
 *! @returns
 *!   If @[paths_or_urls] contains at least one URL, an array containing
 *!   information about the commit is returned.  The elements are as follows:
 *! @array
 *!   @elem int revision
 *!     The revision in which the directory(/ies) was created.
 *!   @elem string date
 *!     The server-side date of the commit.
 *!   @elem string author
 *!     The author of the commit.
 *! @endarray
 *!
 *! @seealso
 *!   @[add()]
 */
static void f_mkdir (INT32 args)
{
  struct array *targets;
  apr_array_header_t *targets_aa;
  svn_error_t *err;
  apr_pool_t *pool;
  struct svn_client_commit_info_t *commit_info = NULL;
  struct svalue ret;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("mkdir", args, "%a", &targets);

  pool = svn_pool_create (NULL);

  targets_aa = svn_pike_make_targets_array (targets, pool, FALSE);

  THREADS_ALLOW ();

  err = svn_client_mkdir (&commit_info, targets_aa, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    make_commit_info(&ret, commit_info);

  apr_pool_destroy (pool);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl array(int|string) delete( array(string) paths_or_urls, int|void force )
 *!
 *!  If @[paths_or_urls] contain URLs, immediately attempt to commit the
 *!  deletion of those URLs from the repository.  Else, schedule the
 *!  specified working copy paths for removal from the repository.
 *!
 *! @param paths_or_urls
 *!   Paths to schedule for deletion, or URLs to immediately
 *!   remove in the repository.
 *! @param force
 *!   Unless set, the operation will fail if a working copy path
 *!   that contains locally modified and/or unversioned items is
 *!   specified.
 *!
 *! @returns
 *!   If @[paths_or_urls] contains at least one URL, an array containing
 *!   information about the commit is returned.  The elements are as follows:
 *! @array
 *!   @elem int revision
 *!     The revision in which the item(s) was removed.
 *!   @elem string date
 *!     The server-side date of the commit.
 *!   @elem string author
 *!     The author of the commit.
 *! @endarray
 */
static void f_delete (INT32 args)
{
  struct array *targets;
  apr_array_header_t *targets_aa;
  svn_error_t *err;
  apr_pool_t *pool;
  struct svn_client_commit_info_t *commit_info = NULL;
  struct svalue ret;
  svn_boolean_t force;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("delete", args, "%a", &targets);
  force = svn_pike_check_force_arg ("delete", args, 1);

  pool = svn_pool_create (NULL);

  targets_aa = svn_pike_make_targets_array (targets, pool, FALSE);

  THREADS_ALLOW ();

  err = svn_client_delete (&commit_info, targets_aa, force, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    make_commit_info (&ret, commit_info);

  apr_pool_destroy (pool);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl array(int|string) import( string path, string URL,	    @
 *!                                 int|void non_recursive )
 *!
 *!  Import a file or directory into the repository directory @[URL] at
 *!  head.
 *!
 *! @param path
 *!   The path of the file or directory to import.
 *! @param URL
 *!   The URL of the repository directory in which to place the
 *!   imported item(s).
 *! @param non_recursive
 *!   If non-zero, don't import subdirectories.
 *!
 *! @returns
 *!   An array containing information about the commit is returned.
 *!   The elements are as follows:
 *! @array
 *!   @elem int revision
 *!     The revision in which the item was imported.
 *!   @elem string date
 *!     The server-side date of the commit.
 *!   @elem string author
 *!     The author of the commit.
 *! @endarray
 */
static void f_import (INT32 args)
{
  struct pike_string *path, *url;
  svn_error_t *err;
  apr_pool_t *pool;
  struct svn_client_commit_info_t *commit_info = NULL;
  struct svalue ret;
  svn_boolean_t recurse;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("import", args, "%W%W", &path, &url);
  recurse = svn_pike_check_recurse_arg ("import", args, 2);

  path = svn_pike_to_utf8 (path);
  url = svn_pike_to_utf8 (url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_import (&commit_info,
			   svn_path_canonicalize (APR_STR0 (path), pool),
			   svn_path_canonicalize (APR_STR0 (url), pool),
			   !recurse, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    make_commit_info (&ret, commit_info);

  apr_pool_destroy (pool);

  do_free_string (url);
  do_free_string (path);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl array(int|string) commit( array(string) targets,		    @
 *!                                 int|void non_recursive )
 *!
 *!  Commit a set of files and directorues to the repository at head.
 *!
 *! @param targets
 *!   The paths of the files and directories to commit.
 *! @param non_recursive
 *!   If non-zero, don't commit subdirectories.
 *!
 *! @returns
 *!   An array containing information about the commit is returned.
 *!   The elements are as follows:
 *! @array
 *!   @elem int revision
 *!     The revision in which the targets were committed.
 *!   @elem string date
 *!     The server-side date of the commit.
 *!   @elem string author
 *!     The author of the commit.
 *! @endarray
 */
static void f_commit (INT32 args)
{
  struct array *targets;
  apr_array_header_t *targets_aa;
  svn_error_t *err;
  apr_pool_t *pool;
  struct svn_client_commit_info_t *commit_info = NULL;
  struct svalue ret;
  svn_boolean_t recurse;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("commit", args, "%a", &targets);
  recurse = svn_pike_check_recurse_arg ("commit", args, 1);

  pool = svn_pool_create (NULL);

  targets_aa = svn_pike_make_targets_array (targets, pool, FALSE);

  THREADS_ALLOW ();

  err = svn_client_commit (&commit_info, targets_aa,
			   !recurse, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    make_commit_info (&ret, commit_info);

  apr_pool_destroy (pool);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl int status( string path,				@
 *!		      function(string, mapping(string:mixed):void) status_func, @
 *!                   int|void non_recursive,			@
 *!		      int|void all, int|void update,		@
 *!		      Revision|void revision,			@
 *!		      int|void no_ignore )
 *!
 *!  Request status information for a file or directory.  The status
 *!  information will be passed to the function @[status_func].
 *!
 *! @param path
 *!   The file or directory to get status for.
 *! @param status_func
 *!   A function to invoke once for each file that status is queried on.
 *!   The parameters to this function are as follows:
 *!   @array
 *!     @elem string path
 *!       The path of the entry that this status information concerns
 *!     @elem mapping(string:mixed) status
 *!       A mapping containing status information about the entry.
 *!       The values in the mapping are as follows:
 *!       @mapping
 *!         @member int text_status
 *!           Status of the textual component.
 *!         @member int prop_status
 *!           Status of the property component.
 *!         @member int locked
 *!           Entry is locked.
 *!         @member int copied
 *!           Entry is copied.
 *!         @member int switched
 *!           Entry is switched.
 *!         @member int repos_text_status
 *!           Status of the textual component in the repository.
 *!         @member int repos_prop_status
 *!           Status of the property component in the repository.
 *!         @member string name
 *!           The entry's name.
 *!         @member int revision
 *!           Base revision.
 *!         @member string url
 *!           URL in repository.
 *!         @member string repos
 *!           Canonical repository URL.
 *!         @member int kind
 *!           Node kind (file, dir, ...).
 *!         @member int schedule
 *!           Scheduling (add, delete, replace ...).
 *!         @member int copied
 *!           In a copied state.
 *!         @member int deleted
 *!           In a deleted state.
 *!         @member string copyfrom_url
 *!           Copyfrom location.
 *!         @member int copyfrom_rev
 *!           Copyfrom revision.
 *!         @member string conflict_old
 *!           Old version of conflicted file.
 *!         @member string conflict_new
 *!           New version of conflicted file.
 *!         @member string conflict_wrk
 *!           Wroking version of conflicted file.
 *!         @member string prejfile
 *!           Property reject file
 *!         @member int text_time
 *!           Last up-to-date time for text contents.
 *!         @member int prop_time
 *!           Last up-to-date time for properties.
 *!         @member string checksum
 *!           Base64-encoded checksum for the untranslated text base file.
 *!         @member int cmt_rev
 *!           Last revision this was changed.
 *!         @member int cmt_date
 *!           Last date this was changed.
 *!         @member string cmt_author
 *!           Last commit author of this item.
 *!       @endmapping
 *!   @endarray
 *! @param non_recursive
 *!   If non-zero, don't query subdirectories.
 *! @param all
 *!   If set, all entries are retrieved; otherwise only "interesting"
 *!   entries (local mods and/or out-of-date) will be fetched.
 *! @param update
 *!   If set, the repository will be contacted, so that the status 
 *!   structure is augmented with information about out-of-dateness
 *!   (with respect to @[revision]).
 *! @param revision
 *!   When @[update] is specified, this argument can be used to
 *!   select the revision against which out-of-dateness is checked.
 *!   If @[update] is zero, this argument is not used.
 *! @param no_ignore
 *!   If set, the svn:ignore property is ignored.
 *!
 *! @returns
 *!   The revision number against which out-of-datedness was checked,
 *!   if @[update] is set.  If @[update] is not set, zero is returned.
 */
static void f_status (INT32 args)
{
  struct pike_string *path;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_revnum_t ret_rev = SVN_INVALID_REVNUM;
  svn_opt_revision_t revision;
  svn_boolean_t recurse, get_all, update, no_ignore;
  struct svalue *status_func;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("status", args, "%W%*", &path, &status_func);
  recurse = svn_pike_check_recurse_arg ("status", args, 2);
  get_all = svn_pike_check_force_arg ("status", args, 3);
  update = svn_pike_check_force_arg ("status", args, 4);
  no_ignore = svn_pike_check_force_arg ("status", args, 6);
  svn_pike_check_rev_arg ("status", args, 5, &revision);

  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_status (&ret_rev, svn_path_canonicalize (APR_STR0 (path), pool),
			   &revision, status_func_stub, status_func,
			   recurse, get_all, update, no_ignore,
			   ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (update? ret_rev : 0);
  }
}


/*! @decl void log( array(string) targets,				    @
 *!		    function(int, string, string, string,		    @
 *!		    mapping(string:array(int|string))|void:void) log_func,  @
 *!		    Revision start_revision, Revision end_revision,	    @
 *!		    int|void discover_changed_paths,			    @
 *!                 int|void strict_node_history )
 *!
 *!  Call @[log_func] on each log message from start_revision
 *!  to end_revision in turn, inclusive.
 *!
 *! @param targets
 *!   The paths of the files and directories for which log messages
 *!   are desired.
 *! @param log_func
 *!   This function is invoked once on each log message.  The
 *!   parameters are as follows:
 *!     @array
 *!       @elem int revision
 *!         The revision this log message concerns.
 *!       @elem string author
 *!         The author that committed this revision.
 *!       @elem string date
 *!         The date when this revision was committed.
 *!       @elem string message
 *!         The log message for this revision.
 *!       @elem mapping(string:array(int|string)) changed_paths
 *!         A mapping from entry name to change information for all
 *!         entries that were changed in this revision (if such information
 *!         was requested).  The values in the mapping are as follows:
 *!       @array
 *!         @elem int action
 *!           'A'dd, 'D'elete, 'R'eplace, 'M'odify
 *!         @elem string copyfrom_path
 *!           Source path of copy (if any).
 *!         @elem int copyfrom_rev
 *!           Source revision of copy (if any).
 *!       @endarray
 *!     @endarray
 *! @param start_revision
 *!   The oldest revision for which log messages are desired.
 *! @param end_revision
 *!   The newest revision for which log messages are desired.
 *! @param discover_changed_paths
 *!   If set, then the changed_paths argument to log_func
 *!   will be passed on each invocation.
 *! @param strict_node_history
 *!   If set, copy history will not be traversed while harvest revision
 *!   logs for each target.
 */
static void f_log (INT32 args)
{
  struct array *targets;
  apr_array_header_t *targets_aa;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_boolean_t discover_changed_paths, strict_node_history;
  svn_opt_revision_t start, end;
  struct svalue *log_receiver_func;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("log", args, "%a%*", &targets, &log_receiver_func);
  svn_pike_check_rev_arg ("log", args, 1, &start);
  svn_pike_check_rev_arg ("log", args, 2, &end);
  discover_changed_paths = svn_pike_check_force_arg ("log", args, 3);
  strict_node_history = svn_pike_check_force_arg ("log", args, 4);

  pool = svn_pool_create (NULL);

  targets_aa = svn_pike_make_targets_array (targets, pool, FALSE);

  THREADS_ALLOW ();

  err = svn_client_log (targets_aa, &start, &end,
			discover_changed_paths, strict_node_history,
			svn_pike_log_receiver_func_stub, log_receiver_func,
			ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void blame( string path_or_url,				      @
 *!		      function(int,int,string,string,string:void) receiver,   @
 *!		      Revision start_revision, Revision end_revision )
 *!
 *!  Call @[receiver] on each line-blame item associated with revision
 *!  @[end_revision] of @[path_or_url], using @[start_revision] as the
 *!  default source of all blame.
 *!
 *! @param path_or_url
 *!   Path or URL of the node to examine for blame.
 *! @param receiver
 *!   A function to call for each line-blame item.  The parameters
 *!   are as follows:
 *!    @array
 *!      @elem int line_no
 *!        Line number
 *!      @elem int revision
 *!        Revision number
 *!      @elem string author
 *!        The author of this line
 *!      @elem string date
 *!        Commit datestamp of this line
 *!      @elem string line
 *!        The text contents of the line
 *!    @endarray
 *! @param start_revision
 *!   The default source of all blame.
 *! @param end_revision
 *!   The revision of @[path_or_url] for which to determine blame.
 */
static void f_blame (INT32 args)
{
  struct pike_string *path_or_url;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_opt_revision_t start, end;
  struct svalue *blame_receiver_func;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("blame", args, "%W%*", &path_or_url, &blame_receiver_func);
  svn_pike_check_rev_arg ("log", args, 2, &start);
  svn_pike_check_rev_arg ("log", args, 3, &end);

  path_or_url = svn_pike_to_utf8 (path_or_url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_blame (svn_path_canonicalize (APR_STR0 (path_or_url), pool),
			  &start, &end, blame_receiver_func_stub,
			  blame_receiver_func, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path_or_url);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void diff( string path1, Revision revision1,			@
 *!		     string path2, Revision revision2,			@
 *!		     array(string)|void diff_options,			@
 *!		     Stdio.File|void outfile, Stdio.File|void errfile,	@
 *!		     int|void non_recursive, int|void diff_deleted,	@
 *!		     int|void ignore_ancestry );
 *!
 *!  Produce diff output which describes the delta between
 *!  @[path1]/@[revision1] and @[path2]/@[revision2].
 *!
 *! @param path1
 *!   The path of the first file to compare.
 *! @param revision1
 *!   The revision of the first file to compare.
 *! @param path2
 *!   The path of the second file to compare.
 *! @param revision2
 *!   The revision of the second file to compare.
 *! @param diff_options
 *!   Additional command line options to the diff processes invoked
 *!   to compare files.
 *! @param outfile
 *!   File to print diff output to.  If not specified, @[Stdio.stdout]
 *!   will be used.
 *! @param errfile
 *!   File to print diff errors to.  If not specified, @[Stdio.stderr]
 *!   will be used.
 *! @param non_recursive
 *!   If non-zero, don't compare subdirectories.
 *! @param diff_deleted
 *!   If non-zero, generate diff output on deleted files.
 *! @param ignore_ancestry
 *!   Controls whether or not items being diffed will be checked for
 *!   relatedness first.  Unrelated items are typically transmitted to
 *!   the editor as a deletion of one thing and the addition of another,
 *!   but if this flag is non-zero, unrelated items will be diffed as
 *!  if they were related.
 */
static void f_diff_ (INT32 args)
{
  struct array *options = NULL;
  apr_array_header_t *options_aa;
  svn_error_t *err;
  apr_pool_t *pool;
  struct svalue dummy;
  svn_boolean_t recurse, diff_deleted, ignore_ancestry;
  struct pike_string *path1, *path2;
  svn_opt_revision_t rev1, rev2;
  apr_file_t *outfile, *errfile;
  apr_os_file_t outosfile, errosfile;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("diff", args, (args>4? "%W%*%W%*%A":"%W%*%W%*"),
		&path1, &dummy, &path2, &dummy, &options);
  svn_pike_check_rev_arg ("diff", args, 1, &rev1);
  svn_pike_check_rev_arg ("diff", args, 3, &rev2);
  outosfile = svn_pike_check_file_arg ("diff", args, 5);
  errosfile = svn_pike_check_file_arg ("diff", args, 6);
  recurse = svn_pike_check_recurse_arg ("diff", args, 7);
  diff_deleted = svn_pike_check_force_arg ("diff", args, 8);
  ignore_ancestry = svn_pike_check_force_arg ("diff", args, 9);

  path1 = svn_pike_to_utf8 (path1);
  path2 = svn_pike_to_utf8 (path2);

  pool = svn_pool_create (NULL);

  if((outosfile == NO_FILE_SPECIFIED?
      apr_file_open_stdout (&outfile, pool) :
      apr_os_file_put (&outfile, &outosfile, 0, pool)) ||
     (errosfile == NO_FILE_SPECIFIED?
      apr_file_open_stderr (&errfile, pool) :
      apr_os_file_put (&errfile, &errosfile, 0, pool))) {
    apr_pool_destroy (pool);
    do_free_string (path1);
    do_free_string (path2);
    Pike_error ("Failed to open stdout/stderr\n");
  }

  options_aa = svn_pike_make_targets_array (options, pool, TRUE);

  THREADS_ALLOW ();

  err = svn_client_diff (options_aa, svn_path_canonicalize (APR_STR0(path1), pool),
			 &rev1, svn_path_canonicalize (APR_STR0(path2), pool),
			 &rev2, recurse, ignore_ancestry, !diff_deleted,
			 outfile, errfile, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path1);
  do_free_string (path2);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void diff_peg( string path, Revision peg_revision,		    @
 *!			 Revision start_revision, Revision end_revision,    @
 *!			 array(string)|void diff_options,		    @
 *!			 Stdio.File|void outfile, Stdio.File|void errfile,  @
 *!			 int|void non_recursive, int|void diff_deleted,	    @
 *!			 int|void ignore_ancestry );
 *!
 *!  Produce diff output which describes the delta between the
 *!  filesystem object @[path] in peg revision @[peg_revision], as it
 *!  changed between @[start_revision] and @[end_revision].
 *!
 *! @param path
 *!   The path of the file system object.
 *! @param peg_revision
 *!   The peg revision of @[path].
 *! @param start_revision
 *!   The first revision of the delta.
 *! @param end_revision
 *!   The second revision of the delta.
 *! @param diff_options
 *!   Additional command line options to the diff processes invoked
 *!   to compare files.
 *! @param outfile
 *!   File to print diff output to.  If not specified, @[Stdio.stdout]
 *!   will be used.
 *! @param errfile
 *!   File to print diff errors to.  If not specified, @[Stdio.stderr]
 *!   will be used.
 *! @param non_recursive
 *!   If non-zero, don't compare subdirectories.
 *! @param diff_deleted
 *!   If non-zero, generate diff output on deleted files.
 *! @param ignore_ancestry
 *!   Controls whether or not items being diffed will be checked for
 *!   relatedness first.  Unrelated items are typically transmitted to
 *!   the editor as a deletion of one thing and the addition of another,
 *!   but if this flag is non-zero, unrelated items will be diffed as
 *!  if they were related.
 */
static void f_diff_peg (INT32 args)
{
  struct array *options = NULL;
  apr_array_header_t *options_aa;
  svn_error_t *err;
  apr_pool_t *pool;
  struct svalue dummy;
  svn_boolean_t recurse, diff_deleted, ignore_ancestry;
  struct pike_string *path;
  svn_opt_revision_t peg_rev, start_rev, end_rev;
  apr_file_t *outfile, *errfile;
  apr_os_file_t outosfile, errosfile;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("diff_peg", args, (args>4? "%W%*%*%*%A":"%W%*%*%*"),
		&path, &dummy, &dummy, &dummy, &options);
  svn_pike_check_rev_arg ("diff_peg", args, 1, &peg_rev);
  svn_pike_check_rev_arg ("diff_peg", args, 2, &start_rev);
  svn_pike_check_rev_arg ("diff_peg", args, 3, &end_rev);
  outosfile = svn_pike_check_file_arg ("diff_peg", args, 5);
  errosfile = svn_pike_check_file_arg ("diff_peg", args, 6);
  recurse = svn_pike_check_recurse_arg ("diff_peg", args, 7);
  diff_deleted = svn_pike_check_force_arg ("diff_peg", args, 8);
  ignore_ancestry = svn_pike_check_force_arg ("diff_peg", args, 9);

  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  if((outosfile == NO_FILE_SPECIFIED?
      apr_file_open_stdout (&outfile, pool) :
      apr_os_file_put (&outfile, &outosfile, 0, pool)) ||
     (errosfile == NO_FILE_SPECIFIED?
      apr_file_open_stderr (&errfile, pool) :
      apr_os_file_put (&errfile, &errosfile, 0, pool))) {
    apr_pool_destroy (pool);
    do_free_string (path);
    Pike_error ("Failed to open stdout/stderr\n");
  }

  options_aa = svn_pike_make_targets_array (options, pool, TRUE);

  THREADS_ALLOW ();

  err = svn_client_diff_peg (options_aa,
			     svn_path_canonicalize (APR_STR0(path), pool),
			     &peg_rev, &start_rev, &end_rev, recurse,
			     ignore_ancestry, !diff_deleted, outfile, errfile,
			     ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void merge( string source1, Revision revision1,		@
 *!		      string source2, Revision revision2,		@
 *!		      string target_wcpath, int|void non_recursive,	@
 *!		      int|void force, int|void dry_run,			@
 *!		      int|void ignore_ancestry )
 *!
 *!  Merge changes from @[source1]/@[revision1] to @[source2]/@[revision2]
 *!  into the working-copy path @[target_wcpath].
 *!
 *! @param source1
 *!   The repository URL or working copy path of the first file to compare.
 *! @param revision1
 *!   The revision of the first file to compare.
 *! @param source2
 *!   The repository URL or working copy path of the second file to compare.
 *! @param revision2
 *!   The revision of the second file to compare.
 *! @param target_wcpath
 *!   The working-copy path of the file into which to merge the changes
 *!   from @[source1]/@[revision1] to @[source2]/@[revision2].
 *! @param non_recursive
 *!   If non-zero, don't merge subdirectories.
 *! @param force
 *!   If non-zero, files deleted between @[source1]/@[revision1] and
 *!   @[source2]/@[revision2] will be deleted in @[target_wcpath] even
 *!   if they have local modifications.
 *! @param dry_run
 *!   If non-zero, the merge is carried out, and full notification
 *!   feedback is provided, but the working copy is not modified.
 *! @param ignore_ancestry
 *!   Controls whether or not items being diffed will be checked for
 *!   relatedness first.  Unrelated items are typically transmitted to
 *!   the editor as a deletion of one thing and the addition of another,
 *!   but if this flag is non-zero, unrelated items will be diffed as if
 *!   they were related.
 */
static void f_merge (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct svalue dummy;
  svn_boolean_t recurse, force, dry_run, ignore_ancestry;
  struct pike_string *url1, *url2, *path;
  svn_opt_revision_t rev1, rev2;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("merge", args, "%W%*%W%*%W",
		&url1, &dummy, &url2, &dummy, &path);
  svn_pike_check_rev_arg ("merge", args, 1, &rev1);
  svn_pike_check_rev_arg ("merge", args, 3, &rev2);
  recurse = svn_pike_check_recurse_arg ("merge", args, 5);
  force = svn_pike_check_force_arg ("merge", args, 6);
  dry_run = svn_pike_check_force_arg ("merge", args, 7);
  ignore_ancestry = svn_pike_check_force_arg ("merge", args, 8);

  url1 = svn_pike_to_utf8 (url1);
  url2 = svn_pike_to_utf8 (url2);
  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_merge (svn_path_canonicalize (APR_STR0(url1), pool), &rev1,
			  svn_path_canonicalize (APR_STR0(url2), pool), &rev2,
			  svn_path_canonicalize (APR_STR0(path), pool), recurse,
			  ignore_ancestry, force, dry_run, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (url1);
  do_free_string (url2);
  do_free_string (path);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void merge_peg( string source, Revision revision1,		@
 *!			  Revision revision2, Revision peg_revision,	@
 *!			  string target_wcpath, int|void non_recursive,	@
 *!			  int|void force, int|void dry_run,		@
 *!			  int|void ignore_ancestry )
 *!
 *!  Merge the changes between the filesystem object @[source] in peg
 *!  revision @[peg_revision], as it changed between @[revision1] and
 *!  @[revision2].
 *!
 *! @param source
 *!   The repository URL or working copy path of the filesystem object.
 *! @param revision1
 *!   The start revision of the change to merge.
 *! @param revision2
 *!   The end revision of the change to merge.
 *! @param peg_revision
 *!   The peg revision of @[source].
 *! @param target_wcpath
 *!   The working-copy path of the file into which to merge the changes
 *!   from @[revision1] to @[revision2].
 *! @param non_recursive
 *!   If non-zero, don't merge subdirectories.
 *! @param force
 *!   If non-zero, files deleted between @[revision1] and
 *!   @[revision2] will be deleted in @[target_wcpath] even if they have
 *!   local modifications.
 *! @param dry_run
 *!   If non-zero, the merge is carried out, and full notification
 *!   feedback is provided, but the working copy is not modified.
 *! @param ignore_ancestry
 *!   Controls whether or not items being diffed will be checked for
 *!   relatedness first.  Unrelated items are typically transmitted to
 *!   the editor as a deletion of one thing and the addition of another,
 *!   but if this flag is non-zero, unrelated items will be diffed as if
 *!   they were related.
 */
static void f_merge_peg (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct svalue dummy;
  svn_boolean_t recurse, force, dry_run, ignore_ancestry;
  struct pike_string *source, *path;
  svn_opt_revision_t rev1, rev2, peg_rev;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("merge_peg", args, "%W%*%*%*%W",
		&source, &dummy, &dummy, &dummy, &path);
  svn_pike_check_rev_arg ("merge_peg", args, 1, &rev1);
  svn_pike_check_rev_arg ("merge_peg", args, 2, &rev2);
  svn_pike_check_rev_arg ("merge_peg", args, 3, &peg_rev);
  recurse = svn_pike_check_recurse_arg ("merge_peg", args, 5);
  force = svn_pike_check_force_arg ("merge_peg", args, 6);
  dry_run = svn_pike_check_force_arg ("merge_peg", args, 7);
  ignore_ancestry = svn_pike_check_force_arg ("merge_peg", args, 8);

  source = svn_pike_to_utf8 (source);
  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_merge_peg (svn_path_canonicalize (APR_STR0(source), pool),
			      &rev1, &rev2, &peg_rev,
			      svn_path_canonicalize (APR_STR0(path), pool),
			      recurse, ignore_ancestry, force, dry_run,
			      ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (source);
  do_free_string (path);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void cleanup( string dir )
 *!
 *!  Recursively cleanup a working copy directory @[dir], finishing any
 *!  incomplete operations, removing lockfiles, etc.
 *!
 *! @param dir
 *!   The working-copy path of the directory to cleanup
 */
static void f_cleanup (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct pike_string *path;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("cleanup", args, "%W", &path);

  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_cleanup (svn_path_canonicalize (APR_STR0(path), pool), ctx,
			    pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void relocate( string dir, string from, string to,	@
 *!			 int|void non_recursive )
 *!
 *!  Modify a working copy directory @[dir], changing any
 *!  repository URLs that begin with @[from] to begin with @[to] instead,
 *!  recursing into subdirectories unless @[non_recursive] is non-zero.
 *!
 *! @param dir
 *!   Working copy directory
 *! @param from
 *!   Original URL
 *! @param to
 *!   New URL
 *! @param non_recursive
 *!   If non-zero, don't relocate subdirectories.
 */
static void f_relocate (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  svn_boolean_t recurse;
  struct pike_string *dir, *from, *to;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("relocate", args, "%W%W%W", &dir, &from, &to);
  recurse = svn_pike_check_recurse_arg ("relocate", args, 3);

  dir = svn_pike_to_utf8 (dir);
  from = svn_pike_to_utf8 (from);
  to = svn_pike_to_utf8 (to);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_relocate (svn_path_canonicalize (APR_STR0(dir), pool),
			     svn_path_canonicalize (APR_STR0(from), pool),
			     svn_path_canonicalize (APR_STR0(to), pool),
			     recurse, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (dir);
  do_free_string (from);
  do_free_string (to);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void revert( array(string) paths, int|void non_recursive )
 *!
 *!  Restore the pristine version of a working copy @[paths], effectively
 *!  undoing any local modifications.
 *!
 *! @param paths
 *!   An array of working-copy paths of the files or directories to revert.
 *! @param non_recursive
 *!   If non-zero, don't revert directory contents.
 */
static void f_revert (INT32 args)
{
  struct array *paths;
  apr_array_header_t *paths_aa;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_boolean_t recurse;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("revert", args, "%a", &paths);
  recurse = svn_pike_check_recurse_arg ("revert", args, 1);

  pool = svn_pool_create (NULL);

  paths_aa = svn_pike_make_targets_array (paths, pool, FALSE);

  THREADS_ALLOW ();

  err = svn_client_revert (paths_aa, recurse, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl void resolved( string path, int|void non_recursive )
 *!
 *!  Remove the 'conflicted' state on a working copy @[path].
 *!  This will not semantically resolve conflicts;  it just allows
 *!  @[path] to be committed in the future.  The implementation details
 *!  are opaque.
 *!
 *! @param path
 *!   The working-copy path of the file which is in a 'conflicted' state.
 *! @param non_recursive
 *!   If non-zero, don't resolv conflicts in subdirectories.
 */
static void f_resolved (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  svn_boolean_t recurse;
  struct pike_string *path;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("resolved", args, "%W", &path);
  recurse = svn_pike_check_recurse_arg ("resolved", args, 1);

  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_resolved (svn_path_canonicalize (APR_STR0(path), pool),
			     recurse, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl array(int|string) copy( string src_path_or_url,		@
 *!				  Revision src_revision,    		@
 *!				  string dst_path_or_url )
 *!
 *!  Copy @[src_path_or_url] to @[dst_path_or_url].
 *!
 *! @param src_path_or_url
 *!   Path to schedule for copying, or URL to immediately
 *!   copy in the repository.
 *! @param src_revision
 *!   The revision of @[src_path_or_url] to copy.
 *! @param dst_path_or_url
 *!   Path where to put the copy, or URL to immediately commit the copy
 *!   to the repository.
 *!
 *! @returns
 *!   If either @[src_path_or_url] or @[dst_path_or_url] is an URL, an
 *!   array containing information about the commit is returned.
 *!   The elements are as follows:
 *! @array
 *!   @elem int revision
 *!     The revision in which the item was copied.
 *!   @elem string date
 *!     The server-side date of the commit.
 *!   @elem string author
 *!     The author of the commit.
 *! @endarray
 */
static void f_copy (INT32 args)
{
  struct pike_string *src_path_or_url, *dst_path_or_url;
  svn_opt_revision_t rev;
  svn_error_t *err;
  apr_pool_t *pool;
  struct svn_client_commit_info_t *commit_info = NULL;
  struct svalue dummy, ret;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("copy", args, "%W%*%W", &src_path_or_url,
		&dummy, &dst_path_or_url);
  svn_pike_check_rev_arg ("copy", args, 1, &rev);

  src_path_or_url = svn_pike_to_utf8 (src_path_or_url);
  dst_path_or_url = svn_pike_to_utf8 (dst_path_or_url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_copy (&commit_info,
			 svn_path_canonicalize (APR_STR0 (src_path_or_url), pool),
			 &rev,
			 svn_path_canonicalize (APR_STR0 (dst_path_or_url), pool),
			 ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    make_commit_info (&ret, commit_info);

  apr_pool_destroy (pool);

  do_free_string (src_path_or_url);
  do_free_string (dst_path_or_url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl array(int|string) move( string src_path_or_url,		@
 *!				  Revision src_revision,    		@
 *!				  string dst_path_or_url, int|void force )
 *!
 *!  Move @[src_path_or_url] to @[dst_path_or_url].
 *!
 *! @param src_path_or_url
 *!   Path to schedule for moving, or URL to immediately
 *!   move in the repository.
 *! @param src_revision
 *!   The revision of @[src_path_or_url] to move.
 *! @param dst_path_or_url
 *!   Path where to put the moved item, or URL to immediately commit the
 *!   move to the repository.
 *! @param force
 *!   Unless set, the operation will fail if a working copy path
 *!   that contains locally modified and/or unversioned items is
 *!   specified as the destination.
 *!
 *! @returns
 *!   If either @[src_path_or_url] or @[dst_path_or_url] is an URL, an
 *!   array containing information about the commit is returned.
 *!   The elements are as follows:
 *! @array
 *!   @elem int revision
 *!     The revision in which the item was moved.
 *!   @elem string date
 *!     The server-side date of the commit.
 *!   @elem string author
 *!     The author of the commit.
 *! @endarray
 */
static void f_move (INT32 args)
{
  struct pike_string *src_path_or_url, *dst_path_or_url;
  svn_opt_revision_t rev;
  svn_error_t *err;
  apr_pool_t *pool;
  struct svn_client_commit_info_t *commit_info = NULL;
  struct svalue dummy, ret;
  svn_boolean_t force;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("move", args, "%W%*%W", &src_path_or_url,
		&dummy, &dst_path_or_url);
  svn_pike_check_rev_arg ("move", args, 1, &rev);
  force = svn_pike_check_force_arg ("move", args, 3);

  src_path_or_url = svn_pike_to_utf8 (src_path_or_url);
  dst_path_or_url = svn_pike_to_utf8 (dst_path_or_url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_move (&commit_info,
			 svn_path_canonicalize (APR_STR0 (src_path_or_url), pool),
			 &rev,
			 svn_path_canonicalize (APR_STR0 (dst_path_or_url), pool),
			 force, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    make_commit_info (&ret, commit_info);

  apr_pool_destroy (pool);

  do_free_string (src_path_or_url);
  do_free_string (dst_path_or_url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl void propset( string propname, string propval, string target,	  @
 *!			int|void non_recursive )
 *!
 *!  Set property @[propname] to @[propval] on @[target].
 *!
 *! @param propname
 *!   The name of the property to set.
 *! @param propval
 *!   The value to set the property to, or zero to delete it.
 *! @param target
 *!   The path of the file or directory on which to set the property.
 *! @param non_recursive
 *!   If non-zero, set the property only on target, even if it is a directory.
 */
static void f_propset (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct pike_string *propname, *propval=NULL, *target;
  struct svalue dummy;
  svn_string_t propval_string;
  svn_boolean_t recurse;

  if(args > 1 && UNSAFE_IS_ZERO (&Pike_sp[1-args]))
    get_all_args ("propset", args, "%W%*%W", &propname, &dummy, &target);
  else
    get_all_args ("propset", args, "%W%W%W", &propname, &propval, &target);
  recurse = svn_pike_check_recurse_arg ("propset", args, 3);

  propname = svn_pike_to_utf8 (propname);
  if (propval) {
    if (svn_prop_needs_translation (APR_STR0(propname)))
      propval = svn_pike_to_utf8 (propval);
    else
      reference_shared_string (propval);
    if (propval->size_shift) {
      do_free_string (propname);
      do_free_string (propval);
      Pike_error("Binary property can't contain wide characters.\n");
    }
    propval_string.data = APR_STR0 (propval);
    propval_string.len = propval->len;
  }
  target = svn_pike_to_utf8 (target);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_propset (APR_STR0(propname), (propval? &propval_string : NULL),
			    svn_path_canonicalize (APR_STR0(target), pool),
			    recurse, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (propname);
  do_free_string (propval);
  do_free_string (target);

  if (err)
    pike_throw ();
  else
    pop_n_elems (args);
}


/*! @decl int revprop_set( string propname, string propval, string URL,	  @
 *!			   Revision revision, int|void force )
 *!
 *!  Set property @[propname] to @[propval] on revision @[revision] in
 *!  the repository represented by @[URL].
 *!
 *!  Note that unlike its cousin @[propset()], this function
 *!  doesn't affect the working copy at all;  it's a pure network
 *!  operation that changes an @b{unversioned@} property attached to a
 *!  revision.  This can be used to tweak log messages, dates, authors,
 *!  and the like.  Be careful:  it's a lossy operation.
 *!
 *! @param propname
 *!   The name of the property to set.
 *! @param propval
 *!   The value to set the property to, or zero to delete it.
 *! @param URL
 *!   The URL of the repository.
 *! @param revision
 *!   The revision to set the property on.
 *! @param force
 *!   If non-zero, allow newlines in the author property.
 *!
 *! @returns
 *!   The actual revision number in which the property was set.
 */
static void f_revprop_set (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct svalue dummy;
  struct pike_string *propname, *propval=NULL, *url;
  svn_string_t propval_string;
  svn_opt_revision_t rev;
  svn_revnum_t ret_rev;
  svn_boolean_t force;
  svn_client_ctx_t *ctx = THIS->ctx;

  if(args > 1 && UNSAFE_IS_ZERO (&Pike_sp[1-args]))
    get_all_args ("revprop_set", args, "%W%*%W", &propname, &dummy, &url);
  else
    get_all_args ("revprop_set", args, "%W%W%W", &propname, &propval, &url);
  svn_pike_check_rev_arg ("revprop_set", args, 3, &rev);
  force = svn_pike_check_force_arg ("revprop_set", args, 4);

  propname = svn_pike_to_utf8 (propname);
  if (propval) {
    if (svn_prop_needs_translation (APR_STR0(propname)))
      propval = svn_pike_to_utf8 (propval);
    else
      reference_shared_string (propval);
    if (propval->size_shift) {
      do_free_string (propname);
      do_free_string (propval);
      Pike_error("Binary property can't contain wide characters.\n");
    }
    propval_string.data = APR_STR0 (propval);
    propval_string.len = propval->len;
  }
  url = svn_pike_to_utf8 (url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_revprop_set (APR_STR0(propname),
				(propval? &propval_string : NULL),
				svn_path_canonicalize (APR_STR0(url), pool),
				&rev, &ret_rev, force, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (propname);
  do_free_string (propval);
  do_free_string (url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (ret_rev);
  }
}


/*! @decl mapping(string:string) propget( string propname, string target,    @
 *!					  int|void non_recursive,	     @
 *!					  Revision|void revision )
 *!
 *!  Get property @[propname] for @[target].
 *!
 *! @param propname
 *!   The name of the property to get.
 *! @param target
 *!   The path of the file or directory for which to get the property.
 *! @param non_recursive
 *!   If non-zero, get the property only for target, even if it is a directory.
 *! @param revision
 *!   If specified, the revisison of the property to get.  If no revision
 *!   is given, get the property from the working copy, or from the repository
 *!   head if the target is an URL.
 *!
 *! @returns
 *!   A mapping from pathname to property value, with one element for
 *!   each node under target which has the named property set.
 */
static void f_propget (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct pike_string *propname, *target;
  struct svalue ret;
  svn_boolean_t recurse;
  apr_hash_t *props = NULL;
  svn_opt_revision_t rev;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("propget", args, "%W%W", &propname, &target);
  recurse = svn_pike_check_recurse_arg ("propget", args, 2);
  svn_pike_check_rev_arg ("propget", args, 3, &rev);

  propname = svn_pike_to_utf8 (propname);
  target = svn_pike_to_utf8 (target);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_propget (&props, APR_STR0(propname),
			    svn_path_canonicalize (APR_STR0(target), pool),
			    &rev, recurse, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    svn_pike_make_propmap (&ret, props,
			   !!svn_prop_needs_translation (APR_STR0(propname)));

  apr_pool_destroy (pool);

  do_free_string (propname);
  do_free_string (target);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl array(int|string) revprop_get( string propname, string URL,	@
 *!					 Revision revision )
 *!
 *!  Get property @[propname] for revision @[revision] of the
 *!  repository represented by @[URL].
 *!
 *!  Note that unlike its cousin @[propget()], this routine
 *!  doesn't affect the working copy at all; it's a pure network
 *!  operation that queries an @b{unversioned@} property attached to a
 *!  revision.  This can be query log messages, dates, authors, and the
 *!  like.
 *!
 *! @param propname
 *!   The name of the property to get.
 *! @param URL
 *!   The URL of the repository.
 *! @param revision
 *!   The revision for which to get the property.
 *!
 *! @returns
 *!   An array with two elements:
 *! @array
 *!   @elem int revision
 *!     The actual revision number from which the property value was fetched.
 *!   @elem string propval
 *!     The property value itself, or zero if the property was not set.
 *! @endarray
 */
static void f_revprop_get (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct pike_string *propname, *url;
  svn_opt_revision_t rev;
  svn_revnum_t ret_rev;
  svn_string_t *propval_string = NULL;
  struct pike_string *propval = NULL;
  svn_boolean_t prop_is_utf;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("revprop_get", args, "%W%W", &propname, &url);
  svn_pike_check_rev_arg ("revprop_get", args, 2, &rev);

  propname = svn_pike_to_utf8 (propname);
  url = svn_pike_to_utf8 (url);

  pool = svn_pool_create (NULL);

  prop_is_utf = svn_prop_needs_translation (APR_STR0(propname));

  THREADS_ALLOW ();

  err = svn_client_revprop_get (APR_STR0(propname), &propval_string,
				svn_path_canonicalize (APR_STR0(url), pool),
				&rev, &ret_rev, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else if (propval_string)
    propval = make_shared_binary_string(propval_string->data,
					propval_string->len);

  apr_pool_destroy (pool);

  do_free_string (propname);
  do_free_string (url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (ret_rev);
    if (propval) {
      push_string (propval);
      if (prop_is_utf)
	f_utf8_to_string (1);
    } else push_undefined();
    f_aggregate (2);
  }
}


/*! @decl mapping(string:mapping(string:string))			@
 *!		proplist( string target, int|void non_recursive,	@
 *!			  Revision|void revision )
 *!
 *!  List all properties for @[target].
 *!
 *! @param target
 *!   The path of the file or directory for which to list all properties.
 *! @param non_recursive
 *!   If non-zero, list only the properties for target, even if it is
 *!   a directory.
 *! @param revision
 *!   If specified, the revisison of target to list the properties for.
 *!   If no revision is given, list the properties from the working copy,
 *!   or from the repository head if the target is an URL.
 *!
 *! @returns
 *!   A mapping from pathnames to property mappings, with one element for
 *!   each node under target which has properties.  Each property mapping
 *!   is a mapping from property name to property value containing all
 *!   currently set properties for that node.
 */
static void f_proplist (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct pike_string *target;
  struct svalue ret;
  svn_boolean_t recurse;
  apr_array_header_t *props = NULL;
  svn_opt_revision_t rev;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("proplist", args, "%W", &target);
  recurse = svn_pike_check_recurse_arg ("proplist", args, 1);
  svn_pike_check_rev_arg ("proplist", args, 2, &rev);

  target = svn_pike_to_utf8 (target);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_proplist (&props,
			     svn_path_canonicalize (APR_STR0(target), pool),
			     &rev, recurse, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    make_proplist (&ret, props);

  apr_pool_destroy (pool);

  do_free_string (target);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl array(int|mapping(string:string)) revprop_list( string URL,	      @
 *!							  Revision revision )
 *!
 *!  List all properties for revision @[revision] of the repository
 *!  represented by @[URL].
 *!
 *!  Note that unlike its cousin @[proplist()], this function
 *!  doesn't read a working copy at all; it's a pure network operation
 *!  that reads @b{unversioned@} properties attached to a revision.
 *!
 *! @param URL
 *!   The URL of the repository.
 *! @param revision
 *!   The revision to list the properties of.
 *!
 *! @returns
 *!   An array with two elements:
 *! @array
 *!   @elem int revision
 *!     The actual revision number for which the property values were listed.
 *!   @elem mapping(string:string) props
 *!     A mapping from property name to property value containing all
 *!     the properties of this revision.
 *! @endarray
 */
static void f_revprop_list (INT32 args)
{
  svn_error_t *err;
  apr_pool_t *pool;
  struct svalue ret;
  struct pike_string *url;
  svn_opt_revision_t rev;
  svn_revnum_t ret_rev;
  apr_hash_t *props = NULL;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("revprop_list", args, "%W", &url);
  svn_pike_check_rev_arg ("revprop_list", args, 1, &rev);

  url = svn_pike_to_utf8 (url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_revprop_list (&props,
				 svn_path_canonicalize (APR_STR0(url), pool),
				 &rev, &ret_rev, ctx, pool);
  
  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else
    svn_pike_make_propmap (&ret, props, -1);

  apr_pool_destroy (pool);

  do_free_string (url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (ret_rev);
    *Pike_sp++ = ret;
    f_aggregate (2);
  }
}


/*! @decl int export( string from, string to, Revision|void revision,	@
 *!		      int|void force, string|void native_eol )
 *!
 *!  Export the contents of either a subversion repository or
 *!  a subversion working copy into a 'clean' directory (meaning a
 *!  directory with no administrative directories).
 *!
 *! @param from
 *!   Either the path of a working copy on disk, or an URL to the
 *!   repository you wish to export.
 *! @param to
 *!   The path to the directory where you wish to create the exported tree.
 *! @param revision
 *!   Revision number to export (only used when exporting from repository).
 *! @param force
 *!   If non-zero, causes the export to overwrite files or directories.
 *! @param native_eol
 *!   Allows you to override the standard eol marker on the platform you
 *!   are running on.  If zero, the standard eol marker will be used.
 *!  @dl
 *!   @item '"LF"'
 *!      The eol marker is line feed.
 *!   @item '"CR"'
 *!      The eol marker is carriage return.
 *!   @item '"CRLF"'
 *!      The eol marker is carriage return followed by line feed.
 *!  @enddl
 *!
 *! @returns
 *!   The actual revision number that was exported out, if @[from] is an
 *!   URL.  For local exports, -1 is returned.
 */
static void f_export (INT32 args)
{
  struct pike_string *src_path, *dst_path, *native_eol = NULL;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_revnum_t ret_rev = SVN_INVALID_REVNUM;
  svn_opt_revision_t revision;
  svn_boolean_t force;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("export", args, "%W%W", &src_path, &dst_path);
  svn_pike_check_rev_arg ("export", args, 2, &revision);
  force = svn_pike_check_force_arg ("export", args, 3);
  if (args > 4 && Pike_sp[4-args].type == PIKE_T_STRING)
    native_eol = Pike_sp[4-args].u.string;

  src_path = svn_pike_to_utf8 (src_path);
  dst_path = svn_pike_to_utf8 (dst_path);
  native_eol = svn_pike_to_utf8 (native_eol);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_export2 (&ret_rev,
			    svn_path_canonicalize (APR_STR0 (src_path), pool),
			    svn_path_canonicalize (APR_STR0 (dst_path), pool),
			    &revision, force,
			    (native_eol? APR_STR0 (native_eol) : NULL), ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (src_path);
  do_free_string (dst_path);
  do_free_string (native_eol);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (ret_rev);
  }
}


/*! @decl mapping(string:array) ls( string URL, Revision|void revision,	@
 *!				    int|void nonrecursive )
 *!
 *!  List a repository directory or file.
 *!
 *! @param URL
 *!   The URL of the repository item to list.
 *! @param revision
 *!   Revision to list, or UNDEFINED for the latest revision.
 *! @param non_recursive
 *!   If non-zero, don't list contents of subdirectories.
 *!
 *! @returns
 *!   A mapping from entry name to entry information, or UNDEFINED
 *!   if no such entry exists in the repository (at the specified revision).
 *!   The values in the mapping are as follows:
 *! @array
 *!   @elem int kind
 *!     Node kind (dir, file), see @[RA.Library.Session.check_path()].
 *!   @elem int size
 *!     Length of file text, or 0 for directories.
 *!   @elem int has_props
 *!     Non-zero if the node has properties.
 *!   @elem int created_rev
 *!     Last revision in which this node changed.
 *!   @elem int time
 *!     Time of created_rev (modification time).
 *!   @elem string last_author
 *!     Author of created_rev
 *! @endarray
 */
static void f_ls (INT32 args)
{
  struct pike_string *url;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_opt_revision_t revision;
  apr_hash_t *dirents = NULL;
  struct svalue ret;
  svn_boolean_t recurse;
  svn_client_ctx_t *ctx = THIS->ctx;

  get_all_args ("ls", args, "%W", &url);
  svn_pike_check_rev_arg ("ls", args, 1, &revision);
  recurse = svn_pike_check_recurse_arg ("ls", args, 2);

  url = svn_pike_to_utf8 (url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_ls (&dirents, svn_path_canonicalize (APR_STR0 (url), pool),
		       &revision, recurse, ctx, pool);

  THREADS_DISALLOW ();

  if (err && err->apr_err == SVN_ERR_FS_NOT_FOUND) {
    dirents = NULL;
    err = NULL;
  }

  if (err)
    svn_pike_set_error (err);
  else
    svn_pike_make_dirents (&ret, dirents);

  apr_pool_destroy (pool);

  do_free_string (url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    *Pike_sp++ = ret;
  }
}


/*! @decl void cat( Stream out, string path_or_url, Revision|void revision )
 *!
 *!  Output the content of a file to a stream.
 *!
 *! @param out
 *!   The stream on which to output the file's contents.
 *! @param path_or_url
 *!   Identifies the file to output.
 *! @param revision
 *!   Revision of the contents to output, or UNDEFINED for current contents.
 */
static void f_cat (INT32 args)
{
  struct pike_string *path_or_url;
  svn_error_t *err;
  svn_stream_t *stream_stub;
  apr_pool_t *pool;
  svn_opt_revision_t revision;
  svn_client_ctx_t *ctx = THIS->ctx;
  struct object *out_obj;

  get_all_args ("cat", args, "%o%W", &out_obj, &path_or_url);
  svn_pike_check_rev_arg ("cat", args, 2, &revision);
  svn_pike_check_stream_arg ("cat", args, 0, &stream_stub,
			     NULL, &pool);

  path_or_url = svn_pike_to_utf8 (path_or_url);

  THREADS_ALLOW ();

  err = svn_client_cat (stream_stub,
			svn_path_canonicalize (APR_STR0 (path_or_url), pool),
			&revision, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);

  apr_pool_destroy (pool);

  do_free_string (path_or_url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    push_int (0);
  }
}


/*! @decl string url_from_path( string path_or_url )
 *!
 *!  If @[path_or_url] is already an URL, return @[path_or_url].
 *!
 *!  If @[path_or_url] is a versioned item, return the entry URL of
 *!  that item.
 *!
 *!  If @[path_or_url] is unversioned (has no entry), return 0.
 *!
 *! @param path_or_url
 *!   The item to get the entry URL of.
 */
static void f_url_from_path (INT32 args)
{
  struct pike_string *path_or_url;
  svn_error_t *err;
  apr_pool_t *pool;
  const char *url = NULL;
  struct pike_string *ret = NULL;

  get_all_args ("url_from_path", args, "%W", &path_or_url);

  path_or_url = svn_pike_to_utf8 (path_or_url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_url_from_path (&url,
				  svn_path_canonicalize (APR_STR0 (path_or_url),
							 pool), pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else if (url)
    ret = make_shared_string(url);

  apr_pool_destroy (pool);

  do_free_string (path_or_url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    if (ret) {
      push_string (ret);
      f_utf8_to_string (1);
    } else
      push_int (0);
  }
}


/*! @decl string uuid_from_url( string url )
 *!
 *!  Get repository UUID for a @[url].
 *!
 *! @param url
 *!   The URL to the repository you want the UUID for.
 */
static void f_uuid_from_url (INT32 args)
{
  struct pike_string *url;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_client_ctx_t *ctx = THIS->ctx;
  const char *uuid = NULL;
  struct pike_string *ret = NULL;

  get_all_args ("uuid_from_url", args, "%W", &url);

  url = svn_pike_to_utf8 (url);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  err = svn_client_uuid_from_url (&uuid,
				  svn_path_canonicalize (APR_STR0 (url), pool),
				  ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else if (uuid)
    ret = make_shared_string(uuid);

  apr_pool_destroy (pool);

  do_free_string (url);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    if (ret) {
      push_string (ret);
      f_utf8_to_string (1);
    } else
      push_int (0);
  }
}


/*! @decl string uuid_from_path( string path )
 *!
 *!  Return the repository UUID for working-copy @[path].
 *!
 *! @param path
 *!   The path to the repository to get the UUID for.
 */
static void f_uuid_from_path (INT32 args)
{
  struct pike_string *path;
  svn_error_t *err;
  apr_pool_t *pool;
  svn_wc_adm_access_t *adm_access;
  svn_client_ctx_t *ctx = THIS->ctx;
  const char *path_can, *uuid = NULL;
  struct pike_string *ret = NULL;

  get_all_args ("uuid_from_path", args, "%W", &path);

  path = svn_pike_to_utf8 (path);

  pool = svn_pool_create (NULL);

  THREADS_ALLOW ();

  path_can = svn_path_canonicalize (APR_STR0 (path), pool);

  if (!(err = svn_wc_adm_open (&adm_access, NULL, path_can,
			       FALSE, FALSE, pool)))
    err = svn_client_uuid_from_path (&uuid, path_can, adm_access, ctx, pool);

  THREADS_DISALLOW ();

  if (err)
    svn_pike_set_error (err);
  else if (uuid)
    ret = make_shared_string(uuid);

  apr_pool_destroy (pool);

  do_free_string (path);

  if (err)
    pike_throw ();
  else {
    pop_n_elems (args);
    if (ret) {
      push_string (ret);
      f_utf8_to_string (1);
    } else
      push_int (0);
  }
}


/*! @decl Version version( )
 *!
 *!  Get libsvn_client version information.
 */
static void f_version (INT32 args)
{
  pop_n_elems (args);
  svn_pike_push_version (svn_client_version ());
}


/*! @decl void create( array(Auth.AuthProvider)|void auth_providers,	@
 *!		       mapping(string:Config)|void config )
 *!
 *!  Create a Subversion client.
 *!
 *! @param auth_providers
 *!   An ordered list of objects providing authentication credentials.
 *! @param config
 *!   A mapping from names to @[Config]s.  For example, the @[Config]
 *!   for the "~/.subversion/config" file is under the index "config".
 */
static void f_client_create (INT32 args)
{
  struct client_obj *co = THIS;
  struct array *auths = NULL;
  apr_array_header_t *aa;
  INT32 i;

  do_free_mapping(co->config);
  do_free_array(co->auth_providers);
  co->config = NULL;
  co->auth_providers = NULL;

  if (args)
    get_all_args ("create", args, (args>1? "%A%m":"%A"), &auths, &co->config);

  if(co->config)
    co->config = copy_mapping(co->config);

  co->ctx->config = svn_pike_mapping_to_config_hash (co->config, co->pool);

  if (auths) {

    co->auth_providers = auths = copy_array (auths);

    aa = apr_array_make (co->pool, auths->size,
			 sizeof (svn_auth_provider_object_t *));

    if (!aa)
      Pike_error ("Out of memory.\n");

    for (i=0; isize; i++) {
      svn_auth_provider_object_t *po;
      
      if (ITEM (auths)[i].type != PIKE_T_OBJECT ||
	  !(po = (svn_auth_provider_object_t *)
	    get_storage (ITEM (auths)[i].u.object,
			 svn_pike_auth_provider_program)))
	Pike_error ("Not an AuthProvider object.\n");
      
      *(svn_auth_provider_object_t **)apr_array_push (aa) = po;
    }

    svn_auth_open (&co->ctx->auth_baton, aa, co->pool);

  }

  pop_n_elems (args);
}

static void init_client_obj (struct object *o)
{
  struct client_obj *co = THIS;
  svn_error_t *err;
  int idlevel = Pike_fp->context.identifier_level;

  co->pool = svn_pool_create (NULL);

  low_object_index_no_free (&co->notify_func, Pike_fp->current_object,
			    notify_function + idlevel);
  low_object_index_no_free (&co->log_msg_func, Pike_fp->current_object,
			    log_msg_function + idlevel);
  low_object_index_no_free (&co->cancel_func, Pike_fp->current_object,
			    cancel_function + idlevel);

  if(!co->pool)
    Pike_error("Out of memory.\n");

  err = svn_client_create_context(&co->ctx, co->pool);

  if (err) {
    svn_pike_set_error (err);
    pike_throw();
  }

  svn_auth_open (&co->ctx->auth_baton,
		 apr_array_make (co->pool, 0,
				 sizeof (svn_auth_provider_object_t *)),
		 co->pool);

  co->ctx->notify_func = notify_func_stub;
  co->ctx->notify_baton = &co->notify_func;
  co->ctx->log_msg_func = log_msg_func_stub;
  co->ctx->log_msg_baton = &co->log_msg_func;
  co->ctx->cancel_func = cancel_func_stub;
  co->ctx->cancel_baton = &co->cancel_func;
  co->ctx->config = NULL;
}

static void exit_client_obj (struct object *o)
{
  struct client_obj *co = THIS;

  free_svalue (&co->log_msg_func);
  free_svalue (&co->notify_func);
  free_svalue (&co->cancel_func);

  if (co->pool) {
    apr_pool_destroy (co->pool);
    co->pool = NULL;
  }
}



/* Initialize Client class */

void svn_pike_init_client (void)
{
  ptrdiff_t off;

  start_new_program ();

  off = ADD_STORAGE (struct client_obj);
  set_init_callback(init_client_obj);
  set_exit_callback(exit_client_obj);

  map_variable ("config", "mapping", ID_STATIC,
		off + OFFSETOF (client_obj, config),
		PIKE_T_MAPPING);
  map_variable ("auth_providers", "array", ID_STATIC,
		off + OFFSETOF (client_obj, auth_providers),
		PIKE_T_ARRAY);

  notify_function = ADD_FUNCTION ("notify_func", f_notify_func,
				  tFunc (tStr tInt tInt tStr tInt tInt tInt,
					 tVoid), 0);

  log_msg_function = ADD_FUNCTION ("log_msg_func", f_log_msg_func,
				   tFunc (tArr (tArr (tOr (tStr, tInt))),
					  tStr), 0);

  cancel_function = ADD_FUNCTION ("cancel_func", f_cancel_func,
				  tFunc (tNone, tVoid), 0);

  ADD_FUNCTION ("create", f_client_create, tFunc (tOr (tArr (tObj), tVoid),
						  tVoid), ID_STATIC);

  ADD_FUNCTION ("checkout", f_checkout, tFunc (tStr tStr tOr (tRev, tVoid)
					       tOr (tInt, tVoid), tInt), 0);
  ADD_FUNCTION ("update", f_update, tFunc (tStr tOr (tRev, tVoid)
					   tOr (tInt, tVoid), tInt), 0);
  ADD_FUNCTION ("switch", f_switch, tFunc (tStr tStr tOr (tRev, tVoid)
					   tOr (tInt, tVoid), tInt), 0);
  ADD_FUNCTION ("add", f_add_, tFunc (tStr tOr (tInt, tVoid), tVoid), 0);
  ADD_FUNCTION ("mkdir", f_mkdir, tFunc (tArr (tStr),
					 tArr (tOr (tInt, tStr))), 0);
  ADD_FUNCTION ("delete", f_delete, tFunc (tArr (tStr) tOr (tInt, tVoid),
					   tArr (tOr (tInt, tStr))), 0);
  ADD_FUNCTION ("import", f_import, tFunc (tStr tStr tOr (tInt, tVoid),
					   tArr (tOr (tInt, tStr))), 0);
  ADD_FUNCTION ("commit", f_commit, tFunc (tArr (tStr) tOr (tInt, tVoid),
					   tArr (tOr (tInt, tStr))), 0);
  ADD_FUNCTION ("status", f_status, tFunc (tStr
					   tFunc (tStr tMap (tStr, tMixed),
						  tVoid) tOr (tInt, tVoid)
					   tOr (tInt, tVoid) tOr (tInt, tVoid)
					   tOr (tRev, tVoid) tOr (tInt, tVoid),
					   tInt), 0);
  ADD_FUNCTION ("log", f_log, tFunc (tArr (tStr) tFunc (tInt tStr tStr tStr
							tOr (tMap (tStr,
								   tArr (tOr (tInt,
									      tStr))),
							     tVoid),
							tVoid)
				     tRev tRev tOr (tInt, tVoid)
				     tOr (tInt, tVoid), tVoid), 0);
  ADD_FUNCTION ("blame", f_blame, tFunc (tStr tFunc (tInt tInt tStr tStr tStr,
						     tVoid)
					 tRev tRev, tVoid), 0);
  ADD_FUNCTION ("diff", f_diff_, tFunc (tStr tRev tStr tRev tOr (tArr (tStr),
								 tVoid)
					tOr (tObjImpl_STDIO_FD, tVoid)
					tOr (tObjImpl_STDIO_FD, tVoid)
					tOr (tInt, tVoid) tOr (tInt, tVoid)
					tOr (tInt, tVoid), tVoid), 0);
  ADD_FUNCTION ("diff_peg", f_diff_peg, tFunc (tStr tRev tRev tRev
					       tOr (tArr (tStr), tVoid)
					       tOr (tObjImpl_STDIO_FD, tVoid)
					       tOr (tObjImpl_STDIO_FD, tVoid)
					       tOr (tInt, tVoid)
					       tOr (tInt, tVoid)
					       tOr (tInt, tVoid), tVoid), 0);
  ADD_FUNCTION ("merge", f_merge, tFunc (tStr tRev tStr tRev tStr
					 tOr (tInt, tVoid) tOr (tInt, tVoid)
					 tOr (tInt, tVoid) tOr (tInt, tVoid),
					 tVoid), 0);
  ADD_FUNCTION ("merge_peg", f_merge_peg, tFunc (tStr tRev tRev tRev tStr
						 tOr (tInt, tVoid)
						 tOr (tInt, tVoid)
						 tOr (tInt, tVoid)
						 tOr (tInt, tVoid), tVoid), 0);
  ADD_FUNCTION ("cleanup", f_cleanup, tFunc (tStr, tVoid), 0);
  ADD_FUNCTION ("relocate", f_relocate, tFunc (tStr tStr tStr tOr (tInt, tVoid),
					       tVoid), 0);
  ADD_FUNCTION ("revert", f_revert, tFunc (tArr (tStr) tOr (tInt, tVoid),
					   tVoid), 0);
  ADD_FUNCTION ("resolved", f_resolved, tFunc (tStr tOr (tInt, tVoid),
					       tVoid), 0);
  ADD_FUNCTION ("copy", f_copy, tFunc (tStr tRev tStr,
				       tArr (tOr (tInt, tStr))), 0);
  ADD_FUNCTION ("move", f_move, tFunc (tStr tRev tStr tOr (tInt, tVoid),
				       tArr (tOr (tInt, tStr))), 0);
  ADD_FUNCTION ("propset", f_propset, tFunc (tStr tStr tStr tOr (tInt, tVoid),
					     tVoid), 0);
  ADD_FUNCTION ("revprop_set", f_revprop_set, tFunc (tStr tStr tStr tRev
						     tOr (tInt, tVoid), tInt),
		0);
  ADD_FUNCTION ("propget", f_propget, tFunc (tStr tStr tOr (tInt, tVoid),
					     tMap (tStr, tStr)), 0);
  ADD_FUNCTION ("revprop_get", f_revprop_get,
		tFunc (tStr tStr tRev, tArr (tOr (tInt, tStr))), 0);
  ADD_FUNCTION ("proplist", f_proplist, tFunc (tStr tOr (tInt, tVoid),
					       tMap (tStr, tMap (tStr, tStr))),
		0);
  ADD_FUNCTION ("revprop_list", f_revprop_list,
		tFunc (tStr tRev, tArr (tOr (tInt, tMap (tStr, tStr)))), 0);
  ADD_FUNCTION ("export", f_export, tFunc (tStr tStr tOr (tRev, tVoid)
					   tOr (tInt, tVoid) tOr (tStr, tVoid),
					   tInt), 0);
  ADD_FUNCTION ("ls", f_ls, tFunc (tStr tOr (tRev, tVoid) tOr (tInt, tVoid),
				   tMap (tStr, tArray)), 0);
  ADD_FUNCTION ("cat", f_cat, tFunc (tObj tStr tOr (tRev, tVoid), tVoid), 0);
  ADD_FUNCTION ("url_from_path", f_url_from_path, tFunc (tStr, tStr), 0);
  ADD_FUNCTION ("uuid_from_url", f_uuid_from_url, tFunc (tStr, tStr), 0);
  ADD_FUNCTION ("uuid_from_path", f_uuid_from_path, tFunc (tStr, tStr), 0);

  ADD_FUNCTION ("version", f_version, tFunc (tNone, tObj), 0);

  end_class ("Client", 0);
}

/*! @endclass  */
/*! @endmodule */