Attachment #46796 for bug #75294

View | Details | Raw Unified | Return to bug 75294
Collapse All | Expand All




       (http://svn.collab.net/repos/svn)
r12144:  clkao | 2004-12-04T15:13:55.095399Z
* Pass pool to methods in Perl for close_baton.
* Use a hash to cache SWIG_TypeQuery results.

  * libsvn_swig_perl/swigutil_pl.c:
    (close_baton): Pass pool to methods in Perl.
      Use svn_swig_pl_callback_thunk.

    (_swig_perl_type_query): New.
    (_SWIG_TYPE): New.
 
    Change callers of SWIG_TypeQuery to use _swig_perl_type_query.
++ subversion/bindings/swig/perl/libsvn_swig_perl/swigutil_pl.c  (patch 11x level 1)


#include "swigutil_pl.h"

/* cache SWIG_TypeQuery results in a perl hash */
static HV *type_cache = NULL;

#define _SWIG_TYPE(name) _swig_perl_type_query(name, sizeof (name)-1)
#define POOLINFO         _SWIG_TYPE("apr_pool_t *")

static swig_type_info *_swig_perl_type_query (const char *typename, U32 klen)
{
    SV **type_info;
    swig_type_info *tinfo;

    if (!type_cache)
        type_cache = newHV ();

    if (klen == 0)
        klen = strlen (typename);

    if ((type_info = hv_fetch(type_cache, typename, klen, 0)))
        return (swig_type_info *) (SvIV (*type_info));

    tinfo = SWIG_TypeQuery(typename);
    hv_store(type_cache, typename, klen, newSViv ((IV)tinfo), 0);

    return tinfo;
}

/* element convertors for perl -> c */
typedef void *(*pl_element_converter_t)(SV *value, void *ctx, 
                                        apr_pool_t *pool);

                                             const char *typename,
                                             apr_pool_t *pool)
{
    swig_type_info *tinfo = _swig_perl_type_query(typename, 0);
    return svn_swig_pl_objs_to_hash (source, tinfo, pool);
}


	case 'S': /* swig object */
	    o = va_arg (ap, void *);
	    t = va_arg (ap, swig_type_info *);

	    obj = sv_newmortal ();
	    SWIG_MakePtr (obj, o, t, 0);
	    XPUSHs(obj);

    return newb;
}

static svn_error_t * close_baton(void *baton, const char *method, apr_pool_t *pool)
{
    item_baton *ib = baton;
    dSP ;

    if (ib->baton) {
        SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
                                             (void *)method, NULL,
                                             "OOS", ib->editor, ib->baton,
                                             pool, POOLINFO));
        SvREFCNT_dec(ib->baton);
    }
    else {
        SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
                                             (void *)method, NULL,
                                             "OS", ib->editor, pool, POOLINFO));
    }

    PUSHMARK(SP) ;
    XPUSHs(ib->editor);

    if (ib->baton)
	XPUSHs(ib->baton);

    PUTBACK;

    call_method(method, G_DISCARD);

    /* check result? */

    SvREFCNT_dec(ib->editor);
    if (ib->baton)
	SvREFCNT_dec(ib->baton);

#ifdef SVN_DEBUG
    ib->editor = ib->baton = NULL;
#endif

    FREETMPS ;
    LEAVE ;

    return SVN_NO_ERROR;
}


                                     void **root_baton)
{
    item_baton *ib = edit_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");
    SV *result;

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"open_root", &result,
				         "OrS", ib->editor, base_revision,
				         dir_pool, POOLINFO));

    *root_baton = make_baton(dir_pool, ib->editor, result);
    return SVN_NO_ERROR;

                                        apr_pool_t *pool)
{
    item_baton *ib = parent_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"delete_entry", NULL,
				         "OsrOS", ib->editor, path, revision,
				         ib->baton, pool, POOLINFO));
    return SVN_NO_ERROR;
}


                                         void **child_baton)
{
    item_baton *ib = parent_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");
    SV *result;

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"add_directory", &result,
				         "OsOsrS", ib->editor, path, ib->baton,
				         copyfrom_path, copyfrom_revision, 
				         dir_pool, POOLINFO));
    *child_baton = make_baton(dir_pool, ib->editor, result);
    return SVN_NO_ERROR;
}

{
    item_baton *ib = parent_baton;
    SV *result;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"open_directory", &result,
				         "OsOrS", ib->editor, path, ib->baton,
				         base_revision, dir_pool, POOLINFO));

    *child_baton = make_baton(dir_pool, ib->editor, result);


                                           apr_pool_t *pool)
{
    item_baton *ib = dir_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"change_dir_prop", NULL,
				         "OOssS", ib->editor, ib->baton, name,
				         value ? value->data : NULL,
				         pool, POOLINFO));

    return SVN_NO_ERROR;
}

static svn_error_t * thunk_close_directory(void *dir_baton,
                                           apr_pool_t *pool)
{
    return close_baton(dir_baton, "close_directory", pool);
}

static svn_error_t * thunk_absent_directory(const char *path,

					    apr_pool_t *pool)
{
    item_baton *ib = parent_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
	   			         (void *)"absent_directory", NULL,
				         "OsOS", ib->editor, path, ib->baton,
				         pool, POOLINFO));

    return SVN_NO_ERROR;
}

{
    item_baton *ib = parent_baton;
    SV *result;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"add_file", &result,
				         "OsOsrS", ib->editor, path, ib->baton,
				         copyfrom_path, copyfrom_revision,
				         file_pool, POOLINFO));

    *file_baton = make_baton(file_pool, ib->editor, result);
    return SVN_NO_ERROR;

                                     void **file_baton)
{
    item_baton *ib = parent_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");
    SV *result;

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"open_file", &result,
				         "OsOrS", ib->editor, path, ib->baton,
				         base_revision, file_pool, POOLINFO));

    *file_baton = make_baton(file_pool, ib->editor, result);
    return SVN_NO_ERROR;

        SvREFCNT_dec(handler);
    }
    else {
	swig_type_info *tinfo = _SWIG_TYPE("svn_txdelta_window_t *");
	SVN_ERR (svn_swig_pl_callback_thunk (CALL_SV, handler,
				             NULL, "S", window, tinfo));
    }

                      void **h_baton)
{
    item_baton *ib = file_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");
    SV *result;

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"apply_textdelta", &result,
				         "OOsS", ib->editor, ib->baton,
					 base_checksum, pool, POOLINFO));
    if (SvOK(result)) {
	if (SvROK(result) && SvTYPE(SvRV(result)) == SVt_PVAV) {
	    swig_type_info *handler_info = 
              _SWIG_TYPE("svn_txdelta_window_handler_t");
            swig_type_info *void_info = _SWIG_TYPE("void *");
	    AV *array = (AV *)SvRV(result);

	    if (SWIG_ConvertPtr(*av_fetch (array, 0, 0),

                                            apr_pool_t *pool)
{
    item_baton *ib = file_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"change_file_prop", NULL,
				         "OOssS", ib->editor, ib->baton, name,
				         value ? value->data : NULL,
				         pool, POOLINFO));
  
    return SVN_NO_ERROR;
}

                                      apr_pool_t *pool)
{
    item_baton *ib = file_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"close_file", NULL, "OOsS",
				         ib->editor, ib->baton, text_checksum,
				         pool, POOLINFO));

    SvREFCNT_dec(ib->editor);
    SvREFCNT_dec(ib->baton);

#ifdef SVN_DEBUG
    ib->editor = ib->baton = NULL;
#endif

    return SVN_NO_ERROR;
}


				       apr_pool_t *pool)
{
    item_baton *ib = parent_baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    SVN_ERR (svn_swig_pl_callback_thunk (CALL_METHOD,
				         (void *)"absent_file", NULL,
				         "OsOS", ib->editor, path, ib->baton,
				         pool, POOLINFO));

    return SVN_NO_ERROR;
}

static svn_error_t * thunk_close_edit(void *edit_baton,
                                      apr_pool_t *pool)
{
    return close_baton(edit_baton, "close_edit", pool);
}

static svn_error_t * thunk_abort_edit(void *edit_baton,
                                      apr_pool_t *pool)
{
    return close_baton(edit_baton, "abort_edit", pool);
}

void svn_delta_make_editor(svn_delta_editor_t **editor,

					    apr_pool_t *pool)
{
    SV *receiver = baton;
    swig_type_info *tinfo = _SWIG_TYPE("svn_log_changed_path_t *");
    swig_type_info *tinfo = SWIG_TypeQuery("svn_log_changed_path_t *");

    if (!SvOK(receiver))
	return SVN_NO_ERROR;

			        "OrsssS", (changed_paths) ?
			        svn_swig_pl_convert_hash(changed_paths, tinfo)
			        : &PL_sv_undef,
			        rev, author, date, msg, pool, POOLINFO);

    return SVN_NO_ERROR;
}

                                            apr_pool_t *pool)
{
    SV *func = baton;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");

    if (!SvOK(func))
	return SVN_NO_ERROR;

    svn_swig_pl_callback_thunk (CALL_SV,
			        func, NULL,
			        "srS", path, revision, pool, POOLINFO);

    return SVN_NO_ERROR;
}

                                           apr_pool_t *pool)
{
    SV *func = baton, *result;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");
    swig_type_info *rootinfo = SWIG_TypeQuery("svn_fs_root_t *");

    if (!SvOK(func))
	return SVN_NO_ERROR;

    svn_swig_pl_callback_thunk (CALL_SV,
			        func, &result,
			        "SsS", root, _SWIG_TYPE("svn_fs_root_t *"),
                                path, pool, POOLINFO);

    *allowed = SvIV (result);
    SvREFCNT_dec (result);

					 apr_pool_t *pool)
{
    SV *result;
    swig_type_info *tinfo = _SWIG_TYPE("apr_file_t *");

    svn_swig_pl_callback_thunk (CALL_METHOD, (void *)"open_tmp_file",
			        &result, "OS", callback_baton, pool, POOLINFO);

				   SV *perl_callbacks,
				   apr_pool_t *pool)
{
    swig_type_info *tinfo = SWIG_TypeQuery("svn_auth_baton_t *");
    SV *auth_baton;

    *cb = apr_pcalloc (pool, sizeof(**cb));

    auth_baton = *hv_fetch((HV *)SvRV(perl_callbacks), "auth", 4, 0);

    if (SWIG_ConvertPtr(auth_baton, 
                        (void **)&(*cb)->auth_baton, _SWIG_TYPE("svn_auth_baton_t *"),0) < 0) {
	croak("Unable to convert from SWIG Type");
    }
    *c_baton = perl_callbacks;

                                             svn_boolean_t may_save,
                                             apr_pool_t *pool)
{
    swig_type_info *poolinfo = SWIG_TypeQuery ("apr_pool_t *");
    swig_type_info *credinfo = SWIG_TypeQuery ("svn_auth_cred_simple_t *");

    /* Be nice and allocate the memory for the cred structure before passing it
     * off to the perl space */
    *cred = apr_pcalloc (pool, sizeof (**cred));

    }
    svn_swig_pl_callback_thunk (CALL_SV,
                                baton, NULL,
                                "SssbS", *cred, _SWIG_TYPE ("svn_auth_cred_simple_t *"),
                                realm, username, may_save, pool, POOLINFO);

    return SVN_NO_ERROR;
}

                                               svn_boolean_t may_save,
                                               apr_pool_t *pool)
{
    swig_type_info *poolinfo = SWIG_TypeQuery ("apr_pool_t *");
    swig_type_info *credinfo = SWIG_TypeQuery ("svn_auth_cred_username_t *");

    /* Be nice and allocate the memory for the cred structure before passing it
     * off to the perl space */
    *cred = apr_pcalloc (pool, sizeof (**cred));

    }
    svn_swig_pl_callback_thunk (CALL_SV,
                                baton, NULL,
                                "SsbS", *cred, _SWIG_TYPE("svn_auth_cred_username_t *"),
                                realm, may_save, pool, POOLINFO);

    return SVN_NO_ERROR;
}

                              svn_boolean_t may_save,
                              apr_pool_t *pool)
{
    swig_type_info *poolinfo = SWIG_TypeQuery ("apr_pool_t *");
    swig_type_info *credinfo = SWIG_TypeQuery (
                                 "svn_auth_cred_ssl_server_trust_t *");
    swig_type_info *cert_info_info = SWIG_TypeQuery (
                                 "svn_auth_ssl_server_cert_info_t *");

    /* Be nice and allocate the memory for the cred structure before passing it
     * off to the perl space */
    *cred = apr_pcalloc (pool, sizeof (**cred));

    }
    svn_swig_pl_callback_thunk (CALL_SV,
                                baton, NULL,
                                "SsiSbS", *cred, _SWIG_TYPE ("svn_auth_cred_ssl_server_trust_t *"),
                                realm, failures, 
                                cert_info, _SWIG_TYPE ("svn_auth_ssl_server_cert_info_t *"),
                                may_save, pool, POOLINFO);

    /* Allow the perl callback to indicate failure by setting all vars to 0 
     * or by simply doing nothing.  While still allowing them to indicate

                svn_boolean_t may_save,
                apr_pool_t *pool)
{
    swig_type_info *poolinfo = SWIG_TypeQuery ("apr_pool_t *");
    swig_type_info *credinfo = SWIG_TypeQuery (
                                 "svn_auth_cred_ssl_client_cert_t *");
    
    /* Be nice and allocate the memory for the cred structure before passing it
     * off to the perl space */
    *cred = apr_pcalloc (pool, sizeof (**cred));

    }
    svn_swig_pl_callback_thunk (CALL_SV,
                                baton, NULL,
                                "SsbS", *cred, _SWIG_TYPE ("svn_auth_cred_ssl_client_cert_t *"),
                                realm, may_save, pool, POOLINFO);

    return SVN_NO_ERROR;
}

                                     svn_boolean_t may_save,
                                     apr_pool_t *pool)
{
    swig_type_info *poolinfo = SWIG_TypeQuery ("apr_pool_t *");
    swig_type_info *credinfo = SWIG_TypeQuery (
                                 "svn_auth_cred_ssl_client_cert_pw_t *");

    /* Be nice and allocate the memory for the cred structure before passing it
     * off to the perl space */
    *cred = apr_pcalloc (pool, sizeof (**cred));

    }
    svn_swig_pl_callback_thunk (CALL_SV,
                                baton, NULL,
                                "SsbS", *cred, _SWIG_TYPE ("svn_auth_cred_ssl_client_cert_pw_t *"),
                                realm, may_save, pool, POOLINFO);

    return SVN_NO_ERROR;
}

    SV *log_msg_sv;
    SV *tmp_file_sv;
    SV *commit_items_sv;
    swig_type_info *commit_itemsinfo = SWIG_TypeQuery 
	                                ("svn_client_commit_item_t *");
    swig_type_info *poolinfo = SWIG_TypeQuery ("apr_pool_t *");

    if (!SvOK((SV *)baton)) {
        *log_msg = apr_pstrdup (pool, "");

    
    log_msg_sv = newRV_noinc (sv_newmortal ());
    tmp_file_sv = newRV_noinc (sv_newmortal ());
    commit_items_sv = svn_swig_pl_convert_array
      (commit_items, _SWIG_TYPE("svn_client_commit_item_t *"));

    svn_swig_pl_callback_thunk (CALL_SV,
	                        baton, &result,
				"OOOS", log_msg_sv, tmp_file_sv,
				commit_items_sv, pool, POOLINFO);

    if (!SvOK(SvRV(log_msg_sv))) {
        /* client returned undef to us */

    }

    if (sv_derived_from (result, "_p_svn_error_t")) {
        swig_type_info *errorinfo = _SWIG_TYPE("svn_error_t *");
	if (SWIG_ConvertPtr(result, (void *)&ret_val, errorinfo, 0) < 0) {
            SvREFCNT_dec(result);
	    croak("Unable to convert from SWIG Type");

    svn_swig_pl_callback_thunk(CALL_SV, cancel_baton, &result, "");

    if (sv_derived_from(result,"_p_svn_error_t")) { 
        swig_type_info *errorinfo = _SWIG_TYPE("svn_error_t *");
	if (SWIG_ConvertPtr(result, (void *)&ret_val, errorinfo, 0) < 0) {
	    SvREFCNT_dec(result);
	    croak("Unable to convert from SWIG Type");

                             const char *path,
                             svn_wc_status_t *status)
{
  swig_type_info *statusinfo = _SWIG_TYPE ("svn_wc_status_t *");

  if (!SvOK ((SV *)baton)) {
    return;

{
    SV *result;
    svn_error_t *ret_val = SVN_NO_ERROR;
    swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");
 
    svn_swig_pl_callback_thunk (CALL_SV, baton, &result, "LrsssS",
		                line_no, revision, author, date, line,
				pool, POOLINFO);

    if (sv_derived_from (result, "_p_svn_error_t")) {
        swig_type_info *errorinfo = _SWIG_TYPE("svn_error_t *");
	if (SWIG_ConvertPtr(result, (void *)&ret_val, errorinfo, 0) < 0) {
            SvREFCNT_dec(result);
	    croak("Unable to convert from SWIG Type");

    apr_pool_t *pool;

    if (obj && sv_isobject (obj)) {
	swig_type_info *poolinfo = SWIG_TypeQuery("apr_pool_t *");
	if (sv_derived_from (obj, "SVN::Pool")) {
	    obj = SvRV(obj);
	}
	if (sv_derived_from(obj, "_p_apr_pool_t")) {
	    SWIG_ConvertPtr(obj, (void **)&pool, POOLINFO, 0);
	    return pool;
	}
    }


svn_error_t *svn_swig_pl_make_stream (svn_stream_t **stream, SV *obj)
{
    swig_type_info *tinfo = SWIG_TypeQuery("svn_stream_t *");
    IO *io;
    int simple_type = 1;


            simple_type = 0;

        if (simple_type) {
            SWIG_ConvertPtr(obj, (void **)stream, _SWIG_TYPE("svn_stream_t *"), 0);
            return SVN_NO_ERROR;
        }
    }


SV *svn_swig_pl_from_stream (svn_stream_t *stream)
{
    swig_type_info *tinfo = SWIG_TypeQuery("svn_stream_t *");
    SV *ret;

    svn_swig_pl_callback_thunk (CALL_METHOD, (void *)"new", &ret, "sS",
			        "SVN::Stream", stream, _SWIG_TYPE("svn_stream_t *"));

    return sv_2mortal (ret);
}

Return to bug 75294