Alien-SVN
view release on metacpan or search on metacpan
src/subversion/subversion/bindings/swig/python/libsvn_swig_py/swigutil_py.c view on Meta::CPAN
static svn_error_t *callback_exception_error(void)
{
PyObject *svn_module = NULL, *svn_exc = NULL;
PyObject *exc, *exc_type, *exc_traceback;
svn_error_t *rv = NULL;
PyErr_Fetch(&exc_type, &exc, &exc_traceback);
if ((svn_module = PyImport_ImportModule("svn.core")) == NULL)
goto finished;
svn_exc = PyObject_GetAttrString(svn_module, "SubversionException");
Py_DECREF(svn_module);
if (svn_exc == NULL)
goto finished;
if (PyErr_GivenExceptionMatches(exc_type, svn_exc))
{
rv = exception_to_error(exc);
}
else
{
PyErr_Restore(exc_type, exc, exc_traceback);
exc_type = exc = exc_traceback = NULL;
}
finished:
Py_XDECREF(svn_exc);
Py_XDECREF(exc_type);
Py_XDECREF(exc);
Py_XDECREF(exc_traceback);
/* By now, either rv is set and the exception is cleared, or rv is NULL
and an exception is pending (possibly a new one). */
return rv ? rv : svn_error_create(SVN_ERR_SWIG_PY_EXCEPTION_SET, NULL,
"Python callback raised an exception");
}
/* Raise a TypeError exception with MESSAGE, and return a Subversion
error about an invalid return from a callback. */
static svn_error_t *callback_bad_return_error(const char *message)
{
PyErr_SetString(PyExc_TypeError, message);
return svn_error_create(APR_EGENERAL, NULL,
"Python callback returned an invalid object");
}
/* Return a generic error about not being able to map types. */
static svn_error_t *type_conversion_error(const char *datatype)
{
return svn_error_createf(APR_EGENERAL, NULL,
"Error converting object of type '%s'", datatype);
}
/*** Editor Wrapping ***/
/* this baton is used for the editor, directory, and file batons. */
typedef struct item_baton {
PyObject *editor; /* the editor handling the callbacks */
PyObject *baton; /* the dir/file baton (or NULL for edit baton) */
} item_baton;
static item_baton *make_baton(apr_pool_t *pool,
PyObject *editor,
PyObject *baton)
{
item_baton *newb = apr_palloc(pool, sizeof(*newb));
/* Note: We steal the caller's reference to 'baton'. Also, to avoid
memory leaks, we borrow the caller's reference to 'editor'. In this
case, borrowing the reference to 'editor' is safe because the contents
of an item_baton struct are only used by functino calls which operate on
the editor itself. */
newb->editor = editor;
newb->baton = baton;
return newb;
}
static svn_error_t *close_baton(void *baton,
const char *method)
{
item_baton *ib = baton;
PyObject *result;
svn_error_t *err;
svn_swig_py_acquire_py_lock();
/* If there is no baton object, then it is an edit_baton, and we should
not bother to pass an object. Note that we still shove a NULL onto
the stack, but the format specified just won't reference it. */
/* ### python doesn't have 'const' on the method name and format */
if ((result = PyObject_CallMethod(ib->editor, (char *)method,
ib->baton ? (char *)"(O)" : NULL,
ib->baton)) == NULL)
{
err = callback_exception_error();
goto finished;
}
/* there is no return value, so just toss this object (probably Py_None) */
Py_DECREF(result);
/* We're now done with the baton. Since there isn't really a free, all
we need to do is note that its objects are no longer referenced by
the baton. */
Py_XDECREF(ib->baton);
#ifdef SVN_DEBUG
ib->editor = ib->baton = NULL;
#endif
err = SVN_NO_ERROR;
finished:
svn_swig_py_release_py_lock();
return err;
}
src/subversion/subversion/bindings/swig/python/libsvn_swig_py/swigutil_py.c view on Meta::CPAN
}
svn_error_t *
svn_swig_py_config_auth_walk_func(svn_boolean_t *delete_cred,
void *walk_baton,
const char *cred_kind,
const char *realmstring,
apr_hash_t *hash,
apr_pool_t *scratch_pool)
{
PyObject *function = walk_baton;
PyObject *result;
PyObject *py_scratch_pool, *py_hash;
svn_error_t *err = SVN_NO_ERROR;
*delete_cred = FALSE;
if (function == NULL || function == Py_None)
return SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
py_scratch_pool = make_ob_pool(scratch_pool);
if (py_scratch_pool == NULL)
{
err = callback_exception_error();
goto finished;
}
py_hash = svn_swig_py_prophash_to_dict(hash);
if (py_hash == NULL)
{
Py_DECREF(py_scratch_pool);
err = callback_exception_error();
goto finished;
}
if ((result = PyObject_CallFunction(function, (char *)"ssOO",
cred_kind, realmstring,
py_hash, py_scratch_pool)) == NULL)
{
err = callback_exception_error();
}
else
{
if (PyInt_Check(result))
*delete_cred = PyInt_AsLong(result) ? TRUE : FALSE;
else if (PyLong_Check(result))
*delete_cred = PyLong_AsLong(result) ? TRUE : FALSE;
else
err = callback_bad_return_error("Not an integer");
Py_DECREF(result);
}
Py_DECREF(py_hash);
Py_DECREF(py_scratch_pool);
finished:
svn_swig_py_release_py_lock();
return err;
}
/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_open_tmp_file(apr_file_t **fp,
void *callback_baton,
apr_pool_t *pool)
{
PyObject *callbacks = (PyObject *)callback_baton;
PyObject *py_callback, *result;
svn_error_t *err = SVN_NO_ERROR;
*fp = NULL;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)"open_tmp_file");
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
if ((result = PyObject_CallFunction(py_callback,
(char *)"O&",
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
else if (result != Py_None)
{
*fp = svn_swig_py_make_file(result, pool);
if (*fp == NULL)
{
err = callback_exception_error();
}
}
Py_XDECREF(result);
finished:
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_get_wc_prop(void *baton,
const char *path,
const char *name,
const svn_string_t **value,
apr_pool_t *pool)
{
PyObject *callbacks = (PyObject *)baton;
PyObject *py_callback, *result;
svn_error_t *err = SVN_NO_ERROR;
*value = NULL;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)"get_wc_prop");
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
if ((result = PyObject_CallFunction(py_callback,
(char *)"ssO&", path, name,
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
else if (result != Py_None)
{
char *buf;
Py_ssize_t len;
if (PyString_AsStringAndSize(result, &buf, &len) == -1)
{
err = callback_exception_error();
}
else
{
*value = svn_string_ncreate(buf, len, pool);
}
}
Py_XDECREF(result);
finished:
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_push_or_set_wc_prop(const char *callback,
void *baton,
const char *path,
const char *name,
const svn_string_t *value,
apr_pool_t *pool)
{
PyObject *callbacks = (PyObject *)baton;
PyObject *py_callback, *py_value, *result;
svn_error_t *err = SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)callback);
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
if ((py_value = PyString_FromStringAndSize(value->data, value->len)) == NULL)
{
err = callback_exception_error();
goto finished;
}
if ((result = PyObject_CallFunction(py_callback,
(char *)"ssOO&", path, name, py_value,
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
Py_XDECREF(result);
finished:
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_set_wc_prop(void *baton,
const char *path,
const char *name,
const svn_string_t *value,
apr_pool_t *pool)
{
return ra_callbacks_push_or_set_wc_prop("set_wc_prop", baton, path,
name, value, pool);
}
/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_push_wc_prop(void *baton,
const char *path,
const char *name,
const svn_string_t *value,
apr_pool_t *pool)
{
return ra_callbacks_push_or_set_wc_prop("push_wc_prop", baton, path,
name, value, pool);
}
/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_invalidate_wc_props(void *baton,
const char *path,
const char *name,
apr_pool_t *pool)
{
PyObject *callbacks = (PyObject *)baton;
PyObject *py_callback, *result;
svn_error_t *err = SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks,
(char *)"invalidate_wc_props");
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
if ((result = PyObject_CallFunction(py_callback,
(char *)"ssO&", path, name,
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
Py_XDECREF(result);
finished:
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_ra_callbacks_t */
static void
ra_callbacks_progress_func(apr_off_t progress,
apr_off_t total,
void *baton,
apr_pool_t *pool)
{
PyObject *callbacks = (PyObject *)baton;
PyObject *py_callback, *py_progress, *py_total, *result;
py_progress = py_total = NULL;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks,
(char *)"progress_func");
if (py_callback == NULL)
{
/* Ouch, no way to pass on exceptions! */
/* err = callback_exception_error(); */
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
/* Create PyLongs for progress and total up-front, rather than
passing them directly, so we don't have to worry about the size
(if apr_off_t is 4 bytes, we'd better use the l specifier; if 8
bytes, better use L...) */
if ((py_progress = PyLong_FromLongLong(progress)) == NULL)
{
/* Ouch, no way to pass on exceptions! */
/* err = callback_exception_error(); */
goto finished;
}
if ((py_total = PyLong_FromLongLong(total)) == NULL)
{
/* Ouch, no way to pass on exceptions! */
/* err = callback_exception_error(); */
goto finished;
}
if ((result = PyObject_CallFunction(py_callback,
(char *)"OOO&", py_progress, py_total,
make_ob_pool, pool)) == NULL)
{
/* Ouch, no way to pass on exceptions! */
/* err = callback_exception_error(); */
}
Py_XDECREF(result);
finished:
Py_XDECREF(py_callback);
Py_XDECREF(py_progress);
Py_XDECREF(py_total);
svn_swig_py_release_py_lock();
/* Sure hope nothing went wrong... */
/* return err; */
}
/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_cancel_func(void *baton)
{
PyObject *callbacks = (PyObject *)baton;
PyObject *py_callback;
svn_error_t *err;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks,
(char *)"cancel_func");
svn_swig_py_release_py_lock();
err = svn_swig_py_cancel_func(py_callback);
svn_swig_py_acquire_py_lock();
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_ra_callbacks_t */
static svn_error_t *
ra_callbacks_get_client_string(void *baton,
const char **name,
apr_pool_t *pool)
{
PyObject *callbacks = (PyObject *)baton;
PyObject *py_callback, *result;
svn_error_t *err = SVN_NO_ERROR;
*name = NULL;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)"get_client_string");
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
if ((result = PyObject_CallFunction(py_callback,
(char *)"O&",
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
else if (result != Py_None)
{
if ((*name = PyString_AsString(result)) == NULL)
{
err = callback_exception_error();
}
}
Py_XDECREF(result);
finished:
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
void
svn_swig_py_setup_ra_callbacks(svn_ra_callbacks2_t **callbacks,
void **baton,
PyObject *py_callbacks,
apr_pool_t *pool)
{
svn_error_t *err = svn_ra_create_callbacks(callbacks, pool);
PyObject *py_auth_baton;
if (err)
{
svn_swig_py_svn_exception(err);
return;
}
(*callbacks)->open_tmp_file = ra_callbacks_open_tmp_file;
py_auth_baton = PyObject_GetAttrString(py_callbacks, (char *)"auth_baton");
if (svn_swig_ConvertPtrString(py_auth_baton,
(void **)&((*callbacks)->auth_baton),
"svn_auth_baton_t *"))
{
err = type_conversion_error("svn_auth_baton_t *");
svn_swig_py_svn_exception(err);
Py_XDECREF(py_auth_baton);
return;
}
Py_XDECREF(py_auth_baton);
(*callbacks)->get_wc_prop = ra_callbacks_get_wc_prop;
(*callbacks)->set_wc_prop = ra_callbacks_set_wc_prop;
(*callbacks)->push_wc_prop = ra_callbacks_push_wc_prop;
(*callbacks)->invalidate_wc_props = ra_callbacks_invalidate_wc_props;
(*callbacks)->progress_func = ra_callbacks_progress_func;
(*callbacks)->progress_baton = py_callbacks;
(*callbacks)->cancel_func = ra_callbacks_cancel_func;
(*callbacks)->get_client_string = ra_callbacks_get_client_string;
*baton = py_callbacks;
}
svn_error_t *svn_swig_py_commit_callback2(const svn_commit_info_t *commit_info,
void *baton,
apr_pool_t *pool)
{
PyObject *receiver = baton;
PyObject *result;
svn_error_t *err = SVN_NO_ERROR;
if ((receiver == NULL) || (receiver == Py_None))
return SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
if ((result = PyObject_CallFunction(receiver,
(char *)"O&O&",
make_ob_commit_info, commit_info,
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
else
{
if (result != Py_None)
err = callback_bad_return_error("Not None");
Py_DECREF(result);
}
svn_swig_py_release_py_lock();
return err;
}
svn_error_t *svn_swig_py_commit_callback(svn_revnum_t new_revision,
const char *date,
const char *author,
void *baton)
{
PyObject *receiver = baton;
PyObject *result;
svn_error_t *err = SVN_NO_ERROR;
if ((receiver == NULL) || (receiver == Py_None))
return SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
if ((result = PyObject_CallFunction(receiver,
(char *)"lss",
new_revision, date, author)) == NULL)
{
err = callback_exception_error();
}
else
{
if (result != Py_None)
err = callback_bad_return_error("Not None");
Py_DECREF(result);
}
src/subversion/subversion/bindings/swig/python/libsvn_swig_py/swigutil_py.c view on Meta::CPAN
svn_swig_py_acquire_py_lock();
if ((result = PyObject_CallMethod(py_reporter,
(char *)"finish_report",
(char *)"O&",
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
else if (result != Py_None)
{
err = callback_bad_return_error("Not None");
}
Py_XDECREF(result);
svn_swig_py_release_py_lock();
return err;
}
static svn_error_t *reporter_abort_report(void *report_baton,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
PyObject *py_reporter = report_baton, *result;
if (py_reporter == NULL || py_reporter == Py_None)
return SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
if ((result = PyObject_CallMethod(py_reporter,
(char *)"abort_report",
(char *)"O&",
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
else if (result != Py_None)
{
err = callback_bad_return_error("Not None");
}
Py_XDECREF(result);
svn_swig_py_release_py_lock();
return err;
}
const svn_ra_reporter2_t swig_py_ra_reporter2 = {
reporter_set_path,
reporter_delete_path,
reporter_link_path,
reporter_finish_report,
reporter_abort_report
};
/* svn_wc_diff_callbacks2_t */
static svn_error_t *
wc_diff_callbacks2_file_changed_or_added(const char *callback,
svn_wc_adm_access_t *adm_access,
svn_wc_notify_state_t *contentstate,
svn_wc_notify_state_t *propstate,
const char *path,
const char *tmpfile1,
const char *tmpfile2,
svn_revnum_t rev1,
svn_revnum_t rev2,
const char *mimetype1,
const char *mimetype2,
const apr_array_header_t *propchanges,
apr_hash_t *originalprops,
void *diff_baton)
{
PyObject *callbacks = (PyObject *)diff_baton;
PyObject *py_callback;
PyObject *result = NULL;
int py_contentstate, py_propstate;
svn_error_t *err = SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)callback);
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
result = PyObject_CallFunction(py_callback,
(char *)"O&sssllssO&O&",
make_ob_wc_adm_access, adm_access,
path,
tmpfile1, tmpfile2,
rev1, rev2,
mimetype1, mimetype2,
svn_swig_py_proparray_to_dict, propchanges,
svn_swig_py_prophash_to_dict, originalprops);
if (result == NULL)
{
err = callback_exception_error();
goto finished;
}
if (!PyArg_ParseTuple(result, (char *)"ii", &py_contentstate, &py_propstate))
{
err = callback_exception_error();
goto finished;
}
if (contentstate != NULL)
*contentstate = py_contentstate;
if (propstate != NULL)
*propstate = py_propstate;
finished:
Py_XDECREF(result);
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_wc_diff_callbacks2_t */
static svn_error_t *
wc_diff_callbacks2_file_changed(svn_wc_adm_access_t *adm_access,
svn_wc_notify_state_t *contentstate,
svn_wc_notify_state_t *propstate,
const char *path,
const char *tmpfile1,
const char *tmpfile2,
svn_revnum_t rev1,
svn_revnum_t rev2,
const char *mimetype1,
const char *mimetype2,
const apr_array_header_t *propchanges,
apr_hash_t *originalprops,
void *diff_baton)
{
return wc_diff_callbacks2_file_changed_or_added("file_changed",
adm_access,
contentstate,
propstate,
path,
tmpfile1,
tmpfile2,
rev1, rev2,
mimetype1,
mimetype2,
propchanges,
originalprops,
diff_baton);
}
/* svn_wc_diff_callbacks2_t */
static svn_error_t *
wc_diff_callbacks2_file_added(svn_wc_adm_access_t *adm_access,
svn_wc_notify_state_t *contentstate,
svn_wc_notify_state_t *propstate,
const char *path,
const char *tmpfile1,
const char *tmpfile2,
svn_revnum_t rev1,
svn_revnum_t rev2,
const char *mimetype1,
const char *mimetype2,
const apr_array_header_t *propchanges,
apr_hash_t *originalprops,
void *diff_baton)
{
return wc_diff_callbacks2_file_changed_or_added("file_added",
adm_access,
contentstate,
propstate,
path,
tmpfile1,
tmpfile2,
rev1, rev2,
mimetype1,
mimetype2,
propchanges,
originalprops,
diff_baton);
}
/* svn_wc_diff_callbacks2_t */
static svn_error_t *
wc_diff_callbacks2_file_deleted(svn_wc_adm_access_t *adm_access,
svn_wc_notify_state_t *state,
const char *path,
const char *tmpfile1,
const char *tmpfile2,
const char *mimetype1,
const char *mimetype2,
apr_hash_t *originalprops,
void *diff_baton)
{
PyObject *callbacks = (PyObject *)diff_baton;
PyObject *py_callback, *result = NULL;
long py_state;
svn_error_t *err = SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)"file_deleted");
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
result = PyObject_CallFunction(py_callback,
(char *)"O&sssssO&",
make_ob_wc_adm_access, adm_access,
path,
tmpfile1, tmpfile2,
mimetype1, mimetype2,
svn_swig_py_prophash_to_dict, originalprops);
if (result == NULL)
{
err = callback_exception_error();
goto finished;
}
py_state = PyInt_AsLong(result);
if (py_state == -1 && PyErr_Occurred())
{
err = callback_exception_error();
goto finished;
}
if (state != NULL)
*state = py_state;
finished:
Py_XDECREF(result);
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_wc_diff_callbacks2_t */
static svn_error_t *
wc_diff_callbacks2_dir_added(svn_wc_adm_access_t *adm_access,
svn_wc_notify_state_t *state,
const char *path,
svn_revnum_t rev,
void *diff_baton)
{
PyObject *callbacks = (PyObject *)diff_baton;
PyObject *py_callback, *result = NULL;
long py_state;
svn_error_t *err = SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)"dir_added");
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
result = PyObject_CallFunction(py_callback,
(char *)"O&sl",
make_ob_wc_adm_access, adm_access,
path, rev);
if (result == NULL)
{
err = callback_exception_error();
goto finished;
}
py_state = PyInt_AsLong(result);
if (py_state == -1 && PyErr_Occurred())
{
err = callback_exception_error();
goto finished;
}
if (state != NULL)
*state = py_state;
finished:
Py_XDECREF(result);
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_wc_diff_callbacks2_t */
static svn_error_t *
wc_diff_callbacks2_dir_deleted(svn_wc_adm_access_t *adm_access,
svn_wc_notify_state_t *state,
const char *path,
void *diff_baton)
{
PyObject *callbacks = (PyObject *)diff_baton;
PyObject *py_callback, *result = NULL;
long py_state;
svn_error_t *err = SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)"dir_deleted");
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
result = PyObject_CallFunction(py_callback,
(char *)"O&s",
make_ob_wc_adm_access, adm_access, path);
if (result == NULL)
{
err = callback_exception_error();
goto finished;
}
py_state = PyInt_AsLong(result);
if (py_state == -1 && PyErr_Occurred())
{
err = callback_exception_error();
goto finished;
}
if (state != NULL)
*state = py_state;
finished:
Py_XDECREF(result);
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
/* svn_wc_diff_callbacks2_t */
static svn_error_t *
wc_diff_callbacks2_dir_props_changed(svn_wc_adm_access_t *adm_access,
svn_wc_notify_state_t *state,
const char *path,
const apr_array_header_t *propchanges,
apr_hash_t *originalprops,
void *diff_baton)
{
PyObject *callbacks = (PyObject *)diff_baton;
PyObject *py_callback;
PyObject *result = NULL;
long py_state;
svn_error_t *err = SVN_NO_ERROR;
svn_swig_py_acquire_py_lock();
py_callback = PyObject_GetAttrString(callbacks, (char *)"dir_props_changed");
if (py_callback == NULL)
{
err = callback_exception_error();
goto finished;
}
else if (py_callback == Py_None)
{
goto finished;
}
result = PyObject_CallFunction(py_callback,
(char *)"O&sO&O&",
make_ob_wc_adm_access, adm_access,
path,
svn_swig_py_proparray_to_dict, propchanges,
svn_swig_py_prophash_to_dict, originalprops);
if (result == NULL)
{
err = callback_exception_error();
goto finished;
}
py_state = PyInt_AsLong(result);
if (py_state == -1 && PyErr_Occurred())
{
err = callback_exception_error();
goto finished;
}
if (state != NULL)
*state = py_state;
finished:
Py_XDECREF(result);
Py_XDECREF(py_callback);
svn_swig_py_release_py_lock();
return err;
}
svn_wc_diff_callbacks2_t *
svn_swig_py_setup_wc_diff_callbacks2(void **baton,
PyObject *py_callbacks,
apr_pool_t *pool)
{
svn_wc_diff_callbacks2_t *callbacks = apr_palloc(pool, sizeof(*callbacks));
*baton = py_callbacks;
callbacks->file_changed = wc_diff_callbacks2_file_changed;
callbacks->file_added = wc_diff_callbacks2_file_added;
callbacks->file_deleted = wc_diff_callbacks2_file_deleted;
callbacks->dir_added = wc_diff_callbacks2_dir_added;
callbacks->dir_deleted = wc_diff_callbacks2_dir_deleted;
callbacks->dir_props_changed = wc_diff_callbacks2_dir_props_changed;
return callbacks;
}
svn_boolean_t
svn_swig_py_config_enumerator2(const char *name,
const char *value,
void *baton,
apr_pool_t *pool)
{
PyObject *function = baton;
PyObject *result;
svn_error_t *err = SVN_NO_ERROR;
svn_boolean_t c_result;
svn_swig_py_acquire_py_lock();
if ((result = PyObject_CallFunction(function,
(char *)"ssO&",
name,
value,
make_ob_pool, pool)) == NULL)
{
err = callback_exception_error();
}
else if (!PyBool_Check(result))
{
err = callback_bad_return_error("Not bool");
Py_DECREF(result);
}
/* Any Python exception we might have pending must be cleared,
because the SWIG wrapper will not check for it, and return a value with
the exception still set. */
PyErr_Clear();
if (err)
{
/* We can't return the error, but let's at least stop enumeration. */
svn_error_clear(err);
c_result = FALSE;
}
else
{
c_result = result == Py_True;
Py_DECREF(result);
}
svn_swig_py_release_py_lock();
return c_result;
}
svn_boolean_t
svn_swig_py_config_section_enumerator2(const char *name,
void *baton,
apr_pool_t *pool)
{
PyObject *function = baton;
PyObject *result;
svn_error_t *err = SVN_NO_ERROR;
svn_boolean_t c_result;
( run in 0.696 second using v1.01-cache-2.11-cpan-754626df90b )