svn_types.swg

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

    $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
}

/* -----------------------------------------------------------------------
   Callback: svn_commit_callback_t
   svn_ra get_commit_editor()
   svn_repos_get_commit_editor()
*/

%typemap(perl5, in) (svn_commit_callback_t callback, void *callback_baton) {
    $1 = svn_swig_pl_thunk_commit_callback;
    $2 = (void *)$input;
    svn_swig_pl_hold_ref_in_pool (_global_pool, $input);
};

%typemap(ruby, in) (svn_commit_callback_t callback, void *callback_baton)
{
  $1 = svn_swig_rb_commit_callback;
  $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
};

%typemap(ruby, argout) (svn_commit_callback_t callback, void *callback_baton)
{
  svn_swig_rb_set_baton($result, (VALUE)$2);
};

/* -----------------------------------------------------------------------
   Callback: svn_commit_callback2_t
   svn_ra get_commit_editor2()
   svn_repos_get_commit_editor4()
*/

%typemap(ruby, in) (svn_commit_callback2_t callback, void *callback_baton)
{
  $1 = svn_swig_rb_commit_callback2;
  $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
};

%typemap(ruby, argout) (svn_commit_callback2_t callback, void *callback_baton)
{
  svn_swig_rb_set_baton($result, (VALUE)$2);
};

/* -----------------------------------------------------------------------
   Callback: svn_cancel_func_t
*/

%typemap(python, in) (svn_cancel_func_t cancel_func, void *cancel_baton) {
  $1 = svn_swig_py_cancel_func;
  $2 = $input; /* our function is the baton. */
}

%typemap(ruby, in) (svn_cancel_func_t cancel_func, void *cancel_baton)
{
  $1 = svn_swig_rb_cancel_func;
  $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
}

%typemap(ruby, argout) (svn_cancel_func_t cancel_func, void *cancel_baton)
{
  svn_swig_rb_set_baton($result, (VALUE)$2);
};


/* -----------------------------------------------------------------------
   Callback: svn_info_receiver_t
*/

%typemap(perl5, in) (svn_info_receiver_t receiver, void *receiver_baton)
{
  $1 = svn_swig_pl_info_receiver;
  $2 = (void *)$input;
}

%typemap(ruby, in) (svn_info_receiver_t receiver, void *receiver_baton)
{
  $1 = svn_swig_rb_info_receiver;
  $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
}

/* -----------------------------------------------------------------------
   Callback: svn_fs_warning_callback_t
*/

%typemap(ruby, in) (svn_fs_warning_callback_t warning, void *warning_baton)
{
  VALUE baton = svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
  svn_swig_rb_fs_warning_callback_baton_register(baton, _global_pool);
  $1 = svn_swig_rb_fs_warning_callback;
  $2 = (void *)baton;
}

/* -----------------------------------------------------------------------
   svn_stream_t interoperability with language native io handles
*/

%typemap(python, in) svn_stream_t *WRAPPED_STREAM {
    $1 = svn_swig_py_make_stream ($input, _global_pool);
}

%typemap(perl5, in) svn_stream_t * {
    svn_swig_pl_make_stream (&$1, $input);
}

%typemap(perl5, out) svn_stream_t * {
    $result = svn_swig_pl_from_stream ($1);
    argvi++;
}

%typemap(perl5, argout) svn_stream_t ** {
    $result = svn_swig_pl_from_stream (*$1);
    argvi++;
}

%typemap(ruby, in) svn_stream_t * {
  $1 = svn_swig_rb_make_stream($input);
}

/* -----------------------------------------------------------------------
   Wrap the digest output for functions populating digests.
*/

%typemap(in, numinputs=0) unsigned char digest[ANY]
    ($*1_type temp[APR_MD5_DIGESTSIZE]) {
    $1 = ($1_ltype)temp;
}

%typemap(python, argout, fragment="t_output_helper") unsigned char digest[ANY]
{
    $result = t_output_helper($result,
        PyString_FromString(svn_md5_digest_to_cstring ($1, _global_pool)));
}

%typemap(perl5, argout) unsigned char digest[ANY] {
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++), svn_md5_digest_to_cstring ($1,_global_pool));
}

%typemap(ruby, argout, fragment="output_helper") unsigned char digest[ANY]
{
  char *digest_string = (char *)svn_md5_digest_to_cstring($1, _global_pool);
  $result = output_helper($result, rb_str_new2(digest_string));
}


%typemap(ruby, in, numinputs=0) unsigned char **digest ($*1_type temp)
{
    $1 = &temp;
}

%typemap(ruby, argout, fragment="output_helper") unsigned char **digest
{
  char *digest_string = (char *)svn_md5_digest_to_cstring(*$1, _global_pool);
  $result = output_helper($result, rb_str_new2(digest_string));
}

/* svn_md5_* functions takes const ones as input */
%typemap(perl5, in) const unsigned char digest[] {
    SWIG_ConvertPtr($input, (void **)&$1, $1_descriptor, 0);
}
%typemap(perl5, argout) const unsigned char digest[] {}

%typemap(ruby, in) const unsigned char *digest
{
  if (NIL_P($input)) {
    $1 = NULL;
  } else if (RSTRING($input)->len != APR_MD5_DIGESTSIZE) {
    rb_raise(rb_eArgError, "digest size (%d) must be %d",
             RSTRING($input)->len, APR_MD5_DIGESTSIZE);
  } else {
    $1 = ($1_ltype)StringValuePtr($input);
  }
}
%typemap(ruby, argout) const unsigned char *digest {}

/*
   svn_txdelta_send_stream() uses *digest not digest[] .
   svn_txdelta_apply() uses *result_digest not digest[] .
*/

%typemap(in, numinputs=0) unsigned char *result_digest {
    $1 = (unsigned char *)apr_palloc(_global_pool, APR_MD5_DIGESTSIZE);
}

%typemap(perl5, argout) unsigned char *result_digest {
    ST(argvi) = sv_newmortal();
    ST(argvi++) = svn_swig_pl_from_md5($1);
}

%apply unsigned char digest[ANY] {
    unsigned char *digest
};

#ifndef SWIGPERL
%apply unsigned char digest[ANY] {
    unsigned char *result_digest
};
#endif

/* -----------------------------------------------------------------------
  useful convertors for svn_opt_revision_t
*/
%typemap(perl5, in) svn_opt_revision_t * (svn_opt_revision_t rev) {
    $1 = &rev;
    if ($input == NULL || $input == &PL_sv_undef || !SvOK($input)) {
        rev.kind = svn_opt_revision_unspecified;
    }
    else if (sv_isobject($input) && sv_derived_from($input, "_p_svn_opt_revision_t")) {
        SWIG_ConvertPtr($input, (void **)&$1, $1_descriptor, 0);
    }
    else if (looks_like_number($input)) {
        rev.kind = svn_opt_revision_number;
        rev.value.number = SvIV($input);
    }
    else if (SvPOK($input)) {
        char *input = SvPV_nolen($input);
        if (strcasecmp(input, "BASE") == 0)
            rev.kind = svn_opt_revision_base;
        else if (strcasecmp(input, "HEAD") == 0)
            rev.kind = svn_opt_revision_head;
        else if (strcasecmp(input, "WORKING") == 0)
            rev.kind = svn_opt_revision_working;
        else if (strcasecmp(input, "COMMITTED") == 0)
            rev.kind = svn_opt_revision_committed;
        else if (strcasecmp(input, "PREV") == 0)
            rev.kind = svn_opt_revision_previous;
        else if (*input == '{') {
            svn_boolean_t matched;
            apr_time_t tm;
            svn_error_t *err;

            char *end = strchr(input,'}');
            if (!end)
                SWIG_croak("unknown opt_revision_t type");
            *end = '\0';
            err = svn_parse_date (&matched, &tm, input + 1, apr_time_now(),
                                  svn_swig_pl_make_pool ((SV *)NULL));
            if (err) {
                svn_error_clear (err);
                SWIG_croak("unknown opt_revision_t type");
            }
            if (!matched)
                SWIG_croak("unknown opt_revision_t type");

            rev.kind = svn_opt_revision_date;
            rev.value.date = tm;
        } else
            SWIG_croak("unknown opt_revision_t type");
    } else
        SWIG_croak("unknown opt_revision_t type");
}

%typemap(ruby, in) svn_opt_revision_t * (svn_opt_revision_t rev) {
  $1 = &rev;
  svn_swig_rb_set_revision(&rev, $input);
}

/* -----------------------------------------------------------------------
   apr_hash_t **dirents
   svn_client_ls()
   svn_io_get_dirents()
   svn_ra get_dir()
*/

%typemap(python,in,numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
%typemap(python,argout,fragment="t_output_helper") apr_hash_t **dirents {
  $result = t_output_helper($result, svn_swig_py_convert_hash(*$1, 
    $descriptor(svn_dirent_t *), _global_svn_swig_py_pool));
}

%typemap(perl5,in,numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
%typemap(perl5,argout) apr_hash_t **dirents {
    ST(argvi++) = svn_swig_pl_convert_hash
	(*$1, $descriptor(svn_dirent_t *));
}

%typemap(ruby, in, numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
%typemap(ruby, argout, fragment="output_helper") apr_hash_t **dirents
{
  $result = output_helper($result,
                          svn_swig_rb_apr_hash_to_hash_swig_type
                            (*$1, "svn_dirent_t *"));
}

/* -----------------------------------------------------------------------
   apr_hash_t **locks
   svn_client_ls3()
   svn_repos_fs_get_locks()
   svn_ra_get_locks()
*/

%typemap(ruby, in, numinputs=0) apr_hash_t **locks = apr_hash_t **OUTPUT;
%typemap(ruby, argout, fragment="output_helper") apr_hash_t **locks
{
  $result = output_helper($result,
                          svn_swig_rb_apr_hash_to_hash_swig_type
                            (*$1, "svn_lock_t *"));
}

/* -----------------------------------------------------------------------
   apr_array_header_t *location_revisions
   svn_repos_trace_node_locations()
   svn_ra_get_locations()
*/

%typemap(ruby, in) apr_array_header_t *location_revisions
{
  $1 = svn_swig_rb_array_to_apr_array_revnum($input, _global_pool);
}

/* -----------------------------------------------------------------------
   apr_hash_t **locations
   svn_repos_trace_node_locations()
   svn_ra_get_locations()
*/

%typemap(ruby, in, numinputs=0) apr_hash_t **locations = apr_hash_t **OUTPUT;
%typemap(ruby, argout) apr_hash_t **locations
{
  $result = svn_swig_rb_apr_revnum_key_hash_to_hash_string(*$1);
}

/* -----------------------------------------------------------------------
   Special boolean mapping for ruby.
*/

%typemap(ruby, in) svn_boolean_t "$1 = RTEST($input);";
%typemap(ruby, out, fragment="output_helper") svn_boolean_t
{
  $result = output_helper($result, $1 ? Qtrue : Qfalse);
}

%typemap(ruby, in, numinputs=0) svn_boolean_t * (svn_boolean_t temp)
{
  $1 = &temp;
}

%typemap(ruby, argout, fragment="output_helper") svn_boolean_t *
{
  $result = output_helper($result, *$1 ? Qtrue : Qfalse);
}

/* -----------------------------------------------------------------------
   Handle python thread locking.

   Swig doesn't allow us to specify a language in the %exception command,
   so we have to use #ifdefs for the python-specific parts.
*/

%exception {
#ifdef SWIGPYTHON
    svn_swig_py_release_py_lock();
#endif
    $action
#ifdef SWIGPYTHON
    svn_swig_py_acquire_py_lock();
#endif
}


/* -----------------------------------------------------------------------
   handle config and fs_config in svn_{fs,repos}_create
*/


%typemap(ruby, in) apr_hash_t *config
{
  if (NIL_P($input)) {
    $1 = NULL;
  } else {
    $1 = svn_swig_rb_hash_to_apr_hash_swig_type($input, "svn_config_t *", _global_pool);
  }
}
%typemap(ruby, in) apr_hash_t *fs_config
{
  if (NIL_P($input)) {
    $1 = NULL;
  } else {
    $1 = svn_swig_rb_hash_to_apr_hash_string($input, _global_pool);
  }
}

/* ----------------------------------------------------------------------- */

%{
#ifdef SWIGPYTHON
#include "swigutil_py.h"
#endif

#ifdef SWIGPERL
#include "swigutil_pl.h"
#endif

#ifdef SWIGRUBY
#include <apu.h>
#include <apr_xlate.h>
#include "swigutil_rb.h"
#endif
%}

%include svn_time_h.swg
%include svn_types_h.swg