← Back to branch summary

~ubuntu-branches/ubuntu/trusty/subversion/trusty-proposed

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/python/svn_ra.c

  • Committer: Package Import Robot
  • Author(s): Andy Whitcroft
  • Date: 2012-06-21 15:36:36 UTC
  • mfrom: (0.4.13 sid)
  • Revision ID: package-import@ubuntu.com-20120621153636-amqqmuidgwgxz1ly
Tags: 1.7.5-1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - Create pot file on build.
  - Build a python-subversion-dbg package.
  - Build-depend on python-dbg.
  - Build-depend on default-jre-headless/-jdk.
  - Do not apply java-build patch.
  - debian/rules: Manually create the doxygen output directory, otherwise
    we get weird build failures when running parallel builds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/bindings/swig/python/svn_ra.c
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.36
 
3
 * Version 2.0.4
4
4
 * 
5
5
 * This file is not intended to be easily readable and contains a number of 
6
6
 * coding conventions designed to improve portability and efficiency. Do not make
11
11
#define SWIGPYTHON
12
12
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
13
#define SWIG_PYTHON_CLASSIC
 
14
 
14
15
/* -----------------------------------------------------------------------------
15
16
 *  This section contains generic SWIG labels for method/variable
16
17
 *  declarations/attributes, and other compiler dependent labels.
127
128
/* -----------------------------------------------------------------------------
128
129
 * swigrun.swg
129
130
 *
130
 
 * This file contains generic CAPI SWIG runtime support for pointer
 
131
 * This file contains generic C API SWIG runtime support for pointer
131
132
 * type checking.
132
133
 * ----------------------------------------------------------------------------- */
133
134
 
146
147
 
147
148
/*
148
149
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
149
 
  creating a static or dynamic library from the swig runtime code.
150
 
  In 99.9% of the cases, swig just needs to declare them as 'static'.
 
150
  creating a static or dynamic library from the SWIG runtime code.
 
151
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
151
152
  
152
 
  But only do this if is strictly necessary, ie, if you have problems
153
 
  with your compiler or so.
 
153
  But only do this if strictly necessary, ie, if you have problems
 
154
  with your compiler or suchlike.
154
155
*/
155
156
 
156
157
#ifndef SWIGRUNTIME
177
178
/* 
178
179
   Flags/methods for returning states.
179
180
   
180
 
   The swig conversion methods, as ConvertPtr, return and integer 
 
181
   The SWIG conversion methods, as ConvertPtr, return an integer 
181
182
   that tells if the conversion was successful or not. And if not,
182
183
   an error code can be returned (see swigerrors.swg for the codes).
183
184
   
184
185
   Use the following macros/flags to set or process the returning
185
186
   states.
186
187
   
187
 
   In old swig versions, you usually write code as:
 
188
   In old versions of SWIG, code such as the following was usually written:
188
189
 
189
190
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
190
191
       // success code
192
193
       //fail code
193
194
     }
194
195
 
195
 
   Now you can be more explicit as:
 
196
   Now you can be more explicit:
196
197
 
197
198
    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
198
199
    if (SWIG_IsOK(res)) {
201
202
      // fail code
202
203
    }
203
204
 
204
 
   that seems to be the same, but now you can also do
 
205
   which is the same really, but now you can also do
205
206
 
206
207
    Type *ptr;
207
208
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
219
220
    
220
221
   I.e., now SWIG_ConvertPtr can return new objects and you can
221
222
   identify the case and take care of the deallocation. Of course that
222
 
   requires also to SWIG_ConvertPtr to return new result values, as
 
223
   also requires SWIG_ConvertPtr to return new result values, such as
223
224
 
224
225
      int SWIG_ConvertPtr(obj, ptr,...) {         
225
226
        if (<obj is ok>) {                             
237
238
 
238
239
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
239
240
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
240
 
   swig errors code.
 
241
   SWIG errors code.
241
242
 
242
243
   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
243
244
   allows to return the 'cast rank', for example, if you have this
251
252
      fooi(1)   // cast rank '0'
252
253
 
253
254
   just use the SWIG_AddCast()/SWIG_CheckState()
254
 
 
255
 
 
256
 
 */
 
255
*/
 
256
 
257
257
#define SWIG_OK                    (0) 
258
258
#define SWIG_ERROR                 (-1)
259
259
#define SWIG_IsOK(r)               (r >= 0)
278
278
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
279
279
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
280
280
 
281
 
 
282
281
/* Cast-Rank Mode */
283
282
#if defined(SWIG_CASTRANK_MODE)
284
283
#  ifndef SWIG_TypeRank
301
300
#endif
302
301
 
303
302
 
304
 
 
305
 
 
306
303
#include <string.h>
307
304
 
308
305
#ifdef __cplusplus
399
396
}
400
397
 
401
398
 
402
 
/* think of this as a c++ template<> or a scheme macro */
403
 
#define SWIG_TypeCheck_Template(comparison, ty)         \
404
 
  if (ty) {                                             \
405
 
    swig_cast_info *iter = ty->cast;                    \
406
 
    while (iter) {                                      \
407
 
      if (comparison) {                                 \
408
 
        if (iter == ty->cast) return iter;              \
409
 
        /* Move iter to the top of the linked list */   \
410
 
        iter->prev->next = iter->next;                  \
411
 
        if (iter->next)                                 \
412
 
          iter->next->prev = iter->prev;                \
413
 
        iter->next = ty->cast;                          \
414
 
        iter->prev = 0;                                 \
415
 
        if (ty->cast) ty->cast->prev = iter;            \
416
 
        ty->cast = iter;                                \
417
 
        return iter;                                    \
418
 
      }                                                 \
419
 
      iter = iter->next;                                \
420
 
    }                                                   \
421
 
  }                                                     \
422
 
  return 0
423
 
 
424
399
/*
425
400
  Check the typename
426
401
*/
427
402
SWIGRUNTIME swig_cast_info *
428
403
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
429
 
  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 
404
  if (ty) {
 
405
    swig_cast_info *iter = ty->cast;
 
406
    while (iter) {
 
407
      if (strcmp(iter->type->name, c) == 0) {
 
408
        if (iter == ty->cast)
 
409
          return iter;
 
410
        /* Move iter to the top of the linked list */
 
411
        iter->prev->next = iter->next;
 
412
        if (iter->next)
 
413
          iter->next->prev = iter->prev;
 
414
        iter->next = ty->cast;
 
415
        iter->prev = 0;
 
416
        if (ty->cast) ty->cast->prev = iter;
 
417
        ty->cast = iter;
 
418
        return iter;
 
419
      }
 
420
      iter = iter->next;
 
421
    }
 
422
  }
 
423
  return 0;
430
424
}
431
425
 
432
 
/* Same as previous function, except strcmp is replaced with a pointer comparison */
 
426
/* 
 
427
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 
428
*/
433
429
SWIGRUNTIME swig_cast_info *
434
 
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
435
 
  SWIG_TypeCheck_Template(iter->type == from, into);
 
430
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 
431
  if (ty) {
 
432
    swig_cast_info *iter = ty->cast;
 
433
    while (iter) {
 
434
      if (iter->type == from) {
 
435
        if (iter == ty->cast)
 
436
          return iter;
 
437
        /* Move iter to the top of the linked list */
 
438
        iter->prev->next = iter->next;
 
439
        if (iter->next)
 
440
          iter->next->prev = iter->prev;
 
441
        iter->next = ty->cast;
 
442
        iter->prev = 0;
 
443
        if (ty->cast) ty->cast->prev = iter;
 
444
        ty->cast = iter;
 
445
        return iter;
 
446
      }
 
447
      iter = iter->next;
 
448
    }
 
449
  }
 
450
  return 0;
436
451
}
437
452
 
438
453
/*
711
726
 
712
727
 
713
728
 
 
729
/* Compatibility macros for Python 3 */
 
730
#if PY_VERSION_HEX >= 0x03000000
 
731
 
 
732
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
 
733
#define PyInt_Check(x) PyLong_Check(x)
 
734
#define PyInt_AsLong(x) PyLong_AsLong(x)
 
735
#define PyInt_FromLong(x) PyLong_FromLong(x)
 
736
#define PyString_Check(name) PyBytes_Check(name)
 
737
#define PyString_FromString(x) PyUnicode_FromString(x)
 
738
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
 
739
#define PyString_AsString(str) PyBytes_AsString(str)
 
740
#define PyString_Size(str) PyBytes_Size(str)    
 
741
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
 
742
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
 
743
#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
 
744
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
 
745
 
 
746
#endif
 
747
 
 
748
#ifndef Py_TYPE
 
749
#  define Py_TYPE(op) ((op)->ob_type)
 
750
#endif
 
751
 
 
752
/* SWIG APIs for compatibility of both Python 2 & 3 */
 
753
 
 
754
#if PY_VERSION_HEX >= 0x03000000
 
755
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
 
756
#else
 
757
#  define SWIG_Python_str_FromFormat PyString_FromFormat
 
758
#endif
 
759
 
 
760
 
 
761
/* Warning: This function will allocate a new string in Python 3,
 
762
 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 
763
 */
 
764
SWIGINTERN char*
 
765
SWIG_Python_str_AsChar(PyObject *str)
 
766
{
 
767
#if PY_VERSION_HEX >= 0x03000000
 
768
  char *cstr;
 
769
  char *newstr;
 
770
  Py_ssize_t len;
 
771
  str = PyUnicode_AsUTF8String(str);
 
772
  PyBytes_AsStringAndSize(str, &cstr, &len);
 
773
  newstr = (char *) malloc(len+1);
 
774
  memcpy(newstr, cstr, len+1);
 
775
  Py_XDECREF(str);
 
776
  return newstr;
 
777
#else
 
778
  return PyString_AsString(str);
 
779
#endif
 
780
}
 
781
 
 
782
#if PY_VERSION_HEX >= 0x03000000
 
783
#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
 
784
#else
 
785
#  define SWIG_Python_str_DelForPy3(x) 
 
786
#endif
 
787
 
 
788
 
 
789
SWIGINTERN PyObject*
 
790
SWIG_Python_str_FromChar(const char *c)
 
791
{
 
792
#if PY_VERSION_HEX >= 0x03000000
 
793
  return PyUnicode_FromString(c); 
 
794
#else
 
795
  return PyString_FromString(c);
 
796
#endif
 
797
}
714
798
 
715
799
/* Add PyOS_snprintf for old Pythons */
716
800
#if PY_VERSION_HEX < 0x02020000
757
841
#  define PyObject_GenericGetAttr 0
758
842
# endif
759
843
#endif
 
844
 
760
845
/* Py_NotImplemented is defined in 2.1 and up. */
761
846
#if PY_VERSION_HEX < 0x02010000
762
847
# ifndef Py_NotImplemented
764
849
# endif
765
850
#endif
766
851
 
767
 
 
768
852
/* A crude PyString_AsStringAndSize implementation for old Pythons */
769
853
#if PY_VERSION_HEX < 0x02010000
770
854
# ifndef PyString_AsStringAndSize
779
863
# endif
780
864
#endif
781
865
 
782
 
 
783
866
/* PyBool_FromLong for old Pythons */
784
867
#if PY_VERSION_HEX < 0x02030000
785
868
static
798
881
typedef int Py_ssize_t;
799
882
# define PY_SSIZE_T_MAX INT_MAX
800
883
# define PY_SSIZE_T_MIN INT_MIN
 
884
typedef inquiry lenfunc;
 
885
typedef intargfunc ssizeargfunc;
 
886
typedef intintargfunc ssizessizeargfunc;
 
887
typedef intobjargproc ssizeobjargproc;
 
888
typedef intintobjargproc ssizessizeobjargproc;
 
889
typedef getreadbufferproc readbufferproc;
 
890
typedef getwritebufferproc writebufferproc;
 
891
typedef getsegcountproc segcountproc;
 
892
typedef getcharbufferproc charbufferproc;
 
893
static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
 
894
{
 
895
  long result = 0;
 
896
  PyObject *i = PyNumber_Int(x);
 
897
  if (i) {
 
898
    result = PyInt_AsLong(i);
 
899
    Py_DECREF(i);
 
900
  }
 
901
  return result;
 
902
}
 
903
#endif
 
904
 
 
905
#if PY_VERSION_HEX < 0x02040000
 
906
#define Py_VISIT(op)                            \
 
907
  do {                                          \
 
908
    if (op) {                                   \
 
909
      int vret = visit((op), arg);              \
 
910
      if (vret)                                 \
 
911
        return vret;                            \
 
912
    }                                           \
 
913
  } while (0)
 
914
#endif
 
915
 
 
916
#if PY_VERSION_HEX < 0x02030000
 
917
typedef struct {
 
918
  PyTypeObject type;
 
919
  PyNumberMethods as_number;
 
920
  PyMappingMethods as_mapping;
 
921
  PySequenceMethods as_sequence;
 
922
  PyBufferProcs as_buffer;
 
923
  PyObject *name, *slots;
 
924
} PyHeapTypeObject;
 
925
#endif
 
926
 
 
927
#if PY_VERSION_HEX < 0x02030000
 
928
typedef destructor freefunc;
 
929
#endif
 
930
 
 
931
#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
 
932
     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
 
933
     (PY_MAJOR_VERSION > 3))
 
934
# define SWIGPY_USE_CAPSULE
 
935
# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
 
936
#endif
 
937
 
 
938
#if PY_VERSION_HEX < 0x03020000
 
939
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
 
940
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
801
941
#endif
802
942
 
803
943
/* -----------------------------------------------------------------------------
857
997
 
858
998
  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
859
999
  if (value) {
 
1000
    char *tmp;
860
1001
    PyObject *old_str = PyObject_Str(value);
861
1002
    PyErr_Clear();
862
1003
    Py_XINCREF(type);
863
 
    PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 
1004
 
 
1005
    PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
 
1006
    SWIG_Python_str_DelForPy3(tmp);
864
1007
    Py_DECREF(old_str);
865
1008
    Py_DECREF(value);
866
1009
  } else {
868
1011
  }
869
1012
}
870
1013
 
871
 
 
872
 
 
873
1014
#if defined(SWIG_PYTHON_NO_THREADS)
874
1015
#  if defined(SWIG_PYTHON_THREADS)
875
1016
#    undef SWIG_PYTHON_THREADS
943
1084
 
944
1085
#ifdef __cplusplus
945
1086
extern "C" {
946
 
#if 0
947
 
} /* cc-mode */
948
 
#endif
949
1087
#endif
950
1088
 
951
1089
/* -----------------------------------------------------------------------------
966
1104
  swig_type_info **ptype;
967
1105
} swig_const_info;
968
1106
 
 
1107
 
 
1108
/* -----------------------------------------------------------------------------
 
1109
 * Wrapper of PyInstanceMethod_New() used in Python 3
 
1110
 * It is exported to the generated module, used for -fastproxy
 
1111
 * ----------------------------------------------------------------------------- */
 
1112
#if PY_VERSION_HEX >= 0x03000000
 
1113
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
 
1114
{
 
1115
  return PyInstanceMethod_New(func);
 
1116
}
 
1117
#else
 
1118
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
 
1119
{
 
1120
  return NULL;
 
1121
}
 
1122
#endif
 
1123
 
969
1124
#ifdef __cplusplus
970
 
#if 0
971
 
{ /* cc-mode */
972
 
#endif
973
1125
}
974
1126
#endif
975
1127
 
976
1128
 
977
1129
/* -----------------------------------------------------------------------------
978
 
 * See the LICENSE file for information on copyright, usage and redistribution
979
 
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
980
 
 *
981
1130
 * pyrun.swg
982
1131
 *
983
1132
 * This file contains the runtime support for Python modules
992
1141
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
993
1142
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
994
1143
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
995
 
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
 
1144
 
 
1145
#ifdef SWIGPYTHON_BUILTIN
 
1146
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
 
1147
#else
 
1148
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
 
1149
#endif
 
1150
 
 
1151
#define SWIG_InternalNewPointerObj(ptr, type, flags)    SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
 
1152
 
996
1153
#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
997
1154
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
998
1155
#define swig_owntype                                    int
1007
1164
 
1008
1165
/* for C or C++ function pointers */
1009
1166
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1010
 
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
 
1167
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1011
1168
 
1012
1169
/* for C++ member pointers, ie, member methods */
1013
1170
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1018
1175
 
1019
1176
#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1020
1177
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1021
 
#define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
 
1178
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
1022
1179
 
1023
1180
#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
1024
1181
#define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg                            
1050
1207
 
1051
1208
/* Set a constant value */
1052
1209
 
 
1210
#if defined(SWIGPYTHON_BUILTIN)
 
1211
 
 
1212
SWIGINTERN void
 
1213
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
 
1214
  PyObject *s = PyString_InternFromString(key);
 
1215
  PyList_Append(seq, s);
 
1216
  Py_DECREF(s);
 
1217
}
 
1218
 
 
1219
SWIGINTERN void
 
1220
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
 
1221
  PyDict_SetItemString(d, (char *)name, obj);
 
1222
  Py_DECREF(obj);
 
1223
  if (public_interface)
 
1224
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
 
1225
}
 
1226
 
 
1227
#else
 
1228
 
1053
1229
SWIGINTERN void
1054
1230
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
1055
 
  PyDict_SetItemString(d, (char*) name, obj);
 
1231
  PyDict_SetItemString(d, (char *)name, obj);
1056
1232
  Py_DECREF(obj);                            
1057
1233
}
1058
1234
 
 
1235
#endif
 
1236
 
1059
1237
/* Append a value to the result obj */
1060
1238
 
1061
1239
SWIGINTERN PyObject*
1116
1294
    }
1117
1295
  }  
1118
1296
  if (!PyTuple_Check(args)) {
 
1297
    if (min <= 1 && max >= 1) {
 
1298
      register int i;
 
1299
      objs[0] = args;
 
1300
      for (i = 1; i < max; ++i) {
 
1301
        objs[i] = 0;
 
1302
      }
 
1303
      return 2;
 
1304
    }
1119
1305
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1120
1306
    return 0;
1121
1307
  } else {
1168
1354
 
1169
1355
#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1170
1356
 
 
1357
#define SWIG_BUILTIN_TP_INIT        (SWIG_POINTER_OWN << 2)
 
1358
#define SWIG_BUILTIN_INIT           (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
 
1359
 
1171
1360
#ifdef __cplusplus
1172
1361
extern "C" {
1173
 
#if 0
1174
 
} /* cc-mode */
1175
 
#endif
1176
1362
#endif
1177
1363
 
1178
1364
/*  How to access Py_None */
1214
1400
  return none;
1215
1401
}
1216
1402
 
1217
 
/* PySwigClientData */
 
1403
/* SwigPyClientData */
1218
1404
 
1219
1405
typedef struct {
1220
1406
  PyObject *klass;
1223
1409
  PyObject *destroy;
1224
1410
  int delargs;
1225
1411
  int implicitconv;
1226
 
} PySwigClientData;
 
1412
  PyTypeObject *pytype;
 
1413
} SwigPyClientData;
1227
1414
 
1228
1415
SWIGRUNTIMEINLINE int 
1229
1416
SWIG_Python_CheckImplicit(swig_type_info *ty)
1230
1417
{
1231
 
  PySwigClientData *data = (PySwigClientData *)ty->clientdata;
 
1418
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1232
1419
  return data ? data->implicitconv : 0;
1233
1420
}
1234
1421
 
1235
1422
SWIGRUNTIMEINLINE PyObject *
1236
1423
SWIG_Python_ExceptionType(swig_type_info *desc) {
1237
 
  PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
 
1424
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1238
1425
  PyObject *klass = data ? data->klass : 0;
1239
1426
  return (klass ? klass : PyExc_RuntimeError);
1240
1427
}
1241
1428
 
1242
1429
 
1243
 
SWIGRUNTIME PySwigClientData * 
1244
 
PySwigClientData_New(PyObject* obj)
 
1430
SWIGRUNTIME SwigPyClientData * 
 
1431
SwigPyClientData_New(PyObject* obj)
1245
1432
{
1246
1433
  if (!obj) {
1247
1434
    return 0;
1248
1435
  } else {
1249
 
    PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
 
1436
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1250
1437
    /* the klass element */
1251
1438
    data->klass = obj;
1252
1439
    Py_INCREF(data->klass);
1289
1476
      data->delargs = 0;
1290
1477
    }
1291
1478
    data->implicitconv = 0;
 
1479
    data->pytype = 0;
1292
1480
    return data;
1293
1481
  }
1294
1482
}
1295
1483
 
1296
1484
SWIGRUNTIME void 
1297
 
PySwigClientData_Del(PySwigClientData* data)
1298
 
{
 
1485
SwigPyClientData_Del(SwigPyClientData *data) {
1299
1486
  Py_XDECREF(data->newraw);
1300
1487
  Py_XDECREF(data->newargs);
1301
1488
  Py_XDECREF(data->destroy);
1302
1489
}
1303
1490
 
1304
 
/* =============== PySwigObject =====================*/
 
1491
/* =============== SwigPyObject =====================*/
1305
1492
 
1306
1493
typedef struct {
1307
1494
  PyObject_HEAD
1309
1496
  swig_type_info *ty;
1310
1497
  int own;
1311
1498
  PyObject *next;
1312
 
} PySwigObject;
 
1499
#ifdef SWIGPYTHON_BUILTIN
 
1500
  PyObject *dict;
 
1501
#endif
 
1502
} SwigPyObject;
1313
1503
 
1314
1504
SWIGRUNTIME PyObject *
1315
 
PySwigObject_long(PySwigObject *v)
 
1505
SwigPyObject_long(SwigPyObject *v)
1316
1506
{
1317
1507
  return PyLong_FromVoidPtr(v->ptr);
1318
1508
}
1319
1509
 
1320
1510
SWIGRUNTIME PyObject *
1321
 
PySwigObject_format(const char* fmt, PySwigObject *v)
 
1511
SwigPyObject_format(const char* fmt, SwigPyObject *v)
1322
1512
{
1323
1513
  PyObject *res = NULL;
1324
1514
  PyObject *args = PyTuple_New(1);
1325
1515
  if (args) {
1326
 
    if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1327
 
      PyObject *ofmt = PyString_FromString(fmt);
 
1516
    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
 
1517
      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1328
1518
      if (ofmt) {
 
1519
#if PY_VERSION_HEX >= 0x03000000
 
1520
        res = PyUnicode_Format(ofmt,args);
 
1521
#else
1329
1522
        res = PyString_Format(ofmt,args);
 
1523
#endif
1330
1524
        Py_DECREF(ofmt);
1331
1525
      }
1332
1526
      Py_DECREF(args);
1336
1530
}
1337
1531
 
1338
1532
SWIGRUNTIME PyObject *
1339
 
PySwigObject_oct(PySwigObject *v)
 
1533
SwigPyObject_oct(SwigPyObject *v)
1340
1534
{
1341
 
  return PySwigObject_format("%o",v);
 
1535
  return SwigPyObject_format("%o",v);
1342
1536
}
1343
1537
 
1344
1538
SWIGRUNTIME PyObject *
1345
 
PySwigObject_hex(PySwigObject *v)
 
1539
SwigPyObject_hex(SwigPyObject *v)
1346
1540
{
1347
 
  return PySwigObject_format("%x",v);
 
1541
  return SwigPyObject_format("%x",v);
1348
1542
}
1349
1543
 
1350
1544
SWIGRUNTIME PyObject *
1351
1545
#ifdef METH_NOARGS
1352
 
PySwigObject_repr(PySwigObject *v)
 
1546
SwigPyObject_repr(SwigPyObject *v)
1353
1547
#else
1354
 
PySwigObject_repr(PySwigObject *v, PyObject *args)
 
1548
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1355
1549
#endif
1356
1550
{
1357
1551
  const char *name = SWIG_TypePrettyName(v->ty);
1358
 
  PyObject *hex = PySwigObject_hex(v);    
1359
 
  PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1360
 
  Py_DECREF(hex);
 
1552
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, (void *)v);
1361
1553
  if (v->next) {
1362
 
#ifdef METH_NOARGS
1363
 
    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1364
 
#else
1365
 
    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1366
 
#endif
 
1554
# ifdef METH_NOARGS
 
1555
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
 
1556
# else
 
1557
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
 
1558
# endif
 
1559
# if PY_VERSION_HEX >= 0x03000000
 
1560
    PyObject *joined = PyUnicode_Concat(repr, nrep);
 
1561
    Py_DecRef(repr);
 
1562
    Py_DecRef(nrep);
 
1563
    repr = joined;
 
1564
# else
1367
1565
    PyString_ConcatAndDel(&repr,nrep);
 
1566
# endif
1368
1567
  }
1369
1568
  return repr;  
1370
1569
}
1371
1570
 
1372
1571
SWIGRUNTIME int
1373
 
PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
 
1572
SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1374
1573
{
 
1574
  char *str;
1375
1575
#ifdef METH_NOARGS
1376
 
  PyObject *repr = PySwigObject_repr(v);
 
1576
  PyObject *repr = SwigPyObject_repr(v);
1377
1577
#else
1378
 
  PyObject *repr = PySwigObject_repr(v, NULL);
 
1578
  PyObject *repr = SwigPyObject_repr(v, NULL);
1379
1579
#endif
1380
1580
  if (repr) {
1381
 
    fputs(PyString_AsString(repr), fp);
 
1581
    str = SWIG_Python_str_AsChar(repr); 
 
1582
    fputs(str, fp);
 
1583
    SWIG_Python_str_DelForPy3(str);
1382
1584
    Py_DECREF(repr);
1383
1585
    return 0; 
1384
1586
  } else {
1387
1589
}
1388
1590
 
1389
1591
SWIGRUNTIME PyObject *
1390
 
PySwigObject_str(PySwigObject *v)
 
1592
SwigPyObject_str(SwigPyObject *v)
1391
1593
{
1392
1594
  char result[SWIG_BUFFER_SIZE];
1393
1595
  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1394
 
    PyString_FromString(result) : 0;
 
1596
    SWIG_Python_str_FromChar(result) : 0;
1395
1597
}
1396
1598
 
1397
1599
SWIGRUNTIME int
1398
 
PySwigObject_compare(PySwigObject *v, PySwigObject *w)
 
1600
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1399
1601
{
1400
1602
  void *i = v->ptr;
1401
1603
  void *j = w->ptr;
1402
1604
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1403
1605
}
1404
1606
 
1405
 
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1406
 
 
1407
 
SWIGRUNTIME PyTypeObject*
1408
 
PySwigObject_type(void) {
1409
 
  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
 
1607
/* Added for Python 3.x, would it also be useful for Python 2.x? */
 
1608
SWIGRUNTIME PyObject*
 
1609
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
 
1610
{
 
1611
  PyObject* res;
 
1612
  if( op != Py_EQ && op != Py_NE ) {
 
1613
    Py_INCREF(Py_NotImplemented);
 
1614
    return Py_NotImplemented;
 
1615
  }
 
1616
  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
 
1617
  return res;  
 
1618
}
 
1619
 
 
1620
 
 
1621
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
 
1622
 
 
1623
#ifdef SWIGPYTHON_BUILTIN
 
1624
static swig_type_info *SwigPyObject_stype = 0;
 
1625
SWIGRUNTIME PyTypeObject*
 
1626
SwigPyObject_type(void) {
 
1627
    SwigPyClientData *cd;
 
1628
    assert(SwigPyObject_stype);
 
1629
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
 
1630
    assert(cd);
 
1631
    assert(cd->pytype);
 
1632
    return cd->pytype;
 
1633
}
 
1634
#else
 
1635
SWIGRUNTIME PyTypeObject*
 
1636
SwigPyObject_type(void) {
 
1637
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1410
1638
  return type;
1411
1639
}
 
1640
#endif
1412
1641
 
1413
1642
SWIGRUNTIMEINLINE int
1414
 
PySwigObject_Check(PyObject *op) {
1415
 
  return ((op)->ob_type == PySwigObject_type())
1416
 
    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
 
1643
SwigPyObject_Check(PyObject *op) {
 
1644
#ifdef SWIGPYTHON_BUILTIN
 
1645
  PyTypeObject *target_tp = SwigPyObject_type();
 
1646
  if (PyType_IsSubtype(op->ob_type, target_tp))
 
1647
    return 1;
 
1648
  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
 
1649
#else
 
1650
  return (Py_TYPE(op) == SwigPyObject_type())
 
1651
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
 
1652
#endif
1417
1653
}
1418
1654
 
1419
1655
SWIGRUNTIME PyObject *
1420
 
PySwigObject_New(void *ptr, swig_type_info *ty, int own);
 
1656
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1421
1657
 
1422
1658
SWIGRUNTIME void
1423
 
PySwigObject_dealloc(PyObject *v)
 
1659
SwigPyObject_dealloc(PyObject *v)
1424
1660
{
1425
 
  PySwigObject *sobj = (PySwigObject *) v;
 
1661
  SwigPyObject *sobj = (SwigPyObject *) v;
1426
1662
  PyObject *next = sobj->next;
1427
1663
  if (sobj->own == SWIG_POINTER_OWN) {
1428
1664
    swig_type_info *ty = sobj->ty;
1429
 
    PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
 
1665
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1430
1666
    PyObject *destroy = data ? data->destroy : 0;
1431
1667
    if (destroy) {
1432
1668
      /* destroy is always a VARARGS method */
1433
1669
      PyObject *res;
1434
1670
      if (data->delargs) {
1435
 
        /* we need to create a temporal object to carry the destroy operation */
1436
 
        PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
 
1671
        /* we need to create a temporary object to carry the destroy operation */
 
1672
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1437
1673
        res = SWIG_Python_CallFunctor(destroy, tmp);
1438
1674
        Py_DECREF(tmp);
1439
1675
      } else {
1455
1691
}
1456
1692
 
1457
1693
SWIGRUNTIME PyObject* 
1458
 
PySwigObject_append(PyObject* v, PyObject* next)
 
1694
SwigPyObject_append(PyObject* v, PyObject* next)
1459
1695
{
1460
 
  PySwigObject *sobj = (PySwigObject *) v;
 
1696
  SwigPyObject *sobj = (SwigPyObject *) v;
1461
1697
#ifndef METH_O
1462
1698
  PyObject *tmp = 0;
1463
1699
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464
1700
  next = tmp;
1465
1701
#endif
1466
 
  if (!PySwigObject_Check(next)) {
 
1702
  if (!SwigPyObject_Check(next)) {
1467
1703
    return NULL;
1468
1704
  }
1469
1705
  sobj->next = next;
1473
1709
 
1474
1710
SWIGRUNTIME PyObject* 
1475
1711
#ifdef METH_NOARGS
1476
 
PySwigObject_next(PyObject* v)
 
1712
SwigPyObject_next(PyObject* v)
1477
1713
#else
1478
 
PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 
1714
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479
1715
#endif
1480
1716
{
1481
 
  PySwigObject *sobj = (PySwigObject *) v;
 
1717
  SwigPyObject *sobj = (SwigPyObject *) v;
1482
1718
  if (sobj->next) {    
1483
1719
    Py_INCREF(sobj->next);
1484
1720
    return sobj->next;
1489
1725
 
1490
1726
SWIGINTERN PyObject*
1491
1727
#ifdef METH_NOARGS
1492
 
PySwigObject_disown(PyObject *v)
 
1728
SwigPyObject_disown(PyObject *v)
1493
1729
#else
1494
 
PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 
1730
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495
1731
#endif
1496
1732
{
1497
 
  PySwigObject *sobj = (PySwigObject *)v;
 
1733
  SwigPyObject *sobj = (SwigPyObject *)v;
1498
1734
  sobj->own = 0;
1499
1735
  return SWIG_Py_Void();
1500
1736
}
1501
1737
 
1502
1738
SWIGINTERN PyObject*
1503
1739
#ifdef METH_NOARGS
1504
 
PySwigObject_acquire(PyObject *v)
 
1740
SwigPyObject_acquire(PyObject *v)
1505
1741
#else
1506
 
PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 
1742
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507
1743
#endif
1508
1744
{
1509
 
  PySwigObject *sobj = (PySwigObject *)v;
 
1745
  SwigPyObject *sobj = (SwigPyObject *)v;
1510
1746
  sobj->own = SWIG_POINTER_OWN;
1511
1747
  return SWIG_Py_Void();
1512
1748
}
1513
1749
 
1514
1750
SWIGINTERN PyObject*
1515
 
PySwigObject_own(PyObject *v, PyObject *args)
 
1751
SwigPyObject_own(PyObject *v, PyObject *args)
1516
1752
{
1517
1753
  PyObject *val = 0;
1518
1754
#if (PY_VERSION_HEX < 0x02020000)
1525
1761
    } 
1526
1762
  else
1527
1763
    {
1528
 
      PySwigObject *sobj = (PySwigObject *)v;
 
1764
      SwigPyObject *sobj = (SwigPyObject *)v;
1529
1765
      PyObject *obj = PyBool_FromLong(sobj->own);
1530
1766
      if (val) {
1531
1767
#ifdef METH_NOARGS
1532
1768
        if (PyObject_IsTrue(val)) {
1533
 
          PySwigObject_acquire(v);
 
1769
          SwigPyObject_acquire(v);
1534
1770
        } else {
1535
 
          PySwigObject_disown(v);
 
1771
          SwigPyObject_disown(v);
1536
1772
        }
1537
1773
#else
1538
1774
        if (PyObject_IsTrue(val)) {
1539
 
          PySwigObject_acquire(v,args);
 
1775
          SwigPyObject_acquire(v,args);
1540
1776
        } else {
1541
 
          PySwigObject_disown(v,args);
 
1777
          SwigPyObject_disown(v,args);
1542
1778
        }
1543
1779
#endif
1544
1780
      } 
1549
1785
#ifdef METH_O
1550
1786
static PyMethodDef
1551
1787
swigobject_methods[] = {
1552
 
  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1553
 
  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1554
 
  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555
 
  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1556
 
  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1557
 
  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
 
1788
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
 
1789
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
 
1790
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
 
1791
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
 
1792
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
 
1793
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1558
1794
  {0, 0, 0, 0}  
1559
1795
};
1560
1796
#else
1561
1797
static PyMethodDef
1562
1798
swigobject_methods[] = {
1563
 
  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1564
 
  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1565
 
  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1566
 
  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1567
 
  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1568
 
  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
 
1799
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
 
1800
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
 
1801
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
 
1802
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
 
1803
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
 
1804
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1569
1805
  {0, 0, 0, 0}  
1570
1806
};
1571
1807
#endif
1572
1808
 
1573
1809
#if PY_VERSION_HEX < 0x02020000
1574
1810
SWIGINTERN PyObject *
1575
 
PySwigObject_getattr(PySwigObject *sobj,char *name)
 
1811
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1576
1812
{
1577
1813
  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578
1814
}
1579
1815
#endif
1580
1816
 
1581
1817
SWIGRUNTIME PyTypeObject*
1582
 
_PySwigObject_type(void) {
 
1818
SwigPyObject_TypeOnce(void) {
1583
1819
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
 
  
1585
 
  static PyNumberMethods PySwigObject_as_number = {
 
1820
 
 
1821
  static PyNumberMethods SwigPyObject_as_number = {
1586
1822
    (binaryfunc)0, /*nb_add*/
1587
1823
    (binaryfunc)0, /*nb_subtract*/
1588
1824
    (binaryfunc)0, /*nb_multiply*/
 
1825
    /* nb_divide removed in Python 3 */
 
1826
#if PY_VERSION_HEX < 0x03000000
1589
1827
    (binaryfunc)0, /*nb_divide*/
 
1828
#endif
1590
1829
    (binaryfunc)0, /*nb_remainder*/
1591
1830
    (binaryfunc)0, /*nb_divmod*/
1592
1831
    (ternaryfunc)0,/*nb_power*/
1600
1839
    0,             /*nb_and*/
1601
1840
    0,             /*nb_xor*/
1602
1841
    0,             /*nb_or*/
1603
 
    (coercion)0,   /*nb_coerce*/
1604
 
    (unaryfunc)PySwigObject_long, /*nb_int*/
1605
 
    (unaryfunc)PySwigObject_long, /*nb_long*/
 
1842
#if PY_VERSION_HEX < 0x03000000
 
1843
    0,   /*nb_coerce*/
 
1844
#endif
 
1845
    (unaryfunc)SwigPyObject_long, /*nb_int*/
 
1846
#if PY_VERSION_HEX < 0x03000000
 
1847
    (unaryfunc)SwigPyObject_long, /*nb_long*/
 
1848
#else
 
1849
    0, /*nb_reserved*/
 
1850
#endif
1606
1851
    (unaryfunc)0,                 /*nb_float*/
1607
 
    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
1608
 
    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
1609
 
#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
 
1852
#if PY_VERSION_HEX < 0x03000000
 
1853
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
 
1854
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
 
1855
#endif
 
1856
#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
 
1857
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
 
1858
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1610
1859
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1611
1860
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1612
1861
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1615
1864
#endif
1616
1865
  };
1617
1866
 
1618
 
  static PyTypeObject pyswigobject_type;  
 
1867
  static PyTypeObject swigpyobject_type;
1619
1868
  static int type_init = 0;
1620
1869
  if (!type_init) {
1621
 
    const PyTypeObject tmp
1622
 
      = {
1623
 
        PyObject_HEAD_INIT(NULL)
1624
 
        0,                                  /* ob_size */
1625
 
        (char *)"PySwigObject",             /* tp_name */
1626
 
        sizeof(PySwigObject),               /* tp_basicsize */
1627
 
        0,                                  /* tp_itemsize */
1628
 
        (destructor)PySwigObject_dealloc,   /* tp_dealloc */
1629
 
        (printfunc)PySwigObject_print,      /* tp_print */
 
1870
    const PyTypeObject tmp = {
 
1871
      /* PyObject header changed in Python 3 */
 
1872
#if PY_VERSION_HEX >= 0x03000000
 
1873
      PyVarObject_HEAD_INIT(NULL, 0)
 
1874
#else
 
1875
      PyObject_HEAD_INIT(NULL)
 
1876
      0,                                    /* ob_size */
 
1877
#endif
 
1878
      (char *)"SwigPyObject",               /* tp_name */
 
1879
      sizeof(SwigPyObject),                 /* tp_basicsize */
 
1880
      0,                                    /* tp_itemsize */
 
1881
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
 
1882
      (printfunc)SwigPyObject_print,        /* tp_print */
1630
1883
#if PY_VERSION_HEX < 0x02020000
1631
 
        (getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
1632
 
#else
1633
 
        (getattrfunc)0,                     /* tp_getattr */ 
1634
 
#endif
1635
 
        (setattrfunc)0,                     /* tp_setattr */ 
1636
 
        (cmpfunc)PySwigObject_compare,      /* tp_compare */ 
1637
 
        (reprfunc)PySwigObject_repr,        /* tp_repr */    
1638
 
        &PySwigObject_as_number,            /* tp_as_number */
1639
 
        0,                                  /* tp_as_sequence */
1640
 
        0,                                  /* tp_as_mapping */
1641
 
        (hashfunc)0,                        /* tp_hash */
1642
 
        (ternaryfunc)0,                     /* tp_call */
1643
 
        (reprfunc)PySwigObject_str,         /* tp_str */
1644
 
        PyObject_GenericGetAttr,            /* tp_getattro */
1645
 
        0,                                  /* tp_setattro */
1646
 
        0,                                  /* tp_as_buffer */
1647
 
        Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1648
 
        swigobject_doc,                     /* tp_doc */        
1649
 
        0,                                  /* tp_traverse */
1650
 
        0,                                  /* tp_clear */
1651
 
        0,                                  /* tp_richcompare */
1652
 
        0,                                  /* tp_weaklistoffset */
 
1884
      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
 
1885
#else
 
1886
      (getattrfunc)0,                       /* tp_getattr */
 
1887
#endif
 
1888
      (setattrfunc)0,                       /* tp_setattr */
 
1889
#if PY_VERSION_HEX >= 0x03000000
 
1890
    0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
 
1891
#else
 
1892
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
 
1893
#endif
 
1894
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
 
1895
      &SwigPyObject_as_number,              /* tp_as_number */
 
1896
      0,                                    /* tp_as_sequence */
 
1897
      0,                                    /* tp_as_mapping */
 
1898
      (hashfunc)0,                          /* tp_hash */
 
1899
      (ternaryfunc)0,                       /* tp_call */
 
1900
      (reprfunc)SwigPyObject_str,           /* tp_str */
 
1901
      PyObject_GenericGetAttr,              /* tp_getattro */
 
1902
      0,                                    /* tp_setattro */
 
1903
      0,                                    /* tp_as_buffer */
 
1904
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
 
1905
      swigobject_doc,                       /* tp_doc */
 
1906
      0,                                    /* tp_traverse */
 
1907
      0,                                    /* tp_clear */
 
1908
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
 
1909
      0,                                    /* tp_weaklistoffset */
1653
1910
#if PY_VERSION_HEX >= 0x02020000
1654
 
        0,                                  /* tp_iter */
1655
 
        0,                                  /* tp_iternext */
1656
 
        swigobject_methods,                 /* tp_methods */ 
1657
 
        0,                                  /* tp_members */
1658
 
        0,                                  /* tp_getset */             
1659
 
        0,                                  /* tp_base */               
1660
 
        0,                                  /* tp_dict */               
1661
 
        0,                                  /* tp_descr_get */          
1662
 
        0,                                  /* tp_descr_set */          
1663
 
        0,                                  /* tp_dictoffset */         
1664
 
        0,                                  /* tp_init */               
1665
 
        0,                                  /* tp_alloc */              
1666
 
        0,                                  /* tp_new */                
1667
 
        0,                                  /* tp_free */          
1668
 
        0,                                  /* tp_is_gc */  
1669
 
        0,                                  /* tp_bases */   
1670
 
        0,                                  /* tp_mro */
1671
 
        0,                                  /* tp_cache */   
1672
 
        0,                                  /* tp_subclasses */
1673
 
        0,                                  /* tp_weaklist */
 
1911
      0,                                    /* tp_iter */
 
1912
      0,                                    /* tp_iternext */
 
1913
      swigobject_methods,                   /* tp_methods */
 
1914
      0,                                    /* tp_members */
 
1915
      0,                                    /* tp_getset */
 
1916
      0,                                    /* tp_base */
 
1917
      0,                                    /* tp_dict */
 
1918
      0,                                    /* tp_descr_get */
 
1919
      0,                                    /* tp_descr_set */
 
1920
      0,                                    /* tp_dictoffset */
 
1921
      0,                                    /* tp_init */
 
1922
      0,                                    /* tp_alloc */
 
1923
      0,                                    /* tp_new */
 
1924
      0,                                    /* tp_free */
 
1925
      0,                                    /* tp_is_gc */
 
1926
      0,                                    /* tp_bases */
 
1927
      0,                                    /* tp_mro */
 
1928
      0,                                    /* tp_cache */
 
1929
      0,                                    /* tp_subclasses */
 
1930
      0,                                    /* tp_weaklist */
1674
1931
#endif
1675
1932
#if PY_VERSION_HEX >= 0x02030000
1676
 
        0,                                  /* tp_del */
 
1933
      0,                                    /* tp_del */
 
1934
#endif
 
1935
#if PY_VERSION_HEX >= 0x02060000
 
1936
      0,                                    /* tp_version */
1677
1937
#endif
1678
1938
#ifdef COUNT_ALLOCS
1679
 
        0,0,0,0                             /* tp_alloc -> tp_next */
 
1939
      0,0,0,0                               /* tp_alloc -> tp_next */
1680
1940
#endif
1681
 
      };
1682
 
    pyswigobject_type = tmp;
1683
 
    pyswigobject_type.ob_type = &PyType_Type;
 
1941
    };
 
1942
    swigpyobject_type = tmp;
1684
1943
    type_init = 1;
 
1944
#if PY_VERSION_HEX < 0x02020000
 
1945
    swigpyobject_type.ob_type = &PyType_Type;
 
1946
#else
 
1947
    if (PyType_Ready(&swigpyobject_type) < 0)
 
1948
      return NULL;
 
1949
#endif
1685
1950
  }
1686
 
  return &pyswigobject_type;
 
1951
  return &swigpyobject_type;
1687
1952
}
1688
1953
 
1689
1954
SWIGRUNTIME PyObject *
1690
 
PySwigObject_New(void *ptr, swig_type_info *ty, int own)
 
1955
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1691
1956
{
1692
 
  PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
 
1957
  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1693
1958
  if (sobj) {
1694
1959
    sobj->ptr  = ptr;
1695
1960
    sobj->ty   = ty;
1708
1973
  void *pack;
1709
1974
  swig_type_info *ty;
1710
1975
  size_t size;
1711
 
} PySwigPacked;
 
1976
} SwigPyPacked;
1712
1977
 
1713
1978
SWIGRUNTIME int
1714
 
PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
 
1979
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1715
1980
{
1716
1981
  char result[SWIG_BUFFER_SIZE];
1717
1982
  fputs("<Swig Packed ", fp); 
1725
1990
}
1726
1991
  
1727
1992
SWIGRUNTIME PyObject *
1728
 
PySwigPacked_repr(PySwigPacked *v)
 
1993
SwigPyPacked_repr(SwigPyPacked *v)
1729
1994
{
1730
1995
  char result[SWIG_BUFFER_SIZE];
1731
1996
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1732
 
    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
 
1997
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1733
1998
  } else {
1734
 
    return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
 
1999
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1735
2000
  }  
1736
2001
}
1737
2002
 
1738
2003
SWIGRUNTIME PyObject *
1739
 
PySwigPacked_str(PySwigPacked *v)
 
2004
SwigPyPacked_str(SwigPyPacked *v)
1740
2005
{
1741
2006
  char result[SWIG_BUFFER_SIZE];
1742
2007
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1743
 
    return PyString_FromFormat("%s%s", result, v->ty->name);
 
2008
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1744
2009
  } else {
1745
 
    return PyString_FromString(v->ty->name);
 
2010
    return SWIG_Python_str_FromChar(v->ty->name);
1746
2011
  }  
1747
2012
}
1748
2013
 
1749
2014
SWIGRUNTIME int
1750
 
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
 
2015
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1751
2016
{
1752
2017
  size_t i = v->size;
1753
2018
  size_t j = w->size;
1755
2020
  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1756
2021
}
1757
2022
 
1758
 
SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
 
2023
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
1759
2024
 
1760
2025
SWIGRUNTIME PyTypeObject*
1761
 
PySwigPacked_type(void) {
1762
 
  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
 
2026
SwigPyPacked_type(void) {
 
2027
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1763
2028
  return type;
1764
2029
}
1765
2030
 
1766
2031
SWIGRUNTIMEINLINE int
1767
 
PySwigPacked_Check(PyObject *op) {
1768
 
  return ((op)->ob_type == _PySwigPacked_type()) 
1769
 
    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
 
2032
SwigPyPacked_Check(PyObject *op) {
 
2033
  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
 
2034
    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1770
2035
}
1771
2036
 
1772
2037
SWIGRUNTIME void
1773
 
PySwigPacked_dealloc(PyObject *v)
 
2038
SwigPyPacked_dealloc(PyObject *v)
1774
2039
{
1775
 
  if (PySwigPacked_Check(v)) {
1776
 
    PySwigPacked *sobj = (PySwigPacked *) v;
 
2040
  if (SwigPyPacked_Check(v)) {
 
2041
    SwigPyPacked *sobj = (SwigPyPacked *) v;
1777
2042
    free(sobj->pack);
1778
2043
  }
1779
2044
  PyObject_DEL(v);
1780
2045
}
1781
2046
 
1782
2047
SWIGRUNTIME PyTypeObject*
1783
 
_PySwigPacked_type(void) {
 
2048
SwigPyPacked_TypeOnce(void) {
1784
2049
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1785
 
  static PyTypeObject pyswigpacked_type;
1786
 
  static int type_init = 0;  
 
2050
  static PyTypeObject swigpypacked_type;
 
2051
  static int type_init = 0;
1787
2052
  if (!type_init) {
1788
 
    const PyTypeObject tmp
1789
 
      = {
1790
 
        PyObject_HEAD_INIT(NULL)
1791
 
        0,                                  /* ob_size */       
1792
 
        (char *)"PySwigPacked",             /* tp_name */       
1793
 
        sizeof(PySwigPacked),               /* tp_basicsize */  
1794
 
        0,                                  /* tp_itemsize */   
1795
 
        (destructor)PySwigPacked_dealloc,   /* tp_dealloc */    
1796
 
        (printfunc)PySwigPacked_print,      /* tp_print */      
1797
 
        (getattrfunc)0,                     /* tp_getattr */    
1798
 
        (setattrfunc)0,                     /* tp_setattr */    
1799
 
        (cmpfunc)PySwigPacked_compare,      /* tp_compare */    
1800
 
        (reprfunc)PySwigPacked_repr,        /* tp_repr */       
1801
 
        0,                                  /* tp_as_number */  
1802
 
        0,                                  /* tp_as_sequence */
1803
 
        0,                                  /* tp_as_mapping */ 
1804
 
        (hashfunc)0,                        /* tp_hash */       
1805
 
        (ternaryfunc)0,                     /* tp_call */       
1806
 
        (reprfunc)PySwigPacked_str,         /* tp_str */        
1807
 
        PyObject_GenericGetAttr,            /* tp_getattro */
1808
 
        0,                                  /* tp_setattro */
1809
 
        0,                                  /* tp_as_buffer */
1810
 
        Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1811
 
        swigpacked_doc,                     /* tp_doc */
1812
 
        0,                                  /* tp_traverse */
1813
 
        0,                                  /* tp_clear */
1814
 
        0,                                  /* tp_richcompare */
1815
 
        0,                                  /* tp_weaklistoffset */
 
2053
    const PyTypeObject tmp = {
 
2054
      /* PyObject header changed in Python 3 */
 
2055
#if PY_VERSION_HEX>=0x03000000
 
2056
      PyVarObject_HEAD_INIT(NULL, 0)
 
2057
#else
 
2058
      PyObject_HEAD_INIT(NULL)
 
2059
      0,                                    /* ob_size */
 
2060
#endif
 
2061
      (char *)"SwigPyPacked",               /* tp_name */
 
2062
      sizeof(SwigPyPacked),                 /* tp_basicsize */
 
2063
      0,                                    /* tp_itemsize */
 
2064
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
 
2065
      (printfunc)SwigPyPacked_print,        /* tp_print */
 
2066
      (getattrfunc)0,                       /* tp_getattr */
 
2067
      (setattrfunc)0,                       /* tp_setattr */
 
2068
#if PY_VERSION_HEX>=0x03000000
 
2069
      0, /* tp_reserved in 3.0.1 */
 
2070
#else
 
2071
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
 
2072
#endif
 
2073
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
 
2074
      0,                                    /* tp_as_number */
 
2075
      0,                                    /* tp_as_sequence */
 
2076
      0,                                    /* tp_as_mapping */
 
2077
      (hashfunc)0,                          /* tp_hash */
 
2078
      (ternaryfunc)0,                       /* tp_call */
 
2079
      (reprfunc)SwigPyPacked_str,           /* tp_str */
 
2080
      PyObject_GenericGetAttr,              /* tp_getattro */
 
2081
      0,                                    /* tp_setattro */
 
2082
      0,                                    /* tp_as_buffer */
 
2083
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
 
2084
      swigpacked_doc,                       /* tp_doc */
 
2085
      0,                                    /* tp_traverse */
 
2086
      0,                                    /* tp_clear */
 
2087
      0,                                    /* tp_richcompare */
 
2088
      0,                                    /* tp_weaklistoffset */
1816
2089
#if PY_VERSION_HEX >= 0x02020000
1817
 
        0,                                  /* tp_iter */
1818
 
        0,                                  /* tp_iternext */
1819
 
        0,                                  /* tp_methods */ 
1820
 
        0,                                  /* tp_members */
1821
 
        0,                                  /* tp_getset */             
1822
 
        0,                                  /* tp_base */               
1823
 
        0,                                  /* tp_dict */               
1824
 
        0,                                  /* tp_descr_get */          
1825
 
        0,                                  /* tp_descr_set */          
1826
 
        0,                                  /* tp_dictoffset */         
1827
 
        0,                                  /* tp_init */               
1828
 
        0,                                  /* tp_alloc */              
1829
 
        0,                                  /* tp_new */                
1830
 
        0,                                  /* tp_free */          
1831
 
        0,                                  /* tp_is_gc */  
1832
 
        0,                                  /* tp_bases */   
1833
 
        0,                                  /* tp_mro */
1834
 
        0,                                  /* tp_cache */   
1835
 
        0,                                  /* tp_subclasses */
1836
 
        0,                                  /* tp_weaklist */
 
2090
      0,                                    /* tp_iter */
 
2091
      0,                                    /* tp_iternext */
 
2092
      0,                                    /* tp_methods */
 
2093
      0,                                    /* tp_members */
 
2094
      0,                                    /* tp_getset */
 
2095
      0,                                    /* tp_base */
 
2096
      0,                                    /* tp_dict */
 
2097
      0,                                    /* tp_descr_get */
 
2098
      0,                                    /* tp_descr_set */
 
2099
      0,                                    /* tp_dictoffset */
 
2100
      0,                                    /* tp_init */
 
2101
      0,                                    /* tp_alloc */
 
2102
      0,                                    /* tp_new */
 
2103
      0,                                    /* tp_free */
 
2104
      0,                                    /* tp_is_gc */
 
2105
      0,                                    /* tp_bases */
 
2106
      0,                                    /* tp_mro */
 
2107
      0,                                    /* tp_cache */
 
2108
      0,                                    /* tp_subclasses */
 
2109
      0,                                    /* tp_weaklist */
1837
2110
#endif
1838
2111
#if PY_VERSION_HEX >= 0x02030000
1839
 
        0,                                  /* tp_del */
 
2112
      0,                                    /* tp_del */
 
2113
#endif
 
2114
#if PY_VERSION_HEX >= 0x02060000
 
2115
      0,                                    /* tp_version */
1840
2116
#endif
1841
2117
#ifdef COUNT_ALLOCS
1842
 
        0,0,0,0                             /* tp_alloc -> tp_next */
 
2118
      0,0,0,0                               /* tp_alloc -> tp_next */
1843
2119
#endif
1844
 
      };
1845
 
    pyswigpacked_type = tmp;
1846
 
    pyswigpacked_type.ob_type = &PyType_Type;
 
2120
    };
 
2121
    swigpypacked_type = tmp;
1847
2122
    type_init = 1;
 
2123
#if PY_VERSION_HEX < 0x02020000
 
2124
    swigpypacked_type.ob_type = &PyType_Type;
 
2125
#else
 
2126
    if (PyType_Ready(&swigpypacked_type) < 0)
 
2127
      return NULL;
 
2128
#endif
1848
2129
  }
1849
 
  return &pyswigpacked_type;
 
2130
  return &swigpypacked_type;
1850
2131
}
1851
2132
 
1852
2133
SWIGRUNTIME PyObject *
1853
 
PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
 
2134
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
1854
2135
{
1855
 
  PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
 
2136
  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
1856
2137
  if (sobj) {
1857
2138
    void *pack = malloc(size);
1858
2139
    if (pack) {
1869
2150
}
1870
2151
 
1871
2152
SWIGRUNTIME swig_type_info *
1872
 
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
 
2153
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1873
2154
{
1874
 
  if (PySwigPacked_Check(obj)) {
1875
 
    PySwigPacked *sobj = (PySwigPacked *)obj;
 
2155
  if (SwigPyPacked_Check(obj)) {
 
2156
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
1876
2157
    if (sobj->size != size) return 0;
1877
2158
    memcpy(ptr, sobj->pack, size);
1878
2159
    return sobj->ty;
1888
2169
SWIGRUNTIMEINLINE PyObject *
1889
2170
_SWIG_This(void)
1890
2171
{
1891
 
  return PyString_FromString("this");
 
2172
    return SWIG_Python_str_FromChar("this");
1892
2173
}
1893
2174
 
 
2175
static PyObject *swig_this = NULL;
 
2176
 
1894
2177
SWIGRUNTIME PyObject *
1895
2178
SWIG_This(void)
1896
2179
{
1897
 
  static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
 
2180
  if (swig_this == NULL)
 
2181
    swig_this = _SWIG_This();
1898
2182
  return swig_this;
1899
2183
}
1900
2184
 
1901
2185
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1902
2186
 
1903
 
SWIGRUNTIME PySwigObject *
 
2187
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
 
2188
#if PY_VERSION_HEX>=0x03000000
 
2189
#define SWIG_PYTHON_SLOW_GETSET_THIS 
 
2190
#endif
 
2191
 
 
2192
SWIGRUNTIME SwigPyObject *
1904
2193
SWIG_Python_GetSwigThis(PyObject *pyobj) 
1905
2194
{
1906
 
  if (PySwigObject_Check(pyobj)) {
1907
 
    return (PySwigObject *) pyobj;
1908
 
  } else {
1909
 
    PyObject *obj = 0;
 
2195
  PyObject *obj;
 
2196
 
 
2197
  if (SwigPyObject_Check(pyobj))
 
2198
    return (SwigPyObject *) pyobj;
 
2199
 
 
2200
#ifdef SWIGPYTHON_BUILTIN
 
2201
  (void)obj;
 
2202
# ifdef PyWeakref_CheckProxy
 
2203
  if (PyWeakref_CheckProxy(pyobj)) {
 
2204
    pyobj = PyWeakref_GET_OBJECT(pyobj);
 
2205
    if (pyobj && SwigPyObject_Check(pyobj))
 
2206
      return (SwigPyObject*) pyobj;
 
2207
  }
 
2208
# endif
 
2209
  return NULL;
 
2210
#else
 
2211
 
 
2212
  obj = 0;
 
2213
 
1910
2214
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1911
 
    if (PyInstance_Check(pyobj)) {
1912
 
      obj = _PyInstance_Lookup(pyobj, SWIG_This());      
 
2215
  if (PyInstance_Check(pyobj)) {
 
2216
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
 
2217
  } else {
 
2218
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
 
2219
    if (dictptr != NULL) {
 
2220
      PyObject *dict = *dictptr;
 
2221
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1913
2222
    } else {
1914
 
      PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1915
 
      if (dictptr != NULL) {
1916
 
        PyObject *dict = *dictptr;
1917
 
        obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1918
 
      } else {
1919
2223
#ifdef PyWeakref_CheckProxy
1920
 
        if (PyWeakref_CheckProxy(pyobj)) {
1921
 
          PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1922
 
          return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1923
 
        }
 
2224
      if (PyWeakref_CheckProxy(pyobj)) {
 
2225
        PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
 
2226
        return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
 
2227
      }
1924
2228
#endif
1925
 
        obj = PyObject_GetAttr(pyobj,SWIG_This());
1926
 
        if (obj) {
1927
 
          Py_DECREF(obj);
1928
 
        } else {
1929
 
          if (PyErr_Occurred()) PyErr_Clear();
1930
 
          return 0;
1931
 
        }
 
2229
      obj = PyObject_GetAttr(pyobj,SWIG_This());
 
2230
      if (obj) {
 
2231
        Py_DECREF(obj);
 
2232
      } else {
 
2233
        if (PyErr_Occurred()) PyErr_Clear();
 
2234
        return 0;
1932
2235
      }
1933
2236
    }
 
2237
  }
1934
2238
#else
1935
 
    obj = PyObject_GetAttr(pyobj,SWIG_This());
1936
 
    if (obj) {
1937
 
      Py_DECREF(obj);
1938
 
    } else {
1939
 
      if (PyErr_Occurred()) PyErr_Clear();
1940
 
      return 0;
1941
 
    }
1942
 
#endif
1943
 
    if (obj && !PySwigObject_Check(obj)) {
1944
 
      /* a PyObject is called 'this', try to get the 'real this'
1945
 
         PySwigObject from it */ 
1946
 
      return SWIG_Python_GetSwigThis(obj);
1947
 
    }
1948
 
    return (PySwigObject *)obj;
1949
 
  }
 
2239
  obj = PyObject_GetAttr(pyobj,SWIG_This());
 
2240
  if (obj) {
 
2241
    Py_DECREF(obj);
 
2242
  } else {
 
2243
    if (PyErr_Occurred()) PyErr_Clear();
 
2244
    return 0;
 
2245
  }
 
2246
#endif
 
2247
  if (obj && !SwigPyObject_Check(obj)) {
 
2248
    /* a PyObject is called 'this', try to get the 'real this'
 
2249
       SwigPyObject from it */ 
 
2250
    return SWIG_Python_GetSwigThis(obj);
 
2251
  }
 
2252
  return (SwigPyObject *)obj;
 
2253
#endif
1950
2254
}
1951
2255
 
1952
2256
/* Acquire a pointer value */
1954
2258
SWIGRUNTIME int
1955
2259
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1956
2260
  if (own == SWIG_POINTER_OWN) {
1957
 
    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
 
2261
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
1958
2262
    if (sobj) {
1959
2263
      int oldown = sobj->own;
1960
2264
      sobj->own = own;
1968
2272
 
1969
2273
SWIGRUNTIME int
1970
2274
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1971
 
  if (!obj) return SWIG_ERROR;
 
2275
  int res;
 
2276
  SwigPyObject *sobj;
 
2277
 
 
2278
  if (!obj)
 
2279
    return SWIG_ERROR;
1972
2280
  if (obj == Py_None) {
1973
 
    if (ptr) *ptr = 0;
 
2281
    if (ptr)
 
2282
      *ptr = 0;
1974
2283
    return SWIG_OK;
1975
 
  } else {
1976
 
    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
 
2284
  }
 
2285
 
 
2286
  res = SWIG_ERROR;
 
2287
 
 
2288
  sobj = SWIG_Python_GetSwigThis(obj);
 
2289
  if (own)
 
2290
    *own = 0;
 
2291
  while (sobj) {
 
2292
    void *vptr = sobj->ptr;
 
2293
    if (ty) {
 
2294
      swig_type_info *to = sobj->ty;
 
2295
      if (to == ty) {
 
2296
        /* no type cast needed */
 
2297
        if (ptr) *ptr = vptr;
 
2298
        break;
 
2299
      } else {
 
2300
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
 
2301
        if (!tc) {
 
2302
          sobj = (SwigPyObject *)sobj->next;
 
2303
        } else {
 
2304
          if (ptr) {
 
2305
            int newmemory = 0;
 
2306
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
 
2307
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
 
2308
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
 
2309
              if (own)
 
2310
                *own = *own | SWIG_CAST_NEW_MEMORY;
 
2311
            }
 
2312
          }
 
2313
          break;
 
2314
        }
 
2315
      }
 
2316
    } else {
 
2317
      if (ptr) *ptr = vptr;
 
2318
      break;
 
2319
    }
 
2320
  }
 
2321
  if (sobj) {
1977
2322
    if (own)
1978
 
      *own = 0;
1979
 
    while (sobj) {
1980
 
      void *vptr = sobj->ptr;
1981
 
      if (ty) {
1982
 
        swig_type_info *to = sobj->ty;
1983
 
        if (to == ty) {
1984
 
          /* no type cast needed */
1985
 
          if (ptr) *ptr = vptr;
1986
 
          break;
1987
 
        } else {
1988
 
          swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1989
 
          if (!tc) {
1990
 
            sobj = (PySwigObject *)sobj->next;
1991
 
          } else {
1992
 
            if (ptr) {
1993
 
              int newmemory = 0;
1994
 
              *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
1995
 
              if (newmemory == SWIG_CAST_NEW_MEMORY) {
1996
 
                assert(own);
1997
 
                if (own)
1998
 
                  *own = *own | SWIG_CAST_NEW_MEMORY;
 
2323
      *own = *own | sobj->own;
 
2324
    if (flags & SWIG_POINTER_DISOWN) {
 
2325
      sobj->own = 0;
 
2326
    }
 
2327
    res = SWIG_OK;
 
2328
  } else {
 
2329
    if (flags & SWIG_POINTER_IMPLICIT_CONV) {
 
2330
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
 
2331
      if (data && !data->implicitconv) {
 
2332
        PyObject *klass = data->klass;
 
2333
        if (klass) {
 
2334
          PyObject *impconv;
 
2335
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
 
2336
          impconv = SWIG_Python_CallFunctor(klass, obj);
 
2337
          data->implicitconv = 0;
 
2338
          if (PyErr_Occurred()) {
 
2339
            PyErr_Clear();
 
2340
            impconv = 0;
 
2341
          }
 
2342
          if (impconv) {
 
2343
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
 
2344
            if (iobj) {
 
2345
              void *vptr;
 
2346
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
 
2347
              if (SWIG_IsOK(res)) {
 
2348
                if (ptr) {
 
2349
                  *ptr = vptr;
 
2350
                  /* transfer the ownership to 'ptr' */
 
2351
                  iobj->own = 0;
 
2352
                  res = SWIG_AddCast(res);
 
2353
                  res = SWIG_AddNewMask(res);
 
2354
                } else {
 
2355
                  res = SWIG_AddCast(res);                  
 
2356
                }
1999
2357
              }
2000
2358
            }
2001
 
            break;
2002
 
          }
2003
 
        }
2004
 
      } else {
2005
 
        if (ptr) *ptr = vptr;
2006
 
        break;
2007
 
      }
2008
 
    }
2009
 
    if (sobj) {
2010
 
      if (own)
2011
 
        *own = *own | sobj->own;
2012
 
      if (flags & SWIG_POINTER_DISOWN) {
2013
 
        sobj->own = 0;
2014
 
      }
2015
 
      return SWIG_OK;
2016
 
    } else {
2017
 
      int res = SWIG_ERROR;
2018
 
      if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2019
 
        PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2020
 
        if (data && !data->implicitconv) {
2021
 
          PyObject *klass = data->klass;
2022
 
          if (klass) {
2023
 
            PyObject *impconv;
2024
 
            data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2025
 
            impconv = SWIG_Python_CallFunctor(klass, obj);
2026
 
            data->implicitconv = 0;
2027
 
            if (PyErr_Occurred()) {
2028
 
              PyErr_Clear();
2029
 
              impconv = 0;
2030
 
            }
2031
 
            if (impconv) {
2032
 
              PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2033
 
              if (iobj) {
2034
 
                void *vptr;
2035
 
                res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2036
 
                if (SWIG_IsOK(res)) {
2037
 
                  if (ptr) {
2038
 
                    *ptr = vptr;
2039
 
                    /* transfer the ownership to 'ptr' */
2040
 
                    iobj->own = 0;
2041
 
                    res = SWIG_AddCast(res);
2042
 
                    res = SWIG_AddNewMask(res);
2043
 
                  } else {
2044
 
                    res = SWIG_AddCast(res);                
2045
 
                  }
2046
 
                }
2047
 
              }
2048
 
              Py_DECREF(impconv);
2049
 
            }
2050
 
          }
2051
 
        }
2052
 
      }
2053
 
      return res;
 
2359
            Py_DECREF(impconv);
 
2360
          }
 
2361
        }
 
2362
      }
2054
2363
    }
2055
2364
  }
 
2365
  return res;
2056
2366
}
2057
2367
 
2058
2368
/* Convert a function ptr value */
2067
2377
    /* here we get the method pointer for callbacks */
2068
2378
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2069
2379
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2070
 
    if (desc) {
 
2380
    if (desc)
2071
2381
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2072
 
      if (!desc) return SWIG_ERROR;
2073
 
    }
 
2382
    if (!desc) 
 
2383
      return SWIG_ERROR;
2074
2384
    if (ty) {
2075
2385
      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2076
2386
      if (tc) {
2091
2401
 
2092
2402
SWIGRUNTIME int
2093
2403
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2094
 
  swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
 
2404
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2095
2405
  if (!to) return SWIG_ERROR;
2096
2406
  if (ty) {
2097
2407
    if (to != ty) {
2108
2418
 * ----------------------------------------------------------------------------- */
2109
2419
 
2110
2420
/*
2111
 
  Create a new instance object, whitout calling __init__, and set the
 
2421
  Create a new instance object, without calling __init__, and set the
2112
2422
  'this' attribute.
2113
2423
*/
2114
2424
 
2115
2425
SWIGRUNTIME PyObject* 
2116
 
SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
 
2426
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2117
2427
{
2118
2428
#if (PY_VERSION_HEX >= 0x02020000)
2119
2429
  PyObject *inst = 0;
2137
2447
#endif
2138
2448
    }
2139
2449
  } else {
 
2450
#if PY_VERSION_HEX >= 0x03000000
 
2451
    inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
 
2452
    PyObject_SetAttr(inst, SWIG_This(), swig_this);
 
2453
    Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
 
2454
#else
2140
2455
    PyObject *dict = PyDict_New();
2141
2456
    PyDict_SetItem(dict, SWIG_This(), swig_this);
2142
2457
    inst = PyInstance_NewRaw(data->newargs, dict);
2143
2458
    Py_DECREF(dict);
 
2459
#endif
2144
2460
  }
2145
2461
  return inst;
2146
2462
#else
2203
2519
  if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2204
2520
    return NULL;
2205
2521
  } else {
2206
 
    PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
 
2522
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2207
2523
    if (sthis) {
2208
 
      PySwigObject_append((PyObject*) sthis, obj[1]);
 
2524
      SwigPyObject_append((PyObject*) sthis, obj[1]);
2209
2525
    } else {
2210
2526
      SWIG_Python_SetSwigThis(obj[0], obj[1]);
2211
2527
    }
2216
2532
/* Create a new pointer object */
2217
2533
 
2218
2534
SWIGRUNTIME PyObject *
2219
 
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2220
 
  if (!ptr) {
 
2535
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
 
2536
  SwigPyClientData *clientdata;
 
2537
  PyObject * robj;
 
2538
  int own;
 
2539
 
 
2540
  if (!ptr)
2221
2541
    return SWIG_Py_Void();
2222
 
  } else {
2223
 
    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2224
 
    PyObject *robj = PySwigObject_New(ptr, type, own);
2225
 
    PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2226
 
    if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2227
 
      PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2228
 
      if (inst) {
2229
 
        Py_DECREF(robj);
2230
 
        robj = inst;
 
2542
 
 
2543
  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
 
2544
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
 
2545
  if (clientdata && clientdata->pytype) {
 
2546
    SwigPyObject *newobj;
 
2547
    if (flags & SWIG_BUILTIN_TP_INIT) {
 
2548
      newobj = (SwigPyObject*) self;
 
2549
      if (newobj->ptr) {
 
2550
        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
 
2551
        while (newobj->next)
 
2552
          newobj = (SwigPyObject *) newobj->next;
 
2553
        newobj->next = next_self;
 
2554
        newobj = (SwigPyObject *)next_self;
2231
2555
      }
2232
 
    }
2233
 
    return robj;
2234
 
  }
 
2556
    } else {
 
2557
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
 
2558
    }
 
2559
    if (newobj) {
 
2560
      newobj->ptr = ptr;
 
2561
      newobj->ty = type;
 
2562
      newobj->own = own;
 
2563
      newobj->next = 0;
 
2564
#ifdef SWIGPYTHON_BUILTIN
 
2565
      newobj->dict = 0;
 
2566
#endif
 
2567
      return (PyObject*) newobj;
 
2568
    }
 
2569
    return SWIG_Py_Void();
 
2570
  }
 
2571
 
 
2572
  assert(!(flags & SWIG_BUILTIN_TP_INIT));
 
2573
 
 
2574
  robj = SwigPyObject_New(ptr, type, own);
 
2575
  if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
 
2576
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
 
2577
    if (inst) {
 
2578
      Py_DECREF(robj);
 
2579
      robj = inst;
 
2580
    }
 
2581
  }
 
2582
  return robj;
2235
2583
}
2236
2584
 
2237
2585
/* Create a new packed object */
2238
2586
 
2239
2587
SWIGRUNTIMEINLINE PyObject *
2240
2588
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2241
 
  return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
 
2589
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2242
2590
}
2243
2591
 
2244
2592
/* -----------------------------------------------------------------------------*
2257
2605
#ifdef SWIG_LINK_RUNTIME
2258
2606
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2259
2607
#else
 
2608
# ifdef SWIGPY_USE_CAPSULE
 
2609
    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
 
2610
# else
2260
2611
    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2261
2612
                                    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
 
2613
# endif
2262
2614
    if (PyErr_Occurred()) {
2263
2615
      PyErr_Clear();
2264
2616
      type_pointer = (void *)0;
2301
2653
#endif
2302
2654
 
2303
2655
SWIGRUNTIME void
 
2656
#ifdef SWIGPY_USE_CAPSULE
 
2657
SWIG_Python_DestroyModule(PyObject *obj)
 
2658
#else
2304
2659
SWIG_Python_DestroyModule(void *vptr)
 
2660
#endif
2305
2661
{
 
2662
#ifdef SWIGPY_USE_CAPSULE
 
2663
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
 
2664
#else
2306
2665
  swig_module_info *swig_module = (swig_module_info *) vptr;
 
2666
#endif
2307
2667
  swig_type_info **types = swig_module->types;
2308
2668
  size_t i;
2309
2669
  for (i =0; i < swig_module->size; ++i) {
2310
2670
    swig_type_info *ty = types[i];
2311
2671
    if (ty->owndata) {
2312
 
      PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2313
 
      if (data) PySwigClientData_Del(data);
 
2672
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
 
2673
      if (data) SwigPyClientData_Del(data);
2314
2674
    }
2315
2675
  }
2316
2676
  Py_DECREF(SWIG_This());
 
2677
  swig_this = NULL;
2317
2678
}
2318
2679
 
2319
2680
SWIGRUNTIME void
2320
2681
SWIG_Python_SetModule(swig_module_info *swig_module) {
2321
 
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2322
 
 
2323
 
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2324
 
                                   swig_empty_runtime_method_table);
 
2682
#if PY_VERSION_HEX >= 0x03000000
 
2683
 /* Add a dummy module object into sys.modules */
 
2684
  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
 
2685
#else
 
2686
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
 
2687
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
 
2688
#endif
 
2689
#ifdef SWIGPY_USE_CAPSULE
 
2690
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
 
2691
  if (pointer && module) {
 
2692
    PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
 
2693
  } else {
 
2694
    Py_XDECREF(pointer);
 
2695
  }
 
2696
#else
2325
2697
  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2326
2698
  if (pointer && module) {
2327
2699
    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2328
2700
  } else {
2329
2701
    Py_XDECREF(pointer);
2330
2702
  }
 
2703
#endif
2331
2704
}
2332
2705
 
2333
2706
/* The python cached type query */
2341
2714
SWIG_Python_TypeQuery(const char *type)
2342
2715
{
2343
2716
  PyObject *cache = SWIG_Python_TypeCache();
2344
 
  PyObject *key = PyString_FromString(type); 
 
2717
  PyObject *key = SWIG_Python_str_FromChar(type); 
2345
2718
  PyObject *obj = PyDict_GetItem(cache, key);
2346
2719
  swig_type_info *descriptor;
2347
2720
  if (obj) {
 
2721
#ifdef SWIGPY_USE_CAPSULE
 
2722
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
 
2723
#else
2348
2724
    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
 
2725
#endif
2349
2726
  } else {
2350
2727
    swig_module_info *swig_module = SWIG_Python_GetModule();
2351
2728
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2352
2729
    if (descriptor) {
 
2730
#ifdef SWIGPY_USE_CAPSULE
 
2731
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
 
2732
#else
2353
2733
      obj = PyCObject_FromVoidPtr(descriptor, NULL);
 
2734
#endif
2354
2735
      PyDict_SetItem(cache, key, obj);
2355
2736
      Py_DECREF(obj);
2356
2737
    }
2368
2749
 
2369
2750
SWIGRUNTIME int
2370
2751
SWIG_Python_AddErrMesg(const char* mesg, int infront)
2371
 
{
 
2752
{  
2372
2753
  if (PyErr_Occurred()) {
2373
2754
    PyObject *type = 0;
2374
2755
    PyObject *value = 0;
2375
2756
    PyObject *traceback = 0;
2376
2757
    PyErr_Fetch(&type, &value, &traceback);
2377
2758
    if (value) {
 
2759
      char *tmp;
2378
2760
      PyObject *old_str = PyObject_Str(value);
2379
2761
      Py_XINCREF(type);
2380
2762
      PyErr_Clear();
2381
2763
      if (infront) {
2382
 
        PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
 
2764
        PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2383
2765
      } else {
2384
 
        PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 
2766
        PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2385
2767
      }
 
2768
      SWIG_Python_str_DelForPy3(tmp);
2386
2769
      Py_DECREF(old_str);
2387
2770
    }
2388
2771
    return 1;
2405
2788
}
2406
2789
 
2407
2790
SWIGRUNTIMEINLINE const char *
2408
 
PySwigObject_GetDesc(PyObject *self)
 
2791
SwigPyObject_GetDesc(PyObject *self)
2409
2792
{
2410
 
  PySwigObject *v = (PySwigObject *)self;
 
2793
  SwigPyObject *v = (SwigPyObject *)self;
2411
2794
  swig_type_info *ty = v ? v->ty : 0;
2412
2795
  return ty ? ty->str : (char*)"";
2413
2796
}
2417
2800
{
2418
2801
  if (type) {
2419
2802
#if defined(SWIG_COBJECT_TYPES)
2420
 
    if (obj && PySwigObject_Check(obj)) {
2421
 
      const char *otype = (const char *) PySwigObject_GetDesc(obj);
 
2803
    if (obj && SwigPyObject_Check(obj)) {
 
2804
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2422
2805
      if (otype) {
2423
 
        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
 
2806
        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2424
2807
                     type, otype);
2425
2808
        return;
2426
2809
      }
2430
2813
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
2431
2814
      if (otype) {
2432
2815
        PyObject *str = PyObject_Str(obj);
2433
 
        const char *cstr = str ? PyString_AsString(str) : 0;
 
2816
        const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2434
2817
        if (cstr) {
2435
2818
          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2436
2819
                       type, otype, cstr);
 
2820
          SWIG_Python_str_DelForPy3(cstr);
2437
2821
        } else {
2438
2822
          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2439
2823
                       type, otype);
2451
2835
 
2452
2836
/* Convert a pointer value, signal an exception on a type mismatch */
2453
2837
SWIGRUNTIME void *
2454
 
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
 
2838
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2455
2839
  void *result;
2456
2840
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2457
2841
    PyErr_Clear();
2458
 
    if (flags & SWIG_POINTER_EXCEPTION) {
 
2842
#if SWIG_POINTER_EXCEPTION
 
2843
    if (flags) {
2459
2844
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2460
2845
      SWIG_Python_ArgFail(argnum);
2461
2846
    }
 
2847
#endif
2462
2848
  }
2463
2849
  return result;
2464
2850
}
2465
2851
 
 
2852
SWIGRUNTIME int
 
2853
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
 
2854
  PyTypeObject *tp = obj->ob_type;
 
2855
  PyObject *descr;
 
2856
  PyObject *encoded_name;
 
2857
  descrsetfunc f;
 
2858
  int res;
 
2859
 
 
2860
#ifdef Py_USING_UNICODE
 
2861
  if (PyString_Check(name)) {
 
2862
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
 
2863
    if (!name)
 
2864
      return -1;
 
2865
  } else if (!PyUnicode_Check(name))
 
2866
#else
 
2867
  if (!PyString_Check(name))
 
2868
#endif
 
2869
  {
 
2870
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
 
2871
    return -1;
 
2872
  } else {
 
2873
    Py_INCREF(name);
 
2874
  }
 
2875
 
 
2876
  if (!tp->tp_dict) {
 
2877
    if (PyType_Ready(tp) < 0)
 
2878
      goto done;
 
2879
  }
 
2880
 
 
2881
  res = -1;
 
2882
  descr = _PyType_Lookup(tp, name);
 
2883
  f = NULL;
 
2884
  if (descr != NULL)
 
2885
    f = descr->ob_type->tp_descr_set;
 
2886
  if (!f) {
 
2887
    if (PyString_Check(name)) {
 
2888
      encoded_name = name;
 
2889
      Py_INCREF(name);
 
2890
    } else {
 
2891
      encoded_name = PyUnicode_AsUTF8String(name);
 
2892
    }
 
2893
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
 
2894
    Py_DECREF(encoded_name);
 
2895
  } else {
 
2896
    res = f(descr, obj, value);
 
2897
  }
 
2898
  
 
2899
  done:
 
2900
  Py_DECREF(name);
 
2901
  return res;
 
2902
}
 
2903
 
2466
2904
 
2467
2905
#ifdef __cplusplus
2468
 
#if 0
2469
 
{ /* cc-mode */
2470
 
#endif
2471
2906
}
2472
2907
#endif
2473
2908
 
2586
3021
#define SWIGTYPE_p_svn_dirent_t swig_types[99]
2587
3022
#define SWIGTYPE_p_svn_errno_t swig_types[100]
2588
3023
#define SWIGTYPE_p_svn_error_t swig_types[101]
2589
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[102]
2590
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[103]
2591
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[104]
2592
 
#define SWIGTYPE_p_svn_lock_t swig_types[105]
2593
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[106]
2594
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[107]
2595
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[108]
2596
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[109]
2597
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[110]
2598
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[111]
2599
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[112]
2600
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[113]
2601
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[114]
2602
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[115]
2603
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[116]
2604
 
#define SWIGTYPE_p_svn_prop_kind swig_types[117]
2605
 
#define SWIGTYPE_p_svn_ra_callbacks2_t swig_types[118]
2606
 
#define SWIGTYPE_p_svn_ra_callbacks_t swig_types[119]
2607
 
#define SWIGTYPE_p_svn_ra_plugin_t swig_types[120]
2608
 
#define SWIGTYPE_p_svn_ra_reporter2_t swig_types[121]
2609
 
#define SWIGTYPE_p_svn_ra_reporter3_t swig_types[122]
2610
 
#define SWIGTYPE_p_svn_ra_reporter_t swig_types[123]
2611
 
#define SWIGTYPE_p_svn_ra_session_t swig_types[124]
2612
 
#define SWIGTYPE_p_svn_stream_t swig_types[125]
2613
 
#define SWIGTYPE_p_svn_string_t swig_types[126]
2614
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[127]
2615
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[128]
2616
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[129]
2617
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[130]
2618
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[131]
2619
 
#define SWIGTYPE_p_svn_version_t swig_types[132]
2620
 
#define SWIGTYPE_p_void swig_types[133]
2621
 
static swig_type_info *swig_types[135];
2622
 
static swig_module_info swig_module = {swig_types, 134, 0, 0, 0, 0};
 
3024
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[102]
 
3025
#define SWIGTYPE_p_svn_io_dirent_t swig_types[103]
 
3026
#define SWIGTYPE_p_svn_io_file_del_t swig_types[104]
 
3027
#define SWIGTYPE_p_svn_location_segment_t swig_types[105]
 
3028
#define SWIGTYPE_p_svn_lock_t swig_types[106]
 
3029
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[107]
 
3030
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[108]
 
3031
#define SWIGTYPE_p_svn_log_entry_t swig_types[109]
 
3032
#define SWIGTYPE_p_svn_merge_range_t swig_types[110]
 
3033
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[111]
 
3034
#define SWIGTYPE_p_svn_node_kind_t swig_types[112]
 
3035
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[113]
 
3036
#define SWIGTYPE_p_svn_opt_revision_t swig_types[114]
 
3037
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[115]
 
3038
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[116]
 
3039
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[117]
 
3040
#define SWIGTYPE_p_svn_prop_kind swig_types[118]
 
3041
#define SWIGTYPE_p_svn_ra_callbacks2_t swig_types[119]
 
3042
#define SWIGTYPE_p_svn_ra_callbacks_t swig_types[120]
 
3043
#define SWIGTYPE_p_svn_ra_plugin_t swig_types[121]
 
3044
#define SWIGTYPE_p_svn_ra_reporter2_t swig_types[122]
 
3045
#define SWIGTYPE_p_svn_ra_reporter3_t swig_types[123]
 
3046
#define SWIGTYPE_p_svn_ra_reporter_t swig_types[124]
 
3047
#define SWIGTYPE_p_svn_ra_session_t swig_types[125]
 
3048
#define SWIGTYPE_p_svn_stream_mark_t swig_types[126]
 
3049
#define SWIGTYPE_p_svn_stream_t swig_types[127]
 
3050
#define SWIGTYPE_p_svn_string_t swig_types[128]
 
3051
#define SWIGTYPE_p_svn_stringbuf_t swig_types[129]
 
3052
#define SWIGTYPE_p_svn_tristate_t swig_types[130]
 
3053
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[131]
 
3054
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[132]
 
3055
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[133]
 
3056
#define SWIGTYPE_p_svn_version_checklist_t swig_types[134]
 
3057
#define SWIGTYPE_p_svn_version_t swig_types[135]
 
3058
#define SWIGTYPE_p_unsigned_long swig_types[136]
 
3059
#define SWIGTYPE_p_void swig_types[137]
 
3060
static swig_type_info *swig_types[139];
 
3061
static swig_module_info swig_module = {swig_types, 138, 0, 0, 0, 0};
2623
3062
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2624
3063
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2625
3064
 
2634
3073
/*-----------------------------------------------
2635
3074
              @(target):= _ra.so
2636
3075
  ------------------------------------------------*/
2637
 
#define SWIG_init    init_ra
2638
 
 
 
3076
#if PY_VERSION_HEX >= 0x03000000
 
3077
#  define SWIG_init    PyInit__ra
 
3078
 
 
3079
#else
 
3080
#  define SWIG_init    init_ra
 
3081
 
 
3082
#endif
2639
3083
#define SWIG_name    "_ra"
2640
3084
 
2641
 
#define SWIGVERSION 0x010336 
 
3085
#define SWIGVERSION 0x020004 
2642
3086
#define SWIG_VERSION SWIGVERSION
2643
3087
 
2644
3088
 
2676
3120
#define svn_argnum_obj17 18
2677
3121
#define svn_argnum_obj18 19
2678
3122
#define svn_argnum_obj19 20
 
3123
#define svn_argnum_obj20 21
 
3124
#define svn_argnum_obj21 22
 
3125
#define svn_argnum_obj22 23
 
3126
#define svn_argnum_obj23 24
 
3127
#define svn_argnum_obj24 25
 
3128
#define svn_argnum_obj25 26
 
3129
#define svn_argnum_obj26 27
 
3130
#define svn_argnum_obj27 28
 
3131
#define svn_argnum_obj28 29
 
3132
#define svn_argnum_obj29 30
 
3133
#define svn_argnum_obj30 31
 
3134
#define svn_argnum_obj31 32
 
3135
#define svn_argnum_obj32 33
 
3136
#define svn_argnum_obj33 34
 
3137
#define svn_argnum_obj34 35
 
3138
#define svn_argnum_obj35 36
 
3139
#define svn_argnum_obj36 37
 
3140
#define svn_argnum_obj37 38
 
3141
#define svn_argnum_obj38 39
 
3142
#define svn_argnum_obj39 40
2679
3143
 
2680
3144
 
2681
3145
#include "svn_ra.h"
2697
3161
SWIGINTERN int
2698
3162
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2699
3163
{
2700
 
  if (PyString_Check(obj)) {
 
3164
#if PY_VERSION_HEX>=0x03000000
 
3165
  if (PyUnicode_Check(obj))
 
3166
#else  
 
3167
  if (PyString_Check(obj))
 
3168
#endif
 
3169
  {
2701
3170
    char *cstr; Py_ssize_t len;
 
3171
#if PY_VERSION_HEX>=0x03000000
 
3172
    if (!alloc && cptr) {
 
3173
        /* We can't allow converting without allocation, since the internal
 
3174
           representation of string in Python 3 is UCS-2/UCS-4 but we require
 
3175
           a UTF-8 representation.
 
3176
           TODO(bhy) More detailed explanation */
 
3177
        return SWIG_RuntimeError;
 
3178
    }
 
3179
    obj = PyUnicode_AsUTF8String(obj);
 
3180
    PyBytes_AsStringAndSize(obj, &cstr, &len);
 
3181
    if(alloc) *alloc = SWIG_NEWOBJ;
 
3182
#else
2702
3183
    PyString_AsStringAndSize(obj, &cstr, &len);
2703
 
    if (cptr)  {
 
3184
#endif
 
3185
    if (cptr) {
2704
3186
      if (alloc) {
2705
3187
        /* 
2706
3188
           In python the user should not be able to modify the inner
2725
3207
          *alloc = SWIG_OLDOBJ;
2726
3208
        }
2727
3209
      } else {
2728
 
        *cptr = PyString_AsString(obj);
 
3210
        #if PY_VERSION_HEX>=0x03000000
 
3211
        assert(0); /* Should never reach here in Python 3 */
 
3212
        #endif
 
3213
        *cptr = SWIG_Python_str_AsChar(obj);
2729
3214
      }
2730
3215
    }
2731
3216
    if (psize) *psize = len + 1;
 
3217
#if PY_VERSION_HEX>=0x03000000
 
3218
    Py_XDECREF(obj);
 
3219
#endif
2732
3220
    return SWIG_OK;
2733
3221
  } else {
2734
3222
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2961
3449
    if (size > INT_MAX) {
2962
3450
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2963
3451
      return pchar_descriptor ? 
2964
 
        SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
 
3452
        SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2965
3453
    } else {
 
3454
#if PY_VERSION_HEX >= 0x03000000
 
3455
      return PyUnicode_FromStringAndSize(carray, (int)(size));
 
3456
#else
2966
3457
      return PyString_FromStringAndSize(carray, (int)(size));
 
3458
#endif
2967
3459
    }
2968
3460
  } else {
2969
3461
    return SWIG_Py_Void();
3164
3656
}
3165
3657
 
3166
3658
static svn_error_t * svn_ra_invoke_get_wc_prop_func(
3167
 
  svn_ra_get_wc_prop_func_t _obj, void *baton, const char *relpath, const char *name, const svn_string_t **value, apr_pool_t *pool) {
3168
 
  return _obj(baton, relpath, name, value, pool);
 
3659
  svn_ra_get_wc_prop_func_t _obj, void *baton, const char *path, const char *name, const svn_string_t **value, apr_pool_t *pool) {
 
3660
  return _obj(baton, path, name, value, pool);
3169
3661
}
3170
3662
 
3171
3663
static svn_error_t * svn_ra_invoke_set_wc_prop_func(
5398
5890
  }
5399
5891
  {
5400
5892
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_ra_callbacks2_t,
5401
 
        _global_py_pool, args));
 
5893
        _global_py_pool, args))
 
5894
    
 
5895
    ;
 
5896
  }
 
5897
  {
 
5898
    Py_XDECREF(_global_py_pool);
 
5899
  }
 
5900
  return resultobj;
 
5901
fail:
 
5902
  {
 
5903
    Py_XDECREF(_global_py_pool);
 
5904
  }
 
5905
  return NULL;
 
5906
}
 
5907
 
 
5908
 
 
5909
SWIGINTERN PyObject *_wrap_svn_ra_open4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5910
  PyObject *resultobj = 0;
 
5911
  svn_ra_session_t **arg1 = (svn_ra_session_t **) 0 ;
 
5912
  char **arg2 = (char **) 0 ;
 
5913
  char *arg3 = (char *) 0 ;
 
5914
  char *arg4 = (char *) 0 ;
 
5915
  svn_ra_callbacks2_t *arg5 = (svn_ra_callbacks2_t *) 0 ;
 
5916
  void *arg6 = (void *) 0 ;
 
5917
  apr_hash_t *arg7 = (apr_hash_t *) 0 ;
 
5918
  apr_pool_t *arg8 = (apr_pool_t *) 0 ;
 
5919
  apr_pool_t *_global_pool = NULL ;
 
5920
  PyObject *_global_py_pool = NULL ;
 
5921
  svn_ra_session_t *temp1 ;
 
5922
  char *temp2 ;
 
5923
  PyObject * obj2 = 0 ;
 
5924
  PyObject * obj3 = 0 ;
 
5925
  PyObject * obj4 = 0 ;
 
5926
  svn_error_t *result = 0 ;
 
5927
  
 
5928
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
5929
      &_global_py_pool, &_global_pool))
 
5930
  SWIG_fail;
 
5931
  arg8 = _global_pool;
 
5932
  arg1 = &temp1;
 
5933
  arg2 = &temp2;
 
5934
  if (!PyArg_ParseTuple(args,(char *)"ssOO|O:svn_ra_open4",&arg3,&arg4,&obj2,&obj3,&obj4)) SWIG_fail;
 
5935
  {
 
5936
    svn_swig_py_setup_ra_callbacks(&arg5, &arg6, obj2, _global_pool);
 
5937
  }
 
5938
  {
 
5939
    if (_global_pool == NULL)
 
5940
    {
 
5941
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
5942
          &_global_py_pool, &_global_pool))
 
5943
      SWIG_fail;
 
5944
    }
 
5945
    
 
5946
    arg7 = svn_swig_py_struct_ptr_hash_from_dict(obj3,
 
5947
      SWIGTYPE_p_svn_config_t, _global_pool);
 
5948
    if (PyErr_Occurred())
 
5949
    SWIG_fail;
 
5950
  }
 
5951
  if (obj4) {
 
5952
    /* Verify that the user supplied a valid pool */
 
5953
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
5954
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
5955
      SWIG_arg_fail(svn_argnum_obj4);
 
5956
      SWIG_fail;
 
5957
    }
 
5958
  }
 
5959
  {
 
5960
    if (!arg5) {
 
5961
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
5962
    }
 
5963
  }
 
5964
  {
 
5965
    svn_swig_py_release_py_lock();
 
5966
    
 
5967
    result = (svn_error_t *)svn_ra_open4(arg1,(char const **)arg2,(char const *)arg3,(char const *)arg4,(struct svn_ra_callbacks2_t const *)arg5,arg6,arg7,arg8);
 
5968
    
 
5969
    svn_swig_py_acquire_py_lock();
 
5970
    
 
5971
  }
 
5972
  {
 
5973
    if (result != NULL) {
 
5974
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
5975
      svn_swig_py_svn_exception(result);
 
5976
      else
 
5977
      svn_error_clear(result);
 
5978
      SWIG_fail;
 
5979
    }
 
5980
    Py_INCREF(Py_None);
 
5981
    resultobj = Py_None;
 
5982
  }
 
5983
  {
 
5984
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_ra_session_t,
 
5985
        _global_py_pool, args))
 
5986
    
 
5987
    ;
 
5988
  }
 
5989
  {
 
5990
    PyObject *s;
 
5991
    if (*arg2 == NULL) {
 
5992
      Py_INCREF(Py_None);
 
5993
      s = Py_None;
 
5994
    }
 
5995
    else {
 
5996
      s = PyString_FromString(*arg2);
 
5997
      if (s == NULL)
 
5998
      SWIG_fail;
 
5999
    }
 
6000
    resultobj = SWIG_Python_AppendOutput(resultobj, s);
5402
6001
  }
5403
6002
  {
5404
6003
    Py_XDECREF(_global_py_pool);
5439
6038
    svn_swig_py_setup_ra_callbacks(&arg4, &arg5, obj2, _global_pool);
5440
6039
  }
5441
6040
  {
5442
 
    arg6 = (apr_hash_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_apr_hash_t, svn_argnum_obj3);
5443
 
    if (PyErr_Occurred()) {
 
6041
    if (_global_pool == NULL)
 
6042
    {
 
6043
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
6044
          &_global_py_pool, &_global_pool))
5444
6045
      SWIG_fail;
5445
6046
    }
 
6047
    
 
6048
    arg6 = svn_swig_py_struct_ptr_hash_from_dict(obj3,
 
6049
      SWIGTYPE_p_svn_config_t, _global_pool);
 
6050
    if (PyErr_Occurred())
 
6051
    SWIG_fail;
5446
6052
  }
5447
6053
  if (obj4) {
5448
6054
    /* Verify that the user supplied a valid pool */
5478
6084
  }
5479
6085
  {
5480
6086
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_ra_session_t,
5481
 
        _global_py_pool, args));
 
6087
        _global_py_pool, args))
 
6088
    
 
6089
    ;
5482
6090
  }
5483
6091
  {
5484
6092
    Py_XDECREF(_global_py_pool);
5518
6126
    svn_swig_py_setup_ra_callbacks(&arg3, &arg4, obj1, _global_pool);
5519
6127
  }
5520
6128
  {
5521
 
    arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_apr_hash_t, svn_argnum_obj2);
5522
 
    if (PyErr_Occurred()) {
 
6129
    if (_global_pool == NULL)
 
6130
    {
 
6131
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
6132
          &_global_py_pool, &_global_pool))
5523
6133
      SWIG_fail;
5524
6134
    }
 
6135
    
 
6136
    arg5 = svn_swig_py_struct_ptr_hash_from_dict(obj2,
 
6137
      SWIGTYPE_p_svn_config_t, _global_pool);
 
6138
    if (PyErr_Occurred())
 
6139
    SWIG_fail;
5525
6140
  }
5526
6141
  if (obj3) {
5527
6142
    /* Verify that the user supplied a valid pool */
5557
6172
  }
5558
6173
  {
5559
6174
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_ra_session_t,
5560
 
        _global_py_pool, args));
 
6175
        _global_py_pool, args))
 
6176
    
 
6177
    ;
5561
6178
  }
5562
6179
  {
5563
6180
    Py_XDECREF(_global_py_pool);
5609
6226
    }
5610
6227
  }
5611
6228
  {
5612
 
    arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_apr_hash_t, svn_argnum_obj3);
5613
 
    if (PyErr_Occurred()) {
 
6229
    if (_global_pool == NULL)
 
6230
    {
 
6231
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
6232
          &_global_py_pool, &_global_pool))
5614
6233
      SWIG_fail;
5615
6234
    }
 
6235
    
 
6236
    arg5 = svn_swig_py_struct_ptr_hash_from_dict(obj3,
 
6237
      SWIGTYPE_p_svn_config_t, _global_pool);
 
6238
    if (PyErr_Occurred())
 
6239
    SWIG_fail;
5616
6240
  }
5617
6241
  if (obj4) {
5618
6242
    /* Verify that the user supplied a valid pool */
5643
6267
  }
5644
6268
  {
5645
6269
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_ra_session_t,
5646
 
        _global_py_pool, args));
 
6270
        _global_py_pool, args))
 
6271
    
 
6272
    ;
5647
6273
  }
5648
6274
  {
5649
6275
    Py_XDECREF(_global_py_pool);
5794
6420
}
5795
6421
 
5796
6422
 
 
6423
SWIGINTERN PyObject *_wrap_svn_ra_get_path_relative_to_session(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6424
  PyObject *resultobj = 0;
 
6425
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
6426
  char **arg2 = (char **) 0 ;
 
6427
  char *arg3 = (char *) 0 ;
 
6428
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
6429
  apr_pool_t *_global_pool = NULL ;
 
6430
  PyObject *_global_py_pool = NULL ;
 
6431
  char *temp2 ;
 
6432
  PyObject * obj0 = 0 ;
 
6433
  PyObject * obj2 = 0 ;
 
6434
  svn_error_t *result = 0 ;
 
6435
  
 
6436
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
6437
      &_global_py_pool, &_global_pool))
 
6438
  SWIG_fail;
 
6439
  arg4 = _global_pool;
 
6440
  arg2 = &temp2;
 
6441
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_ra_get_path_relative_to_session",&obj0,&arg3,&obj2)) SWIG_fail;
 
6442
  {
 
6443
    arg1 = (svn_ra_session_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_ra_session_t, svn_argnum_obj0);
 
6444
    if (PyErr_Occurred()) {
 
6445
      SWIG_fail;
 
6446
    }
 
6447
  }
 
6448
  if (obj2) {
 
6449
    /* Verify that the user supplied a valid pool */
 
6450
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
6451
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
6452
      SWIG_arg_fail(svn_argnum_obj2);
 
6453
      SWIG_fail;
 
6454
    }
 
6455
  }
 
6456
  {
 
6457
    svn_swig_py_release_py_lock();
 
6458
    
 
6459
    result = (svn_error_t *)svn_ra_get_path_relative_to_session(arg1,(char const **)arg2,(char const *)arg3,arg4);
 
6460
    
 
6461
    svn_swig_py_acquire_py_lock();
 
6462
    
 
6463
  }
 
6464
  {
 
6465
    if (result != NULL) {
 
6466
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
6467
      svn_swig_py_svn_exception(result);
 
6468
      else
 
6469
      svn_error_clear(result);
 
6470
      SWIG_fail;
 
6471
    }
 
6472
    Py_INCREF(Py_None);
 
6473
    resultobj = Py_None;
 
6474
  }
 
6475
  {
 
6476
    PyObject *s;
 
6477
    if (*arg2 == NULL) {
 
6478
      Py_INCREF(Py_None);
 
6479
      s = Py_None;
 
6480
    }
 
6481
    else {
 
6482
      s = PyString_FromString(*arg2);
 
6483
      if (s == NULL)
 
6484
      SWIG_fail;
 
6485
    }
 
6486
    resultobj = SWIG_Python_AppendOutput(resultobj, s);
 
6487
  }
 
6488
  {
 
6489
    Py_XDECREF(_global_py_pool);
 
6490
  }
 
6491
  return resultobj;
 
6492
fail:
 
6493
  {
 
6494
    Py_XDECREF(_global_py_pool);
 
6495
  }
 
6496
  return NULL;
 
6497
}
 
6498
 
 
6499
 
 
6500
SWIGINTERN PyObject *_wrap_svn_ra_get_path_relative_to_root(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6501
  PyObject *resultobj = 0;
 
6502
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
6503
  char **arg2 = (char **) 0 ;
 
6504
  char *arg3 = (char *) 0 ;
 
6505
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
6506
  apr_pool_t *_global_pool = NULL ;
 
6507
  PyObject *_global_py_pool = NULL ;
 
6508
  char *temp2 ;
 
6509
  PyObject * obj0 = 0 ;
 
6510
  PyObject * obj2 = 0 ;
 
6511
  svn_error_t *result = 0 ;
 
6512
  
 
6513
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
6514
      &_global_py_pool, &_global_pool))
 
6515
  SWIG_fail;
 
6516
  arg4 = _global_pool;
 
6517
  arg2 = &temp2;
 
6518
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_ra_get_path_relative_to_root",&obj0,&arg3,&obj2)) SWIG_fail;
 
6519
  {
 
6520
    arg1 = (svn_ra_session_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_ra_session_t, svn_argnum_obj0);
 
6521
    if (PyErr_Occurred()) {
 
6522
      SWIG_fail;
 
6523
    }
 
6524
  }
 
6525
  if (obj2) {
 
6526
    /* Verify that the user supplied a valid pool */
 
6527
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
6528
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
6529
      SWIG_arg_fail(svn_argnum_obj2);
 
6530
      SWIG_fail;
 
6531
    }
 
6532
  }
 
6533
  {
 
6534
    svn_swig_py_release_py_lock();
 
6535
    
 
6536
    result = (svn_error_t *)svn_ra_get_path_relative_to_root(arg1,(char const **)arg2,(char const *)arg3,arg4);
 
6537
    
 
6538
    svn_swig_py_acquire_py_lock();
 
6539
    
 
6540
  }
 
6541
  {
 
6542
    if (result != NULL) {
 
6543
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
6544
      svn_swig_py_svn_exception(result);
 
6545
      else
 
6546
      svn_error_clear(result);
 
6547
      SWIG_fail;
 
6548
    }
 
6549
    Py_INCREF(Py_None);
 
6550
    resultobj = Py_None;
 
6551
  }
 
6552
  {
 
6553
    PyObject *s;
 
6554
    if (*arg2 == NULL) {
 
6555
      Py_INCREF(Py_None);
 
6556
      s = Py_None;
 
6557
    }
 
6558
    else {
 
6559
      s = PyString_FromString(*arg2);
 
6560
      if (s == NULL)
 
6561
      SWIG_fail;
 
6562
    }
 
6563
    resultobj = SWIG_Python_AppendOutput(resultobj, s);
 
6564
  }
 
6565
  {
 
6566
    Py_XDECREF(_global_py_pool);
 
6567
  }
 
6568
  return resultobj;
 
6569
fail:
 
6570
  {
 
6571
    Py_XDECREF(_global_py_pool);
 
6572
  }
 
6573
  return NULL;
 
6574
}
 
6575
 
 
6576
 
5797
6577
SWIGINTERN PyObject *_wrap_svn_ra_get_latest_revnum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5798
6578
  PyObject *resultobj = 0;
5799
6579
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
5937
6717
}
5938
6718
 
5939
6719
 
 
6720
SWIGINTERN PyObject *_wrap_svn_ra_change_rev_prop2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6721
  PyObject *resultobj = 0;
 
6722
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
6723
  svn_revnum_t arg2 ;
 
6724
  char *arg3 = (char *) 0 ;
 
6725
  svn_string_t **arg4 = (svn_string_t **) 0 ;
 
6726
  svn_string_t *arg5 = (svn_string_t *) 0 ;
 
6727
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
6728
  apr_pool_t *_global_pool = NULL ;
 
6729
  PyObject *_global_py_pool = NULL ;
 
6730
  svn_string_t value5 ;
 
6731
  PyObject * obj0 = 0 ;
 
6732
  PyObject * obj1 = 0 ;
 
6733
  PyObject * obj3 = 0 ;
 
6734
  PyObject * obj4 = 0 ;
 
6735
  PyObject * obj5 = 0 ;
 
6736
  svn_error_t *result = 0 ;
 
6737
  
 
6738
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
6739
      &_global_py_pool, &_global_pool))
 
6740
  SWIG_fail;
 
6741
  arg6 = _global_pool;
 
6742
  if (!PyArg_ParseTuple(args,(char *)"OOsOO|O:svn_ra_change_rev_prop2",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5)) SWIG_fail;
 
6743
  {
 
6744
    arg1 = (svn_ra_session_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_ra_session_t, svn_argnum_obj0);
 
6745
    if (PyErr_Occurred()) {
 
6746
      SWIG_fail;
 
6747
    }
 
6748
  }
 
6749
  {
 
6750
    arg2 = (svn_revnum_t)SWIG_As_long (obj1);
 
6751
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
6752
      SWIG_fail;
 
6753
    }
 
6754
  }
 
6755
  {
 
6756
    arg4 = (svn_string_t **)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_p_svn_string_t, svn_argnum_obj3);
 
6757
    if (PyErr_Occurred()) {
 
6758
      SWIG_fail;
 
6759
    }
 
6760
  }
 
6761
  {
 
6762
    if (obj4 == Py_None)
 
6763
    arg5 = NULL;
 
6764
    else {
 
6765
      if (!PyString_Check(obj4)) {
 
6766
        PyErr_SetString(PyExc_TypeError, "not a string");
 
6767
        SWIG_fail;
 
6768
      }
 
6769
      value5.data = PyString_AS_STRING(obj4);
 
6770
      value5.len = PyString_GET_SIZE(obj4);
 
6771
      arg5 = &value5;
 
6772
    }
 
6773
  }
 
6774
  if (obj5) {
 
6775
    /* Verify that the user supplied a valid pool */
 
6776
    if (obj5 != Py_None && obj5 != _global_py_pool) {
 
6777
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
 
6778
      SWIG_arg_fail(svn_argnum_obj5);
 
6779
      SWIG_fail;
 
6780
    }
 
6781
  }
 
6782
  {
 
6783
    svn_swig_py_release_py_lock();
 
6784
    
 
6785
    result = (svn_error_t *)svn_ra_change_rev_prop2(arg1,arg2,(char const *)arg3,(struct svn_string_t const *const *)arg4,(struct svn_string_t const *)arg5,arg6);
 
6786
    
 
6787
    svn_swig_py_acquire_py_lock();
 
6788
    
 
6789
  }
 
6790
  {
 
6791
    if (result != NULL) {
 
6792
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
6793
      svn_swig_py_svn_exception(result);
 
6794
      else
 
6795
      svn_error_clear(result);
 
6796
      SWIG_fail;
 
6797
    }
 
6798
    Py_INCREF(Py_None);
 
6799
    resultobj = Py_None;
 
6800
  }
 
6801
  {
 
6802
    PyObject *s;
 
6803
    if (*arg4 == NULL) {
 
6804
      Py_INCREF(Py_None);
 
6805
      s = Py_None;
 
6806
    }
 
6807
    else {
 
6808
      s = PyString_FromStringAndSize((*arg4)->data, (*arg4)->len);
 
6809
      if (s == NULL)
 
6810
      SWIG_fail;
 
6811
    }
 
6812
    resultobj = SWIG_Python_AppendOutput(resultobj, s);
 
6813
  }
 
6814
  {
 
6815
    Py_XDECREF(_global_py_pool);
 
6816
  }
 
6817
  return resultobj;
 
6818
fail:
 
6819
  {
 
6820
    Py_XDECREF(_global_py_pool);
 
6821
  }
 
6822
  return NULL;
 
6823
}
 
6824
 
 
6825
 
5940
6826
SWIGINTERN PyObject *_wrap_svn_ra_change_rev_prop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5941
6827
  PyObject *resultobj = 0;
5942
6828
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
6273
7159
  }
6274
7160
  {
6275
7161
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_delta_editor_t,
6276
 
        _global_py_pool, args));
 
7162
        _global_py_pool, args))
 
7163
    
 
7164
    ;
6277
7165
  }
6278
7166
  {
6279
7167
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
6280
 
        _global_py_pool, args));
 
7168
        _global_py_pool, args))
 
7169
    
 
7170
    ;
6281
7171
  }
6282
7172
  {
6283
7173
    Py_XDECREF(_global_py_pool);
6369
7259
  }
6370
7260
  {
6371
7261
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_delta_editor_t,
6372
 
        _global_py_pool, args));
 
7262
        _global_py_pool, args))
 
7263
    
 
7264
    ;
6373
7265
  }
6374
7266
  {
6375
7267
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
6376
 
        _global_py_pool, args));
 
7268
        _global_py_pool, args))
 
7269
    
 
7270
    ;
6377
7271
  }
6378
7272
  {
6379
7273
    Py_XDECREF(_global_py_pool);
6465
7359
  }
6466
7360
  {
6467
7361
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_delta_editor_t,
6468
 
        _global_py_pool, args));
 
7362
        _global_py_pool, args))
 
7363
    
 
7364
    ;
6469
7365
  }
6470
7366
  {
6471
7367
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
6472
 
        _global_py_pool, args));
 
7368
        _global_py_pool, args))
 
7369
    
 
7370
    ;
6473
7371
  }
6474
7372
  {
6475
7373
    Py_XDECREF(_global_py_pool);
6651
7549
  {
6652
7550
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_convert_hash(*arg2,
6653
7551
        SWIGTYPE_p_svn_dirent_t,
6654
 
        _global_py_pool));
 
7552
        _global_py_pool))
 
7553
    
 
7554
    
 
7555
    
 
7556
    ;
6655
7557
  }
6656
7558
  if (SWIG_IsTmpObj(res3)) {
6657
7559
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
6744
7646
  {
6745
7647
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_convert_hash(*arg4,
6746
7648
        SWIGTYPE_p_svn_dirent_t,
6747
 
        _global_py_pool));
 
7649
        _global_py_pool))
 
7650
    
 
7651
    
 
7652
    
 
7653
    ;
6748
7654
  }
6749
7655
  if (SWIG_IsTmpObj(res5)) {
6750
7656
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
6800
7706
    }
6801
7707
  }
6802
7708
  {
6803
 
    arg3 = (apr_array_header_t *) svn_swig_py_strings_to_array(obj1,
 
7709
    arg3 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
 
7710
      sizeof(const char *),
 
7711
      svn_swig_py_unwrap_string,
 
7712
      NULL,
6804
7713
      _global_pool);
6805
7714
    if (PyErr_Occurred())
6806
7715
    SWIG_fail;
6853
7762
  {
6854
7763
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_mergeinfo_catalog_to_dict(*arg2,
6855
7764
        SWIGTYPE_p_svn_merge_range_t,
6856
 
        _global_py_pool));
 
7765
        _global_py_pool))
 
7766
    
 
7767
    
 
7768
    
 
7769
    ;
6857
7770
    if (PyErr_Occurred()) {
6858
7771
      SWIG_fail;
6859
7772
    }
6969
7882
  }
6970
7883
  {
6971
7884
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter3_t,
6972
 
        _global_py_pool, args));
 
7885
        _global_py_pool, args))
 
7886
    
 
7887
    ;
6973
7888
  }
6974
7889
  {
6975
7890
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
6976
 
        _global_py_pool, args));
 
7891
        _global_py_pool, args))
 
7892
    
 
7893
    ;
6977
7894
  }
6978
7895
  {
6979
7896
    Py_XDECREF(_global_py_pool);
7078
7995
  }
7079
7996
  {
7080
7997
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter2_t,
7081
 
        _global_py_pool, args));
 
7998
        _global_py_pool, args))
 
7999
    
 
8000
    ;
7082
8001
  }
7083
8002
  {
7084
8003
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
7085
 
        _global_py_pool, args));
 
8004
        _global_py_pool, args))
 
8005
    
 
8006
    ;
7086
8007
  }
7087
8008
  {
7088
8009
    Py_XDECREF(_global_py_pool);
7188
8109
  }
7189
8110
  {
7190
8111
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter3_t,
7191
 
        _global_py_pool, args));
 
8112
        _global_py_pool, args))
 
8113
    
 
8114
    ;
7192
8115
  }
7193
8116
  {
7194
8117
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
7195
 
        _global_py_pool, args));
 
8118
        _global_py_pool, args))
 
8119
    
 
8120
    ;
7196
8121
  }
7197
8122
  {
7198
8123
    Py_XDECREF(_global_py_pool);
7298
8223
  }
7299
8224
  {
7300
8225
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter2_t,
7301
 
        _global_py_pool, args));
 
8226
        _global_py_pool, args))
 
8227
    
 
8228
    ;
7302
8229
  }
7303
8230
  {
7304
8231
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
7305
 
        _global_py_pool, args));
 
8232
        _global_py_pool, args))
 
8233
    
 
8234
    ;
7306
8235
  }
7307
8236
  {
7308
8237
    Py_XDECREF(_global_py_pool);
7407
8336
  }
7408
8337
  {
7409
8338
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter3_t,
7410
 
        _global_py_pool, args));
 
8339
        _global_py_pool, args))
 
8340
    
 
8341
    ;
7411
8342
  }
7412
8343
  {
7413
8344
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
7414
 
        _global_py_pool, args));
 
8345
        _global_py_pool, args))
 
8346
    
 
8347
    ;
7415
8348
  }
7416
8349
  {
7417
8350
    Py_XDECREF(_global_py_pool);
7516
8449
  }
7517
8450
  {
7518
8451
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter2_t,
7519
 
        _global_py_pool, args));
 
8452
        _global_py_pool, args))
 
8453
    
 
8454
    ;
7520
8455
  }
7521
8456
  {
7522
8457
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
7523
 
        _global_py_pool, args));
 
8458
        _global_py_pool, args))
 
8459
    
 
8460
    ;
7524
8461
  }
7525
8462
  {
7526
8463
    Py_XDECREF(_global_py_pool);
7642
8579
  }
7643
8580
  {
7644
8581
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter3_t,
7645
 
        _global_py_pool, args));
 
8582
        _global_py_pool, args))
 
8583
    
 
8584
    ;
7646
8585
  }
7647
8586
  {
7648
8587
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
7649
 
        _global_py_pool, args));
 
8588
        _global_py_pool, args))
 
8589
    
 
8590
    ;
7650
8591
  }
7651
8592
  {
7652
8593
    Py_XDECREF(_global_py_pool);
7768
8709
  }
7769
8710
  {
7770
8711
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter2_t,
7771
 
        _global_py_pool, args));
 
8712
        _global_py_pool, args))
 
8713
    
 
8714
    ;
7772
8715
  }
7773
8716
  {
7774
8717
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
7775
 
        _global_py_pool, args));
 
8718
        _global_py_pool, args))
 
8719
    
 
8720
    ;
7776
8721
  }
7777
8722
  {
7778
8723
    Py_XDECREF(_global_py_pool);
7886
8831
  }
7887
8832
  {
7888
8833
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_ra_reporter2_t,
7889
 
        _global_py_pool, args));
 
8834
        _global_py_pool, args))
 
8835
    
 
8836
    ;
7890
8837
  }
7891
8838
  {
7892
8839
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
7893
 
        _global_py_pool, args));
 
8840
        _global_py_pool, args))
 
8841
    
 
8842
    ;
7894
8843
  }
7895
8844
  {
7896
8845
    Py_XDECREF(_global_py_pool);
7945
8894
    }
7946
8895
  }
7947
8896
  {
7948
 
    arg2 = (apr_array_header_t *) svn_swig_py_strings_to_array(obj1,
 
8897
    arg2 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
 
8898
      sizeof(const char *),
 
8899
      svn_swig_py_unwrap_string,
 
8900
      NULL,
7949
8901
      _global_pool);
7950
8902
    if (PyErr_Occurred())
7951
8903
    SWIG_fail;
7987
8939
    }
7988
8940
  }
7989
8941
  {
7990
 
    arg9 = (apr_array_header_t *) svn_swig_py_strings_to_array(obj8,
 
8942
    arg9 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj8,
 
8943
      sizeof(const char *),
 
8944
      svn_swig_py_unwrap_string,
 
8945
      NULL,
7991
8946
      _global_pool);
7992
8947
    if (PyErr_Occurred())
7993
8948
    SWIG_fail;
8072
9027
    }
8073
9028
  }
8074
9029
  {
8075
 
    arg2 = (apr_array_header_t *) svn_swig_py_strings_to_array(obj1,
 
9030
    arg2 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
 
9031
      sizeof(const char *),
 
9032
      svn_swig_py_unwrap_string,
 
9033
      NULL,
8076
9034
      _global_pool);
8077
9035
    if (PyErr_Occurred())
8078
9036
    SWIG_fail;
8291
9249
  }
8292
9250
  {
8293
9251
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_svn_dirent_t,
8294
 
        _global_py_pool, args));
 
9252
        _global_py_pool, args))
 
9253
    
 
9254
    ;
8295
9255
  }
8296
9256
  {
8297
9257
    Py_XDECREF(_global_py_pool);
8645
9605
    }
8646
9606
  }
8647
9607
  {
8648
 
    arg5 = (apr_array_header_t *) svn_swig_py_revnums_to_array(obj3,
 
9608
    arg5 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj3,
 
9609
      sizeof(svn_revnum_t),
 
9610
      svn_swig_py_unwrap_revnum,
 
9611
      NULL,
8649
9612
      _global_pool);
8650
 
    if (arg5 == NULL)
 
9613
    if (PyErr_Occurred())
8651
9614
    SWIG_fail;
8652
9615
  }
8653
9616
  if (obj4) {
8661
9624
  {
8662
9625
    svn_swig_py_release_py_lock();
8663
9626
    
8664
 
    result = (svn_error_t *)svn_ra_get_locations(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
 
9627
    result = (svn_error_t *)svn_ra_get_locations(arg1,arg2,(char const *)arg3,arg4,(apr_array_header_t const *)arg5,arg6);
8665
9628
    
8666
9629
    svn_swig_py_acquire_py_lock();
8667
9630
    
9188
10151
  }
9189
10152
  {
9190
10153
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_lock_t,
9191
 
        _global_py_pool, args));
 
10154
        _global_py_pool, args))
 
10155
    
 
10156
    ;
 
10157
  }
 
10158
  {
 
10159
    Py_XDECREF(_global_py_pool);
 
10160
  }
 
10161
  return resultobj;
 
10162
fail:
 
10163
  {
 
10164
    Py_XDECREF(_global_py_pool);
 
10165
  }
 
10166
  return NULL;
 
10167
}
 
10168
 
 
10169
 
 
10170
SWIGINTERN PyObject *_wrap_svn_ra_get_locks2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10171
  PyObject *resultobj = 0;
 
10172
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
10173
  apr_hash_t **arg2 = (apr_hash_t **) 0 ;
 
10174
  char *arg3 = (char *) 0 ;
 
10175
  svn_depth_t arg4 ;
 
10176
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
10177
  apr_pool_t *_global_pool = NULL ;
 
10178
  PyObject *_global_py_pool = NULL ;
 
10179
  apr_hash_t *temp2 ;
 
10180
  PyObject * obj0 = 0 ;
 
10181
  PyObject * obj2 = 0 ;
 
10182
  PyObject * obj3 = 0 ;
 
10183
  svn_error_t *result = 0 ;
 
10184
  
 
10185
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
10186
      &_global_py_pool, &_global_pool))
 
10187
  SWIG_fail;
 
10188
  arg5 = _global_pool;
 
10189
  arg2 = &temp2;
 
10190
  if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_ra_get_locks2",&obj0,&arg3,&obj2,&obj3)) SWIG_fail;
 
10191
  {
 
10192
    arg1 = (svn_ra_session_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_ra_session_t, svn_argnum_obj0);
 
10193
    if (PyErr_Occurred()) {
 
10194
      SWIG_fail;
 
10195
    }
 
10196
  }
 
10197
  {
 
10198
    arg4 = (svn_depth_t)SWIG_As_long (obj2);
 
10199
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
10200
      SWIG_fail;
 
10201
    }
 
10202
  }
 
10203
  if (obj3) {
 
10204
    /* Verify that the user supplied a valid pool */
 
10205
    if (obj3 != Py_None && obj3 != _global_py_pool) {
 
10206
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
 
10207
      SWIG_arg_fail(svn_argnum_obj3);
 
10208
      SWIG_fail;
 
10209
    }
 
10210
  }
 
10211
  {
 
10212
    svn_swig_py_release_py_lock();
 
10213
    
 
10214
    result = (svn_error_t *)svn_ra_get_locks2(arg1,arg2,(char const *)arg3,arg4,arg5);
 
10215
    
 
10216
    svn_swig_py_acquire_py_lock();
 
10217
    
 
10218
  }
 
10219
  {
 
10220
    if (result != NULL) {
 
10221
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
10222
      svn_swig_py_svn_exception(result);
 
10223
      else
 
10224
      svn_error_clear(result);
 
10225
      SWIG_fail;
 
10226
    }
 
10227
    Py_INCREF(Py_None);
 
10228
    resultobj = Py_None;
 
10229
  }
 
10230
  {
 
10231
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_convert_hash(*arg2,
 
10232
        SWIGTYPE_p_svn_lock_t,
 
10233
        _global_py_pool))
 
10234
    
 
10235
    
 
10236
    
 
10237
    ;
9192
10238
  }
9193
10239
  {
9194
10240
    Py_XDECREF(_global_py_pool);
9257
10303
  {
9258
10304
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_convert_hash(*arg2,
9259
10305
        SWIGTYPE_p_svn_lock_t,
9260
 
        _global_py_pool));
 
10306
        _global_py_pool))
 
10307
    
 
10308
    
 
10309
    
 
10310
    ;
9261
10311
  }
9262
10312
  {
9263
10313
    Py_XDECREF(_global_py_pool);
9495
10545
}
9496
10546
 
9497
10547
 
 
10548
SWIGINTERN PyObject *_wrap_svn_ra_get_deleted_rev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10549
  PyObject *resultobj = 0;
 
10550
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
 
10551
  char *arg2 = (char *) 0 ;
 
10552
  svn_revnum_t arg3 ;
 
10553
  svn_revnum_t arg4 ;
 
10554
  svn_revnum_t *arg5 = (svn_revnum_t *) 0 ;
 
10555
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
10556
  apr_pool_t *_global_pool = NULL ;
 
10557
  PyObject *_global_py_pool = NULL ;
 
10558
  svn_revnum_t temp5 ;
 
10559
  int res5 = SWIG_TMPOBJ ;
 
10560
  PyObject * obj0 = 0 ;
 
10561
  PyObject * obj2 = 0 ;
 
10562
  PyObject * obj3 = 0 ;
 
10563
  PyObject * obj4 = 0 ;
 
10564
  svn_error_t *result = 0 ;
 
10565
  
 
10566
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
10567
      &_global_py_pool, &_global_pool))
 
10568
  SWIG_fail;
 
10569
  arg6 = _global_pool;
 
10570
  arg5 = &temp5;
 
10571
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_ra_get_deleted_rev",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
 
10572
  {
 
10573
    arg1 = (svn_ra_session_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_ra_session_t, svn_argnum_obj0);
 
10574
    if (PyErr_Occurred()) {
 
10575
      SWIG_fail;
 
10576
    }
 
10577
  }
 
10578
  {
 
10579
    arg3 = (svn_revnum_t)SWIG_As_long (obj2);
 
10580
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
10581
      SWIG_fail;
 
10582
    }
 
10583
  }
 
10584
  {
 
10585
    arg4 = (svn_revnum_t)SWIG_As_long (obj3);
 
10586
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
10587
      SWIG_fail;
 
10588
    }
 
10589
  }
 
10590
  if (obj4) {
 
10591
    /* Verify that the user supplied a valid pool */
 
10592
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
10593
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
10594
      SWIG_arg_fail(svn_argnum_obj4);
 
10595
      SWIG_fail;
 
10596
    }
 
10597
  }
 
10598
  {
 
10599
    svn_swig_py_release_py_lock();
 
10600
    
 
10601
    result = (svn_error_t *)svn_ra_get_deleted_rev(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
 
10602
    
 
10603
    svn_swig_py_acquire_py_lock();
 
10604
    
 
10605
  }
 
10606
  {
 
10607
    if (result != NULL) {
 
10608
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
10609
      svn_swig_py_svn_exception(result);
 
10610
      else
 
10611
      svn_error_clear(result);
 
10612
      SWIG_fail;
 
10613
    }
 
10614
    Py_INCREF(Py_None);
 
10615
    resultobj = Py_None;
 
10616
  }
 
10617
  if (SWIG_IsTmpObj(res5)) {
 
10618
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
 
10619
  } else {
 
10620
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
10621
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
 
10622
  }
 
10623
  {
 
10624
    Py_XDECREF(_global_py_pool);
 
10625
  }
 
10626
  return resultobj;
 
10627
fail:
 
10628
  {
 
10629
    Py_XDECREF(_global_py_pool);
 
10630
  }
 
10631
  return NULL;
 
10632
}
 
10633
 
 
10634
 
9498
10635
SWIGINTERN PyObject *_wrap_svn_ra_has_capability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9499
10636
  PyObject *resultobj = 0;
9500
10637
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
9566
10703
}
9567
10704
 
9568
10705
 
9569
 
SWIGINTERN PyObject *_wrap_svn_ra_get_deleted_rev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9570
 
  PyObject *resultobj = 0;
9571
 
  svn_ra_session_t *arg1 = (svn_ra_session_t *) 0 ;
9572
 
  char *arg2 = (char *) 0 ;
9573
 
  svn_revnum_t arg3 ;
9574
 
  svn_revnum_t arg4 ;
9575
 
  svn_revnum_t *arg5 = (svn_revnum_t *) 0 ;
9576
 
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
9577
 
  apr_pool_t *_global_pool = NULL ;
9578
 
  PyObject *_global_py_pool = NULL ;
9579
 
  svn_revnum_t temp5 ;
9580
 
  int res5 = SWIG_TMPOBJ ;
9581
 
  PyObject * obj0 = 0 ;
9582
 
  PyObject * obj2 = 0 ;
9583
 
  PyObject * obj3 = 0 ;
9584
 
  PyObject * obj4 = 0 ;
9585
 
  svn_error_t *result = 0 ;
9586
 
  
9587
 
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
9588
 
      &_global_py_pool, &_global_pool))
9589
 
  SWIG_fail;
9590
 
  arg6 = _global_pool;
9591
 
  arg5 = &temp5;
9592
 
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_ra_get_deleted_rev",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
9593
 
  {
9594
 
    arg1 = (svn_ra_session_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_ra_session_t, svn_argnum_obj0);
9595
 
    if (PyErr_Occurred()) {
9596
 
      SWIG_fail;
9597
 
    }
9598
 
  }
9599
 
  {
9600
 
    arg3 = (svn_revnum_t)SWIG_As_long (obj2);
9601
 
    if (SWIG_arg_fail(svn_argnum_obj2)) {
9602
 
      SWIG_fail;
9603
 
    }
9604
 
  }
9605
 
  {
9606
 
    arg4 = (svn_revnum_t)SWIG_As_long (obj3);
9607
 
    if (SWIG_arg_fail(svn_argnum_obj3)) {
9608
 
      SWIG_fail;
9609
 
    }
9610
 
  }
9611
 
  if (obj4) {
9612
 
    /* Verify that the user supplied a valid pool */
9613
 
    if (obj4 != Py_None && obj4 != _global_py_pool) {
9614
 
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
9615
 
      SWIG_arg_fail(svn_argnum_obj4);
9616
 
      SWIG_fail;
9617
 
    }
9618
 
  }
9619
 
  {
9620
 
    svn_swig_py_release_py_lock();
9621
 
    
9622
 
    result = (svn_error_t *)svn_ra_get_deleted_rev(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
9623
 
    
9624
 
    svn_swig_py_acquire_py_lock();
9625
 
    
9626
 
  }
9627
 
  {
9628
 
    if (result != NULL) {
9629
 
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
9630
 
      svn_swig_py_svn_exception(result);
9631
 
      else
9632
 
      svn_error_clear(result);
9633
 
      SWIG_fail;
9634
 
    }
9635
 
    Py_INCREF(Py_None);
9636
 
    resultobj = Py_None;
9637
 
  }
9638
 
  if (SWIG_IsTmpObj(res5)) {
9639
 
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
9640
 
  } else {
9641
 
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
9642
 
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
9643
 
  }
9644
 
  {
9645
 
    Py_XDECREF(_global_py_pool);
9646
 
  }
9647
 
  return resultobj;
9648
 
fail:
9649
 
  {
9650
 
    Py_XDECREF(_global_py_pool);
9651
 
  }
9652
 
  return NULL;
9653
 
}
9654
 
 
9655
 
 
9656
10706
SWIGINTERN PyObject *_wrap_svn_ra_print_modules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9657
10707
  PyObject *resultobj = 0;
9658
10708
  svn_stringbuf_t *arg1 = (svn_stringbuf_t *) 0 ;
10973
12023
  }
10974
12024
  {
10975
12025
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_void,
10976
 
        _global_py_pool, args));
 
12026
        _global_py_pool, args))
 
12027
    
 
12028
    ;
10977
12029
  }
10978
12030
  {
10979
12031
    Py_XDECREF(_global_py_pool);
11043
12095
  }
11044
12096
  {
11045
12097
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_ra_plugin_t,
11046
 
        _global_py_pool, args));
 
12098
        _global_py_pool, args))
 
12099
    
 
12100
    ;
11047
12101
  }
11048
12102
  {
11049
12103
    Py_XDECREF(_global_py_pool);
12305
13359
  }
12306
13360
  {
12307
13361
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_apr_file_t,
12308
 
        _global_py_pool, args));
 
13362
        _global_py_pool, args))
 
13363
    
 
13364
    ;
12309
13365
  }
12310
13366
  {
12311
13367
    Py_XDECREF(_global_py_pool);
12382
13438
  }
12383
13439
  {
12384
13440
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_apr_file_t,
12385
 
        _global_py_pool, args));
 
13441
        _global_py_pool, args))
 
13442
    
 
13443
    ;
12386
13444
  }
12387
13445
  {
12388
13446
    Py_XDECREF(_global_py_pool);
12442
13500
    }
12443
13501
  }
12444
13502
  {
12445
 
    arg6 = (apr_hash_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_apr_hash_t, svn_argnum_obj4);
12446
 
    if (PyErr_Occurred()) {
 
13503
    if (_global_pool == NULL)
 
13504
    {
 
13505
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
13506
          &_global_py_pool, &_global_pool))
12447
13507
      SWIG_fail;
12448
13508
    }
 
13509
    
 
13510
    arg6 = svn_swig_py_struct_ptr_hash_from_dict(obj4,
 
13511
      SWIGTYPE_p_svn_config_t, _global_pool);
 
13512
    if (PyErr_Occurred())
 
13513
    SWIG_fail;
12449
13514
  }
12450
13515
  if (obj5) {
12451
13516
    /* Verify that the user supplied a valid pool */
12476
13541
  }
12477
13542
  {
12478
13543
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
12479
 
        _global_py_pool, args));
 
13544
        _global_py_pool, args))
 
13545
    
 
13546
    ;
12480
13547
  }
12481
13548
  {
12482
13549
    Py_XDECREF(_global_py_pool);
13001
14068
  }
13002
14069
  {
13003
14070
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_svn_delta_editor_t,
13004
 
        _global_py_pool, args));
 
14071
        _global_py_pool, args))
 
14072
    
 
14073
    ;
13005
14074
  }
13006
14075
  {
13007
14076
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_void,
13008
 
        _global_py_pool, args));
 
14077
        _global_py_pool, args))
 
14078
    
 
14079
    ;
13009
14080
  }
13010
14081
  {
13011
14082
    Py_XDECREF(_global_py_pool);
13199
14270
  {
13200
14271
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_convert_hash(*arg5,
13201
14272
        SWIGTYPE_p_svn_dirent_t,
13202
 
        _global_py_pool));
 
14273
        _global_py_pool))
 
14274
    
 
14275
    
 
14276
    
 
14277
    ;
13203
14278
  }
13204
14279
  if (SWIG_IsTmpObj(res6)) {
13205
14280
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg6)));
13323
14398
  }
13324
14399
  {
13325
14400
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_svn_ra_reporter_t,
13326
 
        _global_py_pool, args));
 
14401
        _global_py_pool, args))
 
14402
    
 
14403
    ;
13327
14404
  }
13328
14405
  {
13329
14406
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_void,
13330
 
        _global_py_pool, args));
 
14407
        _global_py_pool, args))
 
14408
    
 
14409
    ;
13331
14410
  }
13332
14411
  {
13333
14412
    Py_XDECREF(_global_py_pool);
13443
14522
  }
13444
14523
  {
13445
14524
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_svn_ra_reporter_t,
13446
 
        _global_py_pool, args));
 
14525
        _global_py_pool, args))
 
14526
    
 
14527
    ;
13447
14528
  }
13448
14529
  {
13449
14530
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_void,
13450
 
        _global_py_pool, args));
 
14531
        _global_py_pool, args))
 
14532
    
 
14533
    ;
13451
14534
  }
13452
14535
  {
13453
14536
    Py_XDECREF(_global_py_pool);
13562
14645
  }
13563
14646
  {
13564
14647
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_svn_ra_reporter_t,
13565
 
        _global_py_pool, args));
 
14648
        _global_py_pool, args))
 
14649
    
 
14650
    ;
13566
14651
  }
13567
14652
  {
13568
14653
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_void,
13569
 
        _global_py_pool, args));
 
14654
        _global_py_pool, args))
 
14655
    
 
14656
    ;
13570
14657
  }
13571
14658
  {
13572
14659
    Py_XDECREF(_global_py_pool);
13690
14777
  }
13691
14778
  {
13692
14779
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_svn_ra_reporter_t,
13693
 
        _global_py_pool, args));
 
14780
        _global_py_pool, args))
 
14781
    
 
14782
    ;
13694
14783
  }
13695
14784
  {
13696
14785
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_void,
13697
 
        _global_py_pool, args));
 
14786
        _global_py_pool, args))
 
14787
    
 
14788
    ;
13698
14789
  }
13699
14790
  {
13700
14791
    Py_XDECREF(_global_py_pool);
13753
14844
    }
13754
14845
  }
13755
14846
  {
13756
 
    arg3 = (apr_array_header_t *) svn_swig_py_strings_to_array(obj2,
 
14847
    arg3 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj2,
 
14848
      sizeof(const char *),
 
14849
      svn_swig_py_unwrap_string,
 
14850
      NULL,
13757
14851
      _global_pool);
13758
14852
    if (PyErr_Occurred())
13759
14853
    SWIG_fail;
14132
15226
    }
14133
15227
  }
14134
15228
  {
14135
 
    arg6 = (apr_array_header_t *) svn_swig_py_revnums_to_array(obj4,
 
15229
    arg6 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj4,
 
15230
      sizeof(svn_revnum_t),
 
15231
      svn_swig_py_unwrap_revnum,
 
15232
      NULL,
14136
15233
      _global_pool);
14137
 
    if (arg6 == NULL)
 
15234
    if (PyErr_Occurred())
14138
15235
    SWIG_fail;
14139
15236
  }
14140
15237
  if (obj5) {
14895
15992
  }
14896
15993
  {
14897
15994
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
14898
 
        _global_py_pool, args));
 
15995
        _global_py_pool, args))
 
15996
    
 
15997
    ;
14899
15998
  }
14900
15999
  {
14901
16000
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
14902
 
        _global_py_pool, args));
 
16001
        _global_py_pool, args))
 
16002
    
 
16003
    ;
14903
16004
  }
14904
16005
  {
14905
16006
    Py_XDECREF(_global_py_pool);
15161
16262
  }
15162
16263
  {
15163
16264
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_svn_delta_editor_t,
15164
 
        _global_py_pool, args));
 
16265
        _global_py_pool, args))
 
16266
    
 
16267
    ;
15165
16268
  }
15166
16269
  {
15167
16270
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg5, SWIGTYPE_p_void,
15168
 
        _global_py_pool, args));
 
16271
        _global_py_pool, args))
 
16272
    
 
16273
    ;
15169
16274
  }
15170
16275
  {
15171
16276
    Py_XDECREF(_global_py_pool);
15457
16562
}
15458
16563
 
15459
16564
static PyMethodDef SwigMethods[] = {
 
16565
         { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
15460
16566
         { (char *)"svn_ra_version", _wrap_svn_ra_version, METH_VARARGS, (char *)"svn_ra_version() -> svn_version_t"},
15461
16567
         { (char *)"svn_ra_reporter3_t_set_path_set", _wrap_svn_ra_reporter3_t_set_path_set, METH_VARARGS, (char *)"svn_ra_reporter3_t_set_path_set(svn_ra_reporter3_t self, svn_error_t set_path)"},
15462
16568
         { (char *)"svn_ra_reporter3_t_set_path_get", _wrap_svn_ra_reporter3_t_set_path_get, METH_VARARGS, (char *)"svn_ra_reporter3_t_set_path_get(svn_ra_reporter3_t self) -> svn_error_t"},
15536
16642
         { (char *)"delete_svn_ra_callbacks_t", _wrap_delete_svn_ra_callbacks_t, METH_VARARGS, (char *)"delete_svn_ra_callbacks_t(svn_ra_callbacks_t self)"},
15537
16643
         { (char *)"svn_ra_callbacks_t_swigregister", svn_ra_callbacks_t_swigregister, METH_VARARGS, NULL},
15538
16644
         { (char *)"svn_ra_initialize", _wrap_svn_ra_initialize, METH_VARARGS, (char *)"svn_ra_initialize(apr_pool_t pool) -> svn_error_t"},
15539
 
         { (char *)"svn_ra_create_callbacks", _wrap_svn_ra_create_callbacks, METH_VARARGS, (char *)"svn_ra_create_callbacks(svn_ra_callbacks2_t callbacks, apr_pool_t pool) -> svn_error_t"},
 
16645
         { (char *)"svn_ra_create_callbacks", _wrap_svn_ra_create_callbacks, METH_VARARGS, (char *)"svn_ra_create_callbacks(apr_pool_t pool) -> svn_error_t"},
 
16646
         { (char *)"svn_ra_open4", _wrap_svn_ra_open4, METH_VARARGS, (char *)"\n"
 
16647
                "svn_ra_open4(char repos_URL, char uuid, svn_ra_callbacks2_t callbacks, \n"
 
16648
                "    apr_hash_t config, apr_pool_t pool) -> svn_error_t\n"
 
16649
                ""},
15540
16650
         { (char *)"svn_ra_open3", _wrap_svn_ra_open3, METH_VARARGS, (char *)"\n"
15541
 
                "svn_ra_open3(svn_ra_session_t session_p, char repos_URL, char uuid, \n"
15542
 
                "    svn_ra_callbacks2_t callbacks, apr_hash_t config, \n"
15543
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
16651
                "svn_ra_open3(char repos_URL, char uuid, svn_ra_callbacks2_t callbacks, \n"
 
16652
                "    apr_hash_t config, apr_pool_t pool) -> svn_error_t\n"
15544
16653
                ""},
15545
16654
         { (char *)"svn_ra_open2", _wrap_svn_ra_open2, METH_VARARGS, (char *)"\n"
15546
 
                "svn_ra_open2(svn_ra_session_t session_p, char repos_URL, svn_ra_callbacks2_t callbacks, \n"
15547
 
                "    apr_hash_t config, apr_pool_t pool) -> svn_error_t\n"
 
16655
                "svn_ra_open2(char repos_URL, svn_ra_callbacks2_t callbacks, apr_hash_t config, \n"
 
16656
                "    apr_pool_t pool) -> svn_error_t\n"
15548
16657
                ""},
15549
16658
         { (char *)"svn_ra_open", _wrap_svn_ra_open, METH_VARARGS, (char *)"\n"
15550
 
                "svn_ra_open(svn_ra_session_t session_p, char repos_URL, svn_ra_callbacks_t callbacks, \n"
15551
 
                "    void callback_baton, apr_hash_t config, \n"
15552
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
16659
                "svn_ra_open(char repos_URL, svn_ra_callbacks_t callbacks, void callback_baton, \n"
 
16660
                "    apr_hash_t config, apr_pool_t pool) -> svn_error_t\n"
15553
16661
                ""},
15554
16662
         { (char *)"svn_ra_reparent", _wrap_svn_ra_reparent, METH_VARARGS, (char *)"svn_ra_reparent(svn_ra_session_t ra_session, char url, apr_pool_t pool) -> svn_error_t"},
15555
 
         { (char *)"svn_ra_get_session_url", _wrap_svn_ra_get_session_url, METH_VARARGS, (char *)"svn_ra_get_session_url(svn_ra_session_t ra_session, char url, apr_pool_t pool) -> svn_error_t"},
15556
 
         { (char *)"svn_ra_get_latest_revnum", _wrap_svn_ra_get_latest_revnum, METH_VARARGS, (char *)"\n"
15557
 
                "svn_ra_get_latest_revnum(svn_ra_session_t session, svn_revnum_t latest_revnum, \n"
15558
 
                "    apr_pool_t pool) -> svn_error_t\n"
15559
 
                ""},
15560
 
         { (char *)"svn_ra_get_dated_revision", _wrap_svn_ra_get_dated_revision, METH_VARARGS, (char *)"\n"
15561
 
                "svn_ra_get_dated_revision(svn_ra_session_t session, svn_revnum_t revision, apr_time_t tm, \n"
 
16663
         { (char *)"svn_ra_get_session_url", _wrap_svn_ra_get_session_url, METH_VARARGS, (char *)"svn_ra_get_session_url(svn_ra_session_t ra_session, apr_pool_t pool) -> svn_error_t"},
 
16664
         { (char *)"svn_ra_get_path_relative_to_session", _wrap_svn_ra_get_path_relative_to_session, METH_VARARGS, (char *)"svn_ra_get_path_relative_to_session(svn_ra_session_t ra_session, char url, apr_pool_t pool) -> svn_error_t"},
 
16665
         { (char *)"svn_ra_get_path_relative_to_root", _wrap_svn_ra_get_path_relative_to_root, METH_VARARGS, (char *)"svn_ra_get_path_relative_to_root(svn_ra_session_t ra_session, char url, apr_pool_t pool) -> svn_error_t"},
 
16666
         { (char *)"svn_ra_get_latest_revnum", _wrap_svn_ra_get_latest_revnum, METH_VARARGS, (char *)"svn_ra_get_latest_revnum(svn_ra_session_t session, apr_pool_t pool) -> svn_error_t"},
 
16667
         { (char *)"svn_ra_get_dated_revision", _wrap_svn_ra_get_dated_revision, METH_VARARGS, (char *)"svn_ra_get_dated_revision(svn_ra_session_t session, apr_time_t tm, apr_pool_t pool) -> svn_error_t"},
 
16668
         { (char *)"svn_ra_change_rev_prop2", _wrap_svn_ra_change_rev_prop2, METH_VARARGS, (char *)"\n"
 
16669
                "svn_ra_change_rev_prop2(svn_ra_session_t session, svn_revnum_t rev, char name, \n"
 
16670
                "    svn_string_t old_value_p, svn_string_t value, \n"
15562
16671
                "    apr_pool_t pool) -> svn_error_t\n"
15563
16672
                ""},
15564
16673
         { (char *)"svn_ra_change_rev_prop", _wrap_svn_ra_change_rev_prop, METH_VARARGS, (char *)"\n"
15565
16674
                "svn_ra_change_rev_prop(svn_ra_session_t session, svn_revnum_t rev, char name, \n"
15566
16675
                "    svn_string_t value, apr_pool_t pool) -> svn_error_t\n"
15567
16676
                ""},
15568
 
         { (char *)"svn_ra_rev_proplist", _wrap_svn_ra_rev_proplist, METH_VARARGS, (char *)"\n"
15569
 
                "svn_ra_rev_proplist(svn_ra_session_t session, svn_revnum_t rev, apr_hash_t props, \n"
15570
 
                "    apr_pool_t pool) -> svn_error_t\n"
15571
 
                ""},
 
16677
         { (char *)"svn_ra_rev_proplist", _wrap_svn_ra_rev_proplist, METH_VARARGS, (char *)"svn_ra_rev_proplist(svn_ra_session_t session, svn_revnum_t rev, apr_pool_t pool) -> svn_error_t"},
15572
16678
         { (char *)"svn_ra_rev_prop", _wrap_svn_ra_rev_prop, METH_VARARGS, (char *)"\n"
15573
16679
                "svn_ra_rev_prop(svn_ra_session_t session, svn_revnum_t rev, char name, \n"
15574
 
                "    svn_string_t value, apr_pool_t pool) -> svn_error_t\n"
 
16680
                "    apr_pool_t pool) -> svn_error_t\n"
15575
16681
                ""},
15576
16682
         { (char *)"svn_ra_get_commit_editor3", _wrap_svn_ra_get_commit_editor3, METH_VARARGS, (char *)"\n"
15577
 
                "svn_ra_get_commit_editor3(svn_ra_session_t session, svn_delta_editor_t editor, \n"
15578
 
                "    void edit_baton, apr_hash_t revprop_table, \n"
 
16683
                "svn_ra_get_commit_editor3(svn_ra_session_t session, apr_hash_t revprop_table, \n"
15579
16684
                "    svn_commit_callback2_t callback, apr_hash_t lock_tokens, \n"
15580
16685
                "    svn_boolean_t keep_locks, apr_pool_t pool) -> svn_error_t\n"
15581
16686
                ""},
15582
16687
         { (char *)"svn_ra_get_commit_editor2", _wrap_svn_ra_get_commit_editor2, METH_VARARGS, (char *)"\n"
15583
 
                "svn_ra_get_commit_editor2(svn_ra_session_t session, svn_delta_editor_t editor, \n"
15584
 
                "    void edit_baton, char log_msg, svn_commit_callback2_t callback, \n"
 
16688
                "svn_ra_get_commit_editor2(svn_ra_session_t session, char log_msg, svn_commit_callback2_t callback, \n"
15585
16689
                "    apr_hash_t lock_tokens, \n"
15586
16690
                "    svn_boolean_t keep_locks, apr_pool_t pool) -> svn_error_t\n"
15587
16691
                ""},
15588
16692
         { (char *)"svn_ra_get_commit_editor", _wrap_svn_ra_get_commit_editor, METH_VARARGS, (char *)"\n"
15589
 
                "svn_ra_get_commit_editor(svn_ra_session_t session, svn_delta_editor_t editor, \n"
15590
 
                "    void edit_baton, char log_msg, svn_commit_callback_t callback, \n"
15591
 
                "    apr_hash_t lock_tokens, svn_boolean_t keep_locks, \n"
15592
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
16693
                "svn_ra_get_commit_editor(svn_ra_session_t session, char log_msg, svn_commit_callback_t callback, \n"
 
16694
                "    apr_hash_t lock_tokens, \n"
 
16695
                "    svn_boolean_t keep_locks, apr_pool_t pool) -> svn_error_t\n"
15593
16696
                ""},
15594
16697
         { (char *)"svn_ra_get_file", _wrap_svn_ra_get_file, METH_VARARGS, (char *)"\n"
15595
16698
                "svn_ra_get_file(svn_ra_session_t session, char path, svn_revnum_t revision, \n"
15596
 
                "    svn_stream_t stream, svn_revnum_t fetched_rev, \n"
15597
 
                "    apr_hash_t props, apr_pool_t pool) -> svn_error_t\n"
 
16699
                "    svn_stream_t stream, apr_pool_t pool) -> svn_error_t\n"
15598
16700
                ""},
15599
16701
         { (char *)"svn_ra_get_dir2", _wrap_svn_ra_get_dir2, METH_VARARGS, (char *)"\n"
15600
 
                "svn_ra_get_dir2(svn_ra_session_t session, apr_hash_t dirents, svn_revnum_t fetched_rev, \n"
15601
 
                "    apr_hash_t props, char path, \n"
15602
 
                "    svn_revnum_t revision, apr_uint32_t dirent_fields, \n"
15603
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
16702
                "svn_ra_get_dir2(svn_ra_session_t session, char path, svn_revnum_t revision, \n"
 
16703
                "    apr_uint32_t dirent_fields, apr_pool_t pool) -> svn_error_t\n"
15604
16704
                ""},
15605
16705
         { (char *)"svn_ra_get_dir", _wrap_svn_ra_get_dir, METH_VARARGS, (char *)"\n"
15606
16706
                "svn_ra_get_dir(svn_ra_session_t session, char path, svn_revnum_t revision, \n"
15607
 
                "    apr_hash_t dirents, svn_revnum_t fetched_rev, \n"
15608
 
                "    apr_hash_t props, apr_pool_t pool) -> svn_error_t\n"
 
16707
                "    apr_pool_t pool) -> svn_error_t\n"
15609
16708
                ""},
15610
16709
         { (char *)"svn_ra_get_mergeinfo", _wrap_svn_ra_get_mergeinfo, METH_VARARGS, (char *)"\n"
15611
 
                "svn_ra_get_mergeinfo(svn_ra_session_t session, svn_mergeinfo_catalog_t catalog, \n"
15612
 
                "    apr_array_header_t paths, svn_revnum_t revision, \n"
15613
 
                "    svn_mergeinfo_inheritance_t inherit, \n"
15614
 
                "    svn_boolean_t include_descendants, apr_pool_t pool) -> svn_error_t\n"
 
16710
                "svn_ra_get_mergeinfo(svn_ra_session_t session, apr_array_header_t paths, \n"
 
16711
                "    svn_revnum_t revision, svn_mergeinfo_inheritance_t inherit, \n"
 
16712
                "    svn_boolean_t include_descendants, \n"
 
16713
                "    apr_pool_t pool) -> svn_error_t\n"
15615
16714
                ""},
15616
16715
         { (char *)"svn_ra_do_update2", _wrap_svn_ra_do_update2, METH_VARARGS, (char *)"\n"
15617
 
                "svn_ra_do_update2(svn_ra_session_t session, svn_ra_reporter3_t reporter, \n"
15618
 
                "    void report_baton, svn_revnum_t revision_to_update_to, \n"
 
16716
                "svn_ra_do_update2(svn_ra_session_t session, svn_revnum_t revision_to_update_to, \n"
15619
16717
                "    char update_target, svn_depth_t depth, \n"
15620
16718
                "    svn_boolean_t send_copyfrom_args, svn_delta_editor_t update_editor, \n"
15621
16719
                "    void update_baton, \n"
15622
16720
                "    apr_pool_t pool) -> svn_error_t\n"
15623
16721
                ""},
15624
16722
         { (char *)"svn_ra_do_update", _wrap_svn_ra_do_update, METH_VARARGS, (char *)"\n"
15625
 
                "svn_ra_do_update(svn_ra_session_t session, svn_ra_reporter2_t reporter, \n"
15626
 
                "    void report_baton, svn_revnum_t revision_to_update_to, \n"
 
16723
                "svn_ra_do_update(svn_ra_session_t session, svn_revnum_t revision_to_update_to, \n"
15627
16724
                "    char update_target, svn_boolean_t recurse, \n"
15628
 
                "    svn_delta_editor_t update_editor, \n"
15629
 
                "    void update_baton, apr_pool_t pool) -> svn_error_t\n"
 
16725
                "    svn_delta_editor_t update_editor, void update_baton, \n"
 
16726
                "    apr_pool_t pool) -> svn_error_t\n"
15630
16727
                ""},
15631
16728
         { (char *)"svn_ra_do_switch2", _wrap_svn_ra_do_switch2, METH_VARARGS, (char *)"\n"
15632
 
                "svn_ra_do_switch2(svn_ra_session_t session, svn_ra_reporter3_t reporter, \n"
15633
 
                "    void report_baton, svn_revnum_t revision_to_switch_to, \n"
 
16729
                "svn_ra_do_switch2(svn_ra_session_t session, svn_revnum_t revision_to_switch_to, \n"
15634
16730
                "    char switch_target, svn_depth_t depth, \n"
15635
16731
                "    char switch_url, svn_delta_editor_t switch_editor, \n"
15636
16732
                "    void switch_baton, apr_pool_t pool) -> svn_error_t\n"
15637
16733
                ""},
15638
16734
         { (char *)"svn_ra_do_switch", _wrap_svn_ra_do_switch, METH_VARARGS, (char *)"\n"
15639
 
                "svn_ra_do_switch(svn_ra_session_t session, svn_ra_reporter2_t reporter, \n"
15640
 
                "    void report_baton, svn_revnum_t revision_to_switch_to, \n"
 
16735
                "svn_ra_do_switch(svn_ra_session_t session, svn_revnum_t revision_to_switch_to, \n"
15641
16736
                "    char switch_target, svn_boolean_t recurse, \n"
15642
16737
                "    char switch_url, svn_delta_editor_t switch_editor, \n"
15643
16738
                "    void switch_baton, apr_pool_t pool) -> svn_error_t\n"
15644
16739
                ""},
15645
16740
         { (char *)"svn_ra_do_status2", _wrap_svn_ra_do_status2, METH_VARARGS, (char *)"\n"
15646
 
                "svn_ra_do_status2(svn_ra_session_t session, svn_ra_reporter3_t reporter, \n"
15647
 
                "    void report_baton, char status_target, svn_revnum_t revision, \n"
 
16741
                "svn_ra_do_status2(svn_ra_session_t session, char status_target, svn_revnum_t revision, \n"
15648
16742
                "    svn_depth_t depth, svn_delta_editor_t status_editor, \n"
15649
16743
                "    void status_baton, \n"
15650
16744
                "    apr_pool_t pool) -> svn_error_t\n"
15651
16745
                ""},
15652
16746
         { (char *)"svn_ra_do_status", _wrap_svn_ra_do_status, METH_VARARGS, (char *)"\n"
15653
 
                "svn_ra_do_status(svn_ra_session_t session, svn_ra_reporter2_t reporter, \n"
15654
 
                "    void report_baton, char status_target, svn_revnum_t revision, \n"
 
16747
                "svn_ra_do_status(svn_ra_session_t session, char status_target, svn_revnum_t revision, \n"
15655
16748
                "    svn_boolean_t recurse, svn_delta_editor_t status_editor, \n"
15656
16749
                "    void status_baton, \n"
15657
16750
                "    apr_pool_t pool) -> svn_error_t\n"
15658
16751
                ""},
15659
16752
         { (char *)"svn_ra_do_diff3", _wrap_svn_ra_do_diff3, METH_VARARGS, (char *)"\n"
15660
 
                "svn_ra_do_diff3(svn_ra_session_t session, svn_ra_reporter3_t reporter, \n"
15661
 
                "    void report_baton, svn_revnum_t revision, \n"
15662
 
                "    char diff_target, svn_depth_t depth, svn_boolean_t ignore_ancestry, \n"
 
16753
                "svn_ra_do_diff3(svn_ra_session_t session, svn_revnum_t revision, char diff_target, \n"
 
16754
                "    svn_depth_t depth, svn_boolean_t ignore_ancestry, \n"
15663
16755
                "    svn_boolean_t text_deltas, \n"
15664
16756
                "    char versus_url, svn_delta_editor_t diff_editor, \n"
15665
16757
                "    void diff_baton, apr_pool_t pool) -> svn_error_t\n"
15666
16758
                ""},
15667
16759
         { (char *)"svn_ra_do_diff2", _wrap_svn_ra_do_diff2, METH_VARARGS, (char *)"\n"
15668
 
                "svn_ra_do_diff2(svn_ra_session_t session, svn_ra_reporter2_t reporter, \n"
15669
 
                "    void report_baton, svn_revnum_t revision, \n"
15670
 
                "    char diff_target, svn_boolean_t recurse, svn_boolean_t ignore_ancestry, \n"
 
16760
                "svn_ra_do_diff2(svn_ra_session_t session, svn_revnum_t revision, char diff_target, \n"
 
16761
                "    svn_boolean_t recurse, svn_boolean_t ignore_ancestry, \n"
15671
16762
                "    svn_boolean_t text_deltas, \n"
15672
16763
                "    char versus_url, svn_delta_editor_t diff_editor, \n"
15673
16764
                "    void diff_baton, apr_pool_t pool) -> svn_error_t\n"
15674
16765
                ""},
15675
16766
         { (char *)"svn_ra_do_diff", _wrap_svn_ra_do_diff, METH_VARARGS, (char *)"\n"
15676
 
                "svn_ra_do_diff(svn_ra_session_t session, svn_ra_reporter2_t reporter, \n"
15677
 
                "    void report_baton, svn_revnum_t revision, \n"
15678
 
                "    char diff_target, svn_boolean_t recurse, svn_boolean_t ignore_ancestry, \n"
15679
 
                "    char versus_url, \n"
15680
 
                "    svn_delta_editor_t diff_editor, void diff_baton, \n"
 
16767
                "svn_ra_do_diff(svn_ra_session_t session, svn_revnum_t revision, char diff_target, \n"
 
16768
                "    svn_boolean_t recurse, svn_boolean_t ignore_ancestry, \n"
 
16769
                "    char versus_url, svn_delta_editor_t diff_editor, \n"
 
16770
                "    void diff_baton, \n"
15681
16771
                "    apr_pool_t pool) -> svn_error_t\n"
15682
16772
                ""},
15683
16773
         { (char *)"svn_ra_get_log2", _wrap_svn_ra_get_log2, METH_VARARGS, (char *)"\n"
15698
16788
                ""},
15699
16789
         { (char *)"svn_ra_check_path", _wrap_svn_ra_check_path, METH_VARARGS, (char *)"\n"
15700
16790
                "svn_ra_check_path(svn_ra_session_t session, char path, svn_revnum_t revision, \n"
15701
 
                "    svn_node_kind_t kind, apr_pool_t pool) -> svn_error_t\n"
 
16791
                "    apr_pool_t pool) -> svn_error_t\n"
15702
16792
                ""},
15703
16793
         { (char *)"svn_ra_stat", _wrap_svn_ra_stat, METH_VARARGS, (char *)"\n"
15704
16794
                "svn_ra_stat(svn_ra_session_t session, char path, svn_revnum_t revision, \n"
15705
 
                "    svn_dirent_t dirent, apr_pool_t pool) -> svn_error_t\n"
 
16795
                "    apr_pool_t pool) -> svn_error_t\n"
15706
16796
                ""},
15707
 
         { (char *)"svn_ra_get_uuid2", _wrap_svn_ra_get_uuid2, METH_VARARGS, (char *)"svn_ra_get_uuid2(svn_ra_session_t session, char uuid, apr_pool_t pool) -> svn_error_t"},
15708
 
         { (char *)"svn_ra_get_uuid", _wrap_svn_ra_get_uuid, METH_VARARGS, (char *)"svn_ra_get_uuid(svn_ra_session_t session, char uuid, apr_pool_t pool) -> svn_error_t"},
15709
 
         { (char *)"svn_ra_get_repos_root2", _wrap_svn_ra_get_repos_root2, METH_VARARGS, (char *)"svn_ra_get_repos_root2(svn_ra_session_t session, char url, apr_pool_t pool) -> svn_error_t"},
15710
 
         { (char *)"svn_ra_get_repos_root", _wrap_svn_ra_get_repos_root, METH_VARARGS, (char *)"svn_ra_get_repos_root(svn_ra_session_t session, char url, apr_pool_t pool) -> svn_error_t"},
 
16797
         { (char *)"svn_ra_get_uuid2", _wrap_svn_ra_get_uuid2, METH_VARARGS, (char *)"svn_ra_get_uuid2(svn_ra_session_t session, apr_pool_t pool) -> svn_error_t"},
 
16798
         { (char *)"svn_ra_get_uuid", _wrap_svn_ra_get_uuid, METH_VARARGS, (char *)"svn_ra_get_uuid(svn_ra_session_t session, apr_pool_t pool) -> svn_error_t"},
 
16799
         { (char *)"svn_ra_get_repos_root2", _wrap_svn_ra_get_repos_root2, METH_VARARGS, (char *)"svn_ra_get_repos_root2(svn_ra_session_t session, apr_pool_t pool) -> svn_error_t"},
 
16800
         { (char *)"svn_ra_get_repos_root", _wrap_svn_ra_get_repos_root, METH_VARARGS, (char *)"svn_ra_get_repos_root(svn_ra_session_t session, apr_pool_t pool) -> svn_error_t"},
15711
16801
         { (char *)"svn_ra_get_locations", _wrap_svn_ra_get_locations, METH_VARARGS, (char *)"\n"
15712
 
                "svn_ra_get_locations(svn_ra_session_t session, apr_hash_t locations, char path, \n"
15713
 
                "    svn_revnum_t peg_revision, apr_array_header_t location_revisions, \n"
 
16802
                "svn_ra_get_locations(svn_ra_session_t session, char path, svn_revnum_t peg_revision, \n"
 
16803
                "    apr_array_header_t location_revisions, \n"
15714
16804
                "    apr_pool_t pool) -> svn_error_t\n"
15715
16805
                ""},
15716
16806
         { (char *)"svn_ra_get_location_segments", _wrap_svn_ra_get_location_segments, METH_VARARGS, (char *)"\n"
15740
16830
                "    svn_ra_lock_callback_t lock_func, \n"
15741
16831
                "    apr_pool_t pool) -> svn_error_t\n"
15742
16832
                ""},
15743
 
         { (char *)"svn_ra_get_lock", _wrap_svn_ra_get_lock, METH_VARARGS, (char *)"\n"
15744
 
                "svn_ra_get_lock(svn_ra_session_t session, svn_lock_t lock, char path, \n"
15745
 
                "    apr_pool_t pool) -> svn_error_t\n"
15746
 
                ""},
15747
 
         { (char *)"svn_ra_get_locks", _wrap_svn_ra_get_locks, METH_VARARGS, (char *)"\n"
15748
 
                "svn_ra_get_locks(svn_ra_session_t session, apr_hash_t locks, char path, \n"
15749
 
                "    apr_pool_t pool) -> svn_error_t\n"
15750
 
                ""},
 
16833
         { (char *)"svn_ra_get_lock", _wrap_svn_ra_get_lock, METH_VARARGS, (char *)"svn_ra_get_lock(svn_ra_session_t session, char path, apr_pool_t pool) -> svn_error_t"},
 
16834
         { (char *)"svn_ra_get_locks2", _wrap_svn_ra_get_locks2, METH_VARARGS, (char *)"\n"
 
16835
                "svn_ra_get_locks2(svn_ra_session_t session, char path, svn_depth_t depth, \n"
 
16836
                "    apr_pool_t pool) -> svn_error_t\n"
 
16837
                ""},
 
16838
         { (char *)"svn_ra_get_locks", _wrap_svn_ra_get_locks, METH_VARARGS, (char *)"svn_ra_get_locks(svn_ra_session_t session, char path, apr_pool_t pool) -> svn_error_t"},
15751
16839
         { (char *)"svn_ra_replay_range", _wrap_svn_ra_replay_range, METH_VARARGS, (char *)"\n"
15752
16840
                "svn_ra_replay_range(svn_ra_session_t session, svn_revnum_t start_revision, \n"
15753
16841
                "    svn_revnum_t end_revision, svn_revnum_t low_water_mark, \n"
15762
16850
                "    svn_delta_editor_t editor, void edit_baton, \n"
15763
16851
                "    apr_pool_t pool) -> svn_error_t\n"
15764
16852
                ""},
15765
 
         { (char *)"svn_ra_has_capability", _wrap_svn_ra_has_capability, METH_VARARGS, (char *)"\n"
15766
 
                "svn_ra_has_capability(svn_ra_session_t session, svn_boolean_t has, char capability, \n"
15767
 
                "    apr_pool_t pool) -> svn_error_t\n"
15768
 
                ""},
15769
16853
         { (char *)"svn_ra_get_deleted_rev", _wrap_svn_ra_get_deleted_rev, METH_VARARGS, (char *)"\n"
15770
16854
                "svn_ra_get_deleted_rev(svn_ra_session_t session, char path, svn_revnum_t peg_revision, \n"
15771
 
                "    svn_revnum_t end_revision, svn_revnum_t revision_deleted, \n"
15772
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
16855
                "    svn_revnum_t end_revision, apr_pool_t pool) -> svn_error_t\n"
15773
16856
                ""},
 
16857
         { (char *)"svn_ra_has_capability", _wrap_svn_ra_has_capability, METH_VARARGS, (char *)"svn_ra_has_capability(svn_ra_session_t session, char capability, apr_pool_t pool) -> svn_error_t"},
15774
16858
         { (char *)"svn_ra_print_modules", _wrap_svn_ra_print_modules, METH_VARARGS, (char *)"svn_ra_print_modules(svn_stringbuf_t output, apr_pool_t pool) -> svn_error_t"},
15775
 
         { (char *)"svn_ra_print_ra_libraries", _wrap_svn_ra_print_ra_libraries, METH_VARARGS, (char *)"svn_ra_print_ra_libraries(svn_stringbuf_t descriptions, void ra_baton, apr_pool_t pool) -> svn_error_t"},
 
16859
         { (char *)"svn_ra_print_ra_libraries", _wrap_svn_ra_print_ra_libraries, METH_VARARGS, (char *)"svn_ra_print_ra_libraries(void ra_baton, apr_pool_t pool) -> svn_error_t"},
15776
16860
         { (char *)"svn_ra_plugin_t_name_set", _wrap_svn_ra_plugin_t_name_set, METH_VARARGS, (char *)"svn_ra_plugin_t_name_set(svn_ra_plugin_t self, char name)"},
15777
16861
         { (char *)"svn_ra_plugin_t_name_get", _wrap_svn_ra_plugin_t_name_get, METH_VARARGS, (char *)"svn_ra_plugin_t_name_get(svn_ra_plugin_t self) -> char"},
15778
16862
         { (char *)"svn_ra_plugin_t_description_set", _wrap_svn_ra_plugin_t_description_set, METH_VARARGS, (char *)"svn_ra_plugin_t_description_set(svn_ra_plugin_t self, char description)"},
15820
16904
         { (char *)"new_svn_ra_plugin_t", _wrap_new_svn_ra_plugin_t, METH_VARARGS, (char *)"new_svn_ra_plugin_t() -> svn_ra_plugin_t"},
15821
16905
         { (char *)"delete_svn_ra_plugin_t", _wrap_delete_svn_ra_plugin_t, METH_VARARGS, (char *)"delete_svn_ra_plugin_t(svn_ra_plugin_t self)"},
15822
16906
         { (char *)"svn_ra_plugin_t_swigregister", svn_ra_plugin_t_swigregister, METH_VARARGS, NULL},
15823
 
         { (char *)"svn_ra_init_ra_libs", _wrap_svn_ra_init_ra_libs, METH_VARARGS, (char *)"svn_ra_init_ra_libs(void ra_baton, apr_pool_t pool) -> svn_error_t"},
15824
 
         { (char *)"svn_ra_get_ra_library", _wrap_svn_ra_get_ra_library, METH_VARARGS, (char *)"svn_ra_get_ra_library(svn_ra_plugin_t library, void ra_baton, char url, apr_pool_t pool) -> svn_error_t"},
 
16907
         { (char *)"svn_ra_init_ra_libs", _wrap_svn_ra_init_ra_libs, METH_VARARGS, (char *)"svn_ra_init_ra_libs(apr_pool_t pool) -> svn_error_t"},
 
16908
         { (char *)"svn_ra_get_ra_library", _wrap_svn_ra_get_ra_library, METH_VARARGS, (char *)"svn_ra_get_ra_library(void ra_baton, char url, apr_pool_t pool) -> svn_error_t"},
15825
16909
         { (char *)"svn_ra_session_t_swigregister", svn_ra_session_t_swigregister, METH_VARARGS, NULL},
15826
16910
         { (char *)"svn_ra_reporter3_invoke_set_path", _wrap_svn_ra_reporter3_invoke_set_path, METH_VARARGS, (char *)"\n"
15827
16911
                "svn_ra_reporter3_invoke_set_path(svn_ra_reporter3_t _obj, void report_baton, char path, \n"
15873
16957
                ""},
15874
16958
         { (char *)"svn_ra_reporter_invoke_finish_report", _wrap_svn_ra_reporter_invoke_finish_report, METH_VARARGS, (char *)"svn_ra_reporter_invoke_finish_report(svn_ra_reporter_t _obj, void report_baton, apr_pool_t pool) -> svn_error_t"},
15875
16959
         { (char *)"svn_ra_reporter_invoke_abort_report", _wrap_svn_ra_reporter_invoke_abort_report, METH_VARARGS, (char *)"svn_ra_reporter_invoke_abort_report(svn_ra_reporter_t _obj, void report_baton, apr_pool_t pool) -> svn_error_t"},
15876
 
         { (char *)"svn_ra_callbacks2_invoke_open_tmp_file", _wrap_svn_ra_callbacks2_invoke_open_tmp_file, METH_VARARGS, (char *)"\n"
15877
 
                "svn_ra_callbacks2_invoke_open_tmp_file(svn_ra_callbacks2_t _obj, apr_file_t fp, void callback_baton, \n"
15878
 
                "    apr_pool_t pool) -> svn_error_t\n"
15879
 
                ""},
15880
 
         { (char *)"svn_ra_callbacks_invoke_open_tmp_file", _wrap_svn_ra_callbacks_invoke_open_tmp_file, METH_VARARGS, (char *)"\n"
15881
 
                "svn_ra_callbacks_invoke_open_tmp_file(svn_ra_callbacks_t _obj, apr_file_t fp, void callback_baton, \n"
15882
 
                "    apr_pool_t pool) -> svn_error_t\n"
15883
 
                ""},
 
16960
         { (char *)"svn_ra_callbacks2_invoke_open_tmp_file", _wrap_svn_ra_callbacks2_invoke_open_tmp_file, METH_VARARGS, (char *)"svn_ra_callbacks2_invoke_open_tmp_file(svn_ra_callbacks2_t _obj, void callback_baton, apr_pool_t pool) -> svn_error_t"},
 
16961
         { (char *)"svn_ra_callbacks_invoke_open_tmp_file", _wrap_svn_ra_callbacks_invoke_open_tmp_file, METH_VARARGS, (char *)"svn_ra_callbacks_invoke_open_tmp_file(svn_ra_callbacks_t _obj, void callback_baton, apr_pool_t pool) -> svn_error_t"},
15884
16962
         { (char *)"svn_ra_plugin_invoke_open", _wrap_svn_ra_plugin_invoke_open, METH_VARARGS, (char *)"\n"
15885
 
                "svn_ra_plugin_invoke_open(svn_ra_plugin_t _obj, void session_baton, char repos_URL, \n"
15886
 
                "    svn_ra_callbacks_t callbacks, void callback_baton, \n"
15887
 
                "    apr_hash_t config, apr_pool_t pool) -> svn_error_t\n"
15888
 
                ""},
15889
 
         { (char *)"svn_ra_plugin_invoke_get_latest_revnum", _wrap_svn_ra_plugin_invoke_get_latest_revnum, METH_VARARGS, (char *)"\n"
15890
 
                "svn_ra_plugin_invoke_get_latest_revnum(svn_ra_plugin_t _obj, void session_baton, svn_revnum_t latest_revnum, \n"
 
16963
                "svn_ra_plugin_invoke_open(svn_ra_plugin_t _obj, char repos_URL, svn_ra_callbacks_t callbacks, \n"
 
16964
                "    void callback_baton, apr_hash_t config, \n"
15891
16965
                "    apr_pool_t pool) -> svn_error_t\n"
15892
16966
                ""},
 
16967
         { (char *)"svn_ra_plugin_invoke_get_latest_revnum", _wrap_svn_ra_plugin_invoke_get_latest_revnum, METH_VARARGS, (char *)"svn_ra_plugin_invoke_get_latest_revnum(svn_ra_plugin_t _obj, void session_baton, apr_pool_t pool) -> svn_error_t"},
15893
16968
         { (char *)"svn_ra_plugin_invoke_get_dated_revision", _wrap_svn_ra_plugin_invoke_get_dated_revision, METH_VARARGS, (char *)"\n"
15894
 
                "svn_ra_plugin_invoke_get_dated_revision(svn_ra_plugin_t _obj, void session_baton, svn_revnum_t revision, \n"
15895
 
                "    apr_time_t tm, apr_pool_t pool) -> svn_error_t\n"
 
16969
                "svn_ra_plugin_invoke_get_dated_revision(svn_ra_plugin_t _obj, void session_baton, apr_time_t tm, \n"
 
16970
                "    apr_pool_t pool) -> svn_error_t\n"
15896
16971
                ""},
15897
16972
         { (char *)"svn_ra_plugin_invoke_change_rev_prop", _wrap_svn_ra_plugin_invoke_change_rev_prop, METH_VARARGS, (char *)"\n"
15898
16973
                "svn_ra_plugin_invoke_change_rev_prop(svn_ra_plugin_t _obj, void session_baton, svn_revnum_t rev, \n"
15900
16975
                ""},
15901
16976
         { (char *)"svn_ra_plugin_invoke_rev_proplist", _wrap_svn_ra_plugin_invoke_rev_proplist, METH_VARARGS, (char *)"\n"
15902
16977
                "svn_ra_plugin_invoke_rev_proplist(svn_ra_plugin_t _obj, void session_baton, svn_revnum_t rev, \n"
15903
 
                "    apr_hash_t props, apr_pool_t pool) -> svn_error_t\n"
 
16978
                "    apr_pool_t pool) -> svn_error_t\n"
15904
16979
                ""},
15905
16980
         { (char *)"svn_ra_plugin_invoke_rev_prop", _wrap_svn_ra_plugin_invoke_rev_prop, METH_VARARGS, (char *)"\n"
15906
16981
                "svn_ra_plugin_invoke_rev_prop(svn_ra_plugin_t _obj, void session_baton, svn_revnum_t rev, \n"
15907
 
                "    char name, svn_string_t value, apr_pool_t pool) -> svn_error_t\n"
 
16982
                "    char name, apr_pool_t pool) -> svn_error_t\n"
15908
16983
                ""},
15909
16984
         { (char *)"svn_ra_plugin_invoke_get_commit_editor", _wrap_svn_ra_plugin_invoke_get_commit_editor, METH_VARARGS, (char *)"\n"
15910
 
                "svn_ra_plugin_invoke_get_commit_editor(svn_ra_plugin_t _obj, void session_baton, svn_delta_editor_t editor, \n"
15911
 
                "    void edit_baton, char log_msg, \n"
 
16985
                "svn_ra_plugin_invoke_get_commit_editor(svn_ra_plugin_t _obj, void session_baton, char log_msg, \n"
15912
16986
                "    svn_commit_callback_t callback, apr_pool_t pool) -> svn_error_t\n"
15913
16987
                ""},
15914
16988
         { (char *)"svn_ra_plugin_invoke_get_file", _wrap_svn_ra_plugin_invoke_get_file, METH_VARARGS, (char *)"\n"
15915
16989
                "svn_ra_plugin_invoke_get_file(svn_ra_plugin_t _obj, void session_baton, char path, \n"
15916
16990
                "    svn_revnum_t revision, svn_stream_t stream, \n"
15917
 
                "    svn_revnum_t fetched_rev, apr_hash_t props, \n"
15918
16991
                "    apr_pool_t pool) -> svn_error_t\n"
15919
16992
                ""},
15920
16993
         { (char *)"svn_ra_plugin_invoke_get_dir", _wrap_svn_ra_plugin_invoke_get_dir, METH_VARARGS, (char *)"\n"
15921
16994
                "svn_ra_plugin_invoke_get_dir(svn_ra_plugin_t _obj, void session_baton, char path, \n"
15922
 
                "    svn_revnum_t revision, apr_hash_t dirents, \n"
15923
 
                "    svn_revnum_t fetched_rev, apr_hash_t props, apr_pool_t pool) -> svn_error_t\n"
 
16995
                "    svn_revnum_t revision, apr_pool_t pool) -> svn_error_t\n"
15924
16996
                ""},
15925
16997
         { (char *)"svn_ra_plugin_invoke_do_update", _wrap_svn_ra_plugin_invoke_do_update, METH_VARARGS, (char *)"\n"
15926
 
                "svn_ra_plugin_invoke_do_update(svn_ra_plugin_t _obj, void session_baton, svn_ra_reporter_t reporter, \n"
15927
 
                "    void report_baton, svn_revnum_t revision_to_update_to, \n"
 
16998
                "svn_ra_plugin_invoke_do_update(svn_ra_plugin_t _obj, void session_baton, svn_revnum_t revision_to_update_to, \n"
15928
16999
                "    char update_target, \n"
15929
17000
                "    svn_boolean_t recurse, svn_delta_editor_t update_editor, \n"
15930
17001
                "    void update_baton, apr_pool_t pool) -> svn_error_t\n"
15931
17002
                ""},
15932
17003
         { (char *)"svn_ra_plugin_invoke_do_switch", _wrap_svn_ra_plugin_invoke_do_switch, METH_VARARGS, (char *)"\n"
15933
 
                "svn_ra_plugin_invoke_do_switch(svn_ra_plugin_t _obj, void session_baton, svn_ra_reporter_t reporter, \n"
15934
 
                "    void report_baton, svn_revnum_t revision_to_switch_to, \n"
 
17004
                "svn_ra_plugin_invoke_do_switch(svn_ra_plugin_t _obj, void session_baton, svn_revnum_t revision_to_switch_to, \n"
15935
17005
                "    char switch_target, \n"
15936
17006
                "    svn_boolean_t recurse, char switch_url, svn_delta_editor_t switch_editor, \n"
15937
17007
                "    void switch_baton, \n"
15938
17008
                "    apr_pool_t pool) -> svn_error_t\n"
15939
17009
                ""},
15940
17010
         { (char *)"svn_ra_plugin_invoke_do_status", _wrap_svn_ra_plugin_invoke_do_status, METH_VARARGS, (char *)"\n"
15941
 
                "svn_ra_plugin_invoke_do_status(svn_ra_plugin_t _obj, void session_baton, svn_ra_reporter_t reporter, \n"
15942
 
                "    void report_baton, char status_target, \n"
 
17011
                "svn_ra_plugin_invoke_do_status(svn_ra_plugin_t _obj, void session_baton, char status_target, \n"
15943
17012
                "    svn_revnum_t revision, svn_boolean_t recurse, \n"
15944
17013
                "    svn_delta_editor_t status_editor, \n"
15945
17014
                "    void status_baton, apr_pool_t pool) -> svn_error_t\n"
15946
17015
                ""},
15947
17016
         { (char *)"svn_ra_plugin_invoke_do_diff", _wrap_svn_ra_plugin_invoke_do_diff, METH_VARARGS, (char *)"\n"
15948
 
                "svn_ra_plugin_invoke_do_diff(svn_ra_plugin_t _obj, void session_baton, svn_ra_reporter_t reporter, \n"
15949
 
                "    void report_baton, svn_revnum_t revision, \n"
 
17017
                "svn_ra_plugin_invoke_do_diff(svn_ra_plugin_t _obj, void session_baton, svn_revnum_t revision, \n"
15950
17018
                "    char diff_target, svn_boolean_t recurse, \n"
15951
17019
                "    svn_boolean_t ignore_ancestry, char versus_url, \n"
15952
17020
                "    svn_delta_editor_t diff_editor, \n"
15961
17029
                ""},
15962
17030
         { (char *)"svn_ra_plugin_invoke_check_path", _wrap_svn_ra_plugin_invoke_check_path, METH_VARARGS, (char *)"\n"
15963
17031
                "svn_ra_plugin_invoke_check_path(svn_ra_plugin_t _obj, void session_baton, char path, \n"
15964
 
                "    svn_revnum_t revision, svn_node_kind_t kind, \n"
15965
 
                "    apr_pool_t pool) -> svn_error_t\n"
15966
 
                ""},
15967
 
         { (char *)"svn_ra_plugin_invoke_get_uuid", _wrap_svn_ra_plugin_invoke_get_uuid, METH_VARARGS, (char *)"\n"
15968
 
                "svn_ra_plugin_invoke_get_uuid(svn_ra_plugin_t _obj, void session_baton, char uuid, \n"
15969
 
                "    apr_pool_t pool) -> svn_error_t\n"
15970
 
                ""},
15971
 
         { (char *)"svn_ra_plugin_invoke_get_repos_root", _wrap_svn_ra_plugin_invoke_get_repos_root, METH_VARARGS, (char *)"\n"
15972
 
                "svn_ra_plugin_invoke_get_repos_root(svn_ra_plugin_t _obj, void session_baton, char url, \n"
15973
 
                "    apr_pool_t pool) -> svn_error_t\n"
15974
 
                ""},
 
17032
                "    svn_revnum_t revision, apr_pool_t pool) -> svn_error_t\n"
 
17033
                ""},
 
17034
         { (char *)"svn_ra_plugin_invoke_get_uuid", _wrap_svn_ra_plugin_invoke_get_uuid, METH_VARARGS, (char *)"svn_ra_plugin_invoke_get_uuid(svn_ra_plugin_t _obj, void session_baton, apr_pool_t pool) -> svn_error_t"},
 
17035
         { (char *)"svn_ra_plugin_invoke_get_repos_root", _wrap_svn_ra_plugin_invoke_get_repos_root, METH_VARARGS, (char *)"svn_ra_plugin_invoke_get_repos_root(svn_ra_plugin_t _obj, void session_baton, apr_pool_t pool) -> svn_error_t"},
15975
17036
         { (char *)"svn_ra_plugin_invoke_get_locations", _wrap_svn_ra_plugin_invoke_get_locations, METH_VARARGS, (char *)"\n"
15976
 
                "svn_ra_plugin_invoke_get_locations(svn_ra_plugin_t _obj, void session_baton, apr_hash_t locations, \n"
15977
 
                "    char path, svn_revnum_t peg_revision, \n"
15978
 
                "    apr_array_header_t location_revisions, \n"
 
17037
                "svn_ra_plugin_invoke_get_locations(svn_ra_plugin_t _obj, void session_baton, char path, \n"
 
17038
                "    svn_revnum_t peg_revision, apr_array_header_t location_revisions, \n"
15979
17039
                "    apr_pool_t pool) -> svn_error_t\n"
15980
17040
                ""},
15981
17041
         { (char *)"svn_ra_plugin_invoke_get_file_revs", _wrap_svn_ra_plugin_invoke_get_file_revs, METH_VARARGS, (char *)"\n"
15985
17045
                ""},
15986
17046
         { (char *)"svn_ra_plugin_invoke_get_version", _wrap_svn_ra_plugin_invoke_get_version, METH_VARARGS, (char *)"svn_ra_plugin_invoke_get_version(svn_ra_plugin_t _obj) -> svn_version_t"},
15987
17047
         { (char *)"svn_ra_invoke_get_wc_prop_func", _wrap_svn_ra_invoke_get_wc_prop_func, METH_VARARGS, (char *)"\n"
15988
 
                "svn_ra_invoke_get_wc_prop_func(svn_ra_get_wc_prop_func_t _obj, void baton, char relpath, \n"
15989
 
                "    char name, svn_string_t value, apr_pool_t pool) -> svn_error_t\n"
 
17048
                "svn_ra_invoke_get_wc_prop_func(svn_ra_get_wc_prop_func_t _obj, void baton, char path, \n"
 
17049
                "    char name, apr_pool_t pool) -> svn_error_t\n"
15990
17050
                ""},
15991
17051
         { (char *)"svn_ra_invoke_set_wc_prop_func", _wrap_svn_ra_invoke_set_wc_prop_func, METH_VARARGS, (char *)"\n"
15992
17052
                "svn_ra_invoke_set_wc_prop_func(svn_ra_set_wc_prop_func_t _obj, void baton, char path, \n"
16000
17060
                "svn_ra_invoke_invalidate_wc_props_func(svn_ra_invalidate_wc_props_func_t _obj, void baton, \n"
16001
17061
                "    char path, char name, apr_pool_t pool) -> svn_error_t\n"
16002
17062
                ""},
16003
 
         { (char *)"svn_ra_invoke_get_latest_revnum_func", _wrap_svn_ra_invoke_get_latest_revnum_func, METH_VARARGS, (char *)"\n"
16004
 
                "svn_ra_invoke_get_latest_revnum_func(svn_ra_get_latest_revnum_func_t _obj, void session_baton, \n"
16005
 
                "    svn_revnum_t latest_revnum) -> svn_error_t\n"
16006
 
                ""},
16007
 
         { (char *)"svn_ra_invoke_get_client_string_func", _wrap_svn_ra_invoke_get_client_string_func, METH_VARARGS, (char *)"\n"
16008
 
                "svn_ra_invoke_get_client_string_func(svn_ra_get_client_string_func_t _obj, void baton, char name, \n"
16009
 
                "    apr_pool_t pool) -> svn_error_t\n"
16010
 
                ""},
 
17063
         { (char *)"svn_ra_invoke_get_latest_revnum_func", _wrap_svn_ra_invoke_get_latest_revnum_func, METH_VARARGS, (char *)"svn_ra_invoke_get_latest_revnum_func(svn_ra_get_latest_revnum_func_t _obj, void session_baton) -> svn_error_t"},
 
17064
         { (char *)"svn_ra_invoke_get_client_string_func", _wrap_svn_ra_invoke_get_client_string_func, METH_VARARGS, (char *)"svn_ra_invoke_get_client_string_func(svn_ra_get_client_string_func_t _obj, void baton, apr_pool_t pool) -> svn_error_t"},
16011
17065
         { (char *)"svn_ra_invoke_file_rev_handler", _wrap_svn_ra_invoke_file_rev_handler, METH_VARARGS, (char *)"\n"
16012
17066
                "svn_ra_invoke_file_rev_handler(svn_ra_file_rev_handler_t _obj, void baton, char path, \n"
16013
 
                "    svn_revnum_t rev, apr_hash_t rev_props, svn_txdelta_window_handler_t delta_handler, \n"
16014
 
                "    void delta_baton, \n"
16015
 
                "    apr_array_header_t prop_diffs, \n"
 
17067
                "    svn_revnum_t rev, apr_hash_t rev_props, apr_array_header_t prop_diffs, \n"
16016
17068
                "    apr_pool_t pool) -> svn_error_t\n"
16017
17069
                ""},
16018
17070
         { (char *)"svn_ra_invoke_lock_callback", _wrap_svn_ra_invoke_lock_callback, METH_VARARGS, (char *)"\n"
16026
17078
                ""},
16027
17079
         { (char *)"svn_ra_invoke_replay_revstart_callback", _wrap_svn_ra_invoke_replay_revstart_callback, METH_VARARGS, (char *)"\n"
16028
17080
                "svn_ra_invoke_replay_revstart_callback(svn_ra_replay_revstart_callback_t _obj, svn_revnum_t revision, \n"
16029
 
                "    void replay_baton, svn_delta_editor_t editor, \n"
16030
 
                "    void edit_baton, apr_hash_t rev_props, \n"
 
17081
                "    void replay_baton, apr_hash_t rev_props, \n"
16031
17082
                "    apr_pool_t pool) -> svn_error_t\n"
16032
17083
                ""},
16033
17084
         { (char *)"svn_ra_invoke_replay_revfinish_callback", _wrap_svn_ra_invoke_replay_revfinish_callback, METH_VARARGS, (char *)"\n"
16160
17211
static swig_type_info _swigt__p_svn_dirent_t = {"_p_svn_dirent_t", "struct svn_dirent_t *|svn_dirent_t *", 0, 0, (void*)0, 0};
16161
17212
static swig_type_info _swigt__p_svn_errno_t = {"_p_svn_errno_t", "enum svn_errno_t *|svn_errno_t *", 0, 0, (void*)0, 0};
16162
17213
static swig_type_info _swigt__p_svn_error_t = {"_p_svn_error_t", "struct svn_error_t *|svn_error_t *", 0, 0, (void*)0, 0};
 
17214
static swig_type_info _swigt__p_svn_io_dirent2_t = {"_p_svn_io_dirent2_t", "struct svn_io_dirent2_t *|svn_io_dirent2_t *", 0, 0, (void*)0, 0};
16163
17215
static swig_type_info _swigt__p_svn_io_dirent_t = {"_p_svn_io_dirent_t", "struct svn_io_dirent_t *|svn_io_dirent_t *", 0, 0, (void*)0, 0};
16164
17216
static swig_type_info _swigt__p_svn_io_file_del_t = {"_p_svn_io_file_del_t", "enum svn_io_file_del_t *|svn_io_file_del_t *", 0, 0, (void*)0, 0};
16165
17217
static swig_type_info _swigt__p_svn_location_segment_t = {"_p_svn_location_segment_t", "struct svn_location_segment_t *|svn_location_segment_t *", 0, 0, (void*)0, 0};
16183
17235
static swig_type_info _swigt__p_svn_ra_reporter3_t = {"_p_svn_ra_reporter3_t", "struct svn_ra_reporter3_t *|svn_ra_reporter3_t *", 0, 0, (void*)0, 0};
16184
17236
static swig_type_info _swigt__p_svn_ra_reporter_t = {"_p_svn_ra_reporter_t", "struct svn_ra_reporter_t *|svn_ra_reporter_t *", 0, 0, (void*)0, 0};
16185
17237
static swig_type_info _swigt__p_svn_ra_session_t = {"_p_svn_ra_session_t", "struct svn_ra_session_t *|svn_ra_session_t *", 0, 0, (void*)0, 0};
 
17238
static swig_type_info _swigt__p_svn_stream_mark_t = {"_p_svn_stream_mark_t", "struct svn_stream_mark_t *|svn_stream_mark_t *", 0, 0, (void*)0, 0};
16186
17239
static swig_type_info _swigt__p_svn_stream_t = {"_p_svn_stream_t", "struct svn_stream_t *|svn_stream_t *", 0, 0, (void*)0, 0};
16187
17240
static swig_type_info _swigt__p_svn_string_t = {"_p_svn_string_t", "struct svn_string_t *|svn_string_t *", 0, 0, (void*)0, 0};
16188
17241
static swig_type_info _swigt__p_svn_stringbuf_t = {"_p_svn_stringbuf_t", "struct svn_stringbuf_t *|svn_stringbuf_t *", 0, 0, (void*)0, 0};
 
17242
static swig_type_info _swigt__p_svn_tristate_t = {"_p_svn_tristate_t", "enum svn_tristate_t *|svn_tristate_t *", 0, 0, (void*)0, 0};
16189
17243
static swig_type_info _swigt__p_svn_txdelta_op_t = {"_p_svn_txdelta_op_t", "struct svn_txdelta_op_t *|svn_txdelta_op_t *", 0, 0, (void*)0, 0};
16190
17244
static swig_type_info _swigt__p_svn_txdelta_stream_t = {"_p_svn_txdelta_stream_t", "struct svn_txdelta_stream_t *|svn_txdelta_stream_t *", 0, 0, (void*)0, 0};
16191
17245
static swig_type_info _swigt__p_svn_txdelta_window_t = {"_p_svn_txdelta_window_t", "struct svn_txdelta_window_t *|svn_txdelta_window_t *", 0, 0, (void*)0, 0};
16192
17246
static swig_type_info _swigt__p_svn_version_checklist_t = {"_p_svn_version_checklist_t", "struct svn_version_checklist_t *|svn_version_checklist_t *", 0, 0, (void*)0, 0};
16193
17247
static swig_type_info _swigt__p_svn_version_t = {"_p_svn_version_t", "struct svn_version_t *|svn_version_t *", 0, 0, (void*)0, 0};
 
17248
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|svn_linenum_t *", 0, 0, (void*)0, 0};
16194
17249
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
16195
17250
 
16196
17251
static swig_type_info *swig_type_initial[] = {
16296
17351
  &_swigt__p_svn_dirent_t,
16297
17352
  &_swigt__p_svn_errno_t,
16298
17353
  &_swigt__p_svn_error_t,
 
17354
  &_swigt__p_svn_io_dirent2_t,
16299
17355
  &_swigt__p_svn_io_dirent_t,
16300
17356
  &_swigt__p_svn_io_file_del_t,
16301
17357
  &_swigt__p_svn_location_segment_t,
16319
17375
  &_swigt__p_svn_ra_reporter3_t,
16320
17376
  &_swigt__p_svn_ra_reporter_t,
16321
17377
  &_swigt__p_svn_ra_session_t,
 
17378
  &_swigt__p_svn_stream_mark_t,
16322
17379
  &_swigt__p_svn_stream_t,
16323
17380
  &_swigt__p_svn_string_t,
16324
17381
  &_swigt__p_svn_stringbuf_t,
 
17382
  &_swigt__p_svn_tristate_t,
16325
17383
  &_swigt__p_svn_txdelta_op_t,
16326
17384
  &_swigt__p_svn_txdelta_stream_t,
16327
17385
  &_swigt__p_svn_txdelta_window_t,
16328
17386
  &_swigt__p_svn_version_checklist_t,
16329
17387
  &_swigt__p_svn_version_t,
 
17388
  &_swigt__p_unsigned_long,
16330
17389
  &_swigt__p_void,
16331
17390
};
16332
17391
 
16432
17491
static swig_cast_info _swigc__p_svn_dirent_t[] = {  {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
16433
17492
static swig_cast_info _swigc__p_svn_errno_t[] = {  {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
16434
17493
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
17494
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
16435
17495
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
16436
17496
static swig_cast_info _swigc__p_svn_io_file_del_t[] = {  {&_swigt__p_svn_io_file_del_t, 0, 0, 0},{0, 0, 0, 0}};
16437
17497
static swig_cast_info _swigc__p_svn_location_segment_t[] = {  {&_swigt__p_svn_location_segment_t, 0, 0, 0},{0, 0, 0, 0}};
16455
17515
static swig_cast_info _swigc__p_svn_ra_reporter3_t[] = {  {&_swigt__p_svn_ra_reporter3_t, 0, 0, 0},{0, 0, 0, 0}};
16456
17516
static swig_cast_info _swigc__p_svn_ra_reporter_t[] = {  {&_swigt__p_svn_ra_reporter_t, 0, 0, 0},{0, 0, 0, 0}};
16457
17517
static swig_cast_info _swigc__p_svn_ra_session_t[] = {  {&_swigt__p_svn_ra_session_t, 0, 0, 0},{0, 0, 0, 0}};
 
17518
static swig_cast_info _swigc__p_svn_stream_mark_t[] = {  {&_swigt__p_svn_stream_mark_t, 0, 0, 0},{0, 0, 0, 0}};
16458
17519
static swig_cast_info _swigc__p_svn_stream_t[] = {  {&_swigt__p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
16459
17520
static swig_cast_info _swigc__p_svn_string_t[] = {  {&_swigt__p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
16460
17521
static swig_cast_info _swigc__p_svn_stringbuf_t[] = {  {&_swigt__p_svn_stringbuf_t, 0, 0, 0},{0, 0, 0, 0}};
 
17522
static swig_cast_info _swigc__p_svn_tristate_t[] = {  {&_swigt__p_svn_tristate_t, 0, 0, 0},{0, 0, 0, 0}};
16461
17523
static swig_cast_info _swigc__p_svn_txdelta_op_t[] = {  {&_swigt__p_svn_txdelta_op_t, 0, 0, 0},{0, 0, 0, 0}};
16462
17524
static swig_cast_info _swigc__p_svn_txdelta_stream_t[] = {  {&_swigt__p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
16463
17525
static swig_cast_info _swigc__p_svn_txdelta_window_t[] = {  {&_swigt__p_svn_txdelta_window_t, 0, 0, 0},{0, 0, 0, 0}};
16464
17526
static swig_cast_info _swigc__p_svn_version_checklist_t[] = {  {&_swigt__p_svn_version_checklist_t, 0, 0, 0},{0, 0, 0, 0}};
16465
17527
static swig_cast_info _swigc__p_svn_version_t[] = {  {&_swigt__p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
 
17528
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
16466
17529
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
16467
17530
 
16468
17531
static swig_cast_info *swig_cast_initial[] = {
16568
17631
  _swigc__p_svn_dirent_t,
16569
17632
  _swigc__p_svn_errno_t,
16570
17633
  _swigc__p_svn_error_t,
 
17634
  _swigc__p_svn_io_dirent2_t,
16571
17635
  _swigc__p_svn_io_dirent_t,
16572
17636
  _swigc__p_svn_io_file_del_t,
16573
17637
  _swigc__p_svn_location_segment_t,
16591
17655
  _swigc__p_svn_ra_reporter3_t,
16592
17656
  _swigc__p_svn_ra_reporter_t,
16593
17657
  _swigc__p_svn_ra_session_t,
 
17658
  _swigc__p_svn_stream_mark_t,
16594
17659
  _swigc__p_svn_stream_t,
16595
17660
  _swigc__p_svn_string_t,
16596
17661
  _swigc__p_svn_stringbuf_t,
 
17662
  _swigc__p_svn_tristate_t,
16597
17663
  _swigc__p_svn_txdelta_op_t,
16598
17664
  _swigc__p_svn_txdelta_stream_t,
16599
17665
  _swigc__p_svn_txdelta_window_t,
16600
17666
  _swigc__p_svn_version_checklist_t,
16601
17667
  _swigc__p_svn_version_t,
 
17668
  _swigc__p_unsigned_long,
16602
17669
  _swigc__p_void,
16603
17670
};
16604
17671
 
16877
17944
  
16878
17945
  SWIGINTERN PyObject *
16879
17946
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
 
17947
#if PY_VERSION_HEX >= 0x03000000
 
17948
    return PyUnicode_InternFromString("<Swig global variables>");
 
17949
#else
16880
17950
    return PyString_FromString("<Swig global variables>");
 
17951
#endif
16881
17952
  }
16882
17953
  
16883
17954
  SWIGINTERN PyObject *
16884
17955
  swig_varlink_str(swig_varlinkobject *v) {
 
17956
#if PY_VERSION_HEX >= 0x03000000
 
17957
    PyObject *str = PyUnicode_InternFromString("(");
 
17958
    PyObject *tail;
 
17959
    PyObject *joined;
 
17960
    swig_globalvar *var;
 
17961
    for (var = v->vars; var; var=var->next) {
 
17962
      tail = PyUnicode_FromString(var->name);
 
17963
      joined = PyUnicode_Concat(str, tail);
 
17964
      Py_DecRef(str);
 
17965
      Py_DecRef(tail);
 
17966
      str = joined;
 
17967
      if (var->next) {
 
17968
        tail = PyUnicode_InternFromString(", ");
 
17969
        joined = PyUnicode_Concat(str, tail);
 
17970
        Py_DecRef(str);
 
17971
        Py_DecRef(tail);
 
17972
        str = joined;
 
17973
      }
 
17974
    }
 
17975
    tail = PyUnicode_InternFromString(")");
 
17976
    joined = PyUnicode_Concat(str, tail);
 
17977
    Py_DecRef(str);
 
17978
    Py_DecRef(tail);
 
17979
    str = joined;
 
17980
#else
16885
17981
    PyObject *str = PyString_FromString("(");
16886
 
    swig_globalvar  *var;
 
17982
    swig_globalvar *var;
16887
17983
    for (var = v->vars; var; var=var->next) {
16888
17984
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
16889
17985
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
16890
17986
    }
16891
17987
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
 
17988
#endif
16892
17989
    return str;
16893
17990
  }
16894
17991
  
16895
17992
  SWIGINTERN int
16896
17993
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
 
17994
    char *tmp;
16897
17995
    PyObject *str = swig_varlink_str(v);
16898
17996
    fprintf(fp,"Swig global variables ");
16899
 
    fprintf(fp,"%s\n", PyString_AsString(str));
 
17997
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
 
17998
    SWIG_Python_str_DelForPy3(tmp);
16900
17999
    Py_DECREF(str);
16901
18000
    return 0;
16902
18001
  }
16950
18049
  swig_varlink_type(void) {
16951
18050
    static char varlink__doc__[] = "Swig var link object";
16952
18051
    static PyTypeObject varlink_type;
16953
 
    static int type_init = 0;  
 
18052
    static int type_init = 0;
16954
18053
    if (!type_init) {
16955
 
      const PyTypeObject tmp
16956
 
      = {
 
18054
      const PyTypeObject tmp = {
 
18055
        /* PyObject header changed in Python 3 */
 
18056
#if PY_VERSION_HEX >= 0x03000000
 
18057
        PyVarObject_HEAD_INIT(NULL, 0)
 
18058
#else
16957
18059
        PyObject_HEAD_INIT(NULL)
16958
 
        0,                                  /* Number of items in variable part (ob_size) */
16959
 
        (char *)"swigvarlink",              /* Type name (tp_name) */
16960
 
        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
16961
 
        0,                                  /* Itemsize (tp_itemsize) */
16962
 
        (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
16963
 
        (printfunc) swig_varlink_print,     /* Print (tp_print) */
16964
 
        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
16965
 
        (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
 
18060
        0,                                  /* ob_size */
 
18061
#endif
 
18062
        (char *)"swigvarlink",              /* tp_name */
 
18063
        sizeof(swig_varlinkobject),         /* tp_basicsize */
 
18064
        0,                                  /* tp_itemsize */
 
18065
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
 
18066
        (printfunc) swig_varlink_print,     /* tp_print */
 
18067
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
 
18068
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
16966
18069
        0,                                  /* tp_compare */
16967
18070
        (reprfunc) swig_varlink_repr,       /* tp_repr */
16968
18071
        0,                                  /* tp_as_number */
16970
18073
        0,                                  /* tp_as_mapping */
16971
18074
        0,                                  /* tp_hash */
16972
18075
        0,                                  /* tp_call */
16973
 
        (reprfunc)swig_varlink_str,        /* tp_str */
 
18076
        (reprfunc) swig_varlink_str,        /* tp_str */
16974
18077
        0,                                  /* tp_getattro */
16975
18078
        0,                                  /* tp_setattro */
16976
18079
        0,                                  /* tp_as_buffer */
16986
18089
#if PY_VERSION_HEX >= 0x02030000
16987
18090
        0,                                  /* tp_del */
16988
18091
#endif
 
18092
#if PY_VERSION_HEX >= 0x02060000
 
18093
        0,                                  /* tp_version */
 
18094
#endif
16989
18095
#ifdef COUNT_ALLOCS
16990
18096
        0,0,0,0                             /* tp_alloc -> tp_next */
16991
18097
#endif
16992
18098
      };
16993
18099
      varlink_type = tmp;
 
18100
      type_init = 1;
 
18101
#if PY_VERSION_HEX < 0x02020000
16994
18102
      varlink_type.ob_type = &PyType_Type;
16995
 
      type_init = 1;
 
18103
#else
 
18104
      if (PyType_Ready(&varlink_type) < 0)
 
18105
      return NULL;
 
18106
#endif
16996
18107
    }
16997
18108
    return &varlink_type;
16998
18109
  }
17043
18154
    for (i = 0; constants[i].type; ++i) {
17044
18155
      switch(constants[i].type) {
17045
18156
      case SWIG_PY_POINTER:
17046
 
        obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
 
18157
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
17047
18158
        break;
17048
18159
      case SWIG_PY_BINARY:
17049
18160
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
17083
18194
          }
17084
18195
        }
17085
18196
        if (ci) {
17086
 
          size_t shift = (ci->ptype) - types;
17087
 
          swig_type_info *ty = types_initial[shift];
17088
 
          size_t ldoc = (c - methods[i].ml_doc);
17089
 
          size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
17090
 
          char *ndoc = (char*)malloc(ldoc + lptr + 10);
17091
 
          if (ndoc) {
17092
 
            char *buff = ndoc;
17093
 
            void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
17094
 
            if (ptr) {
 
18197
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
 
18198
          if (ptr) {
 
18199
            size_t shift = (ci->ptype) - types;
 
18200
            swig_type_info *ty = types_initial[shift];
 
18201
            size_t ldoc = (c - methods[i].ml_doc);
 
18202
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
 
18203
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
 
18204
            if (ndoc) {
 
18205
              char *buff = ndoc;
17095
18206
              strncpy(buff, methods[i].ml_doc, ldoc);
17096
18207
              buff += ldoc;
17097
18208
              strncpy(buff, "swig_ptr: ", 10);
17116
18227
#ifdef __cplusplus
17117
18228
extern "C"
17118
18229
#endif
17119
 
SWIGEXPORT void SWIG_init(void) {
17120
 
  PyObject *m, *d;
 
18230
 
 
18231
SWIGEXPORT 
 
18232
#if PY_VERSION_HEX >= 0x03000000
 
18233
PyObject*
 
18234
#else
 
18235
void
 
18236
#endif
 
18237
SWIG_init(void) {
 
18238
  PyObject *m, *d, *md;
 
18239
#if PY_VERSION_HEX >= 0x03000000
 
18240
  static struct PyModuleDef SWIG_module = {
 
18241
# if PY_VERSION_HEX >= 0x03020000
 
18242
    PyModuleDef_HEAD_INIT,
 
18243
# else
 
18244
    {
 
18245
      PyObject_HEAD_INIT(NULL)
 
18246
      NULL, /* m_init */
 
18247
      0,    /* m_index */
 
18248
      NULL, /* m_copy */
 
18249
    },
 
18250
# endif
 
18251
    (char *) SWIG_name,
 
18252
    NULL,
 
18253
    -1,
 
18254
    SwigMethods,
 
18255
    NULL,
 
18256
    NULL,
 
18257
    NULL,
 
18258
    NULL
 
18259
  };
 
18260
#endif
 
18261
  
 
18262
#if defined(SWIGPYTHON_BUILTIN)
 
18263
  static SwigPyClientData SwigPyObject_clientdata = {
 
18264
    0, 0, 0, 0, 0, 0, 0
 
18265
  };
 
18266
  static PyGetSetDef this_getset_def = {
 
18267
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
 
18268
  };
 
18269
  static SwigPyGetSet thisown_getset_closure = {
 
18270
    (PyCFunction) SwigPyObject_own,
 
18271
    (PyCFunction) SwigPyObject_own
 
18272
  };
 
18273
  static PyGetSetDef thisown_getset_def = {
 
18274
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
 
18275
  };
 
18276
  PyObject *metatype_args;
 
18277
  PyTypeObject *builtin_pytype;
 
18278
  int builtin_base_count;
 
18279
  swig_type_info *builtin_basetype;
 
18280
  PyObject *tuple;
 
18281
  PyGetSetDescrObject *static_getset;
 
18282
  PyTypeObject *metatype;
 
18283
  SwigPyClientData *cd;
 
18284
  PyObject *public_interface, *public_symbol;
 
18285
  PyObject *this_descr;
 
18286
  PyObject *thisown_descr;
 
18287
  int i;
 
18288
  
 
18289
  (void)builtin_pytype;
 
18290
  (void)builtin_base_count;
 
18291
  (void)builtin_basetype;
 
18292
  (void)tuple;
 
18293
  (void)static_getset;
 
18294
  
 
18295
  /* metatype is used to implement static member variables. */
 
18296
  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
 
18297
  assert(metatype_args);
 
18298
  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
 
18299
  assert(metatype);
 
18300
  Py_DECREF(metatype_args);
 
18301
  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
 
18302
  assert(PyType_Ready(metatype) >= 0);
 
18303
#endif
17121
18304
  
17122
18305
  /* Fix SwigMethods to carry the callback ptrs when needed */
17123
18306
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
17124
18307
  
 
18308
#if PY_VERSION_HEX >= 0x03000000
 
18309
  m = PyModule_Create(&SWIG_module);
 
18310
#else
17125
18311
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
17126
 
  d = PyModule_GetDict(m);
 
18312
#endif
 
18313
  md = d = PyModule_GetDict(m);
17127
18314
  
17128
18315
  SWIG_InitializeModule(0);
 
18316
  
 
18317
#ifdef SWIGPYTHON_BUILTIN
 
18318
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
 
18319
  assert(SwigPyObject_stype);
 
18320
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
 
18321
  if (!cd) {
 
18322
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
 
18323
    SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
 
18324
  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
 
18325
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
 
18326
# if PY_VERSION_HEX >= 0x03000000
 
18327
    return NULL;
 
18328
# else
 
18329
    return;
 
18330
# endif
 
18331
  }
 
18332
  
 
18333
  /* All objects have a 'this' attribute */
 
18334
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
 
18335
  (void)this_descr;
 
18336
  
 
18337
  /* All objects have a 'thisown' attribute */
 
18338
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
 
18339
  (void)thisown_descr;
 
18340
  
 
18341
  public_interface = PyList_New(0);
 
18342
  public_symbol = 0;
 
18343
  (void)public_symbol;
 
18344
  
 
18345
  PyDict_SetItemString(md, "__all__", public_interface);
 
18346
  Py_DECREF(public_interface);
 
18347
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
 
18348
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
 
18349
  for (i = 0; swig_const_table[i].name != 0; ++i)
 
18350
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
 
18351
#endif
 
18352
  
17129
18353
  SWIG_InstallConstants(d,swig_const_table);
17130
18354
  
17131
 
  
17132
18355
  SWIG_Python_SetConstant(d, "SVN_RA_CAPABILITY_DEPTH",SWIG_FromCharPtr("depth"));
17133
18356
  SWIG_Python_SetConstant(d, "SVN_RA_CAPABILITY_MERGEINFO",SWIG_FromCharPtr("mergeinfo"));
17134
18357
  SWIG_Python_SetConstant(d, "SVN_RA_CAPABILITY_LOG_REVPROPS",SWIG_FromCharPtr("log-revprops"));
17135
18358
  SWIG_Python_SetConstant(d, "SVN_RA_CAPABILITY_PARTIAL_REPLAY",SWIG_FromCharPtr("partial-replay"));
17136
18359
  SWIG_Python_SetConstant(d, "SVN_RA_CAPABILITY_COMMIT_REVPROPS",SWIG_FromCharPtr("commit-revprops"));
 
18360
  SWIG_Python_SetConstant(d, "SVN_RA_CAPABILITY_ATOMIC_REVPROPS",SWIG_FromCharPtr("atomic-revprops"));
17137
18361
  SWIG_Python_SetConstant(d, "SVN_RA_ABI_VERSION",SWIG_From_long((long)(2)));
 
18362
#if PY_VERSION_HEX >= 0x03000000
 
18363
  return m;
 
18364
#else
 
18365
  return;
 
18366
#endif
17138
18367
}
17139
18368