Index: subversion/bindings/swig/include/apr.swg
===================================================================
--- subversion/bindings/swig/include/apr.swg	(revision 19840)
+++ subversion/bindings/swig/include/apr.swg	(working copy)
@@ -62,23 +62,24 @@
 /* -----------------------------------------------------------------------
    Create perl5 typemaps for long long datatypes
 */
-%typemap(perl5, out) long long {
+#ifdef SWIGPERL
+%typemap(out) long long {
     char temp[256];
     sprintf(temp, "%" APR_INT64_T_FMT, (apr_int64_t) $1);
     ST(argvi) = sv_newmortal();
     sv_setpv((SV*)ST(argvi++), temp);
 }
 
-%typemap(perl5, out) unsigned long long {
+%typemap(out) unsigned long long {
     char temp[256];
     sprintf(temp, "%" APR_UINT64_T_FMT, (apr_uint64_t) $1);
     ST(argvi) = sv_newmortal();
     sv_setpv((SV*)ST(argvi++), temp);
 }
 
-%typemap(perl5, in, numinputs=0) long long *OUTPUT (apr_int64_t temp)
+%typemap(in, numinputs=0) long long *OUTPUT (apr_int64_t temp)
     "$1 = &temp;";
-%typemap(perl5, argout) long long *OUTPUT {
+%typemap(argout) long long *OUTPUT {
   char temp[256];
   if (argvi >= items) {
     EXTEND(sp,1);
@@ -89,9 +90,9 @@
   argvi++;
 }
 
-%typemap(perl5, in, numinputs=0) unsigned long long *OUTPUT (apr_uint64_t temp)
+%typemap(in, numinputs=0) unsigned long long *OUTPUT (apr_uint64_t temp)
     "$1 = &temp;";
-%typemap(perl5, argout) unsigned long long *OUTPUT {
+%typemap(argout) unsigned long long *OUTPUT {
   char temp[256];
   if (argvi >= items) {
     EXTEND(sp,1);
@@ -101,6 +102,7 @@
   sv_setpv($result,temp);
   argvi++;
 }
+#endif
 
 /* -----------------------------------------------------------------------
  * APR datatypes (from apr.h)
@@ -135,89 +137,111 @@
    create an OUTPUT argument typemap for an apr_hash_t **
 */
 
-%typemap(python,in,numinputs=0) apr_hash_t **OUTPUT (apr_hash_t *temp)
+#ifdef SWIGPYTHON
+%typemap(in,numinputs=0) apr_hash_t **OUTPUT (apr_hash_t *temp)
     "$1 = &temp;";
+#endif
 
-%typemap(perl5,in,numinputs=0) apr_hash_t **OUTPUT (apr_hash_t *temp)
+#ifdef SWIGPERL
+%typemap(in,numinputs=0) apr_hash_t **OUTPUT (apr_hash_t *temp)
     "$1 = &temp;";
+#endif
 
-%typemap(ruby,in,numinputs=0) apr_hash_t **OUTPUT (apr_hash_t *temp)
+#ifdef SWIGRUBY
+%typemap(in,numinputs=0) apr_hash_t **OUTPUT (apr_hash_t *temp)
     "$1 = &temp;";
+#endif
 
 /* -----------------------------------------------------------------------
    create an OUTPUT argument defn for an apr_hash_t ** which is storing
    dirent values
 */
-%typemap(python,in,numinputs=0) apr_hash_t **DIRENTHASH = apr_hash_t **OUTPUT;
-%typemap(python,argout,fragment="t_output_helper") apr_hash_t **DIRENTHASH {
+#ifdef SWIGPYTHON
+%typemap(in,numinputs=0) apr_hash_t **DIRENTHASH = apr_hash_t **OUTPUT;
+%typemap(argout,fragment="t_output_helper") apr_hash_t **DIRENTHASH {
     $result = t_output_helper($result,
                               svn_swig_py_convert_hash(*$1, 
                                                        SWIGTYPE_p_svn_dirent_t,
                                                        NULL));
 }
+#endif
 
 /* -----------------------------------------------------------------------
    create an OUTPUT argument defn for an apr_hash_t ** which is storing
    property values
 */
 
-%typemap(python,in,numinputs=0) apr_hash_t **PROPHASH = apr_hash_t **OUTPUT;
-%typemap(python,argout,fragment="t_output_helper") apr_hash_t **PROPHASH {
+#ifdef SWIGPYTHON
+%typemap(in,numinputs=0) apr_hash_t **PROPHASH = apr_hash_t **OUTPUT;
+%typemap(argout,fragment="t_output_helper") apr_hash_t **PROPHASH {
     $result = t_output_helper($result, svn_swig_py_prophash_to_dict(*$1));
 }
+#endif
 
-%typemap(perl5,in,numinputs=0) apr_hash_t **PROPHASH = apr_hash_t **OUTPUT;
-%typemap(perl5,argout) apr_hash_t **PROPHASH {
+#ifdef SWIGPERL
+%typemap(in,numinputs=0) apr_hash_t **PROPHASH = apr_hash_t **OUTPUT;
+%typemap(argout) apr_hash_t **PROPHASH {
     $result = svn_swig_pl_prophash_to_hash(*$1);
     argvi++;
 }
+#endif
 
-%typemap(ruby,in,numinputs=0) apr_hash_t **PROPHASH = apr_hash_t **OUTPUT;
-%typemap(ruby, argout, fragment="output_helper") apr_hash_t **PROPHASH
+#ifdef SWIGRUBY
+%typemap(in,numinputs=0) apr_hash_t **PROPHASH = apr_hash_t **OUTPUT;
+%typemap(argout, fragment="output_helper") apr_hash_t **PROPHASH
 {
   $result = output_helper($result,
                           svn_swig_rb_apr_hash_to_hash_svn_string(*$1));
 }
+#endif
 
 /* -----------------------------------------------------------------------
    create an INPUT argument defn for an apr_hash_t * which is storing
    property values
 */
-%typemap(ruby, in) apr_hash_t *PROPHASH
+#ifdef SWIGRUBY
+%typemap(in) apr_hash_t *PROPHASH
 {
   $1 = svn_swig_rb_hash_to_apr_hash_svn_string($input, _global_pool);
 }
+#endif
 
-%typemap(python, in) apr_hash_t *PROPHASH
+#ifdef SWIGPYTHON
+%typemap(in) apr_hash_t *PROPHASH
 {
   $1 = svn_swig_py_prophash_from_dict($input, _global_pool);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    create an OUTPUT argument defn for an apr_array_header_t ** which is
    storing svn_prop_t * property values
 */
-%typemap(python, in, numinputs=0) 
+#ifdef SWIGPYTHON
+%typemap(in, numinputs=0) 
      apr_array_header_t **OUTPUT_OF_PROP (apr_array_header_t *temp)
 {
   $1 = &temp;
 }
-%typemap(python, argout, fragment="output_helper")
+%typemap(argout, fragment="output_helper")
      apr_array_header_t **OUTPUT_OF_PROP
 {
   /* FIXME: Actually do something here. */
 }
+#endif
 
-%typemap(ruby, in, numinputs=0)
+#ifdef SWIGRUBY
+%typemap(in, numinputs=0)
      apr_array_header_t **OUTPUT_OF_PROP (apr_array_header_t *temp)
 {
   $1 = &temp;
 }
-%typemap(ruby, argout, fragment="output_helper")
+%typemap(argout, fragment="output_helper")
      apr_array_header_t **OUTPUT_OF_PROP
 {
   $result = output_helper($result, svn_swig_rb_apr_array_to_array_prop(*$1));
 }
+#endif
 
 
 /* -----------------------------------------------------------------------
@@ -228,36 +252,51 @@
 (apr_array_header_t *temp) {
     $1 = &temp;
 }
-%typemap(python, argout, fragment="t_output_helper")
+
+#ifdef SWIGPYTHON
+%typemap(argout, fragment="t_output_helper")
 apr_array_header_t **OUTPUT_OF_CONST_CHAR_P {
     $result = t_output_helper($result, svn_swig_py_array_to_list(*$1));
 }
-%typemap(perl5, argout) apr_array_header_t **OUTPUT_OF_CONST_CHAR_P {
+#endif
+
+#ifdef SWIGPERL
+%typemap(argout) apr_array_header_t **OUTPUT_OF_CONST_CHAR_P {
     $result = svn_swig_pl_array_to_list(*$1);
     ++argvi;
 }
-%typemap(ruby, argout, fragment="output_helper")
+#endif
+
+#ifdef SWIGRUBY
+%typemap(argout, fragment="output_helper")
      apr_array_header_t **OUTPUT_OF_CONST_CHAR_P
 {
   $result = output_helper($result, svn_swig_rb_apr_array_to_array_string(*$1));
 }
+#endif
 
 /* -----------------------------------------------------------------------
   handle apr_file_t *
 */
 
-%typemap(python, in) apr_file_t * {
+#ifdef SWIGPYTHON
+%typemap(in) apr_file_t * {
   $1 = svn_swig_py_make_file($input, _global_pool);
   if (!$1) SWIG_fail;
 }
+#endif
 
-%typemap(perl5, in) apr_file_t * {
+#ifdef SWIGPERL
+%typemap(in) apr_file_t * {
   $1 = svn_swig_pl_make_file($input, _global_pool);
 }
+#endif
 
-%typemap(ruby, in) apr_file_t * {
+#ifdef SWIGRUBY
+%typemap(in) apr_file_t * {
   $1 = svn_swig_rb_make_file($input, _global_pool);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    apr_file_t ** is always an OUT param
@@ -266,20 +305,26 @@
 %typemap(in, numinputs=0) apr_file_t ** (apr_file_t *temp)
     "$1 = &temp;";
 
-%typemap(python,argout,fragment="t_output_helper") apr_file_t **
+#ifdef SWIGPYTHON
+%typemap(argout,fragment="t_output_helper") apr_file_t **
     "$result = t_output_helper(
         $result,
         svn_swig_NewPointerObj(*$1, $*1_descriptor, 
            _global_svn_swig_py_pool));";
+#endif
 
-%typemap(perl5, argout) apr_file_t ** {
+#ifdef SWIGPERL
+%typemap(argout) apr_file_t ** {
     ST(argvi) = sv_newmortal();
     SWIG_MakePtr(ST(argvi++), (void *)*$1, $*1_descriptor,0);
 }
+#endif
 
-%typemap(ruby, argout, fragment="output_helper") apr_file_t ** {
+#ifdef SWIGRUBY
+%typemap(argout, fragment="output_helper") apr_file_t ** {
     $result = output_helper($result,
                             SWIG_NewPointerObj((void *)*$1, $*1_descriptor, 0));
 }
+#endif
 
 /* ----------------------------------------------------------------------- */
Index: subversion/bindings/swig/include/svn_types.swg
===================================================================
--- subversion/bindings/swig/include/svn_types.swg	(revision 19840)
+++ subversion/bindings/swig/include/svn_types.swg	(working copy)
@@ -43,28 +43,44 @@
    Note: SWIGTYPE is just a placeholder for "some arbitrary type". This
          typemap will be applied onto a "real" type.
 */
-%typemap(python, in, numinputs=0) SWIGTYPE **OUTPARAM ($*1_type temp) {
+#ifdef SWIGPYTHON
+%typemap(in, numinputs=0) SWIGTYPE **OUTPARAM ($*1_type temp) {
     $1 = ($1_ltype)&temp;
 }
-%typemap(perl5, in, numinputs=0) SWIGTYPE **OUTPARAM ($*1_type temp) {
+#endif
+
+#ifdef SWIGPERL
+%typemap(in, numinputs=0) SWIGTYPE **OUTPARAM ($*1_type temp) {
     $1 = ($1_ltype)&temp;
 }
-%typemap(ruby, in, numinputs=0) SWIGTYPE **OUTPARAM ($*1_type temp) {
+#endif
+
+#ifdef SWIGRUBY
+%typemap(in, numinputs=0) SWIGTYPE **OUTPARAM ($*1_type temp) {
   temp = NULL;
   $1 = ($1_ltype)&temp;
 }
+#endif
 
-%typemap(python, argout, fragment="t_output_helper") SWIGTYPE **OUTPARAM {
+#ifdef SWIGPYTHON
+%typemap(argout, fragment="t_output_helper") SWIGTYPE **OUTPARAM {
     $result = t_output_helper($result,
       svn_swig_NewPointerObj(*$1, $*1_descriptor, _global_svn_swig_py_pool));
 }
-%typemap(perl5, argout) SWIGTYPE **OUTPARAM {
+#endif
+
+#ifdef SWIGPERL
+%typemap(argout) SWIGTYPE **OUTPARAM {
     ST(argvi) = sv_newmortal();
     SWIG_MakePtr(ST(argvi++), (void *)*$1, $*1_descriptor,0);
 }
-%typemap(ruby, argout, fragment="output_helper") SWIGTYPE **OUTPARAM {
+#endif
+
+#ifdef SWIGRUBY
+%typemap(argout, fragment="output_helper") SWIGTYPE **OUTPARAM {
   $result = output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0));
 }
+#endif
 
 /* -----------------------------------------------------------------------
    %apply-ing of typemaps
@@ -87,13 +103,16 @@
 /* -----------------------------------------------------------------------
    Create a typemap for specifying string args that may be NULL.
 */
-%typemap(python, in, parse="z") const char *MAY_BE_NULL "";
+#ifdef SWIGPYTHON
+%typemap(in, parse="z") const char *MAY_BE_NULL "";
+#endif
 
 #ifdef SWIGPERL
 %apply const char * { const char *MAY_BE_NULL };
 #endif
 
-%typemap(ruby, in) const char* MAY_BE_NULL
+#ifdef SWIGRUBY
+%typemap(in) const char* MAY_BE_NULL
 {
   if (NIL_P($input)) {
     $1 = NULL;
@@ -102,7 +121,7 @@
   }
 }
 
-%typemap(ruby, out) const char *
+%typemap(out) const char *
 {
   if ($1) {
     $result = rb_str_new2($1);
@@ -110,13 +129,15 @@
     $result = Qnil;
   }
 }
+#endif
 
 /* -----------------------------------------------------------------------
    const char *header_encoding
    svn_diff_file_output_unified2
    svn_client_diff3
 */
-%typemap(ruby, in) const char *header_encoding
+#ifdef SWIGRUBY
+%typemap(in) const char *header_encoding
 {
   $1 = NULL;
   
@@ -134,20 +155,29 @@
     $1 = (char *)APR_LOCALE_CHARSET;
   }
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Input of scripting hash/dictionary (string => string)
    converted to apr_hash_t (const char * => const char *)
 */
-%typemap(python, in) apr_hash_t *STRING_TO_STRING {
+#ifdef SWIGPYTHON
+%typemap(in) apr_hash_t *STRING_TO_STRING {
     $1 = svn_swig_py_stringhash_from_dict ($input, _global_pool);
 }
-%typemap(perl5, in) apr_hash_t *STRING_TO_STRING {
+#endif
+
+#ifdef SWIGPERL
+%typemap(in) apr_hash_t *STRING_TO_STRING {
     $1 = svn_swig_pl_strings_to_hash ($input, _global_pool);
 }
-%typemap(ruby, in) apr_hash_t *STRING_TO_STRING {
+#endif
+
+#ifdef SWIGRUBY
+%typemap(in) apr_hash_t *STRING_TO_STRING {
     $1 = svn_swig_rb_hash_to_apr_hash_string($input, _global_pool);
 }
+#endif
 
 
 /* -----------------------------------------------------------------------
@@ -168,7 +198,8 @@
 /* -----------------------------------------------------------------------
    Specify how svn_error_t returns are turned into exceptions.
 */
-%typemap(python, out) svn_error_t * {
+#ifdef SWIGPYTHON
+%typemap(out) svn_error_t * {
     if ($1 != NULL) {
         if ($1->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
             svn_swig_py_svn_exception($1);
@@ -179,8 +210,10 @@
     Py_INCREF(Py_None);
     $result = Py_None;
 }
+#endif
 
-%typemap(perl5,out) svn_error_t * {
+#ifdef SWIGPERL
+%typemap(out) svn_error_t * {
     if ($1) {
         SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
 
@@ -197,8 +230,10 @@
         }
     }
 }
+#endif
 
-%typemap(ruby, out) svn_error_t *
+#ifdef SWIGRUBY
+%typemap(out) svn_error_t *
 {
   if ($1) {
     svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
@@ -206,6 +241,7 @@
   }
   $result = Qnil;
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Define an OUTPUT typemap for 'svn_filesize_t *'
@@ -216,7 +252,8 @@
    Define a general ptr/len typemap. This takes a single script argument
    and expands it into a ptr/len pair for the native call.
 */
-%typemap(python, in) (const char *PTR, apr_size_t LEN) {
+#ifdef SWIGPYTHON
+%typemap(in) (const char *PTR, apr_size_t LEN) {
     if (!PyString_Check($input)) {
         PyErr_SetString(PyExc_TypeError, "expecting a string");
         SWIG_fail;
@@ -224,8 +261,10 @@
     $1 = PyString_AS_STRING($input);
     $2 = PyString_GET_SIZE($input);
 }
+#endif
 
-%typemap(perl5, in) (const char *PTR, apr_size_t LEN) {
+#ifdef SWIGPERL
+%typemap(in) (const char *PTR, apr_size_t LEN) {
     if (SvPOK($input)) {
         $1 = SvPV($input, $2);
     } else {
@@ -235,16 +274,19 @@
         SWIG_croak("Expecting a string");
     }
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Handle retrieving the error message from svn_strerror
 */
 
-%typemap(perl5,in,numinputs=0) (char *buf, apr_size_t bufsize) ( char temp[128] ) {
+#ifdef SWIGPERL
+%typemap(in,numinputs=0) (char *buf, apr_size_t bufsize) ( char temp[128] ) {
     memset (temp,0,128); /* paranoia */
     $1 = temp;
     $2 = 128;
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Define a generic arginit mapping for pools.
@@ -266,9 +308,8 @@
     py_pool = svn_swig_NewPointerObj(pool, $descriptor, py_pool);
   }
 %enddef
-#endif
 
-%typemap(python, default) apr_pool_t *(apr_pool_t *_global_pool,
+%typemap(default) apr_pool_t *(apr_pool_t *_global_pool,
   PyObject *_global_svn_swig_py_pool, int _global_pool_is_default_pool)
 {
   int argnum = PyTuple_GET_SIZE(args) - 1;
@@ -301,7 +342,7 @@
   svn_swig_py_pool_check(_global_svn_swig_py_pool)
 }
 
-%typemap(python, in) apr_pool_t * {
+%typemap(in) apr_pool_t * {
   if ($input != Py_None && _global_pool_is_default_pool == 1) {
     svn_swig_py_pool_check($input)
     _global_pool = svn_swig_MustGetPtr($input, $1_descriptor, $svn_argnum, 
@@ -316,16 +357,22 @@
   }
 }
 
-%typemap(python, freearg) apr_pool_t * {
+%typemap(freearg) apr_pool_t * {
   Py_XDECREF(_global_svn_swig_py_pool);
 }
+#endif
 
-%typemap(perl5, in) apr_pool_t *pool "";
-%typemap(perl5, default) apr_pool_t *pool(apr_pool_t *_global_pool) {
+#ifdef SWIGPERL
+
+%typemap(in) apr_pool_t *pool "";
+%typemap(default) apr_pool_t *pool(apr_pool_t *_global_pool) {
     _global_pool = $1 = svn_swig_pl_make_pool (ST(items-1));
 }
-%typemap(ruby, in) apr_pool_t *pool "";
-%typemap(ruby, default) apr_pool_t *pool
+#endif
+
+#ifdef SWIGRUBY
+%typemap(in) apr_pool_t *pool "";
+%typemap(default) apr_pool_t *pool
     (VALUE _global_svn_swig_rb_pool, apr_pool_t *_global_pool)
 {
   svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &$1);
@@ -333,7 +380,7 @@
   svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 }
 
-%typemap(ruby, default) (svn_client_ctx_t *ctx, apr_pool_t *pool)
+%typemap(default) (svn_client_ctx_t *ctx, apr_pool_t *pool)
      (VALUE _global_svn_swig_rb_pool, apr_pool_t *_global_pool)
 {
   int adjusted_argc = argc;
@@ -347,11 +394,12 @@
   svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
 }
 
-%typemap(ruby, argout) apr_pool_t *pool
+%typemap(argout) apr_pool_t *pool
 {
   svn_swig_rb_set_pool($result, _global_svn_swig_rb_pool);
   svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 }
+#endif
 
 #ifdef SWIGPERL
 %apply apr_pool_t *pool {
@@ -374,10 +422,12 @@
    CALLBACK_BATON: Do not convert to C object from Ruby object.
 */
 
-%typemap(ruby, in) void *CALLBACK_BATON
+#ifdef SWIGRUBY
+%typemap(in) void *CALLBACK_BATON
 {
   $1 = (void *)$input;
 }
+#endif
 
 
 /* -----------------------------------------------------------------------
@@ -387,22 +437,29 @@
    svn_repos_get_logs()
 */
 
-%typemap(python, in) (svn_log_message_receiver_t receiver, 
+#ifdef SWIGPYTHON
+%typemap(in) (svn_log_message_receiver_t receiver, 
                       void *receiver_baton) {
     $1 = svn_swig_py_log_receiver;
     $2 = (void *)$input;
 }
-%typemap(perl5, in) (svn_log_message_receiver_t receiver, 
+#endif
+
+#ifdef SWIGPERL
+%typemap(in) (svn_log_message_receiver_t receiver, 
                      void *receiver_baton) {
     $1 = svn_swig_pl_thunk_log_receiver;
     $2 = (void *)$input;
 }
+#endif
 
-%typemap(ruby, in) (svn_log_message_receiver_t receiver, 
+#ifdef SWIGRUBY
+%typemap(in) (svn_log_message_receiver_t receiver, 
                     void *receiver_baton) {
     $1 = svn_swig_rb_log_receiver;
     $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Callback: svn_commit_callback_t
@@ -410,22 +467,26 @@
    svn_repos_get_commit_editor()
 */
 
-%typemap(perl5, in) (svn_commit_callback_t callback, void *callback_baton) {
+#ifdef SWIGPERL
+%typemap(in) (svn_commit_callback_t callback, void *callback_baton) {
     $1 = svn_swig_pl_thunk_commit_callback;
     $2 = (void *)$input;
     svn_swig_pl_hold_ref_in_pool (_global_pool, $input);
 };
+#endif
 
-%typemap(ruby, in) (svn_commit_callback_t callback, void *callback_baton)
+#ifdef SWIGRUBY
+%typemap(in) (svn_commit_callback_t callback, void *callback_baton)
 {
   $1 = svn_swig_rb_commit_callback;
   $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
 };
 
-%typemap(ruby, argout) (svn_commit_callback_t callback, void *callback_baton)
+%typemap(argout) (svn_commit_callback_t callback, void *callback_baton)
 {
   svn_swig_rb_set_baton($result, (VALUE)$2);
 };
+#endif
 
 /* -----------------------------------------------------------------------
    Callback: svn_commit_callback2_t
@@ -433,97 +494,116 @@
    svn_repos_get_commit_editor4()
 */
 
-%typemap(ruby, in) (svn_commit_callback2_t callback, void *callback_baton)
+#ifdef SWIGRUBY
+%typemap(in) (svn_commit_callback2_t callback, void *callback_baton)
 {
   $1 = svn_swig_rb_commit_callback2;
   $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
 };
 
-%typemap(ruby, argout) (svn_commit_callback2_t callback, void *callback_baton)
+%typemap(argout) (svn_commit_callback2_t callback, void *callback_baton)
 {
   svn_swig_rb_set_baton($result, (VALUE)$2);
 };
+#endif
 
-%typemap(python, in) (svn_commit_callback2_t callback, void *callback_baton)
+#ifdef SWIGPYTHON
+%typemap(in) (svn_commit_callback2_t callback, void *callback_baton)
 {
   $1 = svn_swig_py_commit_callback2;
   $2 = (void *)$input;
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Callback: svn_cancel_func_t
 */
 
-%typemap(python, in) (svn_cancel_func_t cancel_func, void *cancel_baton) {
+#ifdef SWIGPYTHON
+%typemap(in) (svn_cancel_func_t cancel_func, void *cancel_baton) {
   $1 = svn_swig_py_cancel_func;
   $2 = $input; /* our function is the baton. */
 }
+#endif
 
-%typemap(ruby, in) (svn_cancel_func_t cancel_func, void *cancel_baton)
+#ifdef SWIGRUBY
+%typemap(in) (svn_cancel_func_t cancel_func, void *cancel_baton)
 {
   $1 = svn_swig_rb_cancel_func;
   $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
 }
 
-%typemap(ruby, argout) (svn_cancel_func_t cancel_func, void *cancel_baton)
+%typemap(argout) (svn_cancel_func_t cancel_func, void *cancel_baton)
 {
   svn_swig_rb_set_baton($result, (VALUE)$2);
 };
+#endif
 
-
 /* -----------------------------------------------------------------------
    Callback: svn_info_receiver_t
 */
 
-%typemap(perl5, in) (svn_info_receiver_t receiver, void *receiver_baton)
+#ifdef SWIGPERL
+%typemap(in) (svn_info_receiver_t receiver, void *receiver_baton)
 {
   $1 = svn_swig_pl_info_receiver;
   $2 = (void *)$input;
 }
+#endif
 
-%typemap(ruby, in) (svn_info_receiver_t receiver, void *receiver_baton)
+#ifdef SWIGRUBY
+%typemap(in) (svn_info_receiver_t receiver, void *receiver_baton)
 {
   $1 = svn_swig_rb_info_receiver;
   $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Callback: svn_fs_warning_callback_t
 */
 
-%typemap(ruby, in) (svn_fs_warning_callback_t warning, void *warning_baton)
+#ifdef SWIGRUBY
+%typemap(in) (svn_fs_warning_callback_t warning, void *warning_baton)
 {
   VALUE baton = svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool);
   svn_swig_rb_fs_warning_callback_baton_register(baton, _global_pool);
   $1 = svn_swig_rb_fs_warning_callback;
   $2 = (void *)baton;
 }
+#endif
 
 /* -----------------------------------------------------------------------
    svn_stream_t interoperability with language native io handles
 */
 
-%typemap(python, in) svn_stream_t *WRAPPED_STREAM {
+#ifdef SWIGPYTHON
+%typemap(in) svn_stream_t *WRAPPED_STREAM {
     $1 = svn_swig_py_make_stream ($input, _global_pool);
 }
+#endif
 
-%typemap(perl5, in) svn_stream_t * {
+#ifdef SWIGPERL
+%typemap(in) svn_stream_t * {
     svn_swig_pl_make_stream (&$1, $input);
 }
 
-%typemap(perl5, out) svn_stream_t * {
+%typemap(out) svn_stream_t * {
     $result = svn_swig_pl_from_stream ($1);
     argvi++;
 }
 
-%typemap(perl5, argout) svn_stream_t ** {
+%typemap(argout) svn_stream_t ** {
     $result = svn_swig_pl_from_stream (*$1);
     argvi++;
 }
+#endif
 
-%typemap(ruby, in) svn_stream_t * {
+#ifdef SWIGRUBY
+%typemap(in) svn_stream_t * {
   $1 = svn_swig_rb_make_stream($input);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Wrap the digest output for functions populating digests.
@@ -534,42 +614,50 @@
     $1 = ($1_ltype)temp;
 }
 
-%typemap(python, argout, fragment="t_output_helper") unsigned char digest[ANY]
+#ifdef SWIGPYTHON
+%typemap(argout, fragment="t_output_helper") unsigned char digest[ANY]
 {
     $result = t_output_helper($result,
         PyString_FromString(svn_md5_digest_to_cstring ($1, _global_pool)));
 }
+#endif
 
-%typemap(perl5, argout) unsigned char digest[ANY] {
+#ifdef SWIGPERL
+%typemap(argout) unsigned char digest[ANY] {
     ST(argvi) = sv_newmortal();
     sv_setpv((SV*)ST(argvi++), svn_md5_digest_to_cstring ($1,_global_pool));
 }
+#endif
 
-%typemap(ruby, argout, fragment="output_helper") unsigned char digest[ANY]
+#ifdef SWIGRUBY
+%typemap(argout, fragment="output_helper") unsigned char digest[ANY]
 {
   char *digest_string = (char *)svn_md5_digest_to_cstring($1, _global_pool);
   $result = output_helper($result, rb_str_new2(digest_string));
 }
 
-
-%typemap(ruby, in, numinputs=0) unsigned char **digest ($*1_type temp)
+%typemap(in, numinputs=0) unsigned char **digest ($*1_type temp)
 {
     $1 = &temp;
 }
 
-%typemap(ruby, argout, fragment="output_helper") unsigned char **digest
+%typemap(argout, fragment="output_helper") unsigned char **digest
 {
   char *digest_string = (char *)svn_md5_digest_to_cstring(*$1, _global_pool);
   $result = output_helper($result, rb_str_new2(digest_string));
 }
+#endif
 
 /* svn_md5_* functions takes const ones as input */
-%typemap(perl5, in) const unsigned char digest[] {
+#ifdef SWIGPERL
+%typemap(in) const unsigned char digest[] {
     SWIG_ConvertPtr($input, (void **)&$1, $1_descriptor, 0);
 }
-%typemap(perl5, argout) const unsigned char digest[] {}
+%typemap(argout) const unsigned char digest[] {}
+#endif
 
-%typemap(ruby, in) const unsigned char *digest
+#ifdef SWIGRUBY
+%typemap(in) const unsigned char *digest
 {
   if (NIL_P($input)) {
     $1 = NULL;
@@ -580,7 +668,8 @@
     $1 = ($1_ltype)StringValuePtr($input);
   }
 }
-%typemap(ruby, argout) const unsigned char *digest {}
+%typemap(argout) const unsigned char *digest {}
+#endif
 
 /*
    svn_txdelta_send_stream() uses *digest not digest[] .
@@ -591,10 +680,12 @@
     $1 = (unsigned char *)apr_palloc(_global_pool, APR_MD5_DIGESTSIZE);
 }
 
-%typemap(perl5, argout) unsigned char *result_digest {
+#ifdef SWIGPERL
+%typemap(argout) unsigned char *result_digest {
     ST(argvi) = sv_newmortal();
     ST(argvi++) = svn_swig_pl_from_md5($1);
 }
+#endif
 
 %apply unsigned char digest[ANY] {
     unsigned char *digest
@@ -609,7 +700,8 @@
 /* -----------------------------------------------------------------------
   useful convertors for svn_opt_revision_t
 */
-%typemap(perl5, in) svn_opt_revision_t * (svn_opt_revision_t rev) {
+#ifdef SWIGPERL
+%typemap(in) svn_opt_revision_t * (svn_opt_revision_t rev) {
     $1 = &rev;
     if ($input == NULL || $input == &PL_sv_undef || !SvOK($input)) {
         rev.kind = svn_opt_revision_unspecified;
@@ -658,11 +750,14 @@
     } else
         SWIG_croak("unknown opt_revision_t type");
 }
+#endif
 
-%typemap(ruby, in) svn_opt_revision_t * (svn_opt_revision_t rev) {
+#ifdef SWIGRUBY
+%typemap(in) svn_opt_revision_t * (svn_opt_revision_t rev) {
   $1 = &rev;
   svn_swig_rb_set_revision(&rev, $input);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    apr_hash_t **dirents
@@ -671,25 +766,31 @@
    svn_ra get_dir()
 */
 
-%typemap(python,in,numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
-%typemap(python,argout,fragment="t_output_helper") apr_hash_t **dirents {
+#ifdef SWIGPYTHON
+%typemap(in,numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
+%typemap(argout,fragment="t_output_helper") apr_hash_t **dirents {
   $result = t_output_helper($result, svn_swig_py_convert_hash(*$1, 
     $descriptor(svn_dirent_t *), _global_svn_swig_py_pool));
 }
+#endif
 
-%typemap(perl5,in,numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
-%typemap(perl5,argout) apr_hash_t **dirents {
+#ifdef SWIGPERL
+%typemap(in,numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
+%typemap(argout) apr_hash_t **dirents {
     ST(argvi++) = svn_swig_pl_convert_hash
 	(*$1, $descriptor(svn_dirent_t *));
 }
+#endif
 
-%typemap(ruby, in, numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
-%typemap(ruby, argout, fragment="output_helper") apr_hash_t **dirents
+#ifdef SWIGRUBY
+%typemap(in, numinputs=0) apr_hash_t **dirents = apr_hash_t **OUTPUT;
+%typemap(argout, fragment="output_helper") apr_hash_t **dirents
 {
   $result = output_helper($result,
                           svn_swig_rb_apr_hash_to_hash_swig_type
                             (*$1, "svn_dirent_t *"));
 }
+#endif
 
 /* -----------------------------------------------------------------------
    apr_hash_t **locks
@@ -698,13 +799,15 @@
    svn_ra_get_locks()
 */
 
-%typemap(ruby, in, numinputs=0) apr_hash_t **locks = apr_hash_t **OUTPUT;
-%typemap(ruby, argout, fragment="output_helper") apr_hash_t **locks
+#ifdef SWIGRUBY
+%typemap(in, numinputs=0) apr_hash_t **locks = apr_hash_t **OUTPUT;
+%typemap(argout, fragment="output_helper") apr_hash_t **locks
 {
   $result = output_helper($result,
                           svn_swig_rb_apr_hash_to_hash_swig_type
                             (*$1, "svn_lock_t *"));
 }
+#endif
 
 /* -----------------------------------------------------------------------
    apr_array_header_t *location_revisions
@@ -712,10 +815,12 @@
    svn_ra_get_locations()
 */
 
-%typemap(ruby, in) apr_array_header_t *location_revisions
+#ifdef SWIGRUBY
+%typemap(in) apr_array_header_t *location_revisions
 {
   $1 = svn_swig_rb_array_to_apr_array_revnum($input, _global_pool);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    apr_hash_t **locations
@@ -723,31 +828,35 @@
    svn_ra_get_locations()
 */
 
-%typemap(ruby, in, numinputs=0) apr_hash_t **locations = apr_hash_t **OUTPUT;
-%typemap(ruby, argout) apr_hash_t **locations
+#ifdef SWIGRUBY
+%typemap(in, numinputs=0) apr_hash_t **locations = apr_hash_t **OUTPUT;
+%typemap(argout) apr_hash_t **locations
 {
   $result = svn_swig_rb_apr_revnum_key_hash_to_hash_string(*$1);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Special boolean mapping for ruby.
 */
 
-%typemap(ruby, in) svn_boolean_t "$1 = RTEST($input);";
-%typemap(ruby, out, fragment="output_helper") svn_boolean_t
+#ifdef SWIGRUBY
+%typemap(in) svn_boolean_t "$1 = RTEST($input);";
+%typemap(out, fragment="output_helper") svn_boolean_t
 {
   $result = output_helper($result, $1 ? Qtrue : Qfalse);
 }
 
-%typemap(ruby, in, numinputs=0) svn_boolean_t * (svn_boolean_t temp)
+%typemap(in, numinputs=0) svn_boolean_t * (svn_boolean_t temp)
 {
   $1 = &temp;
 }
 
-%typemap(ruby, argout, fragment="output_helper") svn_boolean_t *
+%typemap(argout, fragment="output_helper") svn_boolean_t *
 {
   $result = output_helper($result, *$1 ? Qtrue : Qfalse);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    Handle python thread locking.
@@ -771,8 +880,8 @@
    handle config and fs_config in svn_{fs,repos}_create
 */
 
-
-%typemap(ruby, in) apr_hash_t *config
+#ifdef SWIGRUBY
+%typemap(in) apr_hash_t *config
 {
   if (NIL_P($input)) {
     $1 = NULL;
@@ -780,7 +889,7 @@
     $1 = svn_swig_rb_hash_to_apr_hash_swig_type($input, "svn_config_t *", _global_pool);
   }
 }
-%typemap(ruby, in) apr_hash_t *fs_config
+%typemap(in) apr_hash_t *fs_config
 {
   if (NIL_P($input)) {
     $1 = NULL;
@@ -788,6 +897,7 @@
     $1 = svn_swig_rb_hash_to_apr_hash_string($input, _global_pool);
   }
 }
+#endif
 
 /* ----------------------------------------------------------------------- */
 
Index: subversion/bindings/swig/include/svn_string.swg
===================================================================
--- subversion/bindings/swig/include/svn_string.swg	(revision 19840)
+++ subversion/bindings/swig/include/svn_string.swg	(working copy)
@@ -33,7 +33,8 @@
     $1 = &temp;
 }
 
-%typemap(python,argout,fragment="t_output_helper") RET_STRING {
+#ifdef SWIGPYTHON
+%typemap(argout,fragment="t_output_helper") RET_STRING {
     PyObject *s;
     if (*$1 == NULL) {
         Py_INCREF(Py_None);
@@ -46,7 +47,10 @@
     }
     $result = t_output_helper($result, s);
 }
-%typemap(perl5,argout) RET_STRING {
+#endif
+
+#ifdef SWIGPERL
+%typemap(argout) RET_STRING {
     if (*$1) {
 	$result = sv_newmortal();
 	sv_setpvn ($result, (*$1)->data, (*$1)->len);
@@ -55,7 +59,10 @@
 	$result = &PL_sv_undef;
     argvi++;
 }
-%typemap(ruby,argout,fragment="output_helper") RET_STRING
+#endif
+
+#ifdef SWIGRUBY
+%typemap(argout,fragment="output_helper") RET_STRING
 {
   if (*$1) {
     $result = output_helper($result, rb_str_new((*$1)->data, (*$1)->len));
@@ -63,6 +70,7 @@
     $result = output_helper($result, Qnil);
   }
 }
+#endif
 
 %apply RET_STRING {
   svn_string_t **,
@@ -73,7 +81,8 @@
    TYPE: svn_stringbuf_t
 */
 
-%typemap(python,in) svn_stringbuf_t * {
+#ifdef SWIGPYTHON
+%typemap(in) svn_stringbuf_t * {
     if (!PyString_Check($input)) {
         PyErr_SetString(PyExc_TypeError, "not a string");
         SWIG_fail;
@@ -83,8 +92,10 @@
                                /* ### gah... what pool to use? */
                                _global_pool);
 }
+#endif
 
-%typemap(perl5,in) svn_stringbuf_t * {
+#ifdef SWIGPERL
+%typemap(in) svn_stringbuf_t * {
     apr_size_t len;
     char *buf;
 
@@ -100,8 +111,10 @@
         croak("Not a string");
     }
 }
+#endif
 
-%typemap(ruby, in) svn_stringbuf_t *
+#ifdef SWIGRUBY
+%typemap(in) svn_stringbuf_t *
 {
   if (NIL_P($input)) {
     $1 = NULL;
@@ -112,7 +125,7 @@
   }
 }
 
-%typemap(ruby, in) svn_stringbuf_t *node_name
+%typemap(in) svn_stringbuf_t *node_name
 {
   if (NIL_P($input)) {
     $1 = NULL;
@@ -127,35 +140,44 @@
                                pool);
   }
 }
+#endif
 
-
-%typemap(python,out) svn_stringbuf_t * {
+#ifdef SWIGPYTHON
+%typemap(out) svn_stringbuf_t * {
     $result = PyString_FromStringAndSize($1->data, $1->len);
 }
+#endif
 
-%typemap(perl5,out) svn_stringbuf_t * {
+#ifdef SWIGPERL
+%typemap(out) svn_stringbuf_t * {
     SV *sv = sv_newmortal();
     sv_setpvn(sv,$1->data,$1->len);
     $result = sv;
     argvi++;
 }
+#endif
 
-%typemap(ruby, out) svn_stringbuf_t *
+#ifdef SWIGRUBY
+%typemap(out) svn_stringbuf_t *
 {
   $result = rb_str_new($1->data, $1->len);
 }
+#endif
 
-%typemap(ruby, argout) svn_stringbuf_t *output
+#ifdef SWIGRUBY
+%typemap(argout) svn_stringbuf_t *output
 {
   $result = rb_str_new($1->data, $1->len);
 }
+#endif
 
 /* -----------------------------------------------------------------------
    TYPE: svn_string_t
 */
 
+#ifdef SWIGPYTHON
 /* const svn_string_t * is always an input parameter */
-%typemap(python,in) const svn_string_t * (svn_string_t value) {
+%typemap(in) const svn_string_t * (svn_string_t value) {
     if ($input == Py_None)
         $1 = NULL;
     else {
@@ -168,7 +190,10 @@
         $1 = &value;
     }
 }
-%typemap(perl5,in) const svn_string_t * (svn_string_t value) {
+#endif
+
+#ifdef SWIGPERL
+%typemap(in) const svn_string_t * (svn_string_t value) {
     if (SvOK($input)) {
 	value.data = SvPV($input, value.len);
 	$1 = &value;
@@ -177,7 +202,10 @@
         $1 = NULL;
     }
 }
-%typemap(ruby,in) const svn_string_t * (svn_string_t value)
+#endif
+
+#ifdef SWIGRUBY
+%typemap(in) const svn_string_t * (svn_string_t value)
 {
   if (NIL_P($input)) {
     $1 = NULL;
@@ -187,33 +215,50 @@
     $1 = &value;
   }
 }
+#endif
 
 /* when storing an svn_string_t* into a structure, we must allocate the
    svn_string_t structure on the heap. */
-%typemap(python,memberin) const svn_string_t * {
+#ifdef SWIGPYTHON
+%typemap(memberin) const svn_string_t * {
     $1 = svn_string_dup($input, _global_pool);
 }
-%typemap(perl5,memberin) const svn_string_t * {
+#endif
+
+#ifdef SWIGPERL
+%typemap(memberin) const svn_string_t * {
     $1 = svn_string_dup($input, _global_pool);
 }
-%typemap(ruby,memberin) const svn_string_t * {
+#endif
+
+#ifdef SWIGRUBY
+%typemap(memberin) const svn_string_t * {
     $1 = svn_string_dup($input, _global_pool);
 }
+#endif
 
-%typemap(python,out) svn_string_t * {
+#ifdef SWIGPYTHON
+%typemap(out) svn_string_t * {
     $result = PyString_FromStringAndSize($1->data, $1->len);
 }
-%typemap(perl5,out) svn_string_t * {
+#endif
+
+#ifdef SWIGPERL
+%typemap(out) svn_string_t * {
     $result = sv_2mortal(newSVpv($1->data, $1->len));
     ++argvi;
 }
-%typemap(ruby,out) svn_string_t * {
+#endif
+
+#ifdef SWIGRUBY
+%typemap(out) svn_string_t * {
   if ($1) {
     $result = rb_str_new($1->data, $1->len);
   } else {
     $result = Qnil;
   }
 }
+#endif
 
 /* -----------------------------------------------------------------------
    define a way to return a 'const char *'
@@ -223,7 +268,8 @@
 %typemap(in, numinputs=0) const char **OUTPUT (const char *temp = NULL)
     "$1 = (char **)&temp;"
 
-%typemap(python,argout,fragment="t_output_helper") const char **OUTPUT {
+#ifdef SWIGPYTHON
+%typemap(argout,fragment="t_output_helper") const char **OUTPUT {
     PyObject *s;
     if (*$1 == NULL) {
         Py_INCREF(Py_None);
@@ -236,16 +282,20 @@
     }
     $result = t_output_helper($result, s);
 }
+#endif
 
-%typemap(perl5,argout) const char **OUTPUT {
+#ifdef SWIGPERL
+%typemap(argout) const char **OUTPUT {
     if (*$1 == NULL)
 	$result = &PL_sv_undef;
     else
 	$result = sv_2mortal(newSVpv(*$1, 0));
     ++argvi;
 }
+#endif
 
-%typemap(ruby,argout,fragment="output_helper") const char **OUTPUT
+#ifdef SWIGRUBY
+%typemap(argout,fragment="output_helper") const char **OUTPUT
 {
   if (*$1) {
     $result = output_helper($result, rb_str_new2(*$1));
@@ -253,25 +303,33 @@
     $result = output_helper($result, Qnil);
   }
 }
+#endif
 
 /* -----------------------------------------------------------------------
    define a general INPUT param of an array of const char * items.
  */
 
-%typemap(python,in) const apr_array_header_t *STRINGLIST {
+#ifdef SWIGPYTHON
+%typemap(in) const apr_array_header_t *STRINGLIST {
     $1 = (apr_array_header_t *) svn_swig_py_strings_to_array($input,
                                                              _global_pool);
     if ($1 == NULL)
         SWIG_fail;
 }
-%typemap(perl5,in) const apr_array_header_t *STRINGLIST {
+#endif
+
+#ifdef SWIGPERL
+%typemap(in) const apr_array_header_t *STRINGLIST {
     $1 = (apr_array_header_t *) svn_swig_pl_strings_to_array($input,
                                                              _global_pool);
 }
+#endif
 
-%typemap(ruby,in) const apr_array_header_t *STRINGLIST {
+#ifdef SWIGRUBY
+%typemap(in) const apr_array_header_t *STRINGLIST {
   $1 = svn_swig_rb_strings_to_apr_array($input, _global_pool);
 }
+#endif
 
 /* path lists */
 %apply const apr_array_header_t *STRINGLIST {