Alien-SVN
view release on metacpan or search on metacpan
src/subversion/subversion/tests/cmdline/import_tests_data/import_tree/DIR3.foo/file2.txt
src/subversion/subversion/tests/cmdline/import_tests_data/import_tree/DIR4.goo/file3.txt
src/subversion/subversion/tests/cmdline/import_tests_data/import_tree/DIR4.goo/file4.noo
src/subversion/subversion/tests/cmdline/import_tests_data/import_tree/DIR5.moo/file5.txt
src/subversion/subversion/tests/cmdline/import_tests_data/import_tree/DIR6/DIR7/file7.foo
src/subversion/subversion/tests/cmdline/import_tests_data/import_tree/DIR6/file6.foo
src/subversion/subversion/tests/cmdline/info_tests.py
src/subversion/subversion/tests/cmdline/input_validation_tests.py
src/subversion/subversion/tests/cmdline/iprop_authz_tests.py
src/subversion/subversion/tests/cmdline/iprop_tests.py
src/subversion/subversion/tests/cmdline/legacy/utf8_tests.py
src/subversion/subversion/tests/cmdline/lock_tests.py
src/subversion/subversion/tests/cmdline/log_tests.py
src/subversion/subversion/tests/cmdline/log_tests_data/merge_history_repo.png
src/subversion/subversion/tests/cmdline/log_tests_data/xml-invalid-chars.dump
src/subversion/subversion/tests/cmdline/merge_authz_tests.py
src/subversion/subversion/tests/cmdline/merge_automatic_tests.py
src/subversion/subversion/tests/cmdline/merge_reintegrate_tests.py
src/subversion/subversion/tests/cmdline/merge_tests.py
src/subversion/subversion/tests/cmdline/merge_tree_conflict_tests.py
src/subversion/subversion/tests/cmdline/mergeinfo_tests.py
src/subversion/CHANGES view on Meta::CPAN
- Client:
* add peg-rev syntax to co/blame/cat/ls/pget/plist/export (issue #1093)
* 'svn info' now works on URLs (r13123, 13144)
* 'svn* --version' now shows available repository back-ends (r13761)
* new fixed-length keywords (for placement in binary files) (issue #2095)
* on Windows, disk-cached passwords are now encrypted (r13888)
* performance improvements:
- 'svn status' does much less disk parsing (r11677, 11704)
- 'svn st -u' no longer asks server to generate textdeltas (issue #2259)
- 'svn revert -R' doing much less work (r13883)
- utf8<->native conversions are faster now (issue #2016)
* new switches added:
- 'svn commit --no-unlock - retain lock in wc upon commit
- 'svn log --limit N' - show only first N log messages
- 'svn info --revision' - show info on older object (r13265)
- 'svn list --xml' - output listing in XML
- 'svn propset --force' - allow unusual propsets (#2065)
- 'svn diff --force' - show diffs on binary files (#2099)
- 'svn co/up/st --ignore-externals' - skip over externals (#2189)
- 'svn export --non-recursive' - don't export subdirs (issue #2228)
- 'svnversion --help' - show help (r13128)
src/subversion/CHANGES view on Meta::CPAN
* fixed: 'svn copy wc wc' should keep .svn/ hidden (issue #1739)
* fixed: 'svn copy wc wc' of deleted=true doesn't delete (issue #2101)
* fixed: 'svn copy' shouldn't copy into schedule-delete area (issue #2020)
* fixed: 'svn copy dir dir' infinite recursion (issue #2224)
* fixed: 'svn log' throws error on unversioned target (issue #1551)
* fixed: 'svn log' in r0 working copy shows r1 log msg (issue #1950)
* fixed: 'svn export' bugs on deleted dirs or nonexistents (#2226, r13226)
* fixed: 'svn export' on single file from working copy (issue #1708)
* fixed: 'svn import' creating an empty revision (r14293)
* fixed: 'svn commit' ignores --encoding when editing externally (#2244)
* fixed: 'svn commit' log message lost if utf8-conversion failure (r13230)
* fixed: 'svn diff' output encoding bug (r11461)
* fixed: 'svn diff' showing prop-diffs on repos root dir (r13381-2)
* fixed: 'svn diff' label reversal (issue #2033)
* fixed: 'svn propget' prints extra newline in --strict mode (r14505)
* fixed: 'svn propset' should skip unversioned files (#2030)
* fixed: 'svn rm URL1 URL2 URL3...' huge memory usage (issue #2218)
* fixed: 'svn mkdir' cleanup after failure (r11883)
* fixed: 'svn status -u' crash in non-recursive wc's (issue #2122)
* fixed: 'svn revert' should skip unversioned items (issues #2030, 2133)
* fixed: 'svn revert' should suggest --recursive (issue #2114)
* fixed: 'svn add/import' better detects invalid paths (issue #1954)
* fixed: 'svn cleanup' should repair timestamps (r12012)
* fixed: 'svn cat -rBASE' contacts repository (issue #1361)
* fixed: fuzzily escape control-characters when sending over dav (#2147)
* fixed: prevent client from manipulating svn:wc:* properties (r12523)
* fixed: allow portnumber in svn+ssh://user@host:port/ URLs (r14373)
* fixed: xml-escaping bugs over dav (r11090)
* fixed: store symlinks as utf8, always work in non-utf8 locale (r11358-9)
* fixed: bug in special-file detranslation (r11441)
* fixed: show paths in local-style where we weren't (issue #1538)
* fixed: detect invalid propnames better (issue #1832)
* fixed: entire error stack not being printed (issue #1822)
* fixed: improper utf8 conversion of revision strings (issue #1999)
* fixed: use-commit-times timestamp bug (r12906)
* fixed: don't comment out section-names in default config file (r11771)
* more support for user-cancellation (r13083-4, 13086)
* improved error messages (r12920, 11392, 11599, 11913, #2154, #2214)
- Server:
* mod_dav_svn autoversioning feature now complete (see release notes)
* 'svnadmin create' now creates FSFS repositories by default (r13624)
* new pre/post-revprop hook argument to describe propchange (r12162)
* mod_authz_svn groups can now contain other groups (issue #2085)
src/subversion/CHANGES view on Meta::CPAN
Version 1.1.4
(1 April 2005, from /branches/1.1.x)
http://svn.apache.org/repos/asf/subversion/tags/1.1.4
User-visible changes:
- Client:
* fixed: win32 not ignoring versioned symlinks (issue #2173)
* fixed: 'svn merge' can cause broken working copy (issue #2222)
* fixed: 'svn commit' fails when schedule-delete dir has local mod (r11980)
* fixed: 'svn st -u nonexistent_file' segfault (issue #2127)
* fixed: 'svn cp wc wc' utf8 conversion error (r13111)
* fixed: confusing error message about "wc not locked" (issue #2174)
* many translation updates for localized client messages
- Server:
* fixed: nasty (though unusual) performance bug in FSFS commits (r13222-3)
* fixed: FSFS memory leak when auto-merging large tree (r13193)
* fixed: FSFS memory leak in 'svnadmin hotcopy' (r13218, 13465, 13468)
* fixed: FSFS segfault when encountering empty data reps (r13683)
* fixed: two dataloss bugs in svndumpfilter (r12630, r12636)
* fixed: wasteful memory usage in svndumpfilter (r12637, r12640)
src/subversion/CHANGES view on Meta::CPAN
* fixed: 'svnadmin hotcopy PATH .' (r8659)
* fixed: copy crash bug (r8863)
* fixed: 'svn st -u' crash bug (r10841)
* fixed: 'svn commit' segfault (r10676)
* fixed: allow cleanup on .svn/ dirs containing KILLME file (r8891)
* fixed: 'svn revert' detects corrupted text-base (r8897)
* fixed: 'svn status -N' no longer locks entire tree (r8906)
* fixed: several different 'svn switch' bugs (r9192, 9203, 9238, 9698)
* fixed: some 'svn copy' bugs (r9193, 9274)
* fixed: obscure update-deletion bug (r8976)
* fixed: utf8 conversion 'hang' (r9233)
* fixed: missing UTF8->native recoding in 'svn log' output (r10652, 10673)
* fixed: 'svn blame' now defaults to rev (r9440)
* fixed: 'svn blame' closing files before deleting them (issue #1969)
* fixed: 'svn diff' shows truncated paths (r9693)
* fixed: 'svn diff --notice-ancestry' bug (r9699)
* fixed: 'svn subcommand -r{DATE} URL' works if URL not in HEAD (issue #1840)
* fixed: 'svn blame' on non-ascii path truncation (issue #1770)
* fixed: svn:external 'wc not locked' bug (issue #1897)
* fixed: proper mod_dav_svn html/xml escaping (issue #1209)
* fixed: memleak in 'svn propset -R URL' (issue #1928)
src/subversion/CHANGES view on Meta::CPAN
* huge improvements to the mailer.py tool
* more work on the Book and man page
* default global-ignores now built-in, new runtime-config file commented out
Developer-visible changes:
* checksums, checksums everywhere (issues #649, #689):
- filesystem stores them, and verifies them when reading/writing
- working copy stores them, and verifies them when reading/writing
- checksums transferred both ways over network, RA layers verify them
* finish draft of internal diff/diff3 library -- ready for testing/optimizing
* more utf8<->apr conversion work (#872)
* more work on swig/python and ruby bindings
* improvements to win32-innosetup package
* 'svnserve' now has an official IANA-assigned portnumber.
* mod_dav_svn now only sends/understands new xml prop namespaces (#840)
* bug fixes: stop needless fs rep data copies (#1067), wc auth
caching bugs (#1064), use APR_BUFFERED to open files (#1071), lots
of wc 'missing dir' edge-case bugs (#962), prevent wc from
receiving '.svn' (#1068), don't commit symlinks (#1081), better
diff labels (#1080), better fulltext tmpfile names in conflicts (#1079),
prevent ra_dav from deleting out-of-date items (#1017), segfault (#1092),
src/subversion/CHANGES view on Meta::CPAN
- python svn calls can now run as independent threads
- new java-binding build system
- improved swig building features: --prefix, LDFLAGS behaviors
* many, many bug fixes: wc->repos copies (#1029), #943 followup
(#1023), copies of copies (#830), 'svn resolve' cleans up entries
file (#1021), prop merging (#1012), segfault fixes (#1027, #1055),
autoconf 2.5X (#886), O(1) copies (#717), new 'failed revert'
signal (#714), detect missing schedule-add conflicts (#899, #863),
begin dav namespace switchover (#840), status bugs, url auth
inference (#1038), log bug (#1028), newline prompt (#1039),
svnadmin errorchecking, url syntax errors (#1057, #1058), apr/utf8
work (start #872), and many more.
Version 0.16 (released 4 Dec 2002, revision 3987)
User-visible changes:
* new 'svn cat' subcommand
* new --revprop flag to access revision props, -r for versioned props (#943)
* new "compression" runtime option in ~/.subversion/config
* svnadmin/svnlook now use help system, and some subcommands deleted or moved.
src/subversion/COMMITTERS view on Meta::CPAN
gradha Grzegorz A. Hankiewicz <gradha@titanium.sabren.com> (doc: es)
ruben Rubén Gómez <rugoli@euskalnet.net> (doc: es)
dbrouard Diego Brouard <dbrouard@gmail.com> (doc: es)
firemeteor Guo Rui <timmyguo@mail.ustc.edu.cn> (issue-2843-dev
br.)
## Local Variables:
## coding:utf-8
## End:
## vim:fileencoding=utf8
src/subversion/build/generator/ezt.py view on Meta::CPAN
return s
def _html_escape(s):
return _replace(s, REPLACE_HTML_MAP)
def _url_escape(s):
### quote_plus barfs on non-ASCII characters. According to
### http://www.w3.org/International/O-URL-code.html URIs should be
### UTF-8 encoded first.
if isinstance(s, unicode):
s = s.encode('utf8')
return urllib_parse_quote_plus(s)
FORMATTERS = {
FORMAT_RAW: None,
FORMAT_HTML: _html_escape,
FORMAT_XML: _html_escape, ### use the same quoting as HTML for now
FORMAT_JS: _js_escape,
FORMAT_URL: _url_escape,
}
src/subversion/subversion/bindings/cxxhl/src/exception.cpp view on Meta::CPAN
}
namespace {
void handle_one_error(error::message_list& ml, bool show_traces,
int error_code, detail::error_description* descr,
apr_pool_t* pool)
{
if (show_traces && descr->file())
{
const char* file_utf8 = NULL;
svn_error_t* err =
svn_utf_cstring_to_utf8(&file_utf8, descr->file(), pool);
if (err)
{
svn_error_clear(err);
file_utf8 = NULL;
}
std::ostringstream buffer;
if (file_utf8)
buffer << file_utf8 << ':' << descr->line();
else
buffer << "svn:<undefined>";
buffer << ": (apr_err=" << error_code << ')';
ml.push_back(error::message(0, buffer.str()));
}
if (descr->trace())
return;
const char *description = descr->what();
src/subversion/subversion/bindings/cxxhl/src/exception.cpp view on Meta::CPAN
{
char errorbuf[512];
// Is this a Subversion-specific error code?
if (error_code > APR_OS_START_USEERR
&& error_code <= APR_OS_START_CANONERR)
description = svn_strerror(error_code, errorbuf, sizeof(errorbuf));
// Otherwise, this must be an APR error code.
else
{
svn_error_t* err = svn_utf_cstring_to_utf8(
&description,
apr_strerror(error_code, errorbuf, sizeof(errorbuf)),
pool);
if (err)
{
svn_error_clear(err);
description = _("Can't recode error string from APR");
}
}
}
src/subversion/subversion/bindings/javahl/native/JNIUtil.cpp view on Meta::CPAN
#include "svn_path.h"
#include "svn_cache_config.h"
#include <apr_file_info.h>
#include "svn_private_config.h"
#ifdef WIN32
/* FIXME: We're using an internal APR header here, which means we
have to build Subversion with APR sources. This being Win32-only,
that should be fine for now, but a better solution must be found in
combination with issue #850. */
extern "C" {
#include <arch/win32/apr_arch_utf8.h>
};
#endif
#include "SVNBase.h"
#include "JNIMutex.h"
#include "JNICriticalSection.h"
#include "JNIThreadData.h"
#include "JNIStringHolder.h"
#include "Pool.h"
src/subversion/subversion/bindings/javahl/native/JNIUtil.cpp view on Meta::CPAN
settings.cache_size = 0;
settings.file_handle_count = 0;
settings.single_threaded = FALSE;
svn_cache_config_set(&settings);
}
#ifdef ENABLE_NLS
#ifdef WIN32
{
WCHAR ucs2_path[MAX_PATH];
char *utf8_path;
const char *internal_path;
apr_pool_t *pool;
apr_status_t apr_err;
apr_size_t inwords, outbytes;
unsigned int outlength;
pool = svn_pool_create(g_pool);
/* get dll name - our locale info will be in '../share/locale' */
inwords = sizeof(ucs2_path) / sizeof(ucs2_path[0]);
HINSTANCE moduleHandle = GetModuleHandle("libsvnjavahl-1");
GetModuleFileNameW(moduleHandle, ucs2_path, inwords);
inwords = lstrlenW(ucs2_path);
outbytes = outlength = 3 * (inwords + 1);
utf8_path = reinterpret_cast<char *>(apr_palloc(pool, outlength));
apr_err = apr_conv_ucs2_to_utf8((const apr_wchar_t *) ucs2_path,
&inwords, utf8_path, &outbytes);
if (!apr_err && (inwords > 0 || outbytes == 0))
apr_err = APR_INCOMPLETE;
if (apr_err)
{
if (stderr)
fprintf(stderr, "Can't convert module path to UTF-8");
return FALSE;
}
utf8_path[outlength - outbytes] = '\0';
internal_path = svn_dirent_internal_style(utf8_path, pool);
/* get base path name */
internal_path = svn_dirent_dirname(internal_path, pool);
internal_path = svn_dirent_join(internal_path, SVN_LOCALE_RELATIVE_PATH,
pool);
bindtextdomain(PACKAGE_NAME, internal_path);
svn_pool_destroy(pool);
}
#else
bindtextdomain(PACKAGE_NAME, SVN_LOCALE_DIR);
#endif
src/subversion/subversion/bindings/javahl/native/JNIUtil.cpp view on Meta::CPAN
{
/* Is this a Subversion-specific error code? */
if ((err->apr_err > APR_OS_START_USEERR)
&& (err->apr_err <= APR_OS_START_CANONERR))
buffer.append(svn_strerror(err->apr_err, errbuf, sizeof(errbuf)));
/* Otherwise, this must be an APR error code. */
else
{
/* Messages coming from apr_strerror are in the native
encoding, it's a good idea to convert them to UTF-8. */
const char* utf8_message;
apr_strerror(err->apr_err, errbuf, sizeof(errbuf));
svn_error_t* utf8_err = svn_utf_cstring_to_utf8(
&utf8_message, errbuf, err->pool);
if (utf8_err)
{
/* Use fuzzy transliteration instead. */
svn_error_clear(utf8_err);
utf8_message = svn_utf_cstring_from_utf8_fuzzy(errbuf, err->pool);
}
buffer.append(utf8_message);
}
buffer.append("\n");
}
if (err->message)
buffer.append(_("svn: ")).append(err->message).append("\n");
if (err->child)
assembleErrorMessage(err->child, depth + 1, err->apr_err, buffer);
}
src/subversion/subversion/bindings/javahl/native/SVNRepos.cpp view on Meta::CPAN
SVN_JNI_ERR(svn_repos_db_logfiles(&logfiles,
path.getInternalStyle(requestPool),
only_unused, requestPool.getPool()), );
/* Loop, printing log files. We append the log paths to the
* repository path, making sure to return everything to the native
* style and encoding before printing. */
for (int i = 0; i < logfiles->nelts; ++i)
{
const char *log_utf8;
log_utf8 = svn_dirent_join(path.getInternalStyle(requestPool),
APR_ARRAY_IDX(logfiles, i, const char *),
requestPool.getPool());
log_utf8 = svn_dirent_local_style(log_utf8, requestPool.getPool());
receiver.receiveMessage(log_utf8);
}
}
void SVNRepos::listDBLogs(File &path, MessageReceiver &messageReceiver)
{
list_dblogs(path, messageReceiver, false);
}
void SVNRepos::listUnusedDBLogs(File &path,
MessageReceiver &messageReceiver)
src/subversion/subversion/bindings/javahl/native/SVNRepos.cpp view on Meta::CPAN
/* svn_fs_unlock() demands that some username be associated with the
* filesystem, so just use the UID of the person running 'svnadmin'.*/
{
apr_uid_t uid;
apr_gid_t gid;
char *un;
if (apr_uid_current(&uid, &gid, requestPool.getPool()) == APR_SUCCESS &&
apr_uid_name_get(&un, uid, requestPool.getPool()) == APR_SUCCESS)
{
svn_error_t *err = svn_utf_cstring_to_utf8(&username, un,
requestPool.getPool());
svn_error_clear(err);
if (err)
username = "administrator";
}
}
/* Create an access context describing the current user. */
SVN_JNI_ERR(svn_fs_create_access(&access, username, requestPool.getPool()), );
src/subversion/subversion/bindings/swig/core.i view on Meta::CPAN
/* 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. */
src/subversion/subversion/bindings/swig/core.i view on Meta::CPAN
%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 */
src/subversion/subversion/bindings/swig/core.i view on Meta::CPAN
%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;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
apr_pool_t *_global_pool ;
int val1 ;
int ecode1 = 0 ;
int argvi = 0;
dXSARGS;
{
_global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
}
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_initialize2(assume_native_utf8,pool);");
}
ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "svn_utf_initialize2" "', argument " "1"" of type '" "svn_boolean_t""'");
}
arg1 = (svn_boolean_t)(val1);
if (items > 1) {
}
{
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
ST(argvi) = sv_newmortal();
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_stringbuf_to_utf8) {
{
svn_stringbuf_t **arg1 = (svn_stringbuf_t **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
svn_stringbuf_t *temp1 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_stringbuf_to_utf8(src,pool);");
}
{
apr_size_t len;
char *buf;
if (!SvOK(ST(0))) {
arg2 = NULL;
} else if (SvPOK(ST(0))) {
buf = SvPV(ST(0), len);
/* Another case of ugly pool handling, this should use the current
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
arg2 = svn_stringbuf_ncreate(buf,len,
svn_swig_pl_make_pool ((SV *)NULL));
} else {
croak("Not a string");
}
}
if (items > 1) {
}
{
result = (svn_error_t *)svn_utf_stringbuf_to_utf8(arg1,(struct svn_stringbuf_t const *)arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_string_to_utf8) {
{
svn_string_t **arg1 = (svn_string_t **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
svn_string_t *temp1 ;
svn_string_t value2 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_string_to_utf8(src,pool);");
}
{
if (SvOK(ST(0))) {
value2.data = SvPV(ST(0), value2.len);
arg2 = &value2;
}
else {
arg2 = NULL;
}
}
if (items > 1) {
}
{
result = (svn_error_t *)svn_utf_string_to_utf8((struct svn_string_t const **)arg1,(struct svn_string_t const *)arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_to_utf8) {
{
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_cstring_to_utf8(src,pool);");
}
res2 = SWIG_AsCharPtrAndSize(ST(0), &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_utf_cstring_to_utf8" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (items > 1) {
}
{
result = (svn_error_t *)svn_utf_cstring_to_utf8((char const **)arg1,(char const *)arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_to_utf8_ex2) {
{
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
int alloc3 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 2) || (items > 3)) {
SWIG_croak("Usage: svn_utf_cstring_to_utf8_ex2(src,frompage,pool);");
}
res2 = SWIG_AsCharPtrAndSize(ST(0), &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_utf_cstring_to_utf8_ex2" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_utf_cstring_to_utf8_ex2" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (items > 2) {
}
{
result = (svn_error_t *)svn_utf_cstring_to_utf8_ex2((char const **)arg1,(char const *)arg2,(char const *)arg3,arg4);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_to_utf8_ex) {
{
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
int alloc4 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 3) || (items > 4)) {
SWIG_croak("Usage: svn_utf_cstring_to_utf8_ex(src,frompage,convset_key,pool);");
}
res2 = SWIG_AsCharPtrAndSize(ST(0), &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_utf_cstring_to_utf8_ex" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_utf_cstring_to_utf8_ex" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
res4 = SWIG_AsCharPtrAndSize(ST(2), &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_utf_cstring_to_utf8_ex" "', argument " "4"" of type '" "char const *""'");
}
arg4 = (char *)(buf4);
if (items > 3) {
}
{
result = (svn_error_t *)svn_utf_cstring_to_utf8_ex((char const **)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_stringbuf_from_utf8) {
{
svn_stringbuf_t **arg1 = (svn_stringbuf_t **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
svn_stringbuf_t *temp1 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_stringbuf_from_utf8(src,pool);");
}
{
apr_size_t len;
char *buf;
if (!SvOK(ST(0))) {
arg2 = NULL;
} else if (SvPOK(ST(0))) {
buf = SvPV(ST(0), len);
/* Another case of ugly pool handling, this should use the current
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
arg2 = svn_stringbuf_ncreate(buf,len,
svn_swig_pl_make_pool ((SV *)NULL));
} else {
croak("Not a string");
}
}
if (items > 1) {
}
{
result = (svn_error_t *)svn_utf_stringbuf_from_utf8(arg1,(struct svn_stringbuf_t const *)arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_string_from_utf8) {
{
svn_string_t **arg1 = (svn_string_t **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
svn_string_t *temp1 ;
svn_string_t value2 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_string_from_utf8(src,pool);");
}
{
if (SvOK(ST(0))) {
value2.data = SvPV(ST(0), value2.len);
arg2 = &value2;
}
else {
arg2 = NULL;
}
}
if (items > 1) {
}
{
result = (svn_error_t *)svn_utf_string_from_utf8((struct svn_string_t const **)arg1,(struct svn_string_t const *)arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_from_utf8) {
{
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_cstring_from_utf8(src,pool);");
}
res2 = SWIG_AsCharPtrAndSize(ST(0), &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_utf_cstring_from_utf8" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (items > 1) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8((char const **)arg1,(char const *)arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_from_utf8_ex2) {
{
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
int alloc3 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 2) || (items > 3)) {
SWIG_croak("Usage: svn_utf_cstring_from_utf8_ex2(src,topage,pool);");
}
res2 = SWIG_AsCharPtrAndSize(ST(0), &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_utf_cstring_from_utf8_ex2" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_utf_cstring_from_utf8_ex2" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (items > 2) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8_ex2((char const **)arg1,(char const *)arg2,(char const *)arg3,arg4);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_from_utf8_ex) {
{
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
int alloc4 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg5 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 3) || (items > 4)) {
SWIG_croak("Usage: svn_utf_cstring_from_utf8_ex(src,topage,convset_key,pool);");
}
res2 = SWIG_AsCharPtrAndSize(ST(0), &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_utf_cstring_from_utf8_ex" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(ST(1), &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_utf_cstring_from_utf8_ex" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
res4 = SWIG_AsCharPtrAndSize(ST(2), &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_utf_cstring_from_utf8_ex" "', argument " "4"" of type '" "char const *""'");
}
arg4 = (char *)(buf4);
if (items > 3) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8_ex((char const **)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_from_utf8_fuzzy) {
{
char *arg1 = (char *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
char *result = 0 ;
dXSARGS;
{
_global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
}
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_cstring_from_utf8_fuzzy(src,pool);");
}
res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_utf_cstring_from_utf8_fuzzy" "', argument " "1"" of type '" "char const *""'");
}
arg1 = (char *)(buf1);
if (items > 1) {
}
{
result = (char *)svn_utf_cstring_from_utf8_fuzzy((char const *)arg1,arg2);
}
ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XSRETURN(argvi);
fail:
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_from_utf8_stringbuf) {
{
char **arg1 = (char **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
char *temp1 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_cstring_from_utf8_stringbuf(src,pool);");
}
{
apr_size_t len;
char *buf;
if (!SvOK(ST(0))) {
arg2 = NULL;
} else if (SvPOK(ST(0))) {
buf = SvPV(ST(0), len);
/* Another case of ugly pool handling, this should use the current
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
arg2 = svn_stringbuf_ncreate(buf,len,
svn_swig_pl_make_pool ((SV *)NULL));
} else {
croak("Not a string");
}
}
if (items > 1) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8_stringbuf((char const **)arg1,(struct svn_stringbuf_t const *)arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_from_utf8_string) {
{
char **arg1 = (char **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
char *temp1 ;
svn_string_t value2 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_utf_cstring_from_utf8_string(src,pool);");
}
{
if (SvOK(ST(0))) {
value2.data = SvPV(ST(0), value2.len);
arg2 = &value2;
}
else {
arg2 = NULL;
}
}
if (items > 1) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8_string((char const **)arg1,(struct svn_string_t const *)arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_utf_cstring_utf8_width) {
{
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
int result;
dXSARGS;
if ((items < 1) || (items > 1)) {
SWIG_croak("Usage: svn_utf_cstring_utf8_width(cstr);");
}
res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_utf_cstring_utf8_width" "', argument " "1"" of type '" "char const *""'");
}
arg1 = (char *)(buf1);
{
result = (int)svn_utf_cstring_utf8_width((char const *)arg1);
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XSRETURN(argvi);
fail:
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
SWIG_croak_null();
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
{"SVN::_Core::svn_config_get_user_config_path", _wrap_svn_config_get_user_config_path},
{"SVN::_Core::svn_config_dup", _wrap_svn_config_dup},
{"SVN::_Core::svn_config_copy_config", _wrap_svn_config_copy_config},
{"SVN::_Core::svn_config_invoke_section_enumerator", _wrap_svn_config_invoke_section_enumerator},
{"SVN::_Core::svn_config_invoke_section_enumerator2", _wrap_svn_config_invoke_section_enumerator2},
{"SVN::_Core::svn_config_invoke_enumerator", _wrap_svn_config_invoke_enumerator},
{"SVN::_Core::svn_config_invoke_enumerator2", _wrap_svn_config_invoke_enumerator2},
{"SVN::_Core::svn_config_invoke_auth_walk_func", _wrap_svn_config_invoke_auth_walk_func},
{"SVN::_Core::svn_utf_initialize2", _wrap_svn_utf_initialize2},
{"SVN::_Core::svn_utf_initialize", _wrap_svn_utf_initialize},
{"SVN::_Core::svn_utf_stringbuf_to_utf8", _wrap_svn_utf_stringbuf_to_utf8},
{"SVN::_Core::svn_utf_string_to_utf8", _wrap_svn_utf_string_to_utf8},
{"SVN::_Core::svn_utf_cstring_to_utf8", _wrap_svn_utf_cstring_to_utf8},
{"SVN::_Core::svn_utf_cstring_to_utf8_ex2", _wrap_svn_utf_cstring_to_utf8_ex2},
{"SVN::_Core::svn_utf_cstring_to_utf8_ex", _wrap_svn_utf_cstring_to_utf8_ex},
{"SVN::_Core::svn_utf_stringbuf_from_utf8", _wrap_svn_utf_stringbuf_from_utf8},
{"SVN::_Core::svn_utf_string_from_utf8", _wrap_svn_utf_string_from_utf8},
{"SVN::_Core::svn_utf_cstring_from_utf8", _wrap_svn_utf_cstring_from_utf8},
{"SVN::_Core::svn_utf_cstring_from_utf8_ex2", _wrap_svn_utf_cstring_from_utf8_ex2},
{"SVN::_Core::svn_utf_cstring_from_utf8_ex", _wrap_svn_utf_cstring_from_utf8_ex},
{"SVN::_Core::svn_utf_cstring_from_utf8_fuzzy", _wrap_svn_utf_cstring_from_utf8_fuzzy},
{"SVN::_Core::svn_utf_cstring_from_utf8_stringbuf", _wrap_svn_utf_cstring_from_utf8_stringbuf},
{"SVN::_Core::svn_utf_cstring_from_utf8_string", _wrap_svn_utf_cstring_from_utf8_string},
{"SVN::_Core::svn_utf_cstring_utf8_width", _wrap_svn_utf_cstring_utf8_width},
{"SVN::_Core::svn_nls_init", _wrap_svn_nls_init},
{"SVN::_Core::svn_path_internal_style", _wrap_svn_path_internal_style},
{"SVN::_Core::svn_path_local_style", _wrap_svn_path_local_style},
{"SVN::_Core::svn_path_splitext", _wrap_svn_path_splitext},
{"SVN::_Core::svn_path_is_empty", _wrap_svn_path_is_empty},
{"SVN::_Core::svn_dirent_is_root", _wrap_svn_dirent_is_root},
{"SVN::_Core::svn_path_canonicalize", _wrap_svn_path_canonicalize},
{"SVN::_Core::svn_path_is_canonical", _wrap_svn_path_is_canonical},
{"SVN::_Core::svn_path_compare_paths", _wrap_svn_path_compare_paths},
{"SVN::_Core::svn_path_get_longest_ancestor", _wrap_svn_path_get_longest_ancestor},
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_stringbuf_to_utf8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_stringbuf_t **arg1 = (svn_stringbuf_t **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_stringbuf_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_utf_stringbuf_to_utf8",&obj0,&obj1)) SWIG_fail;
{
if (!PyString_Check(obj0)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
arg2 = svn_stringbuf_ncreate(PyString_AS_STRING(obj0),
PyString_GET_SIZE(obj0),
/* ### gah... what pool to use? */
_global_pool);
}
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_stringbuf_to_utf8(arg1,(struct svn_stringbuf_t const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_string_to_utf8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_string_t **arg1 = (svn_string_t **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t *temp1 ;
svn_string_t value2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_utf_string_to_utf8",&obj0,&obj1)) SWIG_fail;
{
if (obj0 == Py_None)
arg2 = NULL;
else {
if (!PyString_Check(obj0)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value2.data = PyString_AS_STRING(obj0);
value2.len = PyString_GET_SIZE(obj0);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_string_to_utf8((struct svn_string_t const **)arg1,(struct svn_string_t const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_to_utf8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"s|O:svn_utf_cstring_to_utf8",&arg2,&obj1)) SWIG_fail;
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_cstring_to_utf8((char const **)arg1,(char const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_to_utf8_ex2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"ss|O:svn_utf_cstring_to_utf8_ex2",&arg2,&arg3,&obj2)) SWIG_fail;
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_cstring_to_utf8_ex2((char const **)arg1,(char const *)arg2,(char const *)arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_to_utf8_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"sss|O:svn_utf_cstring_to_utf8_ex",&arg2,&arg3,&arg4,&obj3)) SWIG_fail;
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_cstring_to_utf8_ex((char const **)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_stringbuf_from_utf8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_stringbuf_t **arg1 = (svn_stringbuf_t **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_stringbuf_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_utf_stringbuf_from_utf8",&obj0,&obj1)) SWIG_fail;
{
if (!PyString_Check(obj0)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
arg2 = svn_stringbuf_ncreate(PyString_AS_STRING(obj0),
PyString_GET_SIZE(obj0),
/* ### gah... what pool to use? */
_global_pool);
}
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_stringbuf_from_utf8(arg1,(struct svn_stringbuf_t const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_string_from_utf8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_string_t **arg1 = (svn_string_t **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t *temp1 ;
svn_string_t value2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_utf_string_from_utf8",&obj0,&obj1)) SWIG_fail;
{
if (obj0 == Py_None)
arg2 = NULL;
else {
if (!PyString_Check(obj0)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value2.data = PyString_AS_STRING(obj0);
value2.len = PyString_GET_SIZE(obj0);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_string_from_utf8((struct svn_string_t const **)arg1,(struct svn_string_t const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_from_utf8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"s|O:svn_utf_cstring_from_utf8",&arg2,&obj1)) SWIG_fail;
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_cstring_from_utf8((char const **)arg1,(char const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_from_utf8_ex2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"ss|O:svn_utf_cstring_from_utf8_ex2",&arg2,&arg3,&obj2)) SWIG_fail;
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_cstring_from_utf8_ex2((char const **)arg1,(char const *)arg2,(char const *)arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_from_utf8_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"sss|O:svn_utf_cstring_from_utf8_ex",&arg2,&arg3,&arg4,&obj3)) SWIG_fail;
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_cstring_from_utf8_ex((char const **)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_from_utf8_fuzzy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"s|O:svn_utf_cstring_from_utf8_fuzzy",&arg1,&obj1)) SWIG_fail;
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_utf_cstring_from_utf8_fuzzy((char const *)arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_from_utf8_stringbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_utf_cstring_from_utf8_stringbuf",&obj0,&obj1)) SWIG_fail;
{
if (!PyString_Check(obj0)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
arg2 = svn_stringbuf_ncreate(PyString_AS_STRING(obj0),
PyString_GET_SIZE(obj0),
/* ### gah... what pool to use? */
_global_pool);
}
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_cstring_from_utf8_stringbuf((char const **)arg1,(struct svn_stringbuf_t const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_from_utf8_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
svn_string_t value2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_utf_cstring_from_utf8_string",&obj0,&obj1)) SWIG_fail;
{
if (obj0 == Py_None)
arg2 = NULL;
else {
if (!PyString_Check(obj0)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value2.data = PyString_AS_STRING(obj0);
value2.len = PyString_GET_SIZE(obj0);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_utf_cstring_from_utf8_string((char const **)arg1,(struct svn_string_t const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_utf_cstring_utf8_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"s:svn_utf_cstring_utf8_width",&arg1)) SWIG_fail;
{
svn_swig_py_release_py_lock();
result = (int)svn_utf_cstring_utf8_width((char const *)arg1);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
""},
{ (char *)"svn_config_invoke_auth_walk_func", _wrap_svn_config_invoke_auth_walk_func, METH_VARARGS, (char *)"\n"
"svn_config_invoke_auth_walk_func(svn_config_auth_walk_func_t _obj, void * cleanup_baton, char const * cred_kind, char const * realmstring, \n"
" apr_hash_t hash, apr_pool_t scratch_pool) -> svn_error_t\n"
""},
{ (char *)"svn_config_section_enumerator_t_swigregister", svn_config_section_enumerator_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_config_section_enumerator2_t_swigregister", svn_config_section_enumerator2_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_config_enumerator_t_swigregister", svn_config_enumerator_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_config_enumerator2_t_swigregister", svn_config_enumerator2_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_config_auth_walk_func_t_swigregister", svn_config_auth_walk_func_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_utf_initialize2", _wrap_svn_utf_initialize2, METH_VARARGS, (char *)"svn_utf_initialize2(svn_boolean_t assume_native_utf8, apr_pool_t pool)"},
{ (char *)"svn_utf_initialize", _wrap_svn_utf_initialize, METH_VARARGS, (char *)"svn_utf_initialize(apr_pool_t pool)"},
{ (char *)"svn_utf_stringbuf_to_utf8", _wrap_svn_utf_stringbuf_to_utf8, METH_VARARGS, (char *)"svn_utf_stringbuf_to_utf8(svn_stringbuf_t const * src, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_string_to_utf8", _wrap_svn_utf_string_to_utf8, METH_VARARGS, (char *)"svn_utf_string_to_utf8(svn_string_t const * src, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_to_utf8", _wrap_svn_utf_cstring_to_utf8, METH_VARARGS, (char *)"svn_utf_cstring_to_utf8(char const * src, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_to_utf8_ex2", _wrap_svn_utf_cstring_to_utf8_ex2, METH_VARARGS, (char *)"svn_utf_cstring_to_utf8_ex2(char const * src, char const * frompage, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_to_utf8_ex", _wrap_svn_utf_cstring_to_utf8_ex, METH_VARARGS, (char *)"svn_utf_cstring_to_utf8_ex(char const * src, char const * frompage, char const * convset_key, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_stringbuf_from_utf8", _wrap_svn_utf_stringbuf_from_utf8, METH_VARARGS, (char *)"svn_utf_stringbuf_from_utf8(svn_stringbuf_t const * src, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_string_from_utf8", _wrap_svn_utf_string_from_utf8, METH_VARARGS, (char *)"svn_utf_string_from_utf8(svn_string_t const * src, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_from_utf8", _wrap_svn_utf_cstring_from_utf8, METH_VARARGS, (char *)"svn_utf_cstring_from_utf8(char const * src, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_from_utf8_ex2", _wrap_svn_utf_cstring_from_utf8_ex2, METH_VARARGS, (char *)"svn_utf_cstring_from_utf8_ex2(char const * src, char const * topage, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_from_utf8_ex", _wrap_svn_utf_cstring_from_utf8_ex, METH_VARARGS, (char *)"svn_utf_cstring_from_utf8_ex(char const * src, char const * topage, char const * convset_key, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_from_utf8_fuzzy", _wrap_svn_utf_cstring_from_utf8_fuzzy, METH_VARARGS, (char *)"svn_utf_cstring_from_utf8_fuzzy(char const * src, apr_pool_t pool) -> char const *"},
{ (char *)"svn_utf_cstring_from_utf8_stringbuf", _wrap_svn_utf_cstring_from_utf8_stringbuf, METH_VARARGS, (char *)"svn_utf_cstring_from_utf8_stringbuf(svn_stringbuf_t const * src, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_from_utf8_string", _wrap_svn_utf_cstring_from_utf8_string, METH_VARARGS, (char *)"svn_utf_cstring_from_utf8_string(svn_string_t const * src, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_utf_cstring_utf8_width", _wrap_svn_utf_cstring_utf8_width, METH_VARARGS, (char *)"svn_utf_cstring_utf8_width(char const * cstr) -> int"},
{ (char *)"svn_nls_init", _wrap_svn_nls_init, METH_VARARGS, (char *)"svn_nls_init() -> svn_error_t"},
{ (char *)"svn_path_internal_style", _wrap_svn_path_internal_style, METH_VARARGS, (char *)"svn_path_internal_style(char const * path, apr_pool_t pool) -> char const *"},
{ (char *)"svn_path_local_style", _wrap_svn_path_local_style, METH_VARARGS, (char *)"svn_path_local_style(char const * path, apr_pool_t pool) -> char const *"},
{ (char *)"svn_path_splitext", _wrap_svn_path_splitext, METH_VARARGS, (char *)"svn_path_splitext(char const * path, apr_pool_t pool)"},
{ (char *)"svn_path_is_empty", _wrap_svn_path_is_empty, METH_VARARGS, (char *)"svn_path_is_empty(char const * path) -> int"},
{ (char *)"svn_dirent_is_root", _wrap_svn_dirent_is_root, METH_VARARGS, (char *)"svn_dirent_is_root(char const * dirent, apr_size_t len) -> svn_boolean_t"},
{ (char *)"svn_path_canonicalize", _wrap_svn_path_canonicalize, METH_VARARGS, (char *)"svn_path_canonicalize(char const * path, apr_pool_t pool) -> char const *"},
{ (char *)"svn_path_is_canonical", _wrap_svn_path_is_canonical, METH_VARARGS, (char *)"svn_path_is_canonical(char const * path, apr_pool_t pool) -> svn_boolean_t"},
{ (char *)"svn_path_compare_paths", _wrap_svn_path_compare_paths, METH_VARARGS, (char *)"svn_path_compare_paths(char const * path1, char const * path2) -> int"},
{ (char *)"svn_path_get_longest_ancestor", _wrap_svn_path_get_longest_ancestor, METH_VARARGS, (char *)"svn_path_get_longest_ancestor(char const * path1, char const * path2, apr_pool_t pool) -> char *"},
src/subversion/subversion/bindings/swig/python/core.py view on Meta::CPAN
return _swig_setattr(self, self.__class__, name, value)
def __call__(self, *args):
return svn_config_invoke_auth_walk_func(self, *args)
svn_config_auth_walk_func_t_swigregister = _core.svn_config_auth_walk_func_t_swigregister
svn_config_auth_walk_func_t_swigregister(svn_config_auth_walk_func_t)
def svn_utf_initialize2(*args):
"""svn_utf_initialize2(svn_boolean_t assume_native_utf8, apr_pool_t pool)"""
return _core.svn_utf_initialize2(*args)
def svn_utf_initialize(*args):
"""svn_utf_initialize(apr_pool_t pool)"""
return _core.svn_utf_initialize(*args)
def svn_utf_stringbuf_to_utf8(*args):
"""svn_utf_stringbuf_to_utf8(svn_stringbuf_t const * src, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_stringbuf_to_utf8(*args)
def svn_utf_string_to_utf8(*args):
"""svn_utf_string_to_utf8(svn_string_t const * src, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_string_to_utf8(*args)
def svn_utf_cstring_to_utf8(*args):
"""svn_utf_cstring_to_utf8(char const * src, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_cstring_to_utf8(*args)
def svn_utf_cstring_to_utf8_ex2(*args):
"""svn_utf_cstring_to_utf8_ex2(char const * src, char const * frompage, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_cstring_to_utf8_ex2(*args)
def svn_utf_cstring_to_utf8_ex(*args):
"""svn_utf_cstring_to_utf8_ex(char const * src, char const * frompage, char const * convset_key, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_cstring_to_utf8_ex(*args)
def svn_utf_stringbuf_from_utf8(*args):
"""svn_utf_stringbuf_from_utf8(svn_stringbuf_t const * src, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_stringbuf_from_utf8(*args)
def svn_utf_string_from_utf8(*args):
"""svn_utf_string_from_utf8(svn_string_t const * src, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_string_from_utf8(*args)
def svn_utf_cstring_from_utf8(*args):
"""svn_utf_cstring_from_utf8(char const * src, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_cstring_from_utf8(*args)
def svn_utf_cstring_from_utf8_ex2(*args):
"""svn_utf_cstring_from_utf8_ex2(char const * src, char const * topage, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_cstring_from_utf8_ex2(*args)
def svn_utf_cstring_from_utf8_ex(*args):
"""svn_utf_cstring_from_utf8_ex(char const * src, char const * topage, char const * convset_key, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_cstring_from_utf8_ex(*args)
def svn_utf_cstring_from_utf8_fuzzy(*args):
"""svn_utf_cstring_from_utf8_fuzzy(char const * src, apr_pool_t pool) -> char const *"""
return _core.svn_utf_cstring_from_utf8_fuzzy(*args)
def svn_utf_cstring_from_utf8_stringbuf(*args):
"""svn_utf_cstring_from_utf8_stringbuf(svn_stringbuf_t const * src, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_cstring_from_utf8_stringbuf(*args)
def svn_utf_cstring_from_utf8_string(*args):
"""svn_utf_cstring_from_utf8_string(svn_string_t const * src, apr_pool_t pool) -> svn_error_t"""
return _core.svn_utf_cstring_from_utf8_string(*args)
def svn_utf_cstring_utf8_width(*args):
"""svn_utf_cstring_utf8_width(char const * cstr) -> int"""
return _core.svn_utf_cstring_utf8_width(*args)
def svn_nls_init():
"""svn_nls_init() -> svn_error_t"""
return _core.svn_nls_init()
def svn_path_internal_style(*args):
"""svn_path_internal_style(char const * path, apr_pool_t pool) -> char const *"""
return _core.svn_path_internal_style(*args)
def svn_path_local_style(*args):
src/subversion/subversion/bindings/swig/python/tests/core.py view on Meta::CPAN
self.assertEqual(svn.core.SubversionException('error message', 1).message,
'error message')
def test_mime_type_is_binary(self):
self.assertEqual(0, svn.core.svn_mime_type_is_binary("text/plain"))
self.assertEqual(1, svn.core.svn_mime_type_is_binary("image/png"))
def test_mime_type_validate(self):
self.assertRaises(svn.core.SubversionException,
svn.core.svn_mime_type_validate, "this\nis\ninvalid\n")
svn.core.svn_mime_type_validate("unknown/but-valid; charset=utf8")
def test_exception_interoperability(self):
"""Test if SubversionException is correctly converted into svn_error_t
and vice versa."""
t = utils.Temper()
(_, _, repos_uri) = t.alloc_empty_repo(suffix='-core')
rev = svn.core.svn_opt_revision_t()
rev.kind = svn.core.svn_opt_revision_head
ctx = svn.client.create_context()
src/subversion/subversion/bindings/swig/python/tests/wc.py view on Meta::CPAN
if kind != core.svn_prop_regular_kind:
continue
got_prop_changes.append((path[len(self.path) + 1:], name, value))
# Save diffs.
got_diffs = {}
def write_diff(path, left, right):
options = svn.diff.file_options_create()
diff = svn.diff.file_diff_2(left, right, options, pool)
original_header = modified_header = ''
encoding = 'utf8'
relative_to_dir = None
sio = StringIO()
svn.diff.file_output_unified3(sio, diff,
left, right,
original_header, modified_header,
encoding, relative_to_dir,
options.show_c_function, pool)
got_diffs[path[len(self.path) + 1:]] = sio.getvalue().splitlines()
# Diff callbacks that call props_changed and write_diff.
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_stringbuf_to_utf8(int argc, VALUE *argv, VALUE self) {
svn_stringbuf_t **arg1 = (svn_stringbuf_t **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
svn_stringbuf_t *temp1 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
{
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
} else {
arg2 = svn_stringbuf_ncreate(StringValuePtr(argv[0]),
RSTRING_LEN(argv[0]),
_global_pool);
}
}
if (argc > 1) {
}
{
result = (svn_error_t *)svn_utf_stringbuf_to_utf8(arg1,(struct svn_stringbuf_t const *)arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_string_to_utf8(int argc, VALUE *argv, VALUE self) {
svn_string_t **arg1 = (svn_string_t **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
svn_string_t *temp1 ;
svn_string_t value2 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
} else {
value2.data = StringValuePtr(argv[0]);
value2.len = RSTRING_LEN(argv[0]);
arg2 = &value2;
}
}
if (argc > 1) {
}
{
result = (svn_error_t *)svn_utf_string_to_utf8((struct svn_string_t const **)arg1,(struct svn_string_t const *)arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_to_utf8(int argc, VALUE *argv, VALUE self) {
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
svn_error_t *result = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
_global_pool = arg3;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 1) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_to_utf8", 2, argv[0] ));
}
arg2 = (char *)(buf2);
if (argc > 1) {
}
{
result = (svn_error_t *)svn_utf_cstring_to_utf8((char const **)arg1,(char const *)arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_to_utf8_ex2(int argc, VALUE *argv, VALUE self) {
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
_global_pool = arg4;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 2) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_to_utf8_ex2", 2, argv[0] ));
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_to_utf8_ex2", 3, argv[1] ));
}
arg3 = (char *)(buf3);
if (argc > 2) {
}
{
result = (svn_error_t *)svn_utf_cstring_to_utf8_ex2((char const **)arg1,(char const *)arg2,(char const *)arg3,arg4);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_to_utf8_ex(int argc, VALUE *argv, VALUE self) {
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
_global_pool = arg5;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 3) || (argc > 4)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_to_utf8_ex", 2, argv[0] ));
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_to_utf8_ex", 3, argv[1] ));
}
arg3 = (char *)(buf3);
res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_to_utf8_ex", 4, argv[2] ));
}
arg4 = (char *)(buf4);
if (argc > 3) {
}
{
result = (svn_error_t *)svn_utf_cstring_to_utf8_ex((char const **)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_stringbuf_from_utf8(int argc, VALUE *argv, VALUE self) {
svn_stringbuf_t **arg1 = (svn_stringbuf_t **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
svn_stringbuf_t *temp1 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
{
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
} else {
arg2 = svn_stringbuf_ncreate(StringValuePtr(argv[0]),
RSTRING_LEN(argv[0]),
_global_pool);
}
}
if (argc > 1) {
}
{
result = (svn_error_t *)svn_utf_stringbuf_from_utf8(arg1,(struct svn_stringbuf_t const *)arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_string_from_utf8(int argc, VALUE *argv, VALUE self) {
svn_string_t **arg1 = (svn_string_t **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
svn_string_t *temp1 ;
svn_string_t value2 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
} else {
value2.data = StringValuePtr(argv[0]);
value2.len = RSTRING_LEN(argv[0]);
arg2 = &value2;
}
}
if (argc > 1) {
}
{
result = (svn_error_t *)svn_utf_string_from_utf8((struct svn_string_t const **)arg1,(struct svn_string_t const *)arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_from_utf8(int argc, VALUE *argv, VALUE self) {
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
svn_error_t *result = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
_global_pool = arg3;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 1) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_from_utf8", 2, argv[0] ));
}
arg2 = (char *)(buf2);
if (argc > 1) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8((char const **)arg1,(char const *)arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_from_utf8_ex2(int argc, VALUE *argv, VALUE self) {
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
_global_pool = arg4;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 2) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_from_utf8_ex2", 2, argv[0] ));
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_from_utf8_ex2", 3, argv[1] ));
}
arg3 = (char *)(buf3);
if (argc > 2) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8_ex2((char const **)arg1,(char const *)arg2,(char const *)arg3,arg4);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_from_utf8_ex(int argc, VALUE *argv, VALUE self) {
char **arg1 = (char **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
char *temp1 ;
int res2 ;
char *buf2 = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
_global_pool = arg5;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 3) || (argc > 4)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_from_utf8_ex", 2, argv[0] ));
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_from_utf8_ex", 3, argv[1] ));
}
arg3 = (char *)(buf3);
res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_from_utf8_ex", 4, argv[2] ));
}
arg4 = (char *)(buf4);
if (argc > 3) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8_ex((char const **)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_from_utf8_fuzzy(int argc, VALUE *argv, VALUE self) {
char *arg1 = (char *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
char *result = 0 ;
VALUE vresult = Qnil;
{
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
_global_pool = arg2;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
if ((argc < 1) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_from_utf8_fuzzy", 1, argv[0] ));
}
arg1 = (char *)(buf1);
if (argc > 1) {
}
{
result = (char *)svn_utf_cstring_from_utf8_fuzzy((char const *)arg1,arg2);
}
{
if (result) {
vresult = rb_str_new2(result);
} else {
vresult = Qnil;
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_from_utf8_stringbuf(int argc, VALUE *argv, VALUE self) {
char **arg1 = (char **) 0 ;
svn_stringbuf_t *arg2 = (svn_stringbuf_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
char *temp1 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
{
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
} else {
arg2 = svn_stringbuf_ncreate(StringValuePtr(argv[0]),
RSTRING_LEN(argv[0]),
_global_pool);
}
}
if (argc > 1) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8_stringbuf((char const **)arg1,(struct svn_stringbuf_t const *)arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_from_utf8_string(int argc, VALUE *argv, VALUE self) {
char **arg1 = (char **) 0 ;
svn_string_t *arg2 = (svn_string_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
char *temp1 ;
svn_string_t value2 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
} else {
value2.data = StringValuePtr(argv[0]);
value2.len = RSTRING_LEN(argv[0]);
arg2 = &value2;
}
}
if (argc > 1) {
}
{
result = (svn_error_t *)svn_utf_cstring_from_utf8_string((char const **)arg1,(struct svn_string_t const *)arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_utf_cstring_utf8_width(int argc, VALUE *argv, VALUE self) {
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int result;
VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","svn_utf_cstring_utf8_width", 1, argv[0] ));
}
arg1 = (char *)(buf1);
{
result = (int)svn_utf_cstring_utf8_width((char const *)arg1);
}
vresult = SWIG_From_int((int)(result));
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return vresult;
fail:
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
rb_define_module_function(mCore, "svn_config_get_user_config_path", _wrap_svn_config_get_user_config_path, -1);
rb_define_module_function(mCore, "svn_config_dup", _wrap_svn_config_dup, -1);
rb_define_module_function(mCore, "svn_config_copy_config", _wrap_svn_config_copy_config, -1);
rb_define_module_function(mCore, "svn_config_invoke_section_enumerator", _wrap_svn_config_invoke_section_enumerator, -1);
rb_define_module_function(mCore, "svn_config_invoke_section_enumerator2", _wrap_svn_config_invoke_section_enumerator2, -1);
rb_define_module_function(mCore, "svn_config_invoke_enumerator", _wrap_svn_config_invoke_enumerator, -1);
rb_define_module_function(mCore, "svn_config_invoke_enumerator2", _wrap_svn_config_invoke_enumerator2, -1);
rb_define_module_function(mCore, "svn_config_invoke_auth_walk_func", _wrap_svn_config_invoke_auth_walk_func, -1);
rb_define_module_function(mCore, "svn_utf_initialize2", _wrap_svn_utf_initialize2, -1);
rb_define_module_function(mCore, "svn_utf_initialize", _wrap_svn_utf_initialize, -1);
rb_define_module_function(mCore, "svn_utf_stringbuf_to_utf8", _wrap_svn_utf_stringbuf_to_utf8, -1);
rb_define_module_function(mCore, "svn_utf_string_to_utf8", _wrap_svn_utf_string_to_utf8, -1);
rb_define_module_function(mCore, "svn_utf_cstring_to_utf8", _wrap_svn_utf_cstring_to_utf8, -1);
rb_define_module_function(mCore, "svn_utf_cstring_to_utf8_ex2", _wrap_svn_utf_cstring_to_utf8_ex2, -1);
rb_define_module_function(mCore, "svn_utf_cstring_to_utf8_ex", _wrap_svn_utf_cstring_to_utf8_ex, -1);
rb_define_module_function(mCore, "svn_utf_stringbuf_from_utf8", _wrap_svn_utf_stringbuf_from_utf8, -1);
rb_define_module_function(mCore, "svn_utf_string_from_utf8", _wrap_svn_utf_string_from_utf8, -1);
rb_define_module_function(mCore, "svn_utf_cstring_from_utf8", _wrap_svn_utf_cstring_from_utf8, -1);
rb_define_module_function(mCore, "svn_utf_cstring_from_utf8_ex2", _wrap_svn_utf_cstring_from_utf8_ex2, -1);
rb_define_module_function(mCore, "svn_utf_cstring_from_utf8_ex", _wrap_svn_utf_cstring_from_utf8_ex, -1);
rb_define_module_function(mCore, "svn_utf_cstring_from_utf8_fuzzy", _wrap_svn_utf_cstring_from_utf8_fuzzy, -1);
rb_define_module_function(mCore, "svn_utf_cstring_from_utf8_stringbuf", _wrap_svn_utf_cstring_from_utf8_stringbuf, -1);
rb_define_module_function(mCore, "svn_utf_cstring_from_utf8_string", _wrap_svn_utf_cstring_from_utf8_string, -1);
rb_define_module_function(mCore, "svn_utf_cstring_utf8_width", _wrap_svn_utf_cstring_utf8_width, -1);
rb_define_module_function(mCore, "svn_nls_init", _wrap_svn_nls_init, -1);
rb_define_module_function(mCore, "svn_path_internal_style", _wrap_svn_path_internal_style, -1);
rb_define_module_function(mCore, "svn_path_local_style", _wrap_svn_path_local_style, -1);
rb_define_module_function(mCore, "svn_path_splitext", _wrap_svn_path_splitext, -1);
rb_define_module_function(mCore, "svn_path_is_empty", _wrap_svn_path_is_empty, -1);
rb_define_module_function(mCore, "svn_dirent_is_root", _wrap_svn_dirent_is_root, -1);
rb_define_module_function(mCore, "svn_path_canonicalize", _wrap_svn_path_canonicalize, -1);
rb_define_module_function(mCore, "svn_path_is_canonical", _wrap_svn_path_is_canonical, -1);
rb_define_module_function(mCore, "svn_path_compare_paths", _wrap_svn_path_compare_paths, -1);
rb_define_module_function(mCore, "svn_path_get_longest_ancestor", _wrap_svn_path_get_longest_ancestor, -1);
src/subversion/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c view on Meta::CPAN
/* initialize */
static VALUE
svn_swig_rb_converter_to_locale_encoding(VALUE self, VALUE str)
{
apr_pool_t *pool;
svn_error_t *err;
const char *dest;
VALUE result;
pool = svn_pool_create(NULL);
err = svn_utf_cstring_from_utf8(&dest, StringValueCStr(str), pool);
if (err) {
svn_pool_destroy(pool);
svn_swig_rb_handle_svn_error(err);
}
result = rb_str_new2(dest);
svn_pool_destroy(pool);
return result;
}
src/subversion/subversion/bindings/swig/ruby/svn/commit-mailer.rb view on Meta::CPAN
true
rescue LoadError
false
end
else
false
end
end
def make_mail
utf8_body = make_body
utf7_body = nil
utf7_body = utf8_to_utf7(utf8_body) if use_utf7?
if utf7_body
body = utf7_body
encoding = "utf-7"
bit = "7bit"
else
body = utf8_body
encoding = "utf-8"
bit = "8bit"
end
unless @max_size.nil?
body = truncate_body(body, !utf7_body.nil?)
end
make_header(encoding, bit) + "\n" + body
end
src/subversion/subversion/bindings/swig/ruby/svn/commit-mailer.rb view on Meta::CPAN
else
repository = "XXX"
end
"X-SVN-Repository: #{repository}"
end
def x_id
"X-SVN-Commit-Id: #{@info.entire_sha256}"
end
def utf8_to_utf7(utf8)
require 'iconv'
Iconv.conv("UTF-7", "UTF-8", utf8)
rescue InvalidEncoding
begin
Iconv.conv("UTF7", "UTF8", utf8)
rescue Exception
nil
end
rescue Exception
nil
end
def truncate_body(body, use_utf7)
return body if body.size < @max_size
truncated_body = body[0, @max_size]
formatted_size = self.class.format_size(@max_size)
truncated_message = "... truncated to #{formatted_size}\n"
truncated_message = utf8_to_utf7(truncated_message) if use_utf7
truncated_message_size = truncated_message.size
lf_index = truncated_body.rindex(/(?:\r|\r\n|\n)/)
while lf_index
if lf_index + truncated_message_size < @max_size
truncated_body[lf_index, @max_size] = "\n#{truncated_message}"
break
else
lf_index = truncated_body.rindex(/(?:\r|\r\n|\n)/, lf_index - 1)
end
src/subversion/subversion/bindings/swig/ruby/svn/info.rb view on Meta::CPAN
@fs = @repos.fs
@root = @fs.root(@revision)
end
def teardown
@repos.close
@repos = @root = @fs = nil
end
def get_info
@author = force_to_utf8(prop(Core::PROP_REVISION_AUTHOR))
@date = prop(Core::PROP_REVISION_DATE)
@log = force_to_utf8(prop(Core::PROP_REVISION_LOG))
end
def get_dirs_changed
editor = traverse(Delta::ChangedDirsEditor)
@changed_dirs = editor.changed_dirs
end
def get_changed
editor = traverse(Delta::ChangedEditor, true)
@copied_files = editor.copied_files
src/subversion/subversion/bindings/swig/ruby/svn/info.rb view on Meta::CPAN
@updated_files = editor.updated_files
@updated_dirs = editor.updated_dirs
end
def get_diff
tree = @repos.delta_tree(@root, @prev_rev)
@diffs = {}
get_diff_recurse(tree, @fs.root(@prev_rev), "", "")
@diffs.each do |key, values|
values.each do |type, diff|
diff.body = force_to_utf8(diff.body)
end
end
end
TYPE_TABLE = [
[:copy?, :copied],
[:add?, :added],
[:delete?, :deleted],
[:replace?, :modified],
]
src/subversion/subversion/bindings/swig/ruby/svn/info.rb view on Meta::CPAN
def get_prop_diff(node, base_root, path, base_path)
local_props = @root.node_prop_list(path)
if node.add?
base_props = {}
else
base_props = base_root.node_prop_list(base_path)
end
prop_changes = Core::Property.diffs2(local_props, base_props)
prop_changes.each do |name, value|
entry = diff_entry(path, :property_changed)
entry.body << "Name: #{force_to_utf8(name)}\n"
orig_value = base_props[name]
entry.body << " - #{force_to_utf8(orig_value)}\n" if orig_value
entry.body << " + #{force_to_utf8(value)}\n" if value
end
end
def try_diff(node, base_root, path, base_path)
if node.replace? and node.text_mod?
differ = Fs::FileDiff.new(base_root, base_path, @root, path)
do_diff(node, base_root, path, base_path, differ)
elsif node.add? and node.text_mod?
differ = Fs::FileDiff.new(nil, base_path, @root, path)
do_diff(node, base_root, path, base_path, differ)
src/subversion/subversion/bindings/swig/ruby/svn/info.rb view on Meta::CPAN
}
end
end
@entire_sha256 = sha.hexdigest
end
def prop(name)
@fs.prop(name, @revision)
end
def force_to_utf8(str)
str = str.to_s
begin
# check UTF-8 or not
Uconv.u8toeuc(str)
str
rescue Uconv::Error
NKF.nkf("-w", str)
end
end
src/subversion/subversion/include/private/svn_opt_private.h view on Meta::CPAN
* Note that *PEG_REVISION will still contain the '@' symbol as the first
* character if a peg revision was found. If a trailing '@' symbol was
* used to escape other '@' characters in UTF8_TARGET, *PEG_REVISION will
* point to the string "@", containing only a single character.
*
* All allocations are done in POOL.
*/
svn_error_t *
svn_opt__split_arg_at_peg_revision(const char **true_target,
const char **peg_revision,
const char *utf8_target,
apr_pool_t *pool);
/* Attempt to transform URL_IN, which is a URL-like user input, into a
* valid URL:
* - escape IRI characters and some other non-URI characters
* - check that no back-path ("..") components are present
* - call svn_uri_canonicalize()
* URL_IN is in UTF-8 encoding and has no peg revision specifier.
* Set *URL_OUT to the result, allocated from POOL.
*/
src/subversion/subversion/include/private/svn_utf_private.h view on Meta::CPAN
lookup tables. It avoids the table memory use (about 400 bytes) but the
function is longer (about 200 bytes extra) and likely to be slower when
the string is valid. If the string is invalid this function may be
faster since it returns immediately rather than continuing to the end of
the string. The main reason this function exists is to test the table
driven implementation. */
const char *
svn_utf__last_valid2(const char *src, apr_size_t len);
const char *
svn_utf__cstring_from_utf8_fuzzy(const char *src,
apr_pool_t *pool,
svn_error_t *(*convert_from_utf8)
(const char **,
const char *,
apr_pool_t *));
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* SVN_UTF_PRIVATE_H */
src/subversion/subversion/include/svn_cmdline.h view on Meta::CPAN
*/
int
svn_cmdline_init(const char *progname,
FILE *error_stream);
/** Set @a *dest to an output-encoded C string from UTF-8 C string @a
* src; allocate @a *dest in @a pool.
*/
svn_error_t *
svn_cmdline_cstring_from_utf8(const char **dest,
const char *src,
apr_pool_t *pool);
/** Like svn_utf_cstring_from_utf8_fuzzy(), but converts to an
* output-encoded C string. */
const char *
svn_cmdline_cstring_from_utf8_fuzzy(const char *src,
apr_pool_t *pool);
/** Set @a *dest to a UTF-8-encoded C string from input-encoded C
* string @a src; allocate @a *dest in @a pool.
*/
svn_error_t *
svn_cmdline_cstring_to_utf8(const char **dest,
const char *src,
apr_pool_t *pool);
/** Set @a *dest to an output-encoded natively-formatted path string
* from canonical path @a src; allocate @a *dest in @a pool.
*/
svn_error_t *
svn_cmdline_path_local_style_from_utf8(const char **dest,
const char *src,
apr_pool_t *pool);
/** Write to stdout, using a printf-like format string @a fmt, passed
* through apr_pvsprintf(). All string arguments are in UTF-8; the output
* is converted to the output encoding. Use @a pool for temporary
* allocation.
*
* @since New in 1.1.
*/
src/subversion/subversion/include/svn_ctype.h view on Meta::CPAN
#define SVN_CTYPE_URISAFE 0x0800
*/
/* Derived extended character classes */
/** Part of a UTF-8 multibyte character. */
#define SVN_CTYPE_UTF8MBC (SVN_CTYPE_UTF8LEAD | SVN_CTYPE_UTF8CONT)
/** All valid UTF-8 bytes. */
#define SVN_CTYPE_UTF8 (SVN_CTYPE_ASCII | SVN_CTYPE_UTF8MBC)
/** Check if @a c is a UTF-8 multibyte lead byte. */
#define svn_ctype_isutf8lead(c) svn_ctype_test((c), SVN_CTYPE_UTF8LEAD)
/** Check if @a c is a UTF-8 multibyte continuation (non-lead) byte. */
#define svn_ctype_isutf8cont(c) svn_ctype_test((c), SVN_CTYLE_UTF8CONT)
/** Check if @a c is part of a UTF-8 multibyte character. */
#define svn_ctype_isutf8mbc(c) svn_ctype_test((c), SVN_CTYPE_UTF8MBC)
/** Check if @a c is valid in UTF-8. */
#define svn_ctype_isutf8(c) svn_ctype_test((c), SVN_CTYPE_UTF8)
/** @} */
/**
* @defgroup ctype_ascii ASCII character value constants
* @{
*/
#define SVN_CTYPE_ASCII_MINUS 45 /**< ASCII value of '-' */
#define SVN_CTYPE_ASCII_DOT 46 /**< ASCII value of '.' */
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
same varieties of @a kind as svn_io_check_path(). */
svn_error_t *
svn_io_check_resolved_path(const char *path,
svn_node_kind_t *kind,
apr_pool_t *pool);
/** Open a new file (for reading and writing) with a unique name based on
* utf-8 encoded @a filename, in the directory @a dirpath. The file handle is
* returned in @a *file, and the name, which ends with @a suffix, is returned
* in @a *unique_name, also utf8-encoded. Either @a file or @a unique_name
* may be @c NULL. If @a file is @c NULL, the file will be created but not
* open.
*
* The file will be deleted according to @a delete_when. If that is
* #svn_io_file_del_on_pool_cleanup, it refers to @a result_pool.
*
* The @c APR_BUFFERED flag will always be used when opening the file.
*
* The first attempt will just append @a suffix. If the result is not
* a unique name, then subsequent attempts will append a dot,
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
/** Set @a *dir to a directory path (allocated in @a pool) deemed
* usable for the creation of temporary files and subdirectories.
*/
svn_error_t *
svn_io_temp_dir(const char **dir,
apr_pool_t *pool);
/** Copy @a src to @a dst atomically, in a "byte-for-byte" manner.
* Overwrite @a dst if it exists, else create it. Both @a src and @a dst
* are utf8-encoded filenames. If @a copy_perms is TRUE, set @a dst's
* permissions to match those of @a src.
*/
svn_error_t *
svn_io_copy_file(const char *src,
const char *dst,
svn_boolean_t copy_perms,
apr_pool_t *pool);
/** Copy permission flags from @a src onto the file at @a dst. Both
* filenames are utf8-encoded filenames.
*
* @since New in 1.6.
*/
svn_error_t *
svn_io_copy_perms(const char *src,
const char *dst,
apr_pool_t *pool);
/**
* Copy symbolic link @a src to @a dst atomically. Overwrite @a dst
* if it exists, else create it. Both @a src and @a dst are
* utf8-encoded filenames. After copying, the @a dst link will point
* to the same thing @a src does.
*
* @since New in 1.1.
*/
svn_error_t *
svn_io_copy_link(const char *src,
const char *dst,
apr_pool_t *pool);
/** Recursively copy directory @a src into @a dst_parent, as a new entry named
* @a dst_basename. If @a dst_basename already exists in @a dst_parent,
* return error. @a copy_perms will be passed through to svn_io_copy_file()
* when any files are copied. @a src, @a dst_parent, and @a dst_basename are
* all utf8-encoded.
*
* If @a cancel_func is non-NULL, invoke it with @a cancel_baton at
* various points during the operation. If it returns any error
* (typically #SVN_ERR_CANCELLED), return that error immediately.
*/
svn_error_t *
svn_io_copy_dir_recursively(const char *src,
const char *dst_parent,
const char *dst_basename,
svn_boolean_t copy_perms,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool);
/** Create directory @a path on the file system, creating intermediate
* directories as required, like <tt>mkdir -p</tt>. Report no error if @a
* path already exists. @a path is utf8-encoded.
*
* This is essentially a wrapper for apr_dir_make_recursive(), passing
* @c APR_OS_DEFAULT as the permissions.
*/
svn_error_t *
svn_io_make_dir_recursively(const char *path,
apr_pool_t *pool);
/** Set @a *is_empty_p to @c TRUE if directory @a path is empty, else to
* @c FALSE if it is not empty. @a path must be a directory, and is
* utf8-encoded. Use @a pool for temporary allocation.
*/
svn_error_t *
svn_io_dir_empty(svn_boolean_t *is_empty_p,
const char *path,
apr_pool_t *pool);
/** Append @a src to @a dst. @a dst will be appended to if it exists, else it
* will be created. Both @a src and @a dst are utf8-encoded.
*/
svn_error_t *
svn_io_append_file(const char *src,
const char *dst,
apr_pool_t *pool);
/** Make a file as read-only as the operating system allows.
* @a path is the utf8-encoded path to the file. If @a ignore_enoent is
* @c TRUE, don't fail if the target file doesn't exist.
*
* If @a path is a symlink, do nothing.
*
* @note If @a path is a directory, act on it as though it were a
* file, as described above, but note that you probably don't want to
* call this function on directories. We have left it effective on
* directories for compatibility reasons, but as its name implies, it
* should be used only for files.
*/
svn_error_t *
svn_io_set_file_read_only(const char *path,
svn_boolean_t ignore_enoent,
apr_pool_t *pool);
/** Make a file as writable as the operating system allows.
* @a path is the utf8-encoded path to the file. If @a ignore_enoent is
* @c TRUE, don't fail if the target file doesn't exist.
* @warning On Unix this function will do the equivalent of chmod a+w path.
* If this is not what you want you should not use this function, but rather
* use apr_file_perms_set().
*
* If @a path is a symlink, do nothing.
*
* @note If @a path is a directory, act on it as though it were a
* file, as described above, but note that you probably don't want to
* call this function on directories. We have left it effective on
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
* permissions, set the permissions on @a path to the permissions that
* are set when a new file is created (effectively honoring the user's
* umask).
*
* When making the file read-only on operating systems with unix style
* permissions, remove all write permissions.
*
* On other operating systems, toggle the file's "writability" as much as
* the operating system allows.
*
* @a path is the utf8-encoded path to the file. If @a enable_write
* is @c TRUE, then make the file read-write. If @c FALSE, make it
* read-only. If @a ignore_enoent is @c TRUE, don't fail if the target
* file doesn't exist.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
*/
SVN_DEPRECATED
svn_error_t *
svn_io_set_file_read_write_carefully(const char *path,
svn_boolean_t enable_write,
svn_boolean_t ignore_enoent,
apr_pool_t *pool);
/** Set @a path's "executability" (but do nothing if it is a symlink).
*
* @a path is the utf8-encoded path to the file. If @a executable
* is @c TRUE, then make the file executable. If @c FALSE, make it
* non-executable. If @a ignore_enoent is @c TRUE, don't fail if the target
* file doesn't exist.
*
* When making the file executable on operating systems with unix style
* permissions, never add an execute permission where there is not
* already a read permission: that is, only make the file executable
* for the user, group or world if the corresponding read permission
* is already set for user, group or world.
*
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
* When the file is out of lines, @c APR_EOF will be returned.
*/
svn_error_t *
svn_io_read_length_line(apr_file_t *file,
char *buf,
apr_size_t *limit,
apr_pool_t *pool);
/** Set @a *apr_time to the time of last modification of the contents of the
* file @a path. @a path is utf8-encoded.
*
* @note This is the APR mtime which corresponds to the traditional mtime
* on Unix, and the last write time on Windows.
*/
svn_error_t *
svn_io_file_affected_time(apr_time_t *apr_time,
const char *path,
apr_pool_t *pool);
/** Set the timestamp of file @a path to @a apr_time. @a path is
* utf8-encoded.
*
* @note This is the APR mtime which corresponds to the traditional mtime
* on Unix, and the last write time on Windows.
*/
svn_error_t *
svn_io_set_file_affected_time(apr_time_t apr_time,
const char *path,
apr_pool_t *pool);
/** Sleep to ensure that any files modified after we exit have a different
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
*
* Errors while retrieving the timestamp resolution will result in sleeping
* to the next second, to keep the working copy stable in error conditions.
*
* @since New in 1.6.
*/
void
svn_io_sleep_for_timestamps(const char *path, apr_pool_t *pool);
/** Set @a *different_p to TRUE if @a file1 and @a file2 have different
* sizes, else set to FALSE. Both @a file1 and @a file2 are utf8-encoded.
*
* Setting @a *different_p to zero does not mean the files definitely
* have the same size, it merely means that the sizes are not
* definitely different. That is, if the size of one or both files
* cannot be determined, then the sizes are not known to be different,
* so @a *different_p is set to FALSE.
*/
svn_error_t *
svn_io_filesizes_different_p(svn_boolean_t *different_p,
const char *file1,
const char *file2,
apr_pool_t *pool);
/** Set @a *different_p12 to non-zero if @a file1 and @a file2 have different
* sizes, else set to zero. Do the similar for @a *different_p23 with
* @a file2 and @a file3, and @a *different_p13 for @a file1 and @a file3.
* The filenames @a file1, @a file2 and @a file3 are utf8-encoded.
*
* Setting @a *different_p12 to zero does not mean the files definitely
* have the same size, it merely means that the sizes are not
* definitely different. That is, if the size of one or both files
* cannot be determined (due to stat() returning an error), then the sizes
* are not known to be different, so @a *different_p12 is set to 0.
*
* @since New in 1.8.
*/
svn_error_t *
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
svn_error_t *
svn_io_files_contents_same_p(svn_boolean_t *same,
const char *file1,
const char *file2,
apr_pool_t *pool);
/** Set @a *same12 to TRUE if @a file1 and @a file2 have the same
* contents, else set it to FALSE. Do the similar for @a *same23
* with @a file2 and @a file3, and @a *same13 for @a file1 and @a
* file3. The filenames @a file1, @a file2 and @a file3 are
* utf8-encoded. Use @a scratch_pool for temporary allocations.
*
* @since New in 1.8.
*/
svn_error_t *
svn_io_files_contents_three_same_p(svn_boolean_t *same12,
svn_boolean_t *same23,
svn_boolean_t *same13,
const char *file1,
const char *file2,
const char *file3,
apr_pool_t *scratch_pool);
/** Create file at utf8-encoded @a file with contents @a contents.
* @a file must not already exist.
* Use @a pool for memory allocations.
*/
svn_error_t *
svn_io_file_create(const char *file,
const char *contents,
apr_pool_t *pool);
/**
* Lock file at @a lock_file. If @a exclusive is TRUE,
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
/** Write to @a stream using a printf-style @a fmt specifier, passed through
* apr_psprintf() using memory from @a pool. The resulting string
* will be translated to @a encoding before it is sent to @a stream.
*
* @note Use @c APR_LOCALE_CHARSET to translate to the encoding of the
* current locale.
*
* @since New in 1.3.
*/
svn_error_t *
svn_stream_printf_from_utf8(svn_stream_t *stream,
const char *encoding,
apr_pool_t *pool,
const char *fmt,
...)
__attribute__((format(printf, 4, 5)));
/** Allocate @a *stringbuf in @a pool, and read into it one line (terminated
* by @a eol) from @a stream. The line-terminator is read from the stream,
* but is not added to the end of the stringbuf. Instead, the stringbuf
* ends with a usual '\\0'.
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
svn_stream_t *
svn_stream_lazyopen_create(svn_stream_lazyopen_func_t open_func,
void *open_baton,
svn_boolean_t open_on_close,
apr_pool_t *result_pool);
/** @} */
/** Set @a *result to a string containing the contents of @a
* filename, which is either "-" (indicating that stdin should be
* read) or the utf8-encoded path of a real file.
*
* @warning Callers should be aware of possible unexpected results
* when using this function to read from stdin where additional
* stdin-reading processes abound. For example, if a program tries
* both to invoke an external editor and to read from stdin, stdin
* could be trashed and the editor might act funky or die outright.
*
* @note due to memory pseudo-reallocation behavior (due to pools), this
* can be a memory-intensive operation for large files.
*
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
* close the file or reset the cursor position.
*
* @note due to memory pseudo-reallocation behavior (due to pools), this
* can be a memory-intensive operation for large files.
*/
svn_error_t *
svn_stringbuf_from_aprfile(svn_stringbuf_t **result,
apr_file_t *file,
apr_pool_t *pool);
/** Remove file @a path, a utf8-encoded path. This wraps apr_file_remove(),
* converting any error to a Subversion error. If @a ignore_enoent is TRUE, and
* the file is not present (APR_STATUS_IS_ENOENT returns TRUE), then no
* error will be returned.
*
* The file will be removed even if it is not writable. (On Windows and
* OS/2, this function first clears the file's read-only bit.)
*
* @since New in 1.7.
*/
svn_error_t *
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
/** Similar to svn_io_remove_file2(), except with @a ignore_enoent set to FALSE.
*
* @deprecated Provided for backwards compatibility with the 1.6 API.
*/
SVN_DEPRECATED
svn_error_t *
svn_io_remove_file(const char *path,
apr_pool_t *pool);
/** Recursively remove directory @a path. @a path is utf8-encoded.
* If @a ignore_enoent is @c TRUE, don't fail if the target directory
* doesn't exist. Use @a pool for temporary allocations.
*
* Because recursive delete of a directory tree can be a lengthy operation,
* provide @a cancel_func and @a cancel_baton for interruptibility.
*
* @since New in 1.5.
*/
svn_error_t *
svn_io_remove_dir2(const char *path,
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
/** Similar to svn_io_remove_dir2(), but with @a ignore_enoent set to
* @c FALSE and @a cancel_func and @a cancel_baton set to @c NULL.
*
* @deprecated Provided for backward compatibility with the 1.4 API
*/
SVN_DEPRECATED
svn_error_t *
svn_io_remove_dir(const char *path,
apr_pool_t *pool);
/** Read all of the disk entries in directory @a path, a utf8-encoded
* path. Set @a *dirents to a hash mapping dirent names (<tt>char *</tt>) to
* undefined non-NULL values, allocated in @a pool.
*
* @note The `.' and `..' directories normally returned by
* apr_dir_read() are NOT returned in the hash.
*
* @since New in 1.4.
* @deprecated Provided for backward compatibility with the 1.6 API.
*/
SVN_DEPRECATED
svn_error_t *
svn_io_get_dir_filenames(apr_hash_t **dirents,
const char *path,
apr_pool_t *pool);
/** Read all of the disk entries in directory @a path, a utf8-encoded
* path. Set @a *dirents to a hash mapping dirent names (<tt>char *</tt>) to
* #svn_io_dirent2_t structures, allocated in @a pool.
*
* If @a only_check_type is set to @c TRUE, only the kind and special
* fields of the svn_io_dirent2_t are filled.
*
* @note The `.' and `..' directories normally returned by
* apr_dir_read() are NOT returned in the hash.
*
* @note The kind field in the @a dirents is set according to the mapping
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
apr_pool_t *scratch_pool);
/** Callback function type for svn_io_dir_walk() */
typedef svn_error_t * (*svn_io_walk_func_t)(void *baton,
const char *path,
const apr_finfo_t *finfo,
apr_pool_t *pool);
/** Recursively walk the directory rooted at @a dirname, a
* utf8-encoded path, invoking @a walk_func (with @a walk_baton) for
* each item in the tree. For a given directory, invoke @a walk_func
* on the directory itself before invoking it on any children thereof.
*
* Deliver to @a walk_func the information specified by @a wanted,
* which is a combination of @c APR_FINFO_* flags, plus the
* information specified by @c APR_FINFO_TYPE and @c APR_FINFO_NAME.
*
* Use @a pool for all allocations.
*
* @note This function does not currently pass all file types to @a
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
*/
SVN_DEPRECATED
svn_error_t *
svn_io_dir_walk(const char *dirname,
apr_int32_t wanted,
svn_io_walk_func_t walk_func,
void *walk_baton,
apr_pool_t *pool);
/**
* Start @a cmd with @a args, using utf8-encoded @a path as working
* directory. Return the process handle for the invoked program in @a
* *cmd_proc.
*
* If @a infile_pipe is TRUE, connect @a cmd's stdin to a pipe;
* otherwise, connect it to @a infile (which may be NULL). If
* @a outfile_pipe is TRUE, connect @a cmd's stdout to a pipe; otherwise,
* connect it to @a outfile (which may be NULL). If @a errfile_pipe
* is TRUE, connect @a cmd's stderr to a pipe; otherwise, connect it
* to @a errfile (which may be NULL). (Callers must pass FALSE for
* each of these boolean values for which the corresponding file
* handle is non-NULL.)
*
* @a args is a list of utf8-encoded <tt>const char *</tt> arguments,
* terminated by @c NULL. @a args[0] is the name of the program, though it
* need not be the same as @a cmd.
*
* If @a inherit is TRUE, the invoked program inherits its environment from
* the caller and @a cmd, if not absolute, is searched for in PATH.
*
* If @a inherit is FALSE @a cmd must be an absolute path and the invoked
* program inherits the environment defined by @a env or runs with an empty
* environment in @a env is NULL.
*
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
const char *const *args,
int *exitcode,
apr_exit_why_e *exitwhy,
svn_boolean_t inherit,
apr_file_t *infile,
apr_file_t *outfile,
apr_file_t *errfile,
apr_pool_t *pool);
/** Invoke the configured @c diff program, with @a user_args (an array
* of utf8-encoded @a num_user_args arguments) if they are specified
* (that is, if @a user_args is non-NULL), or "-u" if they are not.
* If @a user_args is NULL, the value of @a num_user_args is ignored.
*
* Diff runs in utf8-encoded @a dir, and its exit status is stored in
* @a exitcode, if it is not @c NULL.
*
* If @a label1 and/or @a label2 are not NULL they will be passed to the diff
* process as the arguments of "-L" options. @a label1 and @a label2 are also
* in utf8, and will be converted to native charset along with the other args.
*
* @a from is the first file passed to diff, and @a to is the second. The
* stdout of diff will be sent to @a outfile, and the stderr to @a errfile.
*
* @a diff_cmd must be non-NULL.
*
* Do all allocation in @a pool.
* @since New in 1.6.0.
*/
svn_error_t *
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
const char *from,
const char *to,
int *exitcode,
apr_file_t *outfile,
apr_file_t *errfile,
const char *diff_cmd,
apr_pool_t *pool);
/** Invoke the configured @c diff3 program, in utf8-encoded @a dir
* like this:
*
* diff3 -E -m @a mine @a older @a yours > @a merged
*
* (See the diff3 documentation for details.)
*
* If @a user_args is non-NULL, replace "-E" with the <tt>const char*</tt>
* elements that @a user_args contains.
*
* @a mine, @a older and @a yours are utf8-encoded paths (relative to
* @a dir or absolute) to three files that already exist.
*
* @a merged is an open file handle, and is left open after the merge
* result is written to it. (@a merged should *not* be the same file
* as @a mine, or nondeterministic things may happen!)
*
* @a mine_label, @a older_label, @a yours_label are utf8-encoded label
* parameters for diff3's -L option. Any of them may be @c NULL, in
* which case the corresponding @a mine, @a older, or @a yours parameter is
* used instead.
*
* Set @a *exitcode to diff3's exit status. If @a *exitcode is anything
* other than 0 or 1, then return #SVN_ERR_EXTERNAL_PROGRAM. (Note the
* following from the diff3 info pages: "An exit status of 0 means
* `diff3' was successful, 1 means some conflicts were found, and 2
* means trouble.")
*
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
const char *yours,
const char *mine_label,
const char *older_label,
const char *yours_label,
apr_file_t *merged,
int *exitcode,
const char *diff3_cmd,
apr_pool_t *pool);
/** Parse utf8-encoded @a mimetypes_file as a MIME types file (such as
* is provided with Apache HTTP Server), and set @a *type_map to a
* hash mapping <tt>const char *</tt> filename extensions to
* <tt>const char *</tt> MIME types.
*
* @since New in 1.5.
*/
svn_error_t *
svn_io_parse_mimetypes_file(apr_hash_t **type_map,
const char *mimetypes_file,
apr_pool_t *pool);
/** Examine utf8-encoded @a file to determine if it can be described by a
* known (as in, known by this function) Multipurpose Internet Mail
* Extension (MIME) type. If so, set @a *mimetype to a character string
* describing the MIME type, else set it to @c NULL.
*
* If not @c NULL, @a mimetype_map is a hash mapping <tt>const char *</tt>
* filename extensions to <tt>const char *</tt> MIME types, and is the
* first source consulted regarding @a file's MIME type.
*
* Use @a pool for any necessary allocations.
*
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
/** Examine up to @a len bytes of data in @a buf to determine if the
* can be considered binary data, in which case return TRUE.
* If the data can be considered plain-text data, return FALSE.
*
* @since New in 1.7.
*/
svn_boolean_t
svn_io_is_binary_data(const void *buf, apr_size_t len);
/** Wrapper for apr_file_open(). @a fname is utf8-encoded.
Always passed flag | APR_BINARY to apr. */
svn_error_t *
svn_io_file_open(apr_file_t **new_file,
const char *fname,
apr_int32_t flag,
apr_fileperms_t perm,
apr_pool_t *pool);
/** Wrapper for apr_file_close(). */
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
apr_pool_t *pool);
/** Wrapper for apr_file_trunc().
* @since New in 1.6. */
svn_error_t *
svn_io_file_trunc(apr_file_t *file,
apr_off_t offset,
apr_pool_t *pool);
/** Wrapper for apr_stat(). @a fname is utf8-encoded. */
svn_error_t *
svn_io_stat(apr_finfo_t *finfo,
const char *fname,
apr_int32_t wanted,
apr_pool_t *pool);
/** Rename and/or move the node (not necessarily a regular file) at
* @a from_path to a new path @a to_path within the same filesystem.
* In some cases, an existing node at @a to_path will be overwritten.
*
* A wrapper for apr_file_rename(). @a from_path and @a to_path are
* utf8-encoded.
*/
svn_error_t *
svn_io_file_rename(const char *from_path,
const char *to_path,
apr_pool_t *pool);
/** Move the file from @a from_path to @a to_path, even across device
* boundaries. Overwrite @a to_path if it exists.
*
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
* latter fails in the 'across device boundaries' case.
*
* @since New in 1.3.
*/
svn_error_t *
svn_io_file_move(const char *from_path,
const char *to_path,
apr_pool_t *pool);
/** Wrapper for apr_dir_make(). @a path is utf8-encoded. */
svn_error_t *
svn_io_dir_make(const char *path,
apr_fileperms_t perm,
apr_pool_t *pool);
/** Same as svn_io_dir_make(), but sets the hidden attribute on the
directory on systems that support it. */
svn_error_t *
svn_io_dir_make_hidden(const char *path,
apr_fileperms_t perm,
src/subversion/subversion/include/svn_io.h view on Meta::CPAN
* subdirectories created within inherit group ownership from the
* parent instead of from the primary gid.
*
* @since New in 1.1.
*/
svn_error_t *
svn_io_dir_make_sgid(const char *path,
apr_fileperms_t perm,
apr_pool_t *pool);
/** Wrapper for apr_dir_open(). @a dirname is utf8-encoded. */
svn_error_t *
svn_io_dir_open(apr_dir_t **new_dir,
const char *dirname,
apr_pool_t *pool);
/** Wrapper for apr_dir_close().
*
* @since New in 1.7.
*/
svn_error_t *
svn_io_dir_close(apr_dir_t *thedir);
/** Wrapper for apr_dir_remove(). @a dirname is utf8-encoded.
* @note This function has this name to avoid confusion with
* svn_io_remove_dir2(), which is recursive.
*/
svn_error_t *
svn_io_dir_remove_nonrecursive(const char *dirname,
apr_pool_t *pool);
/** Wrapper for apr_dir_read(). Ensures that @a finfo->name is
* utf8-encoded, which means allocating @a finfo->name in @a pool,
* which may or may not be the same as @a finfo's pool. Use @a pool
* for error allocation as well.
*/
svn_error_t *
svn_io_dir_read(apr_finfo_t *finfo,
apr_int32_t wanted,
apr_dir_t *thedir,
apr_pool_t *pool);
/** Wrapper for apr_file_name_get(). @a *filename is utf8-encoded.
*
* @note The file name may be NULL.
*
* @since New in 1.7. */
svn_error_t *
svn_io_file_name_get(const char **filename,
apr_file_t *file,
apr_pool_t *pool);
src/subversion/subversion/include/svn_path.h view on Meta::CPAN
svn_path_uri_autoescape(const char *uri, apr_pool_t *pool);
/** @} */
/** Charset conversion stuff
*
* @defgroup svn_path_charset_stuff Charset conversion
* @{
*/
/** Convert @a path_utf8 from UTF-8 to the internal encoding used by APR. */
svn_error_t *
svn_path_cstring_from_utf8(const char **path_apr,
const char *path_utf8,
apr_pool_t *pool);
/** Convert @a path_apr from the internal encoding used by APR to UTF-8. */
svn_error_t *
svn_path_cstring_to_utf8(const char **path_utf8,
const char *path_apr,
apr_pool_t *pool);
/** @} */
/** Repository relative URLs
*
* @defgroup svn_path_repos_relative_urls Repository relative URLs
src/subversion/subversion/include/svn_subst.h view on Meta::CPAN
svn_boolean_t special,
apr_pool_t *pool);
/* EOL conversion and character encodings */
/** Translate the string @a value from character encoding @a encoding to
* UTF8, and also from its current line-ending style to LF line-endings. If
* @a encoding is @c NULL, translate from the system-default encoding.
*
* If @a translated_to_utf8 is not @c NULL, then set @a *translated_to_utf8
* to @c TRUE if at least one character of @a value in the source character
* encoding was translated to UTF-8, or to @c FALSE otherwise.
*
* If @a translated_line_endings is not @c NULL, then set @a
* *translated_line_endings to @c TRUE if at least one line ending was
* changed to LF, or to @c FALSE otherwise.
*
* If @a value has an inconsistent line ending style, then: if @a repair
* is @c FALSE, return @c SVN_ERR_IO_INCONSISTENT_EOL, else if @a repair is
* @c TRUE, convert any line ending in @a value to "\n" in
* @a *new_value. Recognized line endings are: "\n", "\r", and "\r\n".
*
* Set @a *new_value to the translated string, allocated in @a result_pool.
*
* @a scratch_pool is used for temporary allocations.
*
* @since New in 1.7.
*/
svn_error_t *
svn_subst_translate_string2(svn_string_t **new_value,
svn_boolean_t *translated_to_utf8,
svn_boolean_t *translated_line_endings,
const svn_string_t *value,
const char *encoding,
svn_boolean_t repair,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
/** Similar to svn_subst_translate_string2(), except that the information about
* whether re-encoding or line ending translation were performed is discarded.
*
src/subversion/subversion/include/svn_utf.h view on Meta::CPAN
extern "C" {
#endif /* __cplusplus */
#define SVN_APR_LOCALE_CHARSET APR_LOCALE_CHARSET
#define SVN_APR_DEFAULT_CHARSET APR_DEFAULT_CHARSET
/**
* Initialize the UTF-8 encoding/decoding routines.
* Allocate cached translation handles in a subpool of @a pool.
*
* If @a assume_native_utf8 is TRUE, the native character set is
* assumed to be UTF-8, i.e. conversion is a no-op. This is useful
* in contexts where the native character set is ASCII but UTF-8
* should be used regardless (e.g. for mod_dav_svn which runs within
* httpd and always uses the "C" locale).
*
* @note It is optional to call this function, but if it is used, no other
* svn function may be in use in other threads during the call of this
* function or when @a pool is cleared or destroyed.
* Initializing the UTF-8 routines will improve performance.
*
* @since New in 1.8.
*/
void
svn_utf_initialize2(svn_boolean_t assume_native_utf8,
apr_pool_t *pool);
/**
* Like svn_utf_initialize2() but without the ability to force the
* native encoding to UTF-8.
*
* @deprecated Provided for backward compatibility with the 1.7 API.
*/
SVN_DEPRECATED
void
svn_utf_initialize(apr_pool_t *pool);
/** Set @a *dest to a utf8-encoded stringbuf from native stringbuf @a src;
* allocate @a *dest in @a pool.
*/
svn_error_t *
svn_utf_stringbuf_to_utf8(svn_stringbuf_t **dest,
const svn_stringbuf_t *src,
apr_pool_t *pool);
/** Set @a *dest to a utf8-encoded string from native string @a src; allocate
* @a *dest in @a pool.
*/
svn_error_t *
svn_utf_string_to_utf8(const svn_string_t **dest,
const svn_string_t *src,
apr_pool_t *pool);
/** Set @a *dest to a utf8-encoded C string from native C string @a src;
* allocate @a *dest in @a pool.
*/
svn_error_t *
svn_utf_cstring_to_utf8(const char **dest,
const char *src,
apr_pool_t *pool);
/** Set @a *dest to a utf8 encoded C string from @a frompage encoded C
* string @a src; allocate @a *dest in @a pool.
*
* @since New in 1.4.
*/
svn_error_t *
svn_utf_cstring_to_utf8_ex2(const char **dest,
const char *src,
const char *frompage,
apr_pool_t *pool);
/** Like svn_utf_cstring_to_utf8_ex2() but with @a convset_key which is
* ignored.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
*/
SVN_DEPRECATED
svn_error_t *
svn_utf_cstring_to_utf8_ex(const char **dest,
const char *src,
const char *frompage,
const char *convset_key,
apr_pool_t *pool);
/** Set @a *dest to a natively-encoded stringbuf from utf8 stringbuf @a src;
* allocate @a *dest in @a pool.
*/
svn_error_t *
svn_utf_stringbuf_from_utf8(svn_stringbuf_t **dest,
const svn_stringbuf_t *src,
apr_pool_t *pool);
/** Set @a *dest to a natively-encoded string from utf8 string @a src;
* allocate @a *dest in @a pool.
*/
svn_error_t *
svn_utf_string_from_utf8(const svn_string_t **dest,
const svn_string_t *src,
apr_pool_t *pool);
/** Set @a *dest to a natively-encoded C string from utf8 C string @a src;
* allocate @a *dest in @a pool.
*/
svn_error_t *
svn_utf_cstring_from_utf8(const char **dest,
const char *src,
apr_pool_t *pool);
/** Set @a *dest to a @a topage encoded C string from utf8 encoded C string
* @a src; allocate @a *dest in @a pool.
*
* @since New in 1.4.
*/
svn_error_t *
svn_utf_cstring_from_utf8_ex2(const char **dest,
const char *src,
const char *topage,
apr_pool_t *pool);
/** Like svn_utf_cstring_from_utf8_ex2() but with @a convset_key which is
* ignored.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
*/
SVN_DEPRECATED
svn_error_t *
svn_utf_cstring_from_utf8_ex(const char **dest,
const char *src,
const char *topage,
const char *convset_key,
apr_pool_t *pool);
/** Return a fuzzily native-encoded C string from utf8 C string @a src,
* allocated in @a pool. A fuzzy recoding leaves all 7-bit ascii
* characters the same, and substitutes "?\\XXX" for others, where XXX
* is the unsigned decimal code for that character.
*
* This function cannot error; it is guaranteed to return something.
* First it will recode as described above and then attempt to convert
* the (new) 7-bit UTF-8 string to native encoding. If that fails, it
* will return the raw fuzzily recoded string, which may or may not be
* meaningful in the client's locale, but is (presumably) better than
* nothing.
src/subversion/subversion/include/svn_utf.h view on Meta::CPAN
* "?\\XXX" escape codes for the non-ascii characters.
*
* Ultimately, some callers may prefer the iconv "//TRANSLIT" option,
* so when we can detect that at configure time, things will change.
* Also, this should (?) be moved to apr/apu eventually.
*
* See http://subversion.tigris.org/issues/show_bug.cgi?id=807 for
* details.
*/
const char *
svn_utf_cstring_from_utf8_fuzzy(const char *src,
apr_pool_t *pool);
/** Set @a *dest to a natively-encoded C string from utf8 stringbuf @a src;
* allocate @a *dest in @a pool.
*/
svn_error_t *
svn_utf_cstring_from_utf8_stringbuf(const char **dest,
const svn_stringbuf_t *src,
apr_pool_t *pool);
/** Set @a *dest to a natively-encoded C string from utf8 string @a src;
* allocate @a *dest in @a pool.
*/
svn_error_t *
svn_utf_cstring_from_utf8_string(const char **dest,
const svn_string_t *src,
apr_pool_t *pool);
/** Return the display width of UTF-8-encoded C string @a cstr.
* If the string is not printable or invalid UTF-8, return -1.
*
* @since New in 1.8.
*/
int
svn_utf_cstring_utf8_width(const char *cstr);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* SVN_UTF_H */
src/subversion/subversion/libsvn_client/cmdline.c view on Meta::CPAN
/* Step 1: create a master array of targets that are in UTF-8
encoding, and come from concatenating the targets left by apr_getopt,
plus any extra targets (e.g., from the --targets switch.)
If any of the targets are relative urls, then set the rel_url_found
flag.*/
for (; os->ind < os->argc; os->ind++)
{
/* The apr_getopt targets are still in native encoding. */
const char *raw_target = os->argv[os->ind];
const char *utf8_target;
SVN_ERR(svn_utf_cstring_to_utf8(&utf8_target,
raw_target, pool));
if (svn_path_is_repos_relative_url(utf8_target))
rel_url_found = TRUE;
APR_ARRAY_PUSH(input_targets, const char *) = utf8_target;
}
if (known_targets)
{
for (i = 0; i < known_targets->nelts; i++)
{
/* The --targets array have already been converted to UTF-8,
because we needed to split up the list with svn_cstring_split. */
const char *utf8_target = APR_ARRAY_IDX(known_targets,
i, const char *);
if (svn_path_is_repos_relative_url(utf8_target))
rel_url_found = TRUE;
APR_ARRAY_PUSH(input_targets, const char *) = utf8_target;
}
}
/* Step 2: process each target. */
for (i = 0; i < input_targets->nelts; i++)
{
const char *utf8_target = APR_ARRAY_IDX(input_targets, i, const char *);
/* Relative urls will be canonicalized when they are resolved later in
* the function
*/
if (svn_path_is_repos_relative_url(utf8_target))
{
APR_ARRAY_PUSH(output_targets, const char *) = utf8_target;
}
else
{
const char *true_target;
const char *peg_rev;
const char *target;
/*
* This is needed so that the target can be properly canonicalized,
* otherwise the canonicalization does not treat a ".@BASE" as a "."
* with a BASE peg revision, and it is not canonicalized to "@BASE".
* If any peg revision exists, it is appended to the final
* canonicalized path or URL. Do not use svn_opt_parse_path()
* because the resulting peg revision is a structure that would have
* to be converted back into a string. Converting from a string date
* to the apr_time_t field in the svn_opt_revision_value_t and back to
* a string would not necessarily preserve the exact bytes of the
* input date, so its easier just to keep it in string form.
*/
SVN_ERR(svn_opt__split_arg_at_peg_revision(&true_target, &peg_rev,
utf8_target, pool));
/* URLs and wc-paths get treated differently. */
if (svn_path_is_url(true_target))
{
SVN_ERR(svn_opt__arg_canonicalize_url(&true_target,
true_target, pool));
}
else /* not a url, so treat as a path */
{
const char *base_name;
src/subversion/subversion/libsvn_client/cmdline.c view on Meta::CPAN
/* If the target has the same name as a Subversion
working copy administrative dir, skip it. */
base_name = svn_dirent_basename(true_target, pool);
if (svn_wc_is_adm_dir(base_name, pool))
{
if (!reserved_names)
reserved_names = apr_array_make(pool, DEFAULT_ARRAY_SIZE,
sizeof(const char *));
APR_ARRAY_PUSH(reserved_names, const char *) = utf8_target;
continue;
}
}
target = apr_pstrcat(pool, true_target, peg_rev, (char *)NULL);
if (rel_url_found)
{
/* Later targets have priority over earlier target, I
src/subversion/subversion/libsvn_client/copy.c view on Meta::CPAN
svn_dirent_dirname(pair->dst_abspath_or_url,
iterpool)) == 0)
{
const char *dst;
char *dst_apr;
apr_status_t apr_err;
/* We have a rename inside a directory, which might collide
just because the case insensivity of the filesystem makes
the source match the destination. */
SVN_ERR(svn_path_cstring_from_utf8(&dst,
pair->dst_abspath_or_url,
scratch_pool));
apr_err = apr_filepath_merge(&dst_apr, NULL, dst,
APR_FILEPATH_TRUENAME, iterpool);
if (!apr_err)
{
/* And now bring it back to our canonical format */
SVN_ERR(svn_path_cstring_to_utf8(&dst, dst_apr, iterpool));
dst = svn_dirent_canonicalize(dst, iterpool);
}
/* else: Don't report this error; just report the normal error */
if (!apr_err && strcmp(dst, pair->src_abspath_or_url) == 0)
{
/* Ok, we have a single case only rename. Get out of here */
svn_dirent_split(&pair->dst_parent_abspath, &pair->base_name,
pair->dst_abspath_or_url, result_pool);
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
}
/* Print a git diff header for an addition within a diff between PATH1 and
* PATH2 to the stream OS using HEADER_ENCODING.
* All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_added(svn_stream_t *os, const char *header_encoding,
const char *path1, const char *path2,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
path1, path2, APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"new file mode 10644" APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header for a deletion within a diff between PATH1 and
* PATH2 to the stream OS using HEADER_ENCODING.
* All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_deleted(svn_stream_t *os, const char *header_encoding,
const char *path1, const char *path2,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
path1, path2, APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"deleted file mode 10644"
APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header for a copy from COPYFROM_PATH to PATH to the stream
* OS using HEADER_ENCODING. All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_copied(svn_stream_t *os, const char *header_encoding,
const char *copyfrom_path,
svn_revnum_t copyfrom_rev,
const char *path,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
copyfrom_path, path, APR_EOL_STR));
if (copyfrom_rev != SVN_INVALID_REVNUM)
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"copy from %s@%ld%s", copyfrom_path,
copyfrom_rev, APR_EOL_STR));
else
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"copy from %s%s", copyfrom_path,
APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"copy to %s%s", path, APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header for a rename from COPYFROM_PATH to PATH to the
* stream OS using HEADER_ENCODING. All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_renamed(svn_stream_t *os, const char *header_encoding,
const char *copyfrom_path, const char *path,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
copyfrom_path, path, APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"rename from %s%s", copyfrom_path,
APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"rename to %s%s", path, APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header for a modification within a diff between PATH1 and
* PATH2 to the stream OS using HEADER_ENCODING.
* All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_modified(svn_stream_t *os, const char *header_encoding,
const char *path1, const char *path2,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
path1, path2, APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header showing the OPERATION to the stream OS using
* HEADER_ENCODING. Return suitable diff labels for the git diff in *LABEL1
* and *LABEL2. REPOS_RELPATH1 and REPOS_RELPATH2 are relative to reposroot.
* are the paths passed to the original diff command. REV1 and REV2 are
* revisions being diffed. COPYFROM_PATH and COPYFROM_REV indicate where the
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
{
const char *label1;
const char *label2;
label1 = diff_label(adjusted_path1, rev1, scratch_pool);
label2 = diff_label(adjusted_path2, rev2, scratch_pool);
/* ### Should we show the paths in platform specific format,
* ### diff_content_changed() does not! */
SVN_ERR(svn_stream_printf_from_utf8(outstream, encoding, scratch_pool,
"Index: %s" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
if (use_git_diff_format)
SVN_ERR(print_git_diff_header(outstream, &label1, &label2,
svn_diff_op_modified,
repos_relpath1, repos_relpath2,
rev1, rev2, NULL,
SVN_INVALID_REVNUM,
encoding, scratch_pool));
/* --- label1
* +++ label2 */
SVN_ERR(svn_diff__unidiff_write_header(
outstream, encoding, label1, label2, scratch_pool));
}
SVN_ERR(svn_stream_printf_from_utf8(outstream, encoding, scratch_pool,
_("%sProperty changes on: %s%s"),
APR_EOL_STR,
use_git_diff_format
? repos_relpath1
: index_path,
APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(outstream, encoding, scratch_pool,
SVN_DIFF__UNDER_STRING APR_EOL_STR));
SVN_ERR(svn_diff__display_prop_diffs(
outstream, encoding, propchanges, original_props,
TRUE /* pretty_print_mergeinfo */, scratch_pool));
return SVN_NO_ERROR;
}
/*-----------------------------------------------------------------*/
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
specified, don't attempt to generate a viewable diff at all.
Print a warning and exit. */
if (mimetype1)
mt1_binary = svn_mime_type_is_binary(mimetype1);
if (mimetype2)
mt2_binary = svn_mime_type_is_binary(mimetype2);
if (! diff_cmd_baton->force_binary && (mt1_binary || mt2_binary))
{
/* Print out the diff header. */
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
/* ### Print git diff headers. */
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
_("Cannot display: file marked as a binary type.%s"),
APR_EOL_STR));
if (mt1_binary && !mt2_binary)
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"svn:mime-type = %s" APR_EOL_STR, mimetype1));
else if (mt2_binary && !mt1_binary)
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"svn:mime-type = %s" APR_EOL_STR, mimetype2));
else if (mt1_binary && mt2_binary)
{
if (strcmp(mimetype1, mimetype2) == 0)
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"svn:mime-type = %s" APR_EOL_STR,
mimetype1));
else
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"svn:mime-type = (%s, %s)" APR_EOL_STR,
mimetype1, mimetype2));
}
/* Exit early. */
return SVN_NO_ERROR;
}
if (diff_cmd_baton->diff_cmd)
{
apr_file_t *outfile;
apr_file_t *errfile;
const char *outfilename;
const char *errfilename;
svn_stream_t *stream;
/* Print out the diff header. */
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
/* ### Do we want to add git diff headers here too? I'd say no. The
* ### 'Index' and '===' line is something subversion has added. The rest
* ### is up to the external diff application. We may be dealing with
* ### a non-git compatible diff application.*/
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
SVN_ERR(svn_diff_file_diff_2(&diff, tmpfile1, tmpfile2,
diff_cmd_baton->options.for_internal,
scratch_pool));
if (force_diff
|| diff_cmd_baton->use_git_diff_format
|| svn_diff_contains_diffs(diff))
{
/* Print out the diff header. */
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
if (diff_cmd_baton->use_git_diff_format)
{
const char *repos_relpath1;
const char *repos_relpath2;
SVN_ERR(make_repos_relpath(&repos_relpath1, diff_relpath,
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
}
if (diff_cmd_baton->no_diff_added)
{
const char *index_path = diff_relpath;
if (diff_cmd_baton->anchor)
index_path = svn_dirent_join(diff_cmd_baton->anchor, diff_relpath,
scratch_pool);
SVN_ERR(svn_stream_printf_from_utf8(diff_cmd_baton->outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s (added)" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
wrote_header = TRUE;
}
else if (tmpfile1 && copyfrom_path)
SVN_ERR(diff_content_changed(&wrote_header, diff_relpath,
tmpfile1, tmpfile2, rev1, rev2,
mimetype1, mimetype2,
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
struct diff_cmd_baton *diff_cmd_baton = diff_baton;
if (diff_cmd_baton->no_diff_deleted)
{
const char *index_path = diff_relpath;
if (diff_cmd_baton->anchor)
index_path = svn_dirent_join(diff_cmd_baton->anchor, diff_relpath,
scratch_pool);
SVN_ERR(svn_stream_printf_from_utf8(diff_cmd_baton->outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s (deleted)" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
}
else
{
svn_boolean_t wrote_header = FALSE;
if (tmpfile1)
SVN_ERR(diff_content_changed(&wrote_header, diff_relpath,
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
SVN_CONFIG_OPTION_DIFF_EXTENSIONS, NULL);
if (diff_extensions)
options = svn_cstring_split(diff_extensions, " \t\n\r", TRUE, pool);
}
}
if (options == NULL)
options = apr_array_make(pool, 0, sizeof(const char *));
if (diff_cmd)
SVN_ERR(svn_path_cstring_to_utf8(&diff_cmd_baton->diff_cmd, diff_cmd,
pool));
else
diff_cmd_baton->diff_cmd = NULL;
/* If there was a command, arrange options to pass to it. */
if (diff_cmd_baton->diff_cmd)
{
const char **argv = NULL;
int argc = options->nelts;
if (argc)
{
int i;
argv = apr_palloc(pool, argc * sizeof(char *));
for (i = 0; i < argc; i++)
SVN_ERR(svn_utf_cstring_to_utf8(&argv[i],
APR_ARRAY_IDX(options, i, const char *), pool));
}
diff_cmd_baton->options.for_external.argv = argv;
diff_cmd_baton->options.for_external.argc = argc;
}
else /* No command, so arrange options for internal invocation instead. */
{
diff_cmd_baton->options.for_internal
= svn_diff_file_options_create(pool);
SVN_ERR(svn_diff_file_options_parse
src/subversion/subversion/libsvn_client/externals.c view on Meta::CPAN
/* See if the user wants last-commit timestamps instead of current ones. */
SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
/* Get the external diff3, if any. */
svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
if (diff3_cmd != NULL)
SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, scratch_pool));
/* See which files the user wants to preserve the extension of when
conflict files are made. */
svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
preserved_exts = *preserved_exts_str
? svn_cstring_split(preserved_exts_str, "\n\r\t\v ", FALSE, scratch_pool)
: NULL;
{
src/subversion/subversion/libsvn_client/merge.c view on Meta::CPAN
depth = svn_depth_infinity;
/* Set up the diff3 command, so various callers don't have to. */
cfg = ctx->config
? svn_hash_gets(ctx->config, SVN_CONFIG_CATEGORY_CONFIG)
: NULL;
svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
if (diff3_cmd != NULL)
SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, scratch_pool));
/* See which files the user wants to preserve the extension of when
conflict files are made. */
svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
/* Build the merge context baton (or at least the parts of it that
don't need to be reset for each merge source). */
merge_cmd_baton.force_delete = force_delete;
merge_cmd_baton.dry_run = dry_run;
( run in 1.590 second using v1.01-cache-2.11-cpan-49f99fa48dc )