Alien-SVN
view release on metacpan or search on metacpan
src/subversion/build/ltmain.sh view on Meta::CPAN
/* declarations of non-ANSI functions */
#if defined __MINGW32__
# ifdef __STRICT_ANSI__
int _putenv (const char *);
# endif
#elif defined __CYGWIN__
# ifdef __STRICT_ANSI__
char *realpath (const char *, char *);
int putenv (char *);
int setenv (const char *, const char *, int);
# endif
/* #elif defined other_platform || defined ... */
#endif
/* portability defines, excluding path handling macros */
#if defined _MSC_VER
# define setmode _setmode
# define stat _stat
# define chmod _chmod
# define getcwd _getcwd
src/subversion/build/ltmain.sh view on Meta::CPAN
const char *base_name (const char *name);
char *find_executable (const char *wrapper);
char *chase_symlinks (const char *pathspec);
int make_executable (const char *path);
int check_executable (const char *path);
char *strendzap (char *str, const char *pat);
void lt_debugprintf (const char *file, int line, const char *fmt, ...);
void lt_fatal (const char *file, int line, const char *message, ...);
static const char *nonnull (const char *s);
static const char *nonempty (const char *s);
void lt_setenv (const char *name, const char *value);
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
void lt_update_exe_path (const char *name, const char *value);
void lt_update_lib_path (const char *name, const char *value);
char **prepare_spawn (char **argv);
void lt_dump_script (FILE *f);
EOF
cat <<EOF
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
# define externally_visible volatile
src/subversion/build/ltmain.sh view on Meta::CPAN
}
EOF
;;
esac
cat <<"EOF"
XFREE (target_name);
XFREE (actual_cwrapper_path);
XFREE (actual_cwrapper_name);
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
because on Windows, both *_VARNAMEs are PATH but uninstalled
libraries must come first. */
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
nonnull (lt_argv_zero));
for (i = 0; i < newargc; i++)
src/subversion/build/ltmain.sh view on Meta::CPAN
return s ? s : "(null)";
}
static const char *
nonempty (const char *s)
{
return (s && !*s) ? "(empty)" : nonnull (s);
}
void
lt_setenv (const char *name, const char *value)
{
lt_debugprintf (__FILE__, __LINE__,
"(lt_setenv) setting '%s' to '%s'\n",
nonnull (name), nonnull (value));
{
#ifdef HAVE_SETENV
/* always make a copy, for consistency with !HAVE_SETENV */
char *str = xstrdup (value);
setenv (name, str, 1);
#else
size_t len = strlen (name) + 1 + strlen (value) + 1;
char *str = XMALLOC (char, len);
sprintf (str, "%s=%s", name, value);
if (putenv (str) != EXIT_SUCCESS)
{
XFREE (str);
}
#endif
}
src/subversion/build/ltmain.sh view on Meta::CPAN
if (name && *name && value && *value)
{
char *new_value = lt_extend_str (getenv (name), value, 0);
/* some systems can't cope with a ':'-terminated path #' */
size_t len = strlen (new_value);
while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
{
new_value[--len] = '\0';
}
lt_setenv (name, new_value);
XFREE (new_value);
}
}
void
lt_update_lib_path (const char *name, const char *value)
{
lt_debugprintf (__FILE__, __LINE__,
"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
nonnull (name), nonnull (value));
if (name && *name && value && *value)
{
char *new_value = lt_extend_str (getenv (name), value, 0);
lt_setenv (name, new_value);
XFREE (new_value);
}
}
EOF
case $host_os in
mingw*)
cat <<"EOF"
/* Prepares an argument vector before calling spawn().
src/subversion/subversion/bindings/swig/perl/native/svn_repos.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_repos_hooks_setenv) {
{
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
int res1 = 0 ;
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));
}
if ((items < 2) || (items > 3)) {
SWIG_croak("Usage: svn_repos_hooks_setenv(repos,hooks_env_path,scratch_pool);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_repos_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_repos_hooks_setenv" "', argument " "1"" of type '" "svn_repos_t *""'");
}
arg1 = (svn_repos_t *)(argp1);
res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_repos_hooks_setenv" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (items > 2) {
}
{
result = (svn_error_t *)svn_repos_hooks_setenv(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/svn_repos.c view on Meta::CPAN
{"SVN::_Repos::svn_repos_hook_dir", _wrap_svn_repos_hook_dir},
{"SVN::_Repos::svn_repos_start_commit_hook", _wrap_svn_repos_start_commit_hook},
{"SVN::_Repos::svn_repos_pre_commit_hook", _wrap_svn_repos_pre_commit_hook},
{"SVN::_Repos::svn_repos_post_commit_hook", _wrap_svn_repos_post_commit_hook},
{"SVN::_Repos::svn_repos_pre_revprop_change_hook", _wrap_svn_repos_pre_revprop_change_hook},
{"SVN::_Repos::svn_repos_post_revprop_change_hook", _wrap_svn_repos_post_revprop_change_hook},
{"SVN::_Repos::svn_repos_pre_lock_hook", _wrap_svn_repos_pre_lock_hook},
{"SVN::_Repos::svn_repos_post_lock_hook", _wrap_svn_repos_post_lock_hook},
{"SVN::_Repos::svn_repos_pre_unlock_hook", _wrap_svn_repos_pre_unlock_hook},
{"SVN::_Repos::svn_repos_post_unlock_hook", _wrap_svn_repos_post_unlock_hook},
{"SVN::_Repos::svn_repos_hooks_setenv", _wrap_svn_repos_hooks_setenv},
{"SVN::_Repos::svn_repos_begin_report3", _wrap_svn_repos_begin_report3},
{"SVN::_Repos::svn_repos_begin_report2", _wrap_svn_repos_begin_report2},
{"SVN::_Repos::svn_repos_begin_report", _wrap_svn_repos_begin_report},
{"SVN::_Repos::svn_repos_set_path3", _wrap_svn_repos_set_path3},
{"SVN::_Repos::svn_repos_set_path2", _wrap_svn_repos_set_path2},
{"SVN::_Repos::svn_repos_set_path", _wrap_svn_repos_set_path},
{"SVN::_Repos::svn_repos_link_path3", _wrap_svn_repos_link_path3},
{"SVN::_Repos::svn_repos_link_path2", _wrap_svn_repos_link_path2},
{"SVN::_Repos::svn_repos_link_path", _wrap_svn_repos_link_path},
{"SVN::_Repos::svn_repos_delete_path", _wrap_svn_repos_delete_path},
src/subversion/subversion/bindings/swig/python/repos.py view on Meta::CPAN
return _repos.svn_repos_post_lock_hook(*args)
def svn_repos_pre_unlock_hook(*args):
"""svn_repos_pre_unlock_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"""
return _repos.svn_repos_pre_unlock_hook(*args)
def svn_repos_post_unlock_hook(*args):
"""svn_repos_post_unlock_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"""
return _repos.svn_repos_post_unlock_hook(*args)
def svn_repos_hooks_setenv(*args):
"""svn_repos_hooks_setenv(svn_repos_t * repos, char const * hooks_env_path, apr_pool_t scratch_pool) -> svn_error_t"""
return _repos.svn_repos_hooks_setenv(*args)
def svn_repos_begin_report3(*args):
"""
svn_repos_begin_report3(svn_revnum_t revnum, svn_repos_t * repos, char const * fs_base, char const * target,
char const * tgt_path, svn_boolean_t text_deltas, svn_depth_t depth, svn_boolean_t ignore_ancestry,
svn_boolean_t send_copyfrom_args, svn_delta_editor_t editor,
void * edit_baton, svn_repos_authz_func_t authz_read_func, apr_size_t zero_copy_limit,
apr_pool_t pool) -> svn_error_t
"""
return _repos.svn_repos_begin_report3(*args)
src/subversion/subversion/bindings/swig/python/svn_repos.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_hooks_setenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
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;
arg3 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_hooks_setenv",&obj0,&arg2,&obj2)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
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_repos_hooks_setenv(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/svn_repos.c view on Meta::CPAN
{ (char *)"svn_repos_hook_dir", _wrap_svn_repos_hook_dir, METH_VARARGS, (char *)"svn_repos_hook_dir(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_start_commit_hook", _wrap_svn_repos_start_commit_hook, METH_VARARGS, (char *)"svn_repos_start_commit_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_pre_commit_hook", _wrap_svn_repos_pre_commit_hook, METH_VARARGS, (char *)"svn_repos_pre_commit_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_post_commit_hook", _wrap_svn_repos_post_commit_hook, METH_VARARGS, (char *)"svn_repos_post_commit_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_pre_revprop_change_hook", _wrap_svn_repos_pre_revprop_change_hook, METH_VARARGS, (char *)"svn_repos_pre_revprop_change_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_post_revprop_change_hook", _wrap_svn_repos_post_revprop_change_hook, METH_VARARGS, (char *)"svn_repos_post_revprop_change_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_pre_lock_hook", _wrap_svn_repos_pre_lock_hook, METH_VARARGS, (char *)"svn_repos_pre_lock_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_post_lock_hook", _wrap_svn_repos_post_lock_hook, METH_VARARGS, (char *)"svn_repos_post_lock_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_pre_unlock_hook", _wrap_svn_repos_pre_unlock_hook, METH_VARARGS, (char *)"svn_repos_pre_unlock_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_post_unlock_hook", _wrap_svn_repos_post_unlock_hook, METH_VARARGS, (char *)"svn_repos_post_unlock_hook(svn_repos_t * repos, apr_pool_t pool) -> char const *"},
{ (char *)"svn_repos_hooks_setenv", _wrap_svn_repos_hooks_setenv, METH_VARARGS, (char *)"svn_repos_hooks_setenv(svn_repos_t * repos, char const * hooks_env_path, apr_pool_t scratch_pool) -> svn_error_t"},
{ (char *)"svn_repos_begin_report3", _wrap_svn_repos_begin_report3, METH_VARARGS, (char *)"\n"
"svn_repos_begin_report3(svn_revnum_t revnum, svn_repos_t * repos, char const * fs_base, char const * target, \n"
" char const * tgt_path, svn_boolean_t text_deltas, svn_depth_t depth, svn_boolean_t ignore_ancestry, \n"
" svn_boolean_t send_copyfrom_args, svn_delta_editor_t editor, \n"
" void * edit_baton, svn_repos_authz_func_t authz_read_func, apr_size_t zero_copy_limit, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_begin_report2", _wrap_svn_repos_begin_report2, METH_VARARGS, (char *)"\n"
"svn_repos_begin_report2(svn_revnum_t revnum, svn_repos_t * repos, char const * fs_base, char const * target, \n"
" char const * tgt_path, svn_boolean_t text_deltas, svn_depth_t depth, svn_boolean_t ignore_ancestry, \n"
src/subversion/subversion/bindings/swig/ruby/svn_repos.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_repos_hooks_setenv(int argc, VALUE *argv, VALUE self) {
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
src/subversion/subversion/bindings/swig/ruby/svn_repos.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);
}
if ((argc < 2) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_repos_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_repos_t *","svn_repos_hooks_setenv", 1, argv[0] ));
}
arg1 = (svn_repos_t *)(argp1);
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_repos_hooks_setenv", 2, argv[1] ));
}
arg2 = (char *)(buf2);
if (argc > 2) {
}
{
if (!arg1) {
svn_swig_rb_raise_svn_repos_already_close();
}
}
{
result = (svn_error_t *)svn_repos_hooks_setenv(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/svn_repos.c view on Meta::CPAN
rb_define_module_function(mRepos, "svn_repos_hook_dir", _wrap_svn_repos_hook_dir, -1);
rb_define_module_function(mRepos, "svn_repos_start_commit_hook", _wrap_svn_repos_start_commit_hook, -1);
rb_define_module_function(mRepos, "svn_repos_pre_commit_hook", _wrap_svn_repos_pre_commit_hook, -1);
rb_define_module_function(mRepos, "svn_repos_post_commit_hook", _wrap_svn_repos_post_commit_hook, -1);
rb_define_module_function(mRepos, "svn_repos_pre_revprop_change_hook", _wrap_svn_repos_pre_revprop_change_hook, -1);
rb_define_module_function(mRepos, "svn_repos_post_revprop_change_hook", _wrap_svn_repos_post_revprop_change_hook, -1);
rb_define_module_function(mRepos, "svn_repos_pre_lock_hook", _wrap_svn_repos_pre_lock_hook, -1);
rb_define_module_function(mRepos, "svn_repos_post_lock_hook", _wrap_svn_repos_post_lock_hook, -1);
rb_define_module_function(mRepos, "svn_repos_pre_unlock_hook", _wrap_svn_repos_pre_unlock_hook, -1);
rb_define_module_function(mRepos, "svn_repos_post_unlock_hook", _wrap_svn_repos_post_unlock_hook, -1);
rb_define_module_function(mRepos, "svn_repos_hooks_setenv", _wrap_svn_repos_hooks_setenv, -1);
rb_define_module_function(mRepos, "svn_repos_begin_report3", _wrap_svn_repos_begin_report3, -1);
rb_define_module_function(mRepos, "svn_repos_begin_report2", _wrap_svn_repos_begin_report2, -1);
rb_define_module_function(mRepos, "svn_repos_begin_report", _wrap_svn_repos_begin_report, -1);
rb_define_module_function(mRepos, "svn_repos_set_path3", _wrap_svn_repos_set_path3, -1);
rb_define_module_function(mRepos, "svn_repos_set_path2", _wrap_svn_repos_set_path2, -1);
rb_define_module_function(mRepos, "svn_repos_set_path", _wrap_svn_repos_set_path, -1);
rb_define_module_function(mRepos, "svn_repos_link_path3", _wrap_svn_repos_link_path3, -1);
rb_define_module_function(mRepos, "svn_repos_link_path2", _wrap_svn_repos_link_path2, -1);
rb_define_module_function(mRepos, "svn_repos_link_path", _wrap_svn_repos_link_path, -1);
rb_define_module_function(mRepos, "svn_repos_delete_path", _wrap_svn_repos_delete_path, -1);
src/subversion/subversion/include/svn_repos.h view on Meta::CPAN
*
* Use @a scratch_pool for temporary allocations.
*
* If this function is not called, or if the specified configuration
* file does not define any environment variables, hooks will run in
* an empty environment.
*
* @since New in 1.8.
*/
svn_error_t *
svn_repos_hooks_setenv(svn_repos_t *repos,
const char *hooks_env_path,
apr_pool_t *scratch_pool);
/** @} */
/* ---------------------------------------------------------------*/
/* Reporting the state of a working copy, for updates. */
src/subversion/subversion/libsvn_ra_local/split_url.c view on Meta::CPAN
On on Windows:
file:///dir -> file:///E:/dir (When E: is the current disk)
*/
urlbuf = svn_stringbuf_create(URL, pool);
svn_path_remove_components(urlbuf,
svn_path_component_count(repos_dirent)
- svn_path_component_count(repos_root_dirent));
*repos_url = urlbuf->data;
/* Configure hook script environment variables. */
SVN_ERR(svn_repos_hooks_setenv(*repos, NULL, pool));
return SVN_NO_ERROR;
}
src/subversion/subversion/libsvn_repos/repos.c view on Meta::CPAN
SVN_REPOS__HOOK_DESC_EXT,
pool),
hooks_env_contents, pool),
_("Creating hooks-env file"));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_hooks_setenv(svn_repos_t *repos,
const char *hooks_env_path,
apr_pool_t *scratch_pool)
{
if (hooks_env_path == NULL)
repos->hooks_env_path = svn_dirent_join(repos->conf_path,
SVN_REPOS__CONF_HOOKS_ENV,
repos->pool);
else if (!svn_dirent_is_absolute(hooks_env_path))
repos->hooks_env_path = svn_dirent_join(repos->conf_path,
hooks_env_path,
src/subversion/subversion/mod_dav_svn/repos.c view on Meta::CPAN
r->connection->pool));
if (serr != NULL)
{
return dav_svn__sanitize_error(serr,
"Error storing client capabilities "
"in repos object",
HTTP_INTERNAL_SERVER_ERROR, r);
}
/* Configure hook script environment variables. */
serr = svn_repos_hooks_setenv(repos->repos, dav_svn__get_hooks_env(r),
r->pool);
if (serr)
return dav_svn__sanitize_error(serr,
"Error settings hooks environment",
HTTP_INTERNAL_SERVER_ERROR, r);
}
/* cache the filesystem object */
repos->fs = svn_repos_fs(repos->repos);
src/subversion/subversion/svnserve/serve.c view on Meta::CPAN
|| (!b->tunnel_user && !b->pwdb && !b->use_sasl)))
return error_create_and_log(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
"No access allowed to this repository",
b, conn, pool);
/* Configure hook script environment variables. */
svn_config_get(b->cfg, &hooks_env, SVN_CONFIG_SECTION_GENERAL,
SVN_CONFIG_OPTION_HOOKS_ENV, NULL);
if (hooks_env)
hooks_env = svn_dirent_internal_style(hooks_env, pool);
SVN_ERR(svn_repos_hooks_setenv(b->repos, hooks_env, pool));
return SVN_NO_ERROR;
}
/* Compute the authentication name EXTERNAL should be able to get, if any. */
static const char *get_tunnel_user(serve_params_t *params, apr_pool_t *pool)
{
/* Only offer EXTERNAL for connections tunneled over a login agent. */
if (!params->tunnel)
return NULL;
src/subversion/tools/dev/svn-dev.el view on Meta::CPAN
(message "Please wait, cleaning up the page...done"))
;; Entry point to svn-perldoc functionality.
(defun svn-perldoc (file)
"Run perldoc on FILE, display the output in a buffer."
(interactive "fRun perldoc on file: ")
(let ((outbuf (get-buffer-create
(format "*%s PerlDoc*" (file-name-nondirectory file))))
(savepg (getenv "PAGER")))
(setenv "PAGER" "cat") ;; for perldoc
(save-excursion
(set-buffer outbuf)
(delete-region (point-min) (point-max))
(call-process "perldoc" nil outbuf nil (expand-file-name file))
(svn-perldoc-fontify-buffer)
(svn-perldoc-cleanup-buffer)
;; Clean out the inevitable leading dead space.
(goto-char (point-min))
(re-search-forward "[^ \i\n]")
(beginning-of-line)
(delete-region (point-min) (point)))
(setenv "PAGER" savepg)
(display-buffer outbuf)))
;;; Help developers write log messages.
;; How to use this: just run `svn-log-message'. You might want to
;; bind it to a key, for example,
;;
;; (define-key "\C-cl" 'svn-log-message)
( run in 1.408 second using v1.01-cache-2.11-cpan-3989ada0592 )