| /* |
| * ==================================================================== |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * ==================================================================== |
| * |
| * core.i: SWIG module interface file for libsvn_subr, a few pieces of |
| * APR functionality, and anything else that does not fit into any |
| * of the more specific module files. |
| */ |
| |
| #if defined(SWIGPYTHON) |
| %module(package="libsvn") core |
| #elif defined(SWIGPERL) |
| %module "SVN::_Core" |
| #elif defined(SWIGRUBY) |
| %module "svn::ext::core" |
| #endif |
| |
| %include svn_global.swg |
| |
| %{ |
| #include <apr.h> |
| #include <apr_general.h> |
| |
| #include <apr_md5.h> |
| #include "svn_diff.h" |
| #include "svn_private_config.h" |
| %} |
| |
| #ifdef SWIGRUBY |
| %{ |
| #include <apu.h> |
| #include <apr_xlate.h> |
| %} |
| #endif |
| |
| /* ### for now, let's ignore this thing. */ |
| %ignore svn_prop_t; |
| |
| /* ----------------------------------------------------------------------- |
| The following struct members have to be read-only because otherwise |
| strings assigned to then would never be freed, resulting in memory |
| leaks. This prevents the swig warning "Warning(451): Setting const |
| char * member may leak memory." |
| */ |
| %immutable svn_log_changed_path_t::copyfrom_path; |
| %immutable svn_dirent_t::last_author; |
| %immutable svn_error_t::message; |
| %immutable svn_error_t::file; |
| |
| /* ----------------------------------------------------------------------- |
| completely ignore a number of functions. the presumption is that the |
| scripting language already has facilities for these things (or they |
| are relatively trivial). |
| */ |
| |
| /* svn_io.h: We cherry-pick certain functions from this file. To aid in this, |
| * EVERY function in the file is listed in the order it appears, and is either |
| * %ignore-d, or present as a comment, explicitly documenting that we wrap it. |
| */ |
| |
| %ignore svn_io_check_path; |
| %ignore svn_io_check_special_path; |
| %ignore svn_io_check_resolved_path; |
| /* This is useful for implementing svn_ra_callbacks_t->open_tmp_file */ |
| // svn_io_open_unique_file2 |
| // svn_io_open_unique_file |
| %ignore svn_io_create_unique_link; |
| %ignore svn_io_read_link; |
| %ignore svn_io_temp_dir; |
| %ignore svn_io_copy_file; |
| %ignore svn_io_copy_link; |
| %ignore svn_io_copy_dir_recursively; |
| %ignore svn_io_make_dir_recursively; |
| %ignore svn_io_dir_empty; |
| %ignore svn_io_append_file; |
| %ignore svn_io_set_file_read_only; |
| %ignore svn_io_set_file_read_write; |
| %ignore svn_io_set_file_read_write_carefully; |
| %ignore svn_io_set_file_executable; |
| %ignore svn_io_is_file_executable; |
| %ignore svn_io_read_length_line; |
| %ignore svn_io_file_affected_time; |
| %ignore svn_io_set_file_affected_time; |
| %ignore svn_io_filesizes_different_p; |
| // svn_io_file_checksum |
| // svn_io_files_contents_same_p |
| %ignore svn_io_file_create; |
| %ignore svn_io_file_lock; |
| %ignore svn_io_file_lock2; |
| %ignore svn_io_file_flush_to_disk; |
| %ignore svn_io_dir_file_copy; |
| |
| /* Not useful from scripting languages. Custom streams should be achieved |
| * by passing a scripting language native stream into a svn_stream_t * |
| * parameter, and letting a typemap using svn_swig_xx_make_stream() take |
| * care of the details. */ |
| %ignore svn_stream_create; |
| %ignore svn_stream_set_baton; |
| %ignore svn_stream_set_read; |
| %ignore svn_stream_set_write; |
| %ignore svn_stream_set_close; |
| |
| /* The permitted svn_stream and svn_stringbuf functions could possibly |
| * be used by a script, in conjunction with other APIs which return or |
| * accept streams. This requires that the relevant language's custom |
| * svn_stream_t wrapping code does not obstruct this usage. */ |
| // svn_stream_empty |
| // svn_stream_disown |
| // svn_stream_from_aprfile2 |
| // svn_stream_from_aprfile |
| // svn_stream_for_stdout |
| // svn_stream_from_stringbuf |
| // svn_stream_compressed |
| /* svn_stream_checksummed would require special attention to wrap, because |
| * of the read_digest and write_digest parameters. */ |
| %ignore svn_stream_checksummed; |
| // svn_stream_read |
| // svn_stream_write |
| // svn_stream_close |
| |
| /* Scripts can do the printf, then write to a stream. |
| * We can't really handle the variadic, so ignore it. */ |
| %ignore svn_stream_printf; |
| %ignore svn_stream_printf_from_utf8; |
| |
| // svn_stream_readline |
| // svn_stream_copy |
| // svn_stream_contents_same |
| // svn_stringbuf_from_file |
| // svn_stringbuf_from_aprfile |
| |
| #ifndef SWIGPYTHON |
| /* These functions are useful in Python, because they allow you to |
| * easily delete files which are marked as read-only on Windows. */ |
| %ignore svn_io_remove_file; |
| %ignore svn_io_remove_dir; |
| #endif |
| %ignore svn_io_get_dir_filenames; |
| %ignore svn_io_get_dirents2; |
| %ignore svn_io_get_dirents; |
| %ignore svn_io_dir_walk; |
| %ignore svn_io_start_cmd; |
| %ignore svn_io_wait_for_cmd; |
| %ignore svn_io_run_cmd; |
| %ignore svn_io_run_diff; |
| %ignore svn_io_run_diff3_2; |
| %ignore svn_io_run_diff3; |
| // svn_io_detect_mimetype |
| %ignore svn_io_file_open; |
| %ignore svn_io_file_close; |
| %ignore svn_io_file_getc; |
| %ignore svn_io_file_info_get; |
| %ignore svn_io_file_read; |
| %ignore svn_io_file_read_full; |
| %ignore svn_io_file_seek; |
| %ignore svn_io_file_write; |
| %ignore svn_io_file_write_full; |
| %ignore svn_io_stat; |
| %ignore svn_io_file_rename; |
| %ignore svn_io_file_move; |
| %ignore svn_io_dir_make; |
| %ignore svn_io_dir_make_hidden; |
| %ignore svn_io_dir_make_sgid; |
| %ignore svn_io_dir_open; |
| %ignore svn_io_dir_remove_nonrecursive; |
| %ignore svn_io_dir_read; |
| %ignore svn_io_read_version_file; |
| %ignore svn_io_write_version_file; |
| |
| /* svn_path.h: We cherry-pick certain functions from this file. To aid in this, |
| * EVERY function in the file is listed in the order it appears, and is either |
| * %ignore-d, or present as a comment, explicitly documenting that we wrap it. |
| */ |
| // svn_path_internal_style; |
| // svn_path_local_style; |
| %ignore svn_path_join; |
| %ignore svn_path_join_many; |
| %ignore svn_path_basename; |
| %ignore svn_path_dirname; |
| %ignore svn_path_component_count; |
| %ignore svn_path_add_component; |
| %ignore svn_path_remove_component; |
| %ignore svn_path_remove_components; |
| %ignore svn_path_split; |
| // svn_path_is_empty; |
| // svn_path_canonicalize; |
| // svn_path_compare_paths; |
| // svn_path_get_longest_ancestor; |
| %ignore svn_path_get_absolute; |
| %ignore svn_path_split_if_file; |
| %ignore svn_path_condense_targets; |
| %ignore svn_path_remove_redundancies; |
| %ignore svn_path_decompose; |
| %ignore svn_path_compose; |
| %ignore svn_path_is_single_path_component; |
| %ignore svn_path_is_backpath_present; |
| %ignore svn_path_is_child; |
| %ignore svn_path_is_ancestor; |
| %ignore svn_path_check_valid; |
| // svn_path_is_url; |
| // svn_path_is_uri_safe; |
| %ignore svn_path_uri_encode; |
| %ignore svn_path_uri_decode; |
| %ignore svn_path_url_add_component; |
| %ignore svn_path_uri_from_iri; |
| %ignore svn_path_uri_autoescape; |
| %ignore svn_path_cstring_from_utf8; |
| %ignore svn_path_cstring_to_utf8; |
| |
| /* svn_dirent_uri.h: SWIG can't digest these functions yet, so ignore them |
| * for now. TODO: make them work. |
| */ |
| %ignore svn_dirent_join_many; |
| %ignore svn_dirent_condense_targets; |
| %ignore svn_uri_condense_targets; |
| %ignore svn_dirent_is_under_root; |
| |
| /* Other files */ |
| |
| /* Ignore platform-specific auth functions */ |
| %ignore svn_auth_get_keychain_simple_provider; |
| %ignore svn_auth_get_keychain_ssl_client_cert_pw_provider; |
| %ignore svn_auth_get_windows_simple_provider; |
| %ignore svn_auth_get_windows_ssl_server_trust_provider; |
| %ignore svn_auth_gnome_keyring_version; |
| %ignore svn_auth_get_gnome_keyring_simple_provider; |
| %ignore svn_auth_get_gnome_keyring_ssl_client_cert_pw_provider; |
| %ignore svn_auth_kwallet_version; |
| %ignore svn_auth_get_kwallet_simple_provider; |
| %ignore svn_auth_get_kwallet_ssl_client_cert_pw_provider; |
| %ignore svn_auth_get_gpg_agent_simple_provider; |
| |
| /* bad pool convention */ |
| %ignore svn_opt_print_generic_help; |
| |
| %ignore svn_opt_args_to_target_array; |
| |
| /* svn_cmdline.h */ |
| %ignore svn_cmdline_auth_plaintext_passphrase_prompt; |
| %ignore svn_cmdline_auth_plaintext_prompt; |
| %ignore svn_cmdline_auth_simple_prompt; |
| %ignore svn_cmdline_auth_ssl_client_cert_prompt; |
| %ignore svn_cmdline_auth_ssl_client_cert_pw_prompt; |
| %ignore svn_cmdline_auth_ssl_server_trust_prompt; |
| %ignore svn_cmdline_auth_username_prompt; |
| %ignore svn_cmdline_cstring_from_utf8; |
| %ignore svn_cmdline_cstring_from_utf8_fuzzy; |
| %ignore svn_cmdline_cstring_to_utf8; |
| %ignore svn_cmdline_fflush; |
| %ignore svn_cmdline_fprintf; |
| %ignore svn_cmdline_fputs; |
| %ignore svn_cmdline_handle_exit_error; |
| %ignore svn_cmdline_output_encoding; |
| %ignore svn_cmdline_path_local_style_from_utf8; |
| %ignore svn_cmdline_printf; |
| %ignore svn_cmdline_prompt_baton2_t; |
| %ignore svn_cmdline_prompt_baton_t; |
| %ignore svn_cmdline_prompt_user2; |
| %ignore svn_cmdline_prompt_user; |
| %ignore svn_cmdline_setup_auth_baton; |
| |
| /* Ugliness because the constants are typedefed and SWIG ignores them |
| as a result. */ |
| %constant svn_revnum_t SWIG_SVN_INVALID_REVNUM = -1; |
| %constant svn_revnum_t SWIG_SVN_IGNORED_REVNUM = -1; |
| |
| /* ----------------------------------------------------------------------- |
| input rangelist |
| */ |
| %apply svn_rangelist_t *RANGELIST { |
| svn_rangelist_t *rangeinput, |
| const svn_rangelist_t *rangelist, |
| svn_rangelist_t *from, |
| svn_rangelist_t *to, |
| svn_rangelist_t *changes, |
| svn_rangelist_t *eraser, |
| svn_rangelist_t *whiteboard, |
| svn_rangelist_t *rangelist1, |
| svn_rangelist_t *rangelist2 |
| } |
| |
| /* ----------------------------------------------------------------------- |
| output rangelist |
| */ |
| %apply svn_rangelist_t **RANGELIST { |
| svn_rangelist_t **rangelist, |
| svn_rangelist_t **inheritable_rangelist, |
| svn_rangelist_t **deleted, |
| svn_rangelist_t **added, |
| svn_rangelist_t **output |
| } |
| |
| /* ----------------------------------------------------------------------- |
| input and output rangelist |
| */ |
| %apply svn_rangelist_t **RANGELIST_INOUT { |
| svn_rangelist_t **rangelist_inout |
| } |
| |
| /* ----------------------------------------------------------------------- |
| input mergeinfo hash |
| */ |
| %apply apr_hash_t *MERGEINFO { |
| apr_hash_t *mergefrom, |
| apr_hash_t *mergeto, |
| apr_hash_t *mergein1, |
| apr_hash_t *mergein2, |
| apr_hash_t *mergeinfo, |
| apr_hash_t *mergeinput, |
| apr_hash_t *eraser, |
| apr_hash_t *whiteboard, |
| apr_hash_t *changes |
| } |
| |
| /* ----------------------------------------------------------------------- |
| output mergeinfo |
| */ |
| |
| #if defined(SWIGPYTHON) || defined(SWIGRUBY) |
| %apply apr_hash_t **MERGEINFO_INOUT { |
| apr_hash_t **mergeinfo_inout |
| } |
| |
| %apply apr_hash_t **MERGEINFO { |
| apr_hash_t **mergeinfo, |
| apr_hash_t **inheritable_mergeinfo, |
| apr_hash_t **deleted, |
| apr_hash_t **added |
| } |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| output mergeinfo hash |
| */ |
| |
| #if defined(SWIGRUBY) || defined(SWIGPYTHON) |
| %apply apr_hash_t **MERGEINFO_CATALOG { |
| apr_hash_t **catalog |
| }; |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| allowable null values |
| */ |
| %apply const char *MAY_BE_NULL { |
| /* svn_config_get */ |
| const char *default_value, |
| /* svn_config_read_auth_data */ |
| const char *config_dir, |
| /* svn_diff_file_output_merge */ |
| const char *conflict_original, |
| const char *conflict_modified, |
| const char *conflict_latest, |
| const char *conflict_separator, |
| /* svn_cmdline_create_auth_baton */ |
| const char *username, |
| const char *password |
| }; |
| |
| /* ----------------------------------------------------------------------- |
| fix up the svn_stream_read() ptr/len arguments |
| */ |
| #ifdef SWIGPYTHON |
| %typemap(in) (char *buffer, apr_size_t *len) ($*2_type temp) { |
| if (PyLong_Check($input)) { |
| temp = PyLong_AsUnsignedLong($input); |
| } |
| else if (PyInt_Check($input)) { |
| /* wish there was a PyInt_AsUnsignedLong but there isn't |
| the mask version doesn't do bounds checking for us. |
| I can't see a good way to do the bounds checking ourselves |
| so just stick our head in the sand. With Python3 this |
| problem goes away because PyInt is gone anyway. */ |
| temp = PyInt_AsUnsignedLongMask($input); |
| } |
| else { |
| PyErr_SetString(PyExc_TypeError, |
| "expecting an integer for the buffer size"); |
| SWIG_fail; |
| } |
| $1 = malloc(temp); |
| $2 = ($2_ltype)&temp; |
| } |
| #endif |
| #ifdef SWIGPERL |
| %typemap(in) (char *buffer, apr_size_t *len) ($*2_type temp) { |
| temp = SvIV($input); |
| $1 = malloc(temp); |
| $2 = ($2_ltype)&temp; |
| } |
| #endif |
| #ifdef SWIGRUBY |
| %typemap(in) (char *buffer, apr_size_t *len) ($*2_type temp) { |
| temp = NUM2LONG($input); |
| $1 = malloc(temp); |
| $2 = ($2_ltype)&temp; |
| } |
| #endif |
| |
| /* ### need to use freearg or somesuch to ensure the string is freed. |
| ### watch out for 'return' anywhere in the binding code. */ |
| |
| #ifdef SWIGPYTHON |
| %typemap(argout) (char *buffer, apr_size_t *len) { |
| %append_output(PyString_FromStringAndSize($1, *$2)); |
| free($1); |
| } |
| #endif |
| #ifdef SWIGPERL |
| %typemap(argout) (char *buffer, apr_size_t *len) { |
| %append_output(sv_2mortal(newSVpvn($1, *$2))); |
| free($1); |
| } |
| #endif |
| #ifdef SWIGRUBY |
| %typemap(argout) (char *buffer, apr_size_t *len) { |
| %append_output(*$2 == 0 ? Qnil : rb_str_new($1, *$2)); |
| free($1); |
| } |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| fix up the svn_stream_write() ptr/len arguments |
| */ |
| #ifdef SWIGPYTHON |
| %typemap(in) (const char *data, apr_size_t *len) ($*2_type temp) { |
| if (!PyString_Check($input)) { |
| PyErr_SetString(PyExc_TypeError, |
| "expecting a string for the buffer"); |
| SWIG_fail; |
| } |
| $1 = PyString_AS_STRING($input); |
| temp = PyString_GET_SIZE($input); |
| $2 = ($2_ltype)&temp; |
| } |
| #endif |
| #ifdef SWIGPERL |
| %typemap(in) (const char *data, apr_size_t *len) ($*2_type temp) { |
| $1 = SvPV($input, temp); |
| $2 = ($2_ltype)&temp; |
| } |
| #endif |
| #ifdef SWIGRUBY |
| %typemap(in) (const char *data, apr_size_t *len) ($*2_type temp) |
| { |
| $1 = StringValuePtr($input); |
| temp = RSTRING_LEN($input); |
| $2 = ($2_ltype)&temp; |
| } |
| #endif |
| |
| #ifdef SWIGPYTHON |
| %typemap(argout) (const char *data, apr_size_t *len) { |
| %append_output(PyInt_FromLong(*$2)); |
| } |
| #endif |
| |
| #ifdef SWIGPERL |
| %typemap(argout) (const char *data, apr_size_t *len) { |
| %append_output(sv_2mortal(newSViv(*$2))); |
| } |
| #endif |
| |
| #ifdef SWIGRUBY |
| %typemap(argout) (const char *data, apr_size_t *len) { |
| %append_output(LONG2NUM(*$2)); |
| } |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| auth parameter set/get |
| */ |
| |
| /* set */ |
| #ifdef SWIGPYTHON |
| %typemap(in) const void *value |
| (apr_pool_t *_global_pool = NULL, PyObject *_global_py_pool = NULL) |
| { |
| if (_global_pool == NULL) |
| { |
| if (svn_swig_py_get_parent_pool(args, $descriptor(apr_pool_t *), |
| &_global_py_pool, &_global_pool)) |
| SWIG_fail; |
| } |
| |
| if (PyString_Check($input)) { |
| char *value = PyString_AS_STRING($input); |
| $1 = apr_pstrdup(_global_pool, value); |
| } |
| else if (PyLong_Check($input)) { |
| $1 = apr_palloc(_global_pool, sizeof(apr_uint32_t)); |
| *((apr_uint32_t *)$1) = PyLong_AsLong($input); |
| } |
| else if (PyInt_Check($input)) { |
| $1 = apr_palloc(_global_pool, sizeof(apr_uint32_t)); |
| *((apr_uint32_t *)$1) = PyInt_AsLong($input); |
| } |
| else if ($input == Py_None) { |
| $1 = NULL; |
| } |
| else if (svn_swig_py_convert_ptr($input, (void **)&$1, |
| $descriptor(svn_auth_ssl_server_cert_info_t *)) == 0) { |
| } |
| else { |
| PyErr_SetString(PyExc_TypeError, "not a known type"); |
| SWIG_fail; |
| } |
| } |
| #endif |
| |
| #ifdef SWIGPERL |
| %typemap(in) const void *value |
| (apr_pool_t *_global_pool = NULL) |
| { |
| if (!SvOK($input) || $input == &PL_sv_undef) { |
| $1 = NULL; |
| } |
| else if (SvPOK($input)) { |
| if (_global_pool == NULL) { |
| _global_pool = svn_swig_pl_make_pool((SV *)NULL); |
| SPAGAIN; |
| } |
| $1 = apr_pstrdup(_global_pool, SvPV_nolen($input)); |
| } |
| else { |
| croak("Value is not a string (or undef)"); |
| } |
| } |
| #endif |
| |
| /* |
| - all values are converted to char* |
| - assume the first argument is Ruby object for svn_auth_baton_t* |
| */ |
| #ifdef SWIGRUBY |
| %typemap(in) const void *value |
| { |
| if (NIL_P($input)) { |
| $1 = (void *)NULL; |
| } else { |
| VALUE _rb_pool; |
| apr_pool_t *_global_pool; |
| char *value = StringValuePtr($input); |
| |
| svn_swig_rb_get_pool(1, argv, Qnil, &_rb_pool, &_global_pool); |
| $1 = (void *)apr_pstrdup(_global_pool, value); |
| } |
| } |
| #endif |
| |
| /* get */ |
| /* assume the value is char* */ |
| #ifdef SWIGRUBY |
| %typemap(out) const void * |
| { |
| char *value = $1; |
| if (value) { |
| $result = rb_str_new2(value); |
| } else { |
| $result = Qnil; |
| } |
| } |
| #endif |
| |
| #ifndef SWIGRUBY |
| %ignore svn_auth_get_parameter; |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| svn_io_parse_mimetypes_file() |
| */ |
| |
| #ifdef SWIGRUBY |
| %apply apr_hash_t **HASH_CSTRING { |
| apr_hash_t **type_map |
| } |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| svn_io_detect_mimetype2() |
| */ |
| |
| %apply apr_hash_t *HASH_CSTRING { |
| apr_hash_t *mimetype_map |
| } |
| |
| /* ----------------------------------------------------------------------- |
| describe how to pass a FILE* as a parameter (svn_stream_from_stdio) |
| */ |
| #ifdef SWIGPYTHON |
| %typemap(in) FILE * { |
| $1 = PyFile_AsFile($input); |
| if ($1 == NULL) { |
| PyErr_SetString(PyExc_ValueError, "Must pass in a valid file object"); |
| SWIG_fail; |
| } |
| } |
| #endif |
| #ifdef SWIGPERL |
| %typemap(in) FILE * { |
| $1 = PerlIO_exportFILE (IoIFP (sv_2io ($input)), NULL); |
| } |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| wrap some specific APR functionality |
| */ |
| |
| apr_status_t apr_initialize(void); |
| void apr_terminate(void); |
| |
| apr_status_t apr_time_ansi_put(apr_time_t *result, time_t input); |
| |
| void apr_pool_destroy(apr_pool_t *p); |
| void apr_pool_clear(apr_pool_t *p); |
| |
| apr_status_t apr_file_open_stdout (apr_file_t **out, apr_pool_t *pool); |
| apr_status_t apr_file_open_stderr (apr_file_t **out, apr_pool_t *pool); |
| |
| /* Allow parsing of apr_errno.h without parsing apr.h. */ |
| #define APR_DECLARE(x) x |
| /* Not wrapped, use svn_strerror instead. */ |
| %ignore apr_strerror; |
| /* Wrap the APR status and error codes. */ |
| /* Sigh, or not. This would mean actually having access to apr_errno.h at |
| wrapper generation time, which, when rolling tarballs, the include paths |
| are not currently set up to give us. FIXME. So, instead, we replicate |
| one important typedef here instead. |
| %include apr_errno.h |
| */ |
| typedef int apr_status_t; |
| |
| /* Make possible to parse the SVN_VER_NUM definition. */ |
| #define APR_STRINGIFY_HELPER(n) #n |
| #define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) |
| |
| /* ----------------------------------------------------------------------- |
| pool functions renaming since swig doesn't take care of the #define's |
| */ |
| %rename (svn_pool_create) svn_pool_create_ex; |
| %ignore svn_pool_create_ex_debug; |
| %typemap(default) apr_allocator_t *allocator { |
| $1 = NULL; |
| } |
| |
| /* ----------------------------------------------------------------------- |
| Default pool handling for perl. |
| */ |
| #ifdef SWIGPERL |
| apr_pool_t *current_pool; |
| |
| %{ |
| |
| /* ### Eventually this should go away. This is not thread safe and a very |
| ### good example on HOW NOT TO USE pools */ |
| static apr_pool_t *current_pool = 0; |
| |
| static apr_pool_t * |
| core_get_current_pool (void) |
| { |
| return current_pool; |
| } |
| |
| static void |
| core_set_current_pool (apr_pool_t *pool) |
| { |
| current_pool = pool; |
| } |
| |
| %} |
| |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| wrap config functions |
| */ |
| |
| #ifdef SWIGPERL |
| %callback_typemap(svn_config_enumerator_t callback, void *baton, |
| , |
| svn_swig_pl_thunk_config_enumerator, |
| ) |
| #endif |
| |
| #ifndef SWIGPERL |
| %callback_typemap(svn_config_enumerator2_t callback, void *baton, |
| svn_swig_py_config_enumerator2, |
| , |
| svn_swig_rb_config_enumerator) |
| |
| %callback_typemap(svn_config_section_enumerator2_t callback, void *baton, |
| svn_swig_py_config_section_enumerator2, |
| , |
| svn_swig_rb_config_section_enumerator) |
| #endif |
| |
| /* Allow None to be passed as config_dir argument */ |
| #ifdef SWIGPYTHON |
| %typemap(in,parse="z") const char *config_dir ""; |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| thunk the various authentication prompt functions. |
| PERL NOTE: store the inputed SV in _global_callback for use in the |
| later argout typemap |
| */ |
| #ifdef SWIGPERL |
| %define %authprompt_callback_typemap(AuthType) |
| %typemap(in) (svn_auth_ ## AuthType ## _prompt_func_t prompt_func, |
| void *prompt_baton) { |
| $1 = svn_swig_pl_thunk_ ## AuthType ## _prompt; |
| $2 = $input; |
| _global_callback = $input; |
| } |
| %enddef |
| #else |
| %define %authprompt_callback_typemap(AuthType) |
| %callback_typemap(svn_auth_ ## AuthType ## _prompt_func_t prompt_func, |
| void *prompt_baton, |
| svn_swig_py_auth_ ## AuthType ## _prompt_func,, |
| svn_swig_rb_auth_ ## AuthType ## _prompt_func) |
| %enddef |
| #endif |
| |
| %authprompt_callback_typemap(simple) |
| %authprompt_callback_typemap(username) |
| %authprompt_callback_typemap(ssl_server_trust) |
| %authprompt_callback_typemap(ssl_client_cert) |
| %authprompt_callback_typemap(ssl_client_cert_pw) |
| %authprompt_callback_typemap(gnome_keyring_unlock) |
| |
| #ifdef SWIGPYTHON |
| /* pl and rb aren't yet implemented */ |
| %callback_typemap_maybenull(svn_config_auth_walk_func_t walk_func, |
| void *walk_baton, |
| svn_swig_py_config_auth_walk_func, |
| svn_swig_pl_config_auth_walk_func, |
| svn_swig_rb_config_auth_walk_func) |
| #endif |
| |
| /* ----------------------------------------------------------------------- |
| * For all the various functions that set a callback baton create a reference |
| * for the baton (which in this case is an SV pointing to the callback) |
| * and make that a return from the function. The perl side should |
| * then store the return in the object the baton is attached to. |
| * If the function already returns a value then this value is follows that |
| * function. In the case of the prompt functions auth_open_helper in Core.pm |
| * is used to split up these values. |
| */ |
| #ifdef SWIGPERL |
| %typemap(argout) void *CALLBACK_BATON (SV * _global_callback) { |
| /* callback baton */ |
| %append_output(sv_2mortal(newRV_inc(_global_callback))); |
| } |
| |
| %typemap(in) void *CALLBACK_BATON (SV * _global_callback) { |
| _global_callback = $input; |
| $1 = (void *) _global_callback; |
| } |
| |
| %apply void *CALLBACK_BATON { |
| void *prompt_baton |
| }; |
| #endif |
| |
| |
| /* ----------------------------------------------------------------------- |
| These APIs take an "inout" parameter that necessitates more careful |
| definition. |
| */ |
| %ignore svn_mergeinfo_merge; |
| %ignore svn_mergeinfo_sort; |
| %ignore svn_rangelist_merge; |
| %ignore svn_rangelist_reverse; |
| |
| #ifdef SWIGRUBY |
| %ignore svn_auth_open; |
| %ignore svn_diff_file_options_create; |
| %ignore svn_create_commit_info; |
| %ignore svn_commit_info_dup; |
| |
| %ignore svn_opt_args_to_target_array2; |
| %ignore svn_opt_args_to_target_array3; |
| %ignore svn_opt_parse_num_args; |
| %ignore svn_opt_parse_all_args; |
| #endif |
| |
| #ifdef SWIGPYTHON |
| /* The auth baton depends on the providers, so we preserve a |
| reference to them inside the wrapper. This way, if all external |
| references to the providers are gone, they will still be alive, |
| keeping the baton valid. |
| */ |
| %feature("pythonappend") svn_auth_open %{ |
| val.__dict__["_deps"] = list(args[0]) |
| %} |
| #endif |
| |
| /* ----------------------------------------------------------------------- */ |
| |
| %include svn_error_codes_h.swg |
| %include svn_time_h.swg |
| %include svn_types_h.swg |
| %include svn_pools_h.swg |
| %include svn_version_h.swg |
| |
| /* The constant SVN_PROP_REVISION_ALL_PROPS is a C fragment, not a single |
| data value, so the SWIG parser will raise a 305 warning if we don't |
| suppress it. */ |
| #pragma SWIG nowarn=305 |
| %include svn_props_h.swg |
| #pragma SWIG nowarn=+305 |
| |
| %include svn_opt_h.swg |
| %include svn_cmdline_h.swg |
| %include svn_auth_h.swg |
| %include svn_config_h.swg |
| %include svn_utf_h.swg |
| %include svn_nls_h.swg |
| %include svn_path_h.swg |
| %include svn_dirent_uri_h.swg |
| %include svn_mergeinfo_h.swg |
| %include svn_io_h.swg |
| %include svn_checksum_h.swg |
| %include svn_cache_config_h.swg |
| |
| |
| |
| %inline %{ |
| /* Helper function to set the gnome-keyring unlock prompt function. This |
| * C function accepts an auth baton, a function and a prompt baton, but |
| * the below callback_typemap uses both the function and the prompt |
| * baton, so the resulting binding has just two arguments: The auth |
| * baton and the prompt function. |
| * The prompt function should again have two arguments: The keyring name |
| * (string) and a pool (except for the ruby version, which doesn't have |
| * the pool argument). It should return the entered password (string). |
| * This binding generated for this function generates a reference to the |
| * prompt function that was passed into this. The caller should store |
| * that reference somewhere, to prevent the function from being garbage |
| * collected... |
| */ |
| static void svn_auth_set_gnome_keyring_unlock_prompt_func(svn_auth_baton_t *ab, |
| svn_auth_gnome_keyring_unlock_prompt_func_t prompt_func, |
| void *prompt_baton) { |
| svn_auth_set_parameter(ab, SVN_AUTH_PARAM_GNOME_KEYRING_UNLOCK_PROMPT_FUNC, |
| prompt_func); |
| svn_auth_set_parameter(ab, SVN_AUTH_PARAM_GNOME_KEYRING_UNLOCK_PROMPT_BATON, |
| prompt_baton); |
| } |
| %} |
| |
| #if defined(SWIGPERL) || defined(SWIGRUBY) |
| %include svn_md5_h.swg |
| #endif |
| |
| #ifdef SWIGPERL |
| /* The apr_file_t* 'in' typemap can't cope with struct members, and there |
| is no reason to change this one. */ |
| %immutable svn_patch_t::patch_file; |
| |
| %include svn_diff_h.swg |
| %include svn_error_h.swg |
| |
| %{ |
| #include "svn_private_config.h" |
| %} |
| %init %{ |
| svn_swig_pl__bind_current_pool_fns(&core_get_current_pool, |
| &core_set_current_pool); |
| %} |
| #endif |
| |
| #ifdef SWIGPYTHON |
| |
| void svn_swig_py_set_application_pool(PyObject *py_pool, apr_pool_t *pool); |
| void svn_swig_py_clear_application_pool(); |
| |
| %init %{ |
| /* Theoretically, we should be checking for errors here, |
| but I do not know of any useful way to signal an error to Python |
| from within a module initialization function. */ |
| svn_swig_py_initialize(); |
| %} |
| |
| /* Proxy classes for APR classes */ |
| %include proxy_apr.swg |
| |
| #endif |
| |
| #ifdef SWIGRUBY |
| %init %{ |
| svn_swig_rb_initialize(); |
| |
| rb_define_const(mCore, "SVN_ALLOCATOR_MAX_FREE_UNLIMITED", |
| UINT2NUM(APR_ALLOCATOR_MAX_FREE_UNLIMITED)); |
| %} |
| |
| %header %{ |
| static void apr_pool_wrapper_destroy(apr_pool_wrapper_t *self); |
| static void apr_pool_wrapper_destroy_children(apr_pool_wrapper_t *self); |
| static void apr_pool_wrapper_remove_from_parent(apr_pool_wrapper_t *self); |
| %} |
| |
| /* Dummy declaration */ |
| struct apr_pool_wrapper_t |
| { |
| }; |
| |
| /* Leave memory administration to ruby's GC */ |
| %extend apr_pool_wrapper_t |
| { |
| static void destroy(VALUE object) { |
| svn_swig_rb_destroy_internal_pool(object); |
| } |
| |
| static void set_default_max_free_size(apr_size_t size) { |
| apr_allocator_max_free_set(svn_swig_rb_allocator(), size); |
| } |
| |
| apr_pool_wrapper_t(apr_pool_wrapper_t *parent) { |
| apr_pool_wrapper_t *self; |
| apr_pool_t *parent_pool; |
| |
| self = ALLOC(apr_pool_wrapper_t); |
| if (parent) { |
| parent_pool = parent->pool; |
| APR_ARRAY_PUSH(parent->children, apr_pool_wrapper_t *) = self; |
| } else { |
| parent_pool = svn_swig_rb_pool(); |
| } |
| self->pool = svn_pool_create_ex(parent_pool, NULL); |
| self->destroyed = FALSE; |
| self->parent = parent; |
| self->children = apr_array_make(self->pool, 0, |
| sizeof(apr_pool_wrapper_t *)); |
| return self; |
| } |
| |
| ~apr_pool_wrapper_t() { |
| apr_pool_wrapper_destroy(self); |
| xfree(self); |
| } |
| |
| void set_max_free_size(apr_size_t size) { |
| apr_allocator_t *allocator; |
| |
| allocator = apr_pool_allocator_get(self->pool); |
| apr_allocator_max_free_set(allocator, size); |
| } |
| |
| void _destroy(void) { |
| apr_pool_wrapper_destroy(self); |
| } |
| }; |
| |
| %ignore apr_pool_wrapper_destroy; |
| %ignore apr_pool_wrapper_destroy_children; |
| %ignore apr_pool_wrapper_remove_from_parent; |
| %inline %{ |
| static void |
| apr_pool_wrapper_destroy(apr_pool_wrapper_t *self) |
| { |
| if (!self->destroyed) { |
| self->destroyed = TRUE; |
| apr_pool_wrapper_destroy_children(self); |
| apr_pool_wrapper_remove_from_parent(self); |
| apr_pool_destroy(self->pool); |
| } |
| } |
| |
| static void |
| apr_pool_wrapper_destroy_children(apr_pool_wrapper_t *self) |
| { |
| apr_pool_wrapper_t **child; |
| |
| while ((child = apr_array_pop(self->children))) { |
| if (*child) { |
| apr_pool_wrapper_destroy(*child); |
| } |
| } |
| } |
| |
| static void |
| apr_pool_wrapper_remove_from_parent(apr_pool_wrapper_t *self) |
| { |
| if (self->parent) { |
| apr_pool_wrapper_t *child; |
| int i, len; |
| |
| len = self->parent->children->nelts; |
| for (i = 0; i < len; i++) { |
| child = APR_ARRAY_IDX(self->parent->children, i, apr_pool_wrapper_t *); |
| if (child == self) { |
| APR_ARRAY_IDX(self->parent->children, i, apr_pool_wrapper_t *) = NULL; |
| self->parent = NULL; |
| break; |
| } |
| } |
| } |
| } |
| %} |
| |
| /* Dummy declaration */ |
| struct svn_stream_t |
| { |
| }; |
| |
| %extend svn_stream_t |
| { |
| svn_stream_t(VALUE io) { |
| return svn_swig_rb_make_stream(io); |
| }; |
| |
| ~svn_stream_t() { |
| }; |
| } |
| |
| /* Dummy declaration */ |
| struct svn_auth_baton_t |
| { |
| }; |
| |
| %extend svn_auth_baton_t |
| { |
| svn_auth_baton_t(apr_array_header_t *providers, apr_pool_t *pool) { |
| svn_auth_baton_t *self; |
| svn_auth_open(&self, providers, pool); |
| return self; |
| }; |
| |
| ~svn_auth_baton_t() { |
| }; |
| } |
| |
| %extend svn_diff_file_options_t |
| { |
| svn_diff_file_options_t(apr_pool_t *pool) { |
| return svn_diff_file_options_create(pool); |
| }; |
| |
| ~svn_diff_file_options_t() { |
| }; |
| } |
| |
| %extend svn_commit_info_t |
| { |
| svn_commit_info_t(apr_pool_t *pool) { |
| return svn_create_commit_info(pool); |
| }; |
| |
| ~svn_commit_info_t() { |
| }; |
| |
| svn_commit_info_t *dup(apr_pool_t *pool) { |
| return svn_commit_info_dup(self, pool); |
| }; |
| } |
| |
| %extend svn_merge_range_t |
| { |
| svn_merge_range_t(svn_revnum_t start, svn_revnum_t end, |
| svn_boolean_t inheritable, apr_pool_t *pool) { |
| svn_merge_range_t *self; |
| self = apr_palloc(pool, sizeof(svn_merge_range_t)); |
| self->start = start; |
| self->end = end; |
| self->inheritable = inheritable; |
| return self; |
| }; |
| |
| ~svn_merge_range_t() { |
| }; |
| |
| svn_merge_range_t *dup(apr_pool_t *pool) { |
| return svn_merge_range_dup(self, pool); |
| }; |
| } |
| |
| %include svn_diff_h.swg |
| |
| %inline %{ |
| static VALUE |
| svn_default_charset(void) |
| { |
| return PTR2NUM(APR_DEFAULT_CHARSET); |
| } |
| |
| static VALUE |
| svn_locale_charset(void) |
| { |
| return PTR2NUM(APR_LOCALE_CHARSET); |
| } |
| |
| /* prompt providers return baton for protecting GC */ |
| static VALUE |
| svn_swig_rb_auth_get_simple_prompt_provider( |
| svn_auth_provider_object_t **provider, |
| svn_auth_simple_prompt_func_t prompt_func, |
| void *prompt_baton, |
| int retry_limit, |
| apr_pool_t *pool) |
| { |
| svn_auth_get_simple_prompt_provider(provider, prompt_func, prompt_baton, |
| retry_limit, pool); |
| return rb_ary_new3(1, (VALUE)prompt_baton); |
| } |
| |
| static VALUE |
| svn_swig_rb_auth_get_ssl_client_cert_prompt_provider( |
| svn_auth_provider_object_t **provider, |
| svn_auth_ssl_client_cert_prompt_func_t prompt_func, |
| void *prompt_baton, |
| int retry_limit, |
| apr_pool_t *pool) |
| { |
| svn_auth_get_ssl_client_cert_prompt_provider(provider, prompt_func, |
| prompt_baton, retry_limit, |
| pool); |
| return rb_ary_new3(1, (VALUE)prompt_baton); |
| } |
| |
| static VALUE |
| svn_swig_rb_auth_get_ssl_client_cert_pw_prompt_provider( |
| svn_auth_provider_object_t **provider, |
| svn_auth_ssl_client_cert_pw_prompt_func_t prompt_func, |
| void *prompt_baton, |
| int retry_limit, |
| apr_pool_t *pool) |
| { |
| svn_auth_get_ssl_client_cert_pw_prompt_provider(provider, prompt_func, |
| prompt_baton, retry_limit, |
| pool); |
| return rb_ary_new3(1, (VALUE)prompt_baton); |
| } |
| |
| static VALUE |
| svn_swig_rb_auth_get_ssl_server_trust_prompt_provider( |
| svn_auth_provider_object_t **provider, |
| svn_auth_ssl_server_trust_prompt_func_t prompt_func, |
| void *prompt_baton, |
| apr_pool_t *pool) |
| { |
| svn_auth_get_ssl_server_trust_prompt_provider(provider, prompt_func, |
| prompt_baton, pool); |
| return rb_ary_new3(1, (VALUE)prompt_baton); |
| } |
| |
| static VALUE |
| svn_swig_rb_auth_get_username_prompt_provider( |
| svn_auth_provider_object_t **provider, |
| svn_auth_username_prompt_func_t prompt_func, |
| void *prompt_baton, |
| int retry_limit, |
| apr_pool_t *pool) |
| { |
| svn_auth_get_username_prompt_provider(provider, prompt_func, prompt_baton, |
| retry_limit, pool); |
| return rb_ary_new3(1, (VALUE)prompt_baton); |
| } |
| %} |
| #endif |
| |
| #if defined(SWIGPYTHON) || defined(SWIGRUBY) |
| %inline %{ |
| static svn_error_t * |
| svn_swig_mergeinfo_merge(apr_hash_t **mergeinfo_inout, |
| apr_hash_t *changes, |
| apr_pool_t *pool) |
| { |
| return svn_mergeinfo_merge(*mergeinfo_inout, changes, pool); |
| } |
| |
| static svn_error_t * |
| svn_swig_mergeinfo_sort(apr_hash_t **mergeinfo_inout, apr_pool_t *pool) |
| { |
| return svn_mergeinfo_sort(*mergeinfo_inout, pool); |
| } |
| |
| static svn_error_t * |
| svn_swig_rangelist_merge(svn_rangelist_t **rangelist_inout, |
| svn_rangelist_t *changes, |
| apr_pool_t *pool) |
| { |
| return svn_rangelist_merge(rangelist_inout, changes, pool); |
| } |
| |
| static svn_error_t * |
| svn_swig_rangelist_reverse(svn_rangelist_t **rangelist_inout, |
| apr_pool_t *pool) |
| { |
| return svn_rangelist_reverse(*rangelist_inout, pool); |
| } |
| %} |
| #endif |