Alien-SVN
view release on metacpan or search on metacpan
src/subversion/subversion/tests/cmdline/depth_tests.py
src/subversion/subversion/tests/cmdline/diff_tests.py
src/subversion/subversion/tests/cmdline/diff_tests_data/3449_spurious_v1
src/subversion/subversion/tests/cmdline/diff_tests_data/3449_spurious_v2
src/subversion/subversion/tests/cmdline/diff_tests_data/3449_spurious_v3
src/subversion/subversion/tests/cmdline/entries-dump.c
src/subversion/subversion/tests/cmdline/entries_tests.py
src/subversion/subversion/tests/cmdline/export_tests.py
src/subversion/subversion/tests/cmdline/externals_tests.py
src/subversion/subversion/tests/cmdline/getopt_tests.py
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn--help_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn--help_stdout
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn--version--quiet_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn--version--quiet_stdout
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn--version--verbose_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn--version--verbose_stdout
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn--version_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn--version_stdout
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_help--version_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_help--version_stdout
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_help_bogus-cmd_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_help_bogus-cmd_stdout
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_help_log_switch_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_help_log_switch_stdout
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_help_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_help_stdout
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_stderr
src/subversion/subversion/tests/cmdline/getopt_tests_data/svn_stdout
src/subversion/subversion/tests/cmdline/history_tests.py
src/subversion/subversion/tests/cmdline/import_tests.py
src/subversion/subversion/tests/cmdline/import_tests_data/import_tree/DIR2.doo/file1.txt
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/CHANGES view on Meta::CPAN
- Server-side bugfixes:
* mod_dav_svn is less strict about auto-merging for commits (issue #1704)
* allow SVNListParentPath to be used with authz (issue #2753)
* allow nav to repo list from repo top with SVNListParentPath (issue #3159)
* allow repositories in the root of a drive on windows (issue #3535)
* don't destroy mergeinfo with 'svnadmin load --parent-dir' (issue #3547)
* fixed: 'svnadmin hotcopy' does not duplicate symlinks (issue #2591)
* fixed: post-revprop-change errors cancel commit (issue #2990)
* fixed: mod_dav_svn runs pre-revprop-change hook twice (issue #3085)
* fixed: mod_dav_svn doesn't return stderr to user on failure (issue #3112)
* fixed: hotcopy may corrupt target rep-cache.db (issue #3596)
* fixed: mod_dav_svn can cause spurious merge conflicts (issue #3657)
* fixed: DAV can overwrite directories during copy (issue #3314)
* fixed: 'svn log' returns log of unrelated path (issue #3931)
* match paths against authz rules in case sensitive way (issue #3781)
* svnserve can now force usernames to upper/lower case (issue #3726)
* reduce duplicate log messages in 'log -g' (issue #3650)
* svnserve: don't crash on shutdown with SASL in inetd mode (issue #3664)
* disallow arbitrary HTTP headers from committers (issue #2872)
* limit FSFS memory consumption (issue #3478, #3593)
src/subversion/CHANGES view on Meta::CPAN
* fix the testsuite to avoid FAILs on APR hash order (r1230714, et al)
Version 1.6.18
(29 Mar 2012, from /branches/1.6.x)
http://svn.apache.org/repos/asf/subversion/tags/1.6.18
User-visible changes:
* reject invalid svn:mergeinfo at commit time over DAV (issue #3953)
* fix reintegrate merge regression introduced in 1.6.13 (issue #3957)
* make the stderr output of the post-commit hook XML-safe (r893478)
* fix a rare source of FSFS corruption (r1240752)
* plug a memory leak in the bdb backend (r1205726)
* server-side performance fix for "log -g" (r1152282)
* fix description of svndumpfilter's --targets option (r1151911)
* fix datastream corruption during resumed transfer in ra_serf (r1154733)
* fix a crash in ra_svn SASL authentication (r1166555, -678)
* fix potential corruption on 32-bit FSFS with large files (r1230212)
* make website links point to subversion.apache.org (r896893, -901, r915036)
* fix non-fatal FSFS corruption bug with concurrent commits (issue #4129)
src/subversion/Makefile.in view on Meta::CPAN
install-ctypes-python: ctypes-python
cd $(CTYPES_PYTHON_SRC_DIR); \
$(PYTHON) setup.py install --prefix="$(DESTDIR)$(prefix)"
check-ctypes-python: ctypes-python
cd $(CTYPES_PYTHON_SRC_DIR); \
$(LT_EXECUTE) $(PYTHON) test/run_all.py
# If any of those files exists, run ctypes' 'setup.py clean'. We don't run
# it otherwise because it spams stdout+stderr; see r1479326.
clean-ctypes-python:
cd $(CTYPES_PYTHON_SRC_DIR); \
for b in build csvn/core/functions.py svn_all.py svn_all2.py ; do \
if [ -e "$$b" ] ; then \
$(PYTHON) setup.py clean --all; \
break; \
fi; \
done
# manually describe a dependency, which we won't otherwise detect
src/subversion/build/config.sub view on Meta::CPAN
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program. This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").
# Please send patches with a ChangeLog entry to config-patches@gnu.org.
#
# Configuration subroutine to validate and canonicalize a configuration type.
# Supply the specified configuration type as an argument.
# If it is invalid, we print an error message on stderr and exit with code 1.
# Otherwise, we print the canonical config type on stdout and succeed.
# You can get the latest version of this script from:
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
# This file is supposed to be the same for all GNU packages
# and recognize all the CPU types, system types and aliases
# that are meaningful with *any* GNU software.
# Each package is responsible for reporting which valid configurations
# it does not support. The user should be able to distinguish
src/subversion/build/generator/gen_base.py view on Meta::CPAN
import configparser
except ImportError:
# Python <3.0
import ConfigParser as configparser
import generator.swig
import getversion
def _warning(msg):
sys.stderr.write("WARNING: %s\n" % msg)
def _error(msg):
sys.stderr.write("ERROR: %s\n" % msg)
sys.exit(1)
class GeneratorBase:
#
# Derived classes should define a class attribute named _extension_map.
# This attribute should be a dictionary of the form:
# { (target-type, file-type): file-extension ...}
#
# where: target-type is 'exe', 'lib', ...
src/subversion/build/generator/gen_win.py view on Meta::CPAN
def _find_apr(self):
"Find the APR library and version"
minimal_apr_version = (0, 9, 0)
version_file_path = os.path.join(self.apr_path, 'include',
'apr_version.h')
if not os.path.exists(version_file_path):
sys.stderr.write("ERROR: '%s' not found.\n" % version_file_path);
sys.stderr.write("Use '--with-apr' option to configure APR location.\n");
sys.exit(1)
fp = open(version_file_path)
txt = fp.read()
fp.close()
vermatch = re.search(r'^\s*#define\s+APR_MAJOR_VERSION\s+(\d+)', txt, re.M)
major = int(vermatch.group(1))
vermatch = re.search(r'^\s*#define\s+APR_MINOR_VERSION\s+(\d+)', txt, re.M)
src/subversion/build/generator/gen_win.py view on Meta::CPAN
suffix = ''
if major > 0:
suffix = '-%d' % major
if self.static_apr:
self.apr_lib = 'apr%s.lib' % suffix
else:
self.apr_lib = 'libapr%s.lib' % suffix
if version < minimal_apr_version:
sys.stderr.write("ERROR: apr %s or higher is required "
"(%s found)\n" % (
'.'.join(str(v) for v in minimal_apr_version),
self.apr_version))
sys.exit(1)
else:
print('Found apr %s' % self.apr_version)
def _find_apr_util(self):
"Find the APR-util library and version"
minimal_aprutil_version = (0, 9, 0)
version_file_path = os.path.join(self.apr_util_path, 'include',
'apu_version.h')
if not os.path.exists(version_file_path):
sys.stderr.write("ERROR: '%s' not found.\n" % version_file_path);
sys.stderr.write("Use '--with-apr-util' option to configure APR-Util location.\n");
sys.exit(1)
fp = open(version_file_path)
txt = fp.read()
fp.close()
vermatch = re.search(r'^\s*#define\s+APU_MAJOR_VERSION\s+(\d+)', txt, re.M)
major = int(vermatch.group(1))
vermatch = re.search(r'^\s*#define\s+APU_MINOR_VERSION\s+(\d+)', txt, re.M)
src/subversion/build/generator/gen_win.py view on Meta::CPAN
suffix = ''
if major > 0:
suffix = '-%d' % major
if self.static_apr:
self.aprutil_lib = 'aprutil%s.lib' % suffix
else:
self.aprutil_lib = 'libaprutil%s.lib' % suffix
if version < minimal_aprutil_version:
sys.stderr.write("ERROR: aprutil %s or higher is required "
"(%s found)\n" % (
'.'.join(str(v) for v in minimal_aprutil_version),
self.aprutil_version))
sys.exit(1)
else:
print('Found aprutil %s' % self.aprutil_version)
def _find_sqlite(self):
"Find the Sqlite library and version"
minimal_sqlite_version = (3, 7, 12)
header_file = os.path.join(self.sqlite_path, 'inc', 'sqlite3.h')
# First check for compiled version of SQLite.
if os.path.exists(header_file):
# Compiled SQLite seems found, check for sqlite3.lib file.
lib_file = os.path.join(self.sqlite_path, 'lib', 'sqlite3.lib')
if not os.path.exists(lib_file):
sys.stderr.write("ERROR: '%s' not found.\n" % lib_file)
sys.stderr.write("Use '--with-sqlite' option to configure sqlite location.\n");
sys.exit(1)
self.sqlite_inline = False
else:
# Compiled SQLite not found. Try amalgamation version.
amalg_file = os.path.join(self.sqlite_path, 'sqlite3.c')
if not os.path.exists(amalg_file):
sys.stderr.write("ERROR: SQLite not found in '%s' directory.\n" % self.sqlite_path)
sys.stderr.write("Use '--with-sqlite' option to configure sqlite location.\n");
sys.exit(1)
header_file = os.path.join(self.sqlite_path, 'sqlite3.h')
self.sqlite_inline = True
fp = open(header_file)
txt = fp.read()
fp.close()
vermatch = re.search(r'^\s*#define\s+SQLITE_VERSION\s+"(\d+)\.(\d+)\.(\d+)(?:\.(\d))?"', txt, re.M)
version = vermatch.groups()
# Sqlite doesn't add patch numbers for their ordinary releases
if not version[3]:
version = version[0:3]
version = tuple(map(int, version))
self.sqlite_version = '.'.join(str(v) for v in version)
if version < minimal_sqlite_version:
sys.stderr.write("ERROR: sqlite %s or higher is required "
"(%s found)\n" % (
'.'.join(str(v) for v in minimal_sqlite_version),
self.sqlite_version))
sys.exit(1)
else:
print('Found SQLite %s' % self.sqlite_version)
def _find_zlib(self):
"Find the ZLib library and version"
src/subversion/build/generator/util/executable.py view on Meta::CPAN
# Check that cmd is in PATH (otherwise we'd get a generic OSError later)
import distutils.spawn
if isinstance(cmd, str):
cmdname = cmd
elif isinstance(cmd, list):
cmdname = cmd[0]
if distutils.spawn.find_executable(cmdname) is None:
return None
# Run it
(output, empty_stderr) = subprocess.Popen(cmd, stdout=subprocess.PIPE, \
stderr=subprocess.STDOUT).communicate()
if strip:
return output.strip()
else:
return output
def run(cmd):
"""Run a command"""
exit_code = os.system(cmd)
assert(not exit_code)
src/subversion/build/getversion.py view on Meta::CPAN
sys.stdout.write("%d.%d.%d" % (major, minor, micro))
extractors = {
'SVN' : svn_extractor,
# 'SQLITE' : sqlite_extractor, # not used
}
def usage_and_exit(msg):
if msg:
sys.stderr.write("%s\n\n" % msg)
sys.stderr.write("usage: %s [SVN|SQLITE] [header_file]\n" % \
os.path.basename(sys.argv[0]))
sys.stderr.flush()
sys.exit(1)
if __name__ == '__main__':
if len(sys.argv) == 3:
extractor = extractors[sys.argv[1]]
include_file = sys.argv[2]
else:
usage_and_exit("Incorrect number of arguments")
src/subversion/build/ltmain.sh view on Meta::CPAN
}
return str;
}
void
lt_debugprintf (const char *file, int line, const char *fmt, ...)
{
va_list args;
if (lt_debug)
{
(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
va_start (args, fmt);
(void) vfprintf (stderr, fmt, args);
va_end (args);
}
}
static void
lt_error_core (int exit_status, const char *file,
int line, const char *mode,
const char *message, va_list ap)
{
fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
vfprintf (stderr, message, ap);
fprintf (stderr, ".\n");
if (exit_status >= 0)
exit (exit_status);
}
void
lt_fatal (const char *file, int line, const char *message, ...)
{
va_list ap;
va_start (ap, message);
src/subversion/build/run_tests.py view on Meta::CPAN
server_minor_version=None, verbose=None,
cleanup=None, enable_sasl=None, parallel=None, config_file=None,
fsfs_sharding=None, fsfs_packing=None,
list_tests=None, svn_bin=None, mode_filter=None,
milestone_filter=None, set_log_level=None, ssl_cert=None,
http_proxy=None):
'''Construct a TestHarness instance.
ABS_SRCDIR and ABS_BUILDDIR are the source and build directories.
LOGFILE is the name of the log file. If LOGFILE is None, let tests
print their output to stdout and stderr, and don't print a summary
at the end (since there's no log file to analyze).
BASE_URL is the base url for DAV tests.
FS_TYPE is the FS type for repository creation.
HTTP_LIBRARY is the HTTP library for DAV-based communications.
SERVER_MINOR_VERSION is the minor version of the server being tested.
SVN_BIN is the path where the svn binaries are installed.
MODE_FILTER restricts the TestHarness to tests with the expected mode
XFail, Skip, Pass, or All tests (default). MILESTONE_FILTER is a
string representation of a valid regular expression pattern; when used
in conjunction with LIST_TESTS, the only tests that are listed are
src/subversion/build/run_tests.py view on Meta::CPAN
self.logfile = logfile
self.faillogfile = faillogfile
self.base_url = base_url
self.fs_type = fs_type
self.http_library = http_library
self.server_minor_version = server_minor_version
# If you change the below condition then change in
# ../subversion/tests/cmdline/svntest/main.py too.
if server_minor_version is not None:
if int(server_minor_version) not in range(3, 1+SVN_VER_MINOR):
sys.stderr.write("Test harness only supports server minor versions 3-%d\n"
% SVN_VER_MINOR)
sys.exit(1)
self.verbose = verbose
self.cleanup = cleanup
self.enable_sasl = enable_sasl
self.parallel = parallel
self.fsfs_sharding = fsfs_sharding
self.fsfs_packing = fsfs_packing
if fsfs_packing is not None and fsfs_sharding is None:
raise Exception('--fsfs-packing requires --fsfs-sharding')
src/subversion/build/run_tests.py view on Meta::CPAN
return
dots = (completed * dot_count) / total
if dots > dot_count:
dots = dot_count
dots_to_write = dots - self.dots_written
os.write(sys.stdout.fileno(), '.' * dots_to_write)
self.dots_written = dots
tests_completed = 0
prog = subprocess.Popen(cmdline, stdout=subprocess.PIPE,
stderr=self.log)
line = prog.stdout.readline()
while line:
if sys.platform == 'win32':
# Remove CRs inserted because we parse the output as binary.
line = line.replace('\r', '')
# If using --log-to-stdout self.log in None.
if self.log:
self.log.write(line)
src/subversion/build/run_tests.py view on Meta::CPAN
if self.ssl_cert is not None:
svntest.main.options.ssl_cert = self.ssl_cert
if self.http_proxy is not None:
svntest.main.options.http_proxy = self.http_proxy
svntest.main.options.srcdir = self.srcdir
# setup the output pipes
if self.log:
sys.stdout.flush()
sys.stderr.flush()
self.log.flush()
old_stdout = os.dup(sys.stdout.fileno())
old_stderr = os.dup(sys.stderr.fileno())
os.dup2(self.log.fileno(), sys.stdout.fileno())
os.dup2(self.log.fileno(), sys.stderr.fileno())
# These have to be class-scoped for use in the progress_func()
self.dots_written = 0
self.progress_lock = threading.Lock()
def progress_func(completed, total):
"""Report test suite progress. Can be called from multiple threads
in parallel mode."""
if not self.log:
return
dots = (completed * dot_count) / total
src/subversion/build/run_tests.py view on Meta::CPAN
test_selection=test_selection)
except svntest.Failure:
if self.log:
os.write(old_stdout, '.' * dot_count)
failed = True
# restore some values
sys.path = old_path
if self.log:
sys.stdout.flush()
sys.stderr.flush()
os.dup2(old_stdout, sys.stdout.fileno())
os.dup2(old_stderr, sys.stderr.fileno())
os.close(old_stdout)
os.close(old_stderr)
return failed
def _run_test(self, prog, test_nr, total_tests):
"Run a single test. Return the test's exit code."
if self.log:
log = self.log
else:
log = sys.stdout
src/subversion/build/transform_config_hw.py view on Meta::CPAN
import os
import re
import sys
import platform
def usage_and_exit(msg):
if msg:
sys.stderr.write('%s\n\n' % msg)
sys.stderr.write(
'USAGE: %s ARCHITECTURE TEMPLATE_FILE [OUTPUT_FILE]\n'
' stdout will be used if OUTPUT_FILE is not provided.\n'
% os.path.basename(sys.argv[0]))
sys.stderr.flush()
sys.exit(1)
_wincpu_map = {
'x86': 'x86',
'x64': 'x86_64',
'amd64': 'x86_64',
'x86_64': 'x86_64',
'ia64': 'ia64',
'powerpc': 'powerpc',
src/subversion/build/transform_sql.py view on Meta::CPAN
def methodcaller(method, *args, **kwargs):
return lambda x: getattr(x, method)(*args, **kwargs)
operator.methodcaller = methodcaller
del methodcaller
DEFINE_END = ' ""\n\n'
def usage_and_exit(msg):
if msg:
sys.stderr.write('%s\n\n' % msg)
sys.stderr.write(
'USAGE: %s SQLITE_FILE [OUTPUT_FILE]\n'
' stdout will be used if OUTPUT_FILE is not provided.\n'
% os.path.basename(sys.argv[0]))
sys.stderr.flush()
sys.exit(1)
class Processor(object):
re_comments = re.compile(r'/\*.*?\*/', re.MULTILINE|re.DOTALL)
# a few SQL comments that act as directives for this transform system
re_format = re.compile('-- *format: *([0-9]+)')
re_statement = re.compile('-- *STMT_([A-Z_0-9]+)( +\(([^\)]*)\))?')
re_include = re.compile('-- *include: *([-a-z]+)')
src/subversion/build/win32/make_dist.py view on Meta::CPAN
# The script directory and the source base directory
_scriptdir = os.path.dirname(sys.argv[0])
_srcdir = os.path.join(_scriptdir, '..', '..')
_distname = None
_distdir = None
_readme = None
_stdout = sys.stdout
_stderr = sys.stderr
_logname = os.path.abspath(os.path.join(_scriptdir, 'make_dist.log'))
_logfile = open(_logname, 'w')
sys.stdout = _logfile
sys.stderr = _logfile
def _exit(code=0):
if code:
_stderr.write('make_dist: Exit %d\n' % (code,))
sys.exit(code)
# Action classes
class MissingMethodImpl:
pass
class Action:
def run(self, dir, cfg):
src/subversion/build/win32/make_dist.py view on Meta::CPAN
for module in ('Client', 'Core', 'Delta', 'Fs', 'Ra', 'Repos', 'Wc'):
_disttree['perl/site/lib/auto/SVN/_' + module] = (
File('%(binddir)s/swig/perl/native/_' + module + '.dll'),
File('%(binddir)s/swig/perl/native/_' + module + '.pdb'))
def _system(command):
def reopen_log():
global _logfile
_logfile = open(_logname, 'a')
sys.stdout = _logfile
sys.stderr = _logfile
try:
_logfile.close()
sys.stdout = _stdout
sys.stderr = _stderr
os.system('"%s >>%s 2>&1"' % (command, _logname))
except:
reopen_log()
raise
else:
reopen_log()
def _read_config():
# Read make_dist.conf first. Fill in the default package locations.
src/subversion/build/win32/make_dist.py view on Meta::CPAN
'@apr-iconv':
os.path.abspath(os.path.join(_srcdir, 'apr-iconv')),
'@apr-util':
os.path.abspath(os.path.join(_srcdir, 'apr-util')),
}
cfg = configparser.ConfigParser(path_defaults)
try:
cfg.readfp(open(os.path.join(_scriptdir, 'make_dist.conf'), 'r'))
except:
_stderr.write('Unable to open and read make_dist.conf\n')
_exit(1)
# Read the options config generated by gen-make.py
optcfg = configparser.ConfigParser()
optcfg.readfp(open(os.path.join(_srcdir, 'gen-make.opts'), 'r'))
# Move the runtime options into the DEFAULT section
for opt in optcfg.options('options'):
if not opt[:7] == '--with-':
continue
src/subversion/build/win32/make_dist.py view on Meta::CPAN
_stdout.write('make_dist: Creating ruby gem\n')
gem_script = os.path.join(_scriptdir, 'make_gem.rb')
rubycmd = '"%s" "%s" --output-dir="%s"' % (cfg.get('tools', 'ruby'),
gem_script, _distdir)
rubycmd += ' "' + distdir + '\\README.txt"'
rubycmd += ' "' + distdir + '\\ruby"'
rubycmd += ' "' + distdir + '\\licenses"'
rubycmd += ' "' + distdir + '\\share"'
_system(rubycmd)
except:
traceback.print_exc(None, _stderr)
_exit(1)
if __name__ == '__main__':
opts, args = my_getopt(sys.argv[1:], '', ['readme='])
if len(args) != 2 or len(opts) > 1:
_stderr.write('Usage: make_dist.py [--readme=<file>] <distname> <distdir>\n')
_exit(2)
_distname, _distdir = args
if len(opts) != 0:
_readme = opts[0][1]
cfg = _read_config()
_make_dist(cfg)
src/subversion/configure view on Meta::CPAN
else
as_fn_arith ()
{
as_val=`expr "$@" || test $? -eq 1`
}
fi # as_fn_arith
# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
as_status=$1; test $as_status -eq 0 && as_status=1
if test "$4"; then
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
$as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
fi
$as_echo "$as_me: error: $2" >&2
src/subversion/configure view on Meta::CPAN
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
sed '10a\
... rest of stderr output deleted ...
10q' conftest.err >conftest.er1
cat conftest.er1 >&5
fi
rm -f conftest.er1 conftest.err
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
done
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
src/subversion/configure view on Meta::CPAN
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
sed '10a\
... rest of stderr output deleted ...
10q' conftest.err >conftest.er1
cat conftest.er1 >&5
fi
rm -f conftest.er1 conftest.err
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
done
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
src/subversion/configure view on Meta::CPAN
#
# `ac_cv_env_foo' variables (set or unset) will be overridden when
# loading this file, other *unset* `ac_cv_foo' will be assigned the
# following values.
_ACEOF
# The following way of writing the cache mishandles newlines in values,
# but we know of no workaround that is simple, portable, and efficient.
# So, we kill variables containing newlines.
# Ultrix sh set writes to stderr and can't be redirected directly,
# and sets the high bit in the cache file unless we assign to the vars.
(
for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
eval ac_val=\$$ac_var
case $ac_val in #(
*${as_nl}*)
case $ac_var in #(
*_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
esac
src/subversion/configure view on Meta::CPAN
export LC_ALL
LANGUAGE=C
export LANGUAGE
# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
as_status=$1; test $as_status -eq 0 && as_status=1
if test "$4"; then
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
$as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
fi
$as_echo "$as_me: error: $2" >&2
src/subversion/doc/doxygen.conf view on Meta::CPAN
# doxygen can produce. The string should contain the $file, $line, and $text
# tags, which will be replaced by the file and line number from which the
# warning originated and the warning text. Optionally the format may contain
# $version, which will be replaced by the version of the file (if it could
# be obtained via FILE_VERSION_FILTER)
WARN_FORMAT = "$file:$line: $text "
# The WARN_LOGFILE tag can be used to specify a file to which warning
# and error messages should be written. If left blank the output is written
# to stderr.
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
# The INPUT tag can be used to specify the files and/or directories that contain
# documented source files. You may enter file names like "myfile.cpp" or
# directories like "/usr/src/myproject". Separate the files or directories
src/subversion/subversion/bindings/ctypes-python/csvn/core/__init__.py view on Meta::CPAN
TRUE = 1
FALSE = 0
SVN_DIRENT_ALL = -1
SVN_INVALID_REVNUM = -1
SVN_IGNORED_REVNUM = -1
SVN_INVALID_FILESIZE = -1
SVN_RA_SVN_UNSPECIFIED_NUMBER = -1
# Convert the standard files
stdout = PyFile_AsFile(sys.stdout)
stderr = PyFile_AsFile(sys.stderr)
stdin = PyFile_AsFile(sys.stdin)
def svn_pool_create(pool):
return svn_pool_create_ex(pool, NULL)
def svn_pool_destroy(pool):
return apr_pool_destroy(pool)
def svn_pool_clear(pool):
return apr_pool_clear(pool)
src/subversion/subversion/bindings/ctypes-python/csvn/wc.py view on Meta::CPAN
self._progress_func = progress_func
def _progress_func_wrapper(self, progress, total, baton, pool):
if self._progress_func:
self._progress_func(progress, total)
def diff(self, path1="", revnum1=None, path2=None, revnum2=None,
diff_options=[], recurse=True, ignore_ancestry=True,
no_diff_deleted=False, ignore_content_type=False,
header_encoding="", outfile = sys.stdout, errfile = sys.stderr):
"""Produce svn diff output that describes the difference between
PATH1 at REVISION1 and PATH2 at REVISION2.
Keyword arguments:
path1 -- path to compare in diff (defaults to working copy root)
revnum1 -- revision to look at path1 at (defaults to base revision)
path2 -- second path to compare in diff (defaults to path1)
revnum2 -- revision to look at path2 at (defaults to working revision)
diff_options -- list of options to be passed to the diff process
(defaults to an empty list)
src/subversion/subversion/bindings/ctypes-python/csvn/wc.py view on Meta::CPAN
relatedness before being diffed (default True)
no_diff_deleted -- if True then deleted items will not be included in
the diff (default False)
ignore_content_type -- if True diffs will be generated for binary file
types (default False)
header_encoding -- generated headers will be encoded using this
encoding (defaults to "")
outfile -- file to save output to, which can be a file like object
(defaults to sys.stdout)
errfile -- file to save output to, which can be a file like object
(defaults to sys.stderr)"""
diff_options = self._build_path_list(diff_options)
rev1 = svn_opt_revision_t()
if revnum1:
rev1.kind = svn_opt_revision_number
rev1.value.number = revnum1
else:
rev1.kind = svn_opt_revision_base
src/subversion/subversion/bindings/ctypes-python/examples/example.py view on Meta::CPAN
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import csvn.core
from csvn.repos import *
from csvn.auth import User
import os
csvn.core.svn_cmdline_init("", csvn.core.stderr)
if os.path.exists("/tmp/test-repos"):
svn_repos_delete("/tmp/test-repos", Pool())
user = User(username="joecommitter")
repos = LocalRepository("/tmp/test-repos", user=user, create=True)
print("Repos UUID: %s" % repos.uuid())
# Create a new transaction
txn = repos.txn()
src/subversion/subversion/bindings/ctypes-python/examples/log.py view on Meta::CPAN
default=False)
parser.add_option("-r", "", dest="rev",
help="revision range")
(options, args) = parser.parse_args()
if len(args) != 1:
parser.print_help()
sys.exit(1)
csvn.core.svn_cmdline_init("", csvn.core.stderr)
repos_url = args[0]
revs = options.rev
if revs and ":" in revs:
[start_rev, end_rev] = revs.split(":")
elif revs:
start_rev = revs
end_rev = revs
else:
start_rev = 1
end_rev = "HEAD"
src/subversion/subversion/bindings/ctypes-python/examples/mucc.py view on Meta::CPAN
for line in f:
args.append(line.strip())
if not args:
parser.print_help()
sys.exit(1)
# Initialize variables
root_url = options.root_url
actions = []
svn_cmdline_init("", stderr)
pool = Pool()
action = None
if root_url:
anchor = RepositoryURI(root_url)
else:
anchor = None
states = None
ancestor = None
# A list of the arguments accepted by each command
src/subversion/subversion/bindings/ctypes-python/examples/trunkify.py view on Meta::CPAN
if options.directory:
new_dir_name = options.directory
if options.message:
commit_message = options.message
elif options.file:
commit_message = open(options.file).read()
else:
commit_message = "Move project into new directory '%s'." % new_dir_name
svn_cmdline_init("", stderr)
s = RemoteRepository(repos_url, user=User(username=options.username))
txn = s.txn()
for name in s.list("").keys():
txn.delete(name)
txn.copy(src_path="", dest_path=new_dir_name)
txn.commit(commit_message)
src/subversion/subversion/bindings/ctypes-python/test/setup_path.py view on Meta::CPAN
# $ python -i tests/setup_path.py
# to start an interactive interpreter.
import sys
import os
src_ctypes_python_tests_dir = os.path.dirname(os.path.dirname(__file__))
sys.path[0:0] = [ src_ctypes_python_tests_dir ]
import csvn.core
csvn.core.svn_cmdline_init("", csvn.core.stderr)
src/subversion/subversion/bindings/javahl/native/JNIUtil.cpp view on Meta::CPAN
apr_status_t status;
/* Initialize the APR subsystem, and register an atexit() function
* to Uninitialize that subsystem at program exit. */
status = apr_initialize();
if (status)
{
if (stderr)
{
char buf[1024];
apr_strerror(status, buf, sizeof(buf) - 1);
fprintf(stderr,
"%s: error: cannot initialize APR: %s\n",
"svnjavahl", buf);
}
return FALSE;
}
/* This has to happen before any pools are created. */
if ((err = svn_dso_initialize2()))
{
if (stderr && err->message)
fprintf(stderr, "%s", err->message);
svn_error_clear(err);
return FALSE;
}
if (0 > atexit(apr_terminate))
{
if (stderr)
fprintf(stderr,
"%s: error: atexit registration failed\n",
"svnjavahl");
return FALSE;
}
/* Create our top-level pool. */
g_pool = svn_pool_create(NULL);
apr_allocator_t* allocator = apr_pool_allocator_get(g_pool);
src/subversion/subversion/bindings/javahl/native/JNIUtil.cpp view on Meta::CPAN
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);
src/subversion/subversion/bindings/javahl/native/JNIUtil.cpp view on Meta::CPAN
#if defined(WIN32) || defined(__CYGWIN__)
/* See http://svn.apache.org/repos/asf/subversion/trunk/notes/asp-dot-net-hack.txt */
/* ### This code really only needs to be invoked by consumers of
### the libsvn_wc library, which basically means SVNClient. */
if (getenv("SVN_ASP_DOT_NET_HACK"))
{
err = svn_wc_set_adm_dir("_svn", g_pool);
if (err)
{
if (stderr)
{
fprintf(stderr,
"%s: error: SVN_ASP_DOT_NET_HACK failed: %s\n",
"svnjavahl", err->message);
}
svn_error_clear(err);
return FALSE;
}
}
#endif
svn_error_set_malfunction_handler(svn_error_raise_on_malfunction);
src/subversion/subversion/bindings/swig/core.i view on Meta::CPAN
apr_status_t apr_initialize(void);
void apr_terminate(void);
apr_status_t apr_time_ansi_put(apr_time_t *result, time_t input);
void apr_pool_destroy(apr_pool_t *p);
void apr_pool_clear(apr_pool_t *p);
apr_status_t apr_file_open_stdout (apr_file_t **out, apr_pool_t *pool);
apr_status_t apr_file_open_stderr (apr_file_t **out, apr_pool_t *pool);
/* Allow parsing of apr_errno.h without parsing apr.h. */
#define APR_DECLARE(x) x
/* Not wrapped, use svn_strerror instead. */
%ignore apr_strerror;
/* Wrap the APR status and error codes. */
/* Sigh, or not. This would mean actually having access to apr_errno.h at
wrapper generation time, which, when rolling tarballs, the include paths
are not currently set up to give us. FIXME. So, instead, we replicate
one important typedef here instead.
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_apr_file_open_stderr) {
{
apr_file_t **arg1 = (apr_file_t **) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
apr_file_t *temp1 ;
int argvi = 0;
apr_status_t result;
dXSARGS;
{
_global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 0) || (items > 1)) {
SWIG_croak("Usage: apr_file_open_stderr(pool);");
}
if (items > 0) {
}
{
result = (apr_status_t)apr_file_open_stderr(arg1,arg2);
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
{
if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj(*arg1, SWIGTYPE_p_apr_file_t, 0); argvi++ ;
}
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_stream_for_stderr) {
{
svn_stream_t **arg1 = (svn_stream_t **) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
svn_stream_t *temp1 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 0) || (items > 1)) {
SWIG_croak("Usage: svn_stream_for_stderr(pool);");
}
if (items > 0) {
}
{
result = (svn_error_t *)svn_stream_for_stderr(arg1,arg2);
}
{
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
{ "SVN::_Core::current_pool", MAGIC_CLASS _wrap_current_pool_set, MAGIC_CLASS _wrap_current_pool_get,&SWIGTYPE_p_apr_pool_t },
{0,0,0,0}
};
static swig_command_info swig_commands[] = {
{"SVN::_Core::apr_initialize", _wrap_apr_initialize},
{"SVN::_Core::apr_terminate", _wrap_apr_terminate},
{"SVN::_Core::apr_time_ansi_put", _wrap_apr_time_ansi_put},
{"SVN::_Core::apr_pool_destroy", _wrap_apr_pool_destroy},
{"SVN::_Core::apr_pool_clear", _wrap_apr_pool_clear},
{"SVN::_Core::apr_file_open_stdout", _wrap_apr_file_open_stdout},
{"SVN::_Core::apr_file_open_stderr", _wrap_apr_file_open_stderr},
{"SVN::_Core::svn_time_to_cstring", _wrap_svn_time_to_cstring},
{"SVN::_Core::svn_time_from_cstring", _wrap_svn_time_from_cstring},
{"SVN::_Core::svn_time_to_human_cstring", _wrap_svn_time_to_human_cstring},
{"SVN::_Core::svn_parse_date", _wrap_svn_parse_date},
{"SVN::_Core::svn_sleep_for_timestamps", _wrap_svn_sleep_for_timestamps},
{"SVN::_Core::svn_error_t_apr_err_set", _wrap_svn_error_t_apr_err_set},
{"SVN::_Core::svn_error_t_apr_err_get", _wrap_svn_error_t_apr_err_get},
{"SVN::_Core::svn_error_t_message_get", _wrap_svn_error_t_message_get},
{"SVN::_Core::svn_error_t_child_set", _wrap_svn_error_t_child_set},
{"SVN::_Core::svn_error_t_child_get", _wrap_svn_error_t_child_get},
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
{"SVN::_Core::svn_stream_set_mark", _wrap_svn_stream_set_mark},
{"SVN::_Core::svn_stream_set_seek", _wrap_svn_stream_set_seek},
{"SVN::_Core::svn_stream_empty", _wrap_svn_stream_empty},
{"SVN::_Core::svn_stream_disown", _wrap_svn_stream_disown},
{"SVN::_Core::svn_stream_open_readonly", _wrap_svn_stream_open_readonly},
{"SVN::_Core::svn_stream_open_writable", _wrap_svn_stream_open_writable},
{"SVN::_Core::svn_stream_open_unique", _wrap_svn_stream_open_unique},
{"SVN::_Core::svn_stream_from_aprfile2", _wrap_svn_stream_from_aprfile2},
{"SVN::_Core::svn_stream_from_aprfile", _wrap_svn_stream_from_aprfile},
{"SVN::_Core::svn_stream_for_stdin", _wrap_svn_stream_for_stdin},
{"SVN::_Core::svn_stream_for_stderr", _wrap_svn_stream_for_stderr},
{"SVN::_Core::svn_stream_for_stdout", _wrap_svn_stream_for_stdout},
{"SVN::_Core::svn_stream_from_stringbuf", _wrap_svn_stream_from_stringbuf},
{"SVN::_Core::svn_stream_from_string", _wrap_svn_stream_from_string},
{"SVN::_Core::svn_stream_buffered", _wrap_svn_stream_buffered},
{"SVN::_Core::svn_stream_compressed", _wrap_svn_stream_compressed},
{"SVN::_Core::svn_stream_checksummed2", _wrap_svn_stream_checksummed2},
{"SVN::_Core::svn_stream_read", _wrap_svn_stream_read},
{"SVN::_Core::svn_stream_skip", _wrap_svn_stream_skip},
{"SVN::_Core::svn_stream_write", _wrap_svn_stream_write},
{"SVN::_Core::svn_stream_close", _wrap_svn_stream_close},
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_apr_file_open_stderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
apr_file_t **arg1 = (apr_file_t **) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
apr_file_t *temp1 ;
PyObject * obj0 = 0 ;
apr_status_t result;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"|O:apr_file_open_stderr",&obj0)) SWIG_fail;
if (obj0) {
/* Verify that the user supplied a valid pool */
if (obj0 != Py_None && obj0 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj0);
SWIG_arg_fail(svn_argnum_obj0);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (apr_status_t)apr_file_open_stderr(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_From_long((long)(result));
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_apr_file_t,
_global_py_pool, args))
;
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_stream_for_stderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_stream_t **arg1 = (svn_stream_t **) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_stream_t *temp1 ;
PyObject * obj0 = 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;
arg2 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"|O:svn_stream_for_stderr",&obj0)) SWIG_fail;
if (obj0) {
/* Verify that the user supplied a valid pool */
if (obj0 != Py_None && obj0 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj0);
SWIG_arg_fail(svn_argnum_obj0);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_stream_for_stderr(arg1,arg2);
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
static PyMethodDef SwigMethods[] = {
{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
{ (char *)"apr_initialize", _wrap_apr_initialize, METH_VARARGS, (char *)"apr_initialize() -> apr_status_t"},
{ (char *)"apr_terminate", _wrap_apr_terminate, METH_VARARGS, (char *)"apr_terminate()"},
{ (char *)"apr_time_ansi_put", _wrap_apr_time_ansi_put, METH_VARARGS, (char *)"apr_time_ansi_put(time_t input) -> apr_status_t"},
{ (char *)"apr_pool_destroy", _wrap_apr_pool_destroy, METH_VARARGS, (char *)"apr_pool_destroy(apr_pool_t p)"},
{ (char *)"apr_pool_clear", _wrap_apr_pool_clear, METH_VARARGS, (char *)"apr_pool_clear(apr_pool_t p)"},
{ (char *)"apr_file_open_stdout", _wrap_apr_file_open_stdout, METH_VARARGS, (char *)"apr_file_open_stdout(apr_pool_t pool) -> apr_status_t"},
{ (char *)"apr_file_open_stderr", _wrap_apr_file_open_stderr, METH_VARARGS, (char *)"apr_file_open_stderr(apr_pool_t pool) -> apr_status_t"},
{ (char *)"svn_time_to_cstring", _wrap_svn_time_to_cstring, METH_VARARGS, (char *)"svn_time_to_cstring(apr_time_t when, apr_pool_t pool) -> char const *"},
{ (char *)"svn_time_from_cstring", _wrap_svn_time_from_cstring, METH_VARARGS, (char *)"svn_time_from_cstring(char const * data, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_time_to_human_cstring", _wrap_svn_time_to_human_cstring, METH_VARARGS, (char *)"svn_time_to_human_cstring(apr_time_t when, apr_pool_t pool) -> char const *"},
{ (char *)"svn_parse_date", _wrap_svn_parse_date, METH_VARARGS, (char *)"svn_parse_date(char const * text, apr_time_t now, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_sleep_for_timestamps", _wrap_svn_sleep_for_timestamps, METH_VARARGS, (char *)"svn_sleep_for_timestamps()"},
{ (char *)"svn_error_t_apr_err_set", _wrap_svn_error_t_apr_err_set, METH_VARARGS, (char *)"svn_error_t_apr_err_set(svn_error_t self, apr_status_t apr_err)"},
{ (char *)"svn_error_t_apr_err_get", _wrap_svn_error_t_apr_err_get, METH_VARARGS, (char *)"svn_error_t_apr_err_get(svn_error_t self) -> apr_status_t"},
{ (char *)"svn_error_t_message_get", _wrap_svn_error_t_message_get, METH_VARARGS, (char *)"svn_error_t_message_get(svn_error_t self) -> char const *"},
{ (char *)"svn_error_t_child_set", _wrap_svn_error_t_child_set, METH_VARARGS, (char *)"svn_error_t_child_set(svn_error_t self, svn_error_t child)"},
{ (char *)"svn_error_t_child_get", _wrap_svn_error_t_child_get, METH_VARARGS, (char *)"svn_error_t_child_get(svn_error_t self) -> svn_error_t"},
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
{ (char *)"svn_stream_set_mark", _wrap_svn_stream_set_mark, METH_VARARGS, (char *)"svn_stream_set_mark(svn_stream_t * stream, svn_stream_mark_fn_t mark_fn)"},
{ (char *)"svn_stream_set_seek", _wrap_svn_stream_set_seek, METH_VARARGS, (char *)"svn_stream_set_seek(svn_stream_t * stream, svn_stream_seek_fn_t seek_fn)"},
{ (char *)"svn_stream_empty", _wrap_svn_stream_empty, METH_VARARGS, (char *)"svn_stream_empty(apr_pool_t pool) -> svn_stream_t *"},
{ (char *)"svn_stream_disown", _wrap_svn_stream_disown, METH_VARARGS, (char *)"svn_stream_disown(svn_stream_t * stream, apr_pool_t pool) -> svn_stream_t *"},
{ (char *)"svn_stream_open_readonly", _wrap_svn_stream_open_readonly, METH_VARARGS, (char *)"svn_stream_open_readonly(char const * path, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
{ (char *)"svn_stream_open_writable", _wrap_svn_stream_open_writable, METH_VARARGS, (char *)"svn_stream_open_writable(char const * path, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
{ (char *)"svn_stream_open_unique", _wrap_svn_stream_open_unique, METH_VARARGS, (char *)"svn_stream_open_unique(char const * dirpath, svn_io_file_del_t delete_when, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
{ (char *)"svn_stream_from_aprfile2", _wrap_svn_stream_from_aprfile2, METH_VARARGS, (char *)"svn_stream_from_aprfile2(apr_file_t file, svn_boolean_t disown, apr_pool_t pool) -> svn_stream_t *"},
{ (char *)"svn_stream_from_aprfile", _wrap_svn_stream_from_aprfile, METH_VARARGS, (char *)"svn_stream_from_aprfile(apr_file_t file, apr_pool_t pool) -> svn_stream_t *"},
{ (char *)"svn_stream_for_stdin", _wrap_svn_stream_for_stdin, METH_VARARGS, (char *)"svn_stream_for_stdin(apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_stream_for_stderr", _wrap_svn_stream_for_stderr, METH_VARARGS, (char *)"svn_stream_for_stderr(apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_stream_for_stdout", _wrap_svn_stream_for_stdout, METH_VARARGS, (char *)"svn_stream_for_stdout(apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_stream_from_stringbuf", _wrap_svn_stream_from_stringbuf, METH_VARARGS, (char *)"svn_stream_from_stringbuf(svn_stringbuf_t * str, apr_pool_t pool) -> svn_stream_t *"},
{ (char *)"svn_stream_from_string", _wrap_svn_stream_from_string, METH_VARARGS, (char *)"svn_stream_from_string(svn_string_t const * str, apr_pool_t pool) -> svn_stream_t *"},
{ (char *)"svn_stream_buffered", _wrap_svn_stream_buffered, METH_VARARGS, (char *)"svn_stream_buffered(apr_pool_t result_pool) -> svn_stream_t *"},
{ (char *)"svn_stream_compressed", _wrap_svn_stream_compressed, METH_VARARGS, (char *)"svn_stream_compressed(svn_stream_t * stream, apr_pool_t pool) -> svn_stream_t *"},
{ (char *)"svn_stream_checksummed2", _wrap_svn_stream_checksummed2, METH_VARARGS, (char *)"\n"
"svn_stream_checksummed2(svn_stream_t * stream, svn_checksum_kind_t checksum_kind, svn_boolean_t read_all, \n"
" apr_pool_t pool) -> svn_stream_t *\n"
""},
{ (char *)"svn_stream_read", _wrap_svn_stream_read, METH_VARARGS, (char *)"svn_stream_read(svn_stream_t * stream, char * buffer) -> svn_error_t"},
src/subversion/subversion/bindings/swig/python/core.py view on Meta::CPAN
return _core.apr_pool_destroy(*args)
def apr_pool_clear(*args):
"""apr_pool_clear(apr_pool_t p)"""
return _core.apr_pool_clear(*args)
def apr_file_open_stdout(*args):
"""apr_file_open_stdout(apr_pool_t pool) -> apr_status_t"""
return _core.apr_file_open_stdout(*args)
def apr_file_open_stderr(*args):
"""apr_file_open_stderr(apr_pool_t pool) -> apr_status_t"""
return _core.apr_file_open_stderr(*args)
SVN_ERR_CATEGORY_SIZE = _core.SVN_ERR_CATEGORY_SIZE
SVN_WARNING = _core.SVN_WARNING
SVN_ERR_BAD_CONTAINING_POOL = _core.SVN_ERR_BAD_CONTAINING_POOL
SVN_ERR_BAD_FILENAME = _core.SVN_ERR_BAD_FILENAME
SVN_ERR_BAD_URL = _core.SVN_ERR_BAD_URL
SVN_ERR_BAD_DATE = _core.SVN_ERR_BAD_DATE
SVN_ERR_BAD_MIME_TYPE = _core.SVN_ERR_BAD_MIME_TYPE
SVN_ERR_BAD_PROPERTY_VALUE = _core.SVN_ERR_BAD_PROPERTY_VALUE
SVN_ERR_BAD_VERSION_FILE_FORMAT = _core.SVN_ERR_BAD_VERSION_FILE_FORMAT
SVN_ERR_BAD_RELATIVE_PATH = _core.SVN_ERR_BAD_RELATIVE_PATH
src/subversion/subversion/bindings/swig/python/core.py view on Meta::CPAN
return _core.svn_stream_from_aprfile2(*args)
def svn_stream_from_aprfile(*args):
"""svn_stream_from_aprfile(apr_file_t file, apr_pool_t pool) -> svn_stream_t *"""
return _core.svn_stream_from_aprfile(*args)
def svn_stream_for_stdin(*args):
"""svn_stream_for_stdin(apr_pool_t pool) -> svn_error_t"""
return _core.svn_stream_for_stdin(*args)
def svn_stream_for_stderr(*args):
"""svn_stream_for_stderr(apr_pool_t pool) -> svn_error_t"""
return _core.svn_stream_for_stderr(*args)
def svn_stream_for_stdout(*args):
"""svn_stream_for_stdout(apr_pool_t pool) -> svn_error_t"""
return _core.svn_stream_for_stdout(*args)
def svn_stream_from_stringbuf(*args):
"""svn_stream_from_stringbuf(svn_stringbuf_t * str, apr_pool_t pool) -> svn_stream_t *"""
return _core.svn_stream_from_stringbuf(*args)
def svn_stream_from_string(*args):
src/subversion/subversion/bindings/swig/python/svn/core.py view on Meta::CPAN
# Symbols that 'import *' used to pull (in 1.7)
'Pool',
'SVNSYNC_PROP_CURRENTLY_COPYING',
'SVNSYNC_PROP_FROM_URL',
'SVNSYNC_PROP_FROM_UUID',
'SVNSYNC_PROP_LAST_MERGED_REV',
'SVNSYNC_PROP_LOCK',
'SVNSYNC_PROP_PREFIX',
'SubversionException',
# 'apr_array_header_t',
# 'apr_file_open_stderr',
# 'apr_file_open_stdout',
# 'apr_file_t',
# 'apr_hash_t',
# 'apr_initialize',
# 'apr_pool_clear',
# 'apr_pool_destroy',
# 'apr_pool_t',
# 'apr_terminate',
# 'apr_time_ansi_put',
# 'run_app',
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_apr_file_open_stderr(int argc, VALUE *argv, VALUE self) {
apr_file_t **arg1 = (apr_file_t **) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
apr_file_t *temp1 ;
apr_status_t result;
VALUE vresult = Qnil;
{
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 0) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
if (argc > 0) {
}
{
result = (apr_status_t)apr_file_open_stderr(arg1,arg2);
}
vresult = SWIG_From_int((int)(result));
{
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_apr_file_t, 0));
}
{
VALUE target;
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_stream_for_stderr(int argc, VALUE *argv, VALUE self) {
svn_stream_t **arg1 = (svn_stream_t **) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
svn_stream_t *temp1 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
{
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 0) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
if (argc > 0) {
}
{
result = (svn_error_t *)svn_stream_for_stderr(arg1,arg2);
}
{
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
SWIG_RubyInitializeTrackings();
rb_define_const(mCore, "SWIG_SVN_INVALID_REVNUM", SWIG_From_long((long)(-1)));
rb_define_const(mCore, "SWIG_SVN_IGNORED_REVNUM", SWIG_From_long((long)(-1)));
rb_define_module_function(mCore, "apr_initialize", _wrap_apr_initialize, -1);
rb_define_module_function(mCore, "apr_terminate", _wrap_apr_terminate, -1);
rb_define_module_function(mCore, "apr_time_ansi_put", _wrap_apr_time_ansi_put, -1);
rb_define_module_function(mCore, "apr_pool_destroy", _wrap_apr_pool_destroy, -1);
rb_define_module_function(mCore, "apr_pool_clear", _wrap_apr_pool_clear, -1);
rb_define_module_function(mCore, "apr_file_open_stdout", _wrap_apr_file_open_stdout, -1);
rb_define_module_function(mCore, "apr_file_open_stderr", _wrap_apr_file_open_stderr, -1);
rb_define_const(mCore, "SVN_ERR_CATEGORY_SIZE", SWIG_From_int((int)(5000)));
rb_define_const(mCore, "SVN_WARNING", SWIG_From_int((int)(SVN_WARNING)));
rb_define_const(mCore, "SVN_ERR_BAD_CONTAINING_POOL", SWIG_From_int((int)(SVN_ERR_BAD_CONTAINING_POOL)));
rb_define_const(mCore, "SVN_ERR_BAD_FILENAME", SWIG_From_int((int)(SVN_ERR_BAD_FILENAME)));
rb_define_const(mCore, "SVN_ERR_BAD_URL", SWIG_From_int((int)(SVN_ERR_BAD_URL)));
rb_define_const(mCore, "SVN_ERR_BAD_DATE", SWIG_From_int((int)(SVN_ERR_BAD_DATE)));
rb_define_const(mCore, "SVN_ERR_BAD_MIME_TYPE", SWIG_From_int((int)(SVN_ERR_BAD_MIME_TYPE)));
rb_define_const(mCore, "SVN_ERR_BAD_PROPERTY_VALUE", SWIG_From_int((int)(SVN_ERR_BAD_PROPERTY_VALUE)));
rb_define_const(mCore, "SVN_ERR_BAD_VERSION_FILE_FORMAT", SWIG_From_int((int)(SVN_ERR_BAD_VERSION_FILE_FORMAT)));
rb_define_const(mCore, "SVN_ERR_BAD_RELATIVE_PATH", SWIG_From_int((int)(SVN_ERR_BAD_RELATIVE_PATH)));
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
rb_define_module_function(mCore, "svn_stream_set_mark", _wrap_svn_stream_set_mark, -1);
rb_define_module_function(mCore, "svn_stream_set_seek", _wrap_svn_stream_set_seek, -1);
rb_define_module_function(mCore, "svn_stream_empty", _wrap_svn_stream_empty, -1);
rb_define_module_function(mCore, "svn_stream_disown", _wrap_svn_stream_disown, -1);
rb_define_module_function(mCore, "svn_stream_open_readonly", _wrap_svn_stream_open_readonly, -1);
rb_define_module_function(mCore, "svn_stream_open_writable", _wrap_svn_stream_open_writable, -1);
rb_define_module_function(mCore, "svn_stream_open_unique", _wrap_svn_stream_open_unique, -1);
rb_define_module_function(mCore, "svn_stream_from_aprfile2", _wrap_svn_stream_from_aprfile2, -1);
rb_define_module_function(mCore, "svn_stream_from_aprfile", _wrap_svn_stream_from_aprfile, -1);
rb_define_module_function(mCore, "svn_stream_for_stdin", _wrap_svn_stream_for_stdin, -1);
rb_define_module_function(mCore, "svn_stream_for_stderr", _wrap_svn_stream_for_stderr, -1);
rb_define_module_function(mCore, "svn_stream_for_stdout", _wrap_svn_stream_for_stdout, -1);
rb_define_module_function(mCore, "svn_stream_from_stringbuf", _wrap_svn_stream_from_stringbuf, -1);
rb_define_module_function(mCore, "svn_stream_from_string", _wrap_svn_stream_from_string, -1);
rb_define_module_function(mCore, "svn_stream_buffered", _wrap_svn_stream_buffered, -1);
rb_define_module_function(mCore, "svn_stream_compressed", _wrap_svn_stream_compressed, -1);
rb_define_module_function(mCore, "svn_stream_checksummed2", _wrap_svn_stream_checksummed2, -1);
rb_define_module_function(mCore, "svn_stream_read", _wrap_svn_stream_read, -1);
rb_define_module_function(mCore, "svn_stream_skip", _wrap_svn_stream_skip, -1);
rb_define_module_function(mCore, "svn_stream_write", _wrap_svn_stream_write, -1);
rb_define_module_function(mCore, "svn_stream_close", _wrap_svn_stream_close, -1);
src/subversion/subversion/include/private/svn_cmdline_private.h view on Meta::CPAN
* @since New in 1.7.
*/
svn_error_t *
svn_cmdline__parse_config_option(apr_array_header_t *config_options,
const char *opt_arg,
apr_pool_t *pool);
/** Sets the config options in @a config_options, an apr array containing
* @c svn_cmdline__config_argument_t* elements, to the configuration in @a cfg,
* a hash mapping of <tt>const char *</tt> configuration file names to
* @c svn_config_t *'s. Write warnings to stderr.
*
* Use @a prefix as prefix and @a argument_name in warning messages.
*
* @since New in 1.7.
*/
svn_error_t *
svn_cmdline__apply_config_options(apr_hash_t *config,
const apr_array_header_t *config_options,
const char *prefix,
const char *argument_name);
( run in 1.175 second using v1.01-cache-2.11-cpan-49f99fa48dc )