← 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_delta.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_delta.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
 
2541
2976
#define SWIGTYPE_p_svn_dirent_t swig_types[54]
2542
2977
#define SWIGTYPE_p_svn_errno_t swig_types[55]
2543
2978
#define SWIGTYPE_p_svn_error_t swig_types[56]
2544
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[57]
2545
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[58]
2546
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[59]
2547
 
#define SWIGTYPE_p_svn_lock_t swig_types[60]
2548
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[61]
2549
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[62]
2550
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[63]
2551
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[64]
2552
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[65]
2553
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[66]
2554
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[67]
2555
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[68]
2556
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[69]
2557
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[70]
2558
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[71]
2559
 
#define SWIGTYPE_p_svn_prop_kind swig_types[72]
2560
 
#define SWIGTYPE_p_svn_stream_t swig_types[73]
2561
 
#define SWIGTYPE_p_svn_string_t swig_types[74]
2562
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[75]
2563
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[76]
2564
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[77]
2565
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[78]
2566
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[79]
2567
 
#define SWIGTYPE_p_svn_version_t swig_types[80]
2568
 
#define SWIGTYPE_p_unsigned_char swig_types[81]
2569
 
#define SWIGTYPE_p_void swig_types[82]
2570
 
static swig_type_info *swig_types[84];
2571
 
static swig_module_info swig_module = {swig_types, 83, 0, 0, 0, 0};
 
2979
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[57]
 
2980
#define SWIGTYPE_p_svn_io_dirent_t swig_types[58]
 
2981
#define SWIGTYPE_p_svn_io_file_del_t swig_types[59]
 
2982
#define SWIGTYPE_p_svn_location_segment_t swig_types[60]
 
2983
#define SWIGTYPE_p_svn_lock_t swig_types[61]
 
2984
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[62]
 
2985
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[63]
 
2986
#define SWIGTYPE_p_svn_log_entry_t swig_types[64]
 
2987
#define SWIGTYPE_p_svn_merge_range_t swig_types[65]
 
2988
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[66]
 
2989
#define SWIGTYPE_p_svn_node_kind_t swig_types[67]
 
2990
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[68]
 
2991
#define SWIGTYPE_p_svn_opt_revision_t swig_types[69]
 
2992
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[70]
 
2993
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[71]
 
2994
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[72]
 
2995
#define SWIGTYPE_p_svn_prop_kind swig_types[73]
 
2996
#define SWIGTYPE_p_svn_stream_mark_t swig_types[74]
 
2997
#define SWIGTYPE_p_svn_stream_t swig_types[75]
 
2998
#define SWIGTYPE_p_svn_string_t swig_types[76]
 
2999
#define SWIGTYPE_p_svn_stringbuf_t swig_types[77]
 
3000
#define SWIGTYPE_p_svn_tristate_t swig_types[78]
 
3001
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[79]
 
3002
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[80]
 
3003
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[81]
 
3004
#define SWIGTYPE_p_svn_version_checklist_t swig_types[82]
 
3005
#define SWIGTYPE_p_svn_version_t swig_types[83]
 
3006
#define SWIGTYPE_p_unsigned_char swig_types[84]
 
3007
#define SWIGTYPE_p_unsigned_long swig_types[85]
 
3008
#define SWIGTYPE_p_void swig_types[86]
 
3009
static swig_type_info *swig_types[88];
 
3010
static swig_module_info swig_module = {swig_types, 87, 0, 0, 0, 0};
2572
3011
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2573
3012
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2574
3013
 
2583
3022
/*-----------------------------------------------
2584
3023
              @(target):= _delta.so
2585
3024
  ------------------------------------------------*/
2586
 
#define SWIG_init    init_delta
2587
 
 
 
3025
#if PY_VERSION_HEX >= 0x03000000
 
3026
#  define SWIG_init    PyInit__delta
 
3027
 
 
3028
#else
 
3029
#  define SWIG_init    init_delta
 
3030
 
 
3031
#endif
2588
3032
#define SWIG_name    "_delta"
2589
3033
 
2590
 
#define SWIGVERSION 0x010336 
 
3034
#define SWIGVERSION 0x020004 
2591
3035
#define SWIG_VERSION SWIGVERSION
2592
3036
 
2593
3037
 
2625
3069
#define svn_argnum_obj17 18
2626
3070
#define svn_argnum_obj18 19
2627
3071
#define svn_argnum_obj19 20
 
3072
#define svn_argnum_obj20 21
 
3073
#define svn_argnum_obj21 22
 
3074
#define svn_argnum_obj22 23
 
3075
#define svn_argnum_obj23 24
 
3076
#define svn_argnum_obj24 25
 
3077
#define svn_argnum_obj25 26
 
3078
#define svn_argnum_obj26 27
 
3079
#define svn_argnum_obj27 28
 
3080
#define svn_argnum_obj28 29
 
3081
#define svn_argnum_obj29 30
 
3082
#define svn_argnum_obj30 31
 
3083
#define svn_argnum_obj31 32
 
3084
#define svn_argnum_obj32 33
 
3085
#define svn_argnum_obj33 34
 
3086
#define svn_argnum_obj34 35
 
3087
#define svn_argnum_obj35 36
 
3088
#define svn_argnum_obj36 37
 
3089
#define svn_argnum_obj37 38
 
3090
#define svn_argnum_obj38 39
 
3091
#define svn_argnum_obj39 40
2628
3092
 
2629
3093
 
2630
3094
#include <apr_md5.h>
2631
3095
#include "svn_md5.h"
2632
3096
 
2633
3097
 
 
3098
static PyObject *
 
3099
svn_txdelta_window_t_ops_get(PyObject *window_ob)
 
3100
{
 
3101
  void *window;
 
3102
  PyObject *ops_list, *window_pool;
 
3103
  int status;
 
3104
  
 
3105
  /* Kludge alert!
 
3106
     Normally, these kinds of conversions would belong in a typemap.
 
3107
     However, typemaps won't allow us to change the result type to an array,
 
3108
     so we have to make this custom accessor function.
 
3109
     A cleaner approach would be to use something like: 
 
3110
     
 
3111
     %extend svn_txdelta_window_t { void get_ops(apr_array_header_t ** ops); }
 
3112
     
 
3113
     But that means unnecessary copying, plus more hacks to get the pool for the
 
3114
     array and for wrapping the individual op objects. So we just don't bother.
 
3115
  */
 
3116
  
 
3117
  /* Note: the standard svn-python typemap releases the GIL while calling the
 
3118
     wrapped function, but this function does Python stuff, so we have to
 
3119
     reacquire it again. */
 
3120
  svn_swig_py_acquire_py_lock();
 
3121
  status = svn_swig_ConvertPtr(window_ob, &window,
 
3122
    SWIG_TypeQuery("svn_txdelta_window_t *"));
 
3123
    
 
3124
  if (status != 0)
 
3125
    {
 
3126
      PyErr_SetString(PyExc_TypeError,
 
3127
                      "expected an svn_txdelta_window_t* proxy");
 
3128
      svn_swig_py_release_py_lock();
 
3129
      return NULL;
 
3130
    }
 
3131
    
 
3132
  window_pool = PyObject_GetAttrString(window_ob, "_parent_pool");
 
3133
 
 
3134
  if (window_pool == NULL)
 
3135
    {
 
3136
      svn_swig_py_release_py_lock();
 
3137
      return NULL;
 
3138
    }
 
3139
    
 
3140
  ops_list = svn_swig_py_txdelta_window_t_ops_get(window,
 
3141
    SWIG_TypeQuery("svn_txdelta_op_t *"), window_pool);
 
3142
    
 
3143
  svn_swig_py_release_py_lock();
 
3144
  
 
3145
  return ops_list;
 
3146
}
 
3147
 
 
3148
 
2634
3149
#include "svn_delta.h"
2635
3150
 
2636
3151
 
2856
3371
SWIGINTERN int
2857
3372
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2858
3373
{
2859
 
  if (PyString_Check(obj)) {
 
3374
#if PY_VERSION_HEX>=0x03000000
 
3375
  if (PyUnicode_Check(obj))
 
3376
#else  
 
3377
  if (PyString_Check(obj))
 
3378
#endif
 
3379
  {
2860
3380
    char *cstr; Py_ssize_t len;
 
3381
#if PY_VERSION_HEX>=0x03000000
 
3382
    if (!alloc && cptr) {
 
3383
        /* We can't allow converting without allocation, since the internal
 
3384
           representation of string in Python 3 is UCS-2/UCS-4 but we require
 
3385
           a UTF-8 representation.
 
3386
           TODO(bhy) More detailed explanation */
 
3387
        return SWIG_RuntimeError;
 
3388
    }
 
3389
    obj = PyUnicode_AsUTF8String(obj);
 
3390
    PyBytes_AsStringAndSize(obj, &cstr, &len);
 
3391
    if(alloc) *alloc = SWIG_NEWOBJ;
 
3392
#else
2861
3393
    PyString_AsStringAndSize(obj, &cstr, &len);
2862
 
    if (cptr)  {
 
3394
#endif
 
3395
    if (cptr) {
2863
3396
      if (alloc) {
2864
3397
        /* 
2865
3398
           In python the user should not be able to modify the inner
2884
3417
          *alloc = SWIG_OLDOBJ;
2885
3418
        }
2886
3419
      } else {
2887
 
        *cptr = PyString_AsString(obj);
 
3420
        #if PY_VERSION_HEX>=0x03000000
 
3421
        assert(0); /* Should never reach here in Python 3 */
 
3422
        #endif
 
3423
        *cptr = SWIG_Python_str_AsChar(obj);
2888
3424
      }
2889
3425
    }
2890
3426
    if (psize) *psize = len + 1;
 
3427
#if PY_VERSION_HEX>=0x03000000
 
3428
    Py_XDECREF(obj);
 
3429
#endif
2891
3430
    return SWIG_OK;
2892
3431
  } else {
2893
3432
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2909
3448
 
2910
3449
 
2911
3450
static svn_error_t * svn_delta_editor_invoke_set_target_revision(
2912
 
  svn_delta_editor_t * _obj, void *edit_baton, svn_revnum_t target_revision, apr_pool_t *pool) {
2913
 
  return (_obj->set_target_revision)(edit_baton, target_revision, pool);
 
3451
  svn_delta_editor_t * _obj, void *edit_baton, svn_revnum_t target_revision, apr_pool_t *scratch_pool) {
 
3452
  return (_obj->set_target_revision)(edit_baton, target_revision, scratch_pool);
2914
3453
}
2915
3454
 
2916
3455
static svn_error_t * svn_delta_editor_invoke_open_root(
2917
 
  svn_delta_editor_t * _obj, void *edit_baton, svn_revnum_t base_revision, apr_pool_t *dir_pool, void **root_baton) {
2918
 
  return (_obj->open_root)(edit_baton, base_revision, dir_pool, root_baton);
 
3456
  svn_delta_editor_t * _obj, void *edit_baton, svn_revnum_t base_revision, apr_pool_t *result_pool, void **root_baton) {
 
3457
  return (_obj->open_root)(edit_baton, base_revision, result_pool, root_baton);
2919
3458
}
2920
3459
 
2921
3460
static svn_error_t * svn_delta_editor_invoke_delete_entry(
2922
 
  svn_delta_editor_t * _obj, const char *path, svn_revnum_t revision, void *parent_baton, apr_pool_t *pool) {
2923
 
  return (_obj->delete_entry)(path, revision, parent_baton, pool);
 
3461
  svn_delta_editor_t * _obj, const char *path, svn_revnum_t revision, void *parent_baton, apr_pool_t *scratch_pool) {
 
3462
  return (_obj->delete_entry)(path, revision, parent_baton, scratch_pool);
2924
3463
}
2925
3464
 
2926
3465
static svn_error_t * svn_delta_editor_invoke_add_directory(
2927
 
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_revision, apr_pool_t *dir_pool, void **child_baton) {
2928
 
  return (_obj->add_directory)(path, parent_baton, copyfrom_path, copyfrom_revision, dir_pool, child_baton);
 
3466
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_revision, apr_pool_t *result_pool, void **child_baton) {
 
3467
  return (_obj->add_directory)(path, parent_baton, copyfrom_path, copyfrom_revision, result_pool, child_baton);
2929
3468
}
2930
3469
 
2931
3470
static svn_error_t * svn_delta_editor_invoke_open_directory(
2932
 
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, svn_revnum_t base_revision, apr_pool_t *dir_pool, void **child_baton) {
2933
 
  return (_obj->open_directory)(path, parent_baton, base_revision, dir_pool, child_baton);
 
3471
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, svn_revnum_t base_revision, apr_pool_t *result_pool, void **child_baton) {
 
3472
  return (_obj->open_directory)(path, parent_baton, base_revision, result_pool, child_baton);
2934
3473
}
2935
3474
 
2936
3475
static svn_error_t * svn_delta_editor_invoke_change_dir_prop(
2937
 
  svn_delta_editor_t * _obj, void *dir_baton, const char *name, const svn_string_t *value, apr_pool_t *pool) {
2938
 
  return (_obj->change_dir_prop)(dir_baton, name, value, pool);
 
3476
  svn_delta_editor_t * _obj, void *dir_baton, const char *name, const svn_string_t *value, apr_pool_t *scratch_pool) {
 
3477
  return (_obj->change_dir_prop)(dir_baton, name, value, scratch_pool);
2939
3478
}
2940
3479
 
2941
3480
static svn_error_t * svn_delta_editor_invoke_close_directory(
2942
 
  svn_delta_editor_t * _obj, void *dir_baton, apr_pool_t *pool) {
2943
 
  return (_obj->close_directory)(dir_baton, pool);
 
3481
  svn_delta_editor_t * _obj, void *dir_baton, apr_pool_t *scratch_pool) {
 
3482
  return (_obj->close_directory)(dir_baton, scratch_pool);
2944
3483
}
2945
3484
 
2946
3485
static svn_error_t * svn_delta_editor_invoke_absent_directory(
2947
 
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, apr_pool_t *pool) {
2948
 
  return (_obj->absent_directory)(path, parent_baton, pool);
 
3486
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, apr_pool_t *scratch_pool) {
 
3487
  return (_obj->absent_directory)(path, parent_baton, scratch_pool);
2949
3488
}
2950
3489
 
2951
3490
static svn_error_t * svn_delta_editor_invoke_add_file(
2952
 
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_revision, apr_pool_t *file_pool, void **file_baton) {
2953
 
  return (_obj->add_file)(path, parent_baton, copyfrom_path, copyfrom_revision, file_pool, file_baton);
 
3491
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_revision, apr_pool_t *result_pool, void **file_baton) {
 
3492
  return (_obj->add_file)(path, parent_baton, copyfrom_path, copyfrom_revision, result_pool, file_baton);
2954
3493
}
2955
3494
 
2956
3495
static svn_error_t * svn_delta_editor_invoke_open_file(
2957
 
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, svn_revnum_t base_revision, apr_pool_t *file_pool, void **file_baton) {
2958
 
  return (_obj->open_file)(path, parent_baton, base_revision, file_pool, file_baton);
 
3496
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, svn_revnum_t base_revision, apr_pool_t *result_pool, void **file_baton) {
 
3497
  return (_obj->open_file)(path, parent_baton, base_revision, result_pool, file_baton);
2959
3498
}
2960
3499
 
2961
3500
static svn_error_t * svn_delta_editor_invoke_apply_textdelta(
2962
 
  svn_delta_editor_t * _obj, void *file_baton, const char *base_checksum, apr_pool_t *pool, svn_txdelta_window_handler_t *handler, void **handler_baton) {
2963
 
  return (_obj->apply_textdelta)(file_baton, base_checksum, pool, handler, handler_baton);
 
3501
  svn_delta_editor_t * _obj, void *file_baton, const char *base_checksum, apr_pool_t *result_pool, svn_txdelta_window_handler_t *handler, void **handler_baton) {
 
3502
  return (_obj->apply_textdelta)(file_baton, base_checksum, result_pool, handler, handler_baton);
2964
3503
}
2965
3504
 
2966
3505
static svn_error_t * svn_delta_editor_invoke_change_file_prop(
2967
 
  svn_delta_editor_t * _obj, void *file_baton, const char *name, const svn_string_t *value, apr_pool_t *pool) {
2968
 
  return (_obj->change_file_prop)(file_baton, name, value, pool);
 
3506
  svn_delta_editor_t * _obj, void *file_baton, const char *name, const svn_string_t *value, apr_pool_t *scratch_pool) {
 
3507
  return (_obj->change_file_prop)(file_baton, name, value, scratch_pool);
2969
3508
}
2970
3509
 
2971
3510
static svn_error_t * svn_delta_editor_invoke_close_file(
2972
 
  svn_delta_editor_t * _obj, void *file_baton, const char *text_checksum, apr_pool_t *pool) {
2973
 
  return (_obj->close_file)(file_baton, text_checksum, pool);
 
3511
  svn_delta_editor_t * _obj, void *file_baton, const char *text_checksum, apr_pool_t *scratch_pool) {
 
3512
  return (_obj->close_file)(file_baton, text_checksum, scratch_pool);
2974
3513
}
2975
3514
 
2976
3515
static svn_error_t * svn_delta_editor_invoke_absent_file(
2977
 
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, apr_pool_t *pool) {
2978
 
  return (_obj->absent_file)(path, parent_baton, pool);
 
3516
  svn_delta_editor_t * _obj, const char *path, void *parent_baton, apr_pool_t *scratch_pool) {
 
3517
  return (_obj->absent_file)(path, parent_baton, scratch_pool);
2979
3518
}
2980
3519
 
2981
3520
static svn_error_t * svn_delta_editor_invoke_close_edit(
2982
 
  svn_delta_editor_t * _obj, void *edit_baton, apr_pool_t *pool) {
2983
 
  return (_obj->close_edit)(edit_baton, pool);
 
3521
  svn_delta_editor_t * _obj, void *edit_baton, apr_pool_t *scratch_pool) {
 
3522
  return (_obj->close_edit)(edit_baton, scratch_pool);
2984
3523
}
2985
3524
 
2986
3525
static svn_error_t * svn_delta_editor_invoke_abort_edit(
2987
 
  svn_delta_editor_t * _obj, void *edit_baton, apr_pool_t *pool) {
2988
 
  return (_obj->abort_edit)(edit_baton, pool);
 
3526
  svn_delta_editor_t * _obj, void *edit_baton, apr_pool_t *scratch_pool) {
 
3527
  return (_obj->abort_edit)(edit_baton, scratch_pool);
2989
3528
}
2990
3529
 
2991
3530
static svn_error_t * svn_txdelta_invoke_window_handler(
3062
3601
  resultobj = SWIG_Py_Void();
3063
3602
  {
3064
3603
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
3065
 
        _global_py_pool, args));
 
3604
        _global_py_pool, args))
 
3605
    
 
3606
    ;
3066
3607
  }
3067
3608
  {
3068
3609
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
3069
 
        _global_py_pool, args));
3070
 
  }
3071
 
  {
3072
 
    Py_XDECREF(_global_py_pool);
3073
 
  }
3074
 
  return resultobj;
3075
 
fail:
3076
 
  {
3077
 
    Py_XDECREF(_global_py_pool);
3078
 
  }
 
3610
        _global_py_pool, args))
 
3611
    
 
3612
    ;
 
3613
  }
 
3614
  {
 
3615
    Py_XDECREF(_global_py_pool);
 
3616
  }
 
3617
  return resultobj;
 
3618
fail:
 
3619
  {
 
3620
    Py_XDECREF(_global_py_pool);
 
3621
  }
 
3622
  return NULL;
 
3623
}
 
3624
 
 
3625
 
 
3626
SWIGINTERN PyObject *_wrap_svn_txdelta_window_t_ops_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3627
  PyObject *resultobj = 0;
 
3628
  PyObject *arg1 = (PyObject *) 0 ;
 
3629
  PyObject * obj0 = 0 ;
 
3630
  PyObject *result = 0 ;
 
3631
  
 
3632
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t_ops_get",&obj0)) SWIG_fail;
 
3633
  arg1 = obj0;
 
3634
  {
 
3635
    svn_swig_py_release_py_lock();
 
3636
    
 
3637
    result = (PyObject *)svn_txdelta_window_t_ops_get(arg1);
 
3638
    
 
3639
    svn_swig_py_acquire_py_lock();
 
3640
    
 
3641
  }
 
3642
  resultobj = result;
 
3643
  return resultobj;
 
3644
fail:
3079
3645
  return NULL;
3080
3646
}
3081
3647
 
3543
4109
}
3544
4110
 
3545
4111
 
3546
 
SWIGINTERN PyObject *_wrap_svn_txdelta_window_t_ops_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3547
 
  PyObject *resultobj = 0;
3548
 
  svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
3549
 
  svn_txdelta_op_t *arg2 = (svn_txdelta_op_t *) 0 ;
3550
 
  PyObject * obj0 = 0 ;
3551
 
  PyObject * obj1 = 0 ;
3552
 
  
3553
 
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_txdelta_window_t_ops_set",&obj0,&obj1)) SWIG_fail;
3554
 
  {
3555
 
    arg1 = (svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3556
 
    if (PyErr_Occurred()) {
3557
 
      SWIG_fail;
3558
 
    }
3559
 
  }
3560
 
  {
3561
 
    arg2 = (svn_txdelta_op_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_txdelta_op_t, svn_argnum_obj1);
3562
 
    if (PyErr_Occurred()) {
3563
 
      SWIG_fail;
3564
 
    }
3565
 
  }
3566
 
  if (arg1) (arg1)->ops = (svn_txdelta_op_t const *)arg2;
3567
 
  resultobj = SWIG_Py_Void();
3568
 
  return resultobj;
3569
 
fail:
3570
 
  return NULL;
3571
 
}
3572
 
 
3573
 
 
3574
 
SWIGINTERN PyObject *_wrap_svn_txdelta_window_t_ops_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3575
 
  PyObject *resultobj = 0;
3576
 
  svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
3577
 
  PyObject * obj0 = 0 ;
3578
 
  svn_txdelta_op_t *result = 0 ;
3579
 
  
3580
 
  if (!PyArg_ParseTuple(args,(char *)"O:svn_txdelta_window_t_ops_get",&obj0)) SWIG_fail;
3581
 
  {
3582
 
    arg1 = (svn_txdelta_window_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_txdelta_window_t, svn_argnum_obj0);
3583
 
    if (PyErr_Occurred()) {
3584
 
      SWIG_fail;
3585
 
    }
3586
 
  }
3587
 
  result = (svn_txdelta_op_t *) ((arg1)->ops);
3588
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_txdelta_op_t,
3589
 
    _global_py_pool, args);
3590
 
  return resultobj;
3591
 
fail:
3592
 
  return NULL;
3593
 
}
3594
 
 
3595
 
 
3596
4112
SWIGINTERN PyObject *_wrap_svn_txdelta_window_t_new_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3597
4113
  PyObject *resultobj = 0;
3598
4114
  svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
4082
4598
  }
4083
4599
  {
4084
4600
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_window_t,
4085
 
        _global_py_pool, args));
 
4601
        _global_py_pool, args))
 
4602
    
 
4603
    ;
4086
4604
  }
4087
4605
  {
4088
4606
    Py_XDECREF(_global_py_pool);
4169
4687
  resultobj = SWIG_Py_Void();
4170
4688
  {
4171
4689
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t,
4172
 
        _global_py_pool, args));
 
4690
        _global_py_pool, args))
 
4691
    
 
4692
    ;
4173
4693
  }
4174
4694
  {
4175
4695
    Py_XDECREF(_global_py_pool);
4561
5081
  resultobj = SWIG_Py_Void();
4562
5082
  {
4563
5083
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
4564
 
        _global_py_pool, args));
 
5084
        _global_py_pool, args))
 
5085
    
 
5086
    ;
4565
5087
  }
4566
5088
  {
4567
5089
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
4568
 
        _global_py_pool, args));
 
5090
        _global_py_pool, args))
 
5091
    
 
5092
    ;
 
5093
  }
 
5094
  {
 
5095
    Py_XDECREF(_global_py_pool);
 
5096
  }
 
5097
  return resultobj;
 
5098
fail:
 
5099
  {
 
5100
    Py_XDECREF(_global_py_pool);
 
5101
  }
 
5102
  return NULL;
 
5103
}
 
5104
 
 
5105
 
 
5106
SWIGINTERN PyObject *_wrap_svn_txdelta_to_svndiff3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5107
  PyObject *resultobj = 0;
 
5108
  svn_txdelta_window_handler_t *arg1 = (svn_txdelta_window_handler_t *) 0 ;
 
5109
  void **arg2 = (void **) 0 ;
 
5110
  svn_stream_t *arg3 = (svn_stream_t *) 0 ;
 
5111
  int arg4 ;
 
5112
  int arg5 ;
 
5113
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
5114
  apr_pool_t *_global_pool = NULL ;
 
5115
  PyObject *_global_py_pool = NULL ;
 
5116
  void *temp2 ;
 
5117
  PyObject * obj0 = 0 ;
 
5118
  PyObject * obj1 = 0 ;
 
5119
  PyObject * obj2 = 0 ;
 
5120
  PyObject * obj3 = 0 ;
 
5121
  
 
5122
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
5123
      &_global_py_pool, &_global_pool))
 
5124
  SWIG_fail;
 
5125
  arg6 = _global_pool;
 
5126
  {
 
5127
    if (_global_pool == NULL)
 
5128
    {
 
5129
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
5130
          &_global_py_pool, &_global_pool))
 
5131
      SWIG_fail;
 
5132
    }
 
5133
    arg1 = (svn_txdelta_window_handler_t *) apr_pcalloc(_global_pool, sizeof(svn_txdelta_window_handler_t));
 
5134
    if (arg1 == NULL) SWIG_fail;
 
5135
  }
 
5136
  arg2 = &temp2;
 
5137
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_txdelta_to_svndiff3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
5138
  {
 
5139
    arg3 = svn_swig_py_make_stream (obj0, _global_pool);
 
5140
  }
 
5141
  {
 
5142
    arg4 = (int)SWIG_As_long (obj1);
 
5143
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
5144
      SWIG_fail;
 
5145
    }
 
5146
  }
 
5147
  {
 
5148
    arg5 = (int)SWIG_As_long (obj2);
 
5149
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
5150
      SWIG_fail;
 
5151
    }
 
5152
  }
 
5153
  if (obj3) {
 
5154
    /* Verify that the user supplied a valid pool */
 
5155
    if (obj3 != Py_None && obj3 != _global_py_pool) {
 
5156
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
 
5157
      SWIG_arg_fail(svn_argnum_obj3);
 
5158
      SWIG_fail;
 
5159
    }
 
5160
  }
 
5161
  {
 
5162
    svn_swig_py_release_py_lock();
 
5163
    
 
5164
    svn_txdelta_to_svndiff3(arg1,arg2,arg3,arg4,arg5,arg6);
 
5165
    
 
5166
    svn_swig_py_acquire_py_lock();
 
5167
    
 
5168
  }
 
5169
  resultobj = SWIG_Py_Void();
 
5170
  {
 
5171
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
5172
        _global_py_pool, args))
 
5173
    
 
5174
    ;
 
5175
  }
 
5176
  {
 
5177
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
5178
        _global_py_pool, args))
 
5179
    
 
5180
    ;
4569
5181
  }
4570
5182
  {
4571
5183
    Py_XDECREF(_global_py_pool);
4637
5249
  resultobj = SWIG_Py_Void();
4638
5250
  {
4639
5251
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
4640
 
        _global_py_pool, args));
 
5252
        _global_py_pool, args))
 
5253
    
 
5254
    ;
4641
5255
  }
4642
5256
  {
4643
5257
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
4644
 
        _global_py_pool, args));
 
5258
        _global_py_pool, args))
 
5259
    
 
5260
    ;
4645
5261
  }
4646
5262
  {
4647
5263
    Py_XDECREF(_global_py_pool);
4705
5321
  resultobj = SWIG_Py_Void();
4706
5322
  {
4707
5323
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg3, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
4708
 
        _global_py_pool, args));
 
5324
        _global_py_pool, args))
 
5325
    
 
5326
    ;
4709
5327
  }
4710
5328
  {
4711
5329
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg4, SWIGTYPE_p_void,
4712
 
        _global_py_pool, args));
 
5330
        _global_py_pool, args))
 
5331
    
 
5332
    ;
4713
5333
  }
4714
5334
  {
4715
5335
    Py_XDECREF(_global_py_pool);
4852
5472
  }
4853
5473
  {
4854
5474
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_window_t,
4855
 
        _global_py_pool, args));
 
5475
        _global_py_pool, args))
 
5476
    
 
5477
    ;
4856
5478
  }
4857
5479
  {
4858
5480
    Py_XDECREF(_global_py_pool);
5935
6557
  }
5936
6558
  {
5937
6559
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg5, SWIGTYPE_p_svn_delta_editor_t,
5938
 
        _global_py_pool, args));
 
6560
        _global_py_pool, args))
 
6561
    
 
6562
    ;
5939
6563
  }
5940
6564
  {
5941
6565
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg6, SWIGTYPE_p_void,
5942
 
        _global_py_pool, args));
 
6566
        _global_py_pool, args))
 
6567
    
 
6568
    ;
5943
6569
  }
5944
6570
  {
5945
6571
    Py_XDECREF(_global_py_pool);
6035
6661
  }
6036
6662
  {
6037
6663
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
6038
 
        _global_py_pool, args));
 
6664
        _global_py_pool, args))
 
6665
    
 
6666
    ;
6039
6667
  }
6040
6668
  {
6041
6669
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
6042
 
        _global_py_pool, args));
 
6670
        _global_py_pool, args))
 
6671
    
 
6672
    ;
6043
6673
  }
6044
6674
  {
6045
6675
    Py_XDECREF(_global_py_pool);
6098
6728
    }
6099
6729
  }
6100
6730
  {
6101
 
    arg4 = (apr_array_header_t *) svn_swig_py_strings_to_array(obj3,
 
6731
    arg4 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj3,
 
6732
      sizeof(const char *),
 
6733
      svn_swig_py_unwrap_string,
 
6734
      NULL,
6102
6735
      _global_pool);
6103
6736
    if (PyErr_Occurred())
6104
6737
    SWIG_fail;
6118
6751
  {
6119
6752
    svn_swig_py_release_py_lock();
6120
6753
    
6121
 
    result = (svn_error_t *)svn_delta_path_driver((struct svn_delta_editor_t const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
 
6754
    result = (svn_error_t *)svn_delta_path_driver((struct svn_delta_editor_t const *)arg1,arg2,arg3,(apr_array_header_t const *)arg4,arg5,arg6,arg7);
6122
6755
    
6123
6756
    svn_swig_py_acquire_py_lock();
6124
6757
    
6211
6844
  resultobj = SWIG_Py_Void();
6212
6845
  {
6213
6846
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg1, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
6214
 
        _global_py_pool, args));
 
6847
        _global_py_pool, args))
 
6848
    
 
6849
    ;
6215
6850
  }
6216
6851
  {
6217
6852
    /* FIXME: Missing argout typemap: svn_compat_wrap_file_rev_handler arg 2 (void **) */
6390
7025
  }
6391
7026
  {
6392
7027
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg5, SWIGTYPE_p_void,
6393
 
        _global_py_pool, args));
 
7028
        _global_py_pool, args))
 
7029
    
 
7030
    ;
6394
7031
  }
6395
7032
  {
6396
7033
    Py_XDECREF(_global_py_pool);
6556
7193
  }
6557
7194
  {
6558
7195
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
6559
 
        _global_py_pool, args));
 
7196
        _global_py_pool, args))
 
7197
    
 
7198
    ;
6560
7199
  }
6561
7200
  {
6562
7201
    Py_XDECREF(_global_py_pool);
6642
7281
  }
6643
7282
  {
6644
7283
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg6, SWIGTYPE_p_void,
6645
 
        _global_py_pool, args));
 
7284
        _global_py_pool, args))
 
7285
    
 
7286
    ;
6646
7287
  }
6647
7288
  {
6648
7289
    Py_XDECREF(_global_py_pool);
6957
7598
  }
6958
7599
  {
6959
7600
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
6960
 
        _global_py_pool, args));
 
7601
        _global_py_pool, args))
 
7602
    
 
7603
    ;
6961
7604
  }
6962
7605
  {
6963
7606
    Py_XDECREF(_global_py_pool);
7043
7686
  }
7044
7687
  {
7045
7688
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg6, SWIGTYPE_p_void,
7046
 
        _global_py_pool, args));
 
7689
        _global_py_pool, args))
 
7690
    
 
7691
    ;
7047
7692
  }
7048
7693
  {
7049
7694
    Py_XDECREF(_global_py_pool);
7132
7777
  }
7133
7778
  {
7134
7779
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg5, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
7135
 
        _global_py_pool, args));
 
7780
        _global_py_pool, args))
 
7781
    
 
7782
    ;
7136
7783
  }
7137
7784
  {
7138
7785
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg6, SWIGTYPE_p_void,
7139
 
        _global_py_pool, args));
 
7786
        _global_py_pool, args))
 
7787
    
 
7788
    ;
7140
7789
  }
7141
7790
  {
7142
7791
    Py_XDECREF(_global_py_pool);
7642
8291
  }
7643
8292
  {
7644
8293
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_txdelta_window_t,
7645
 
        _global_py_pool, args));
 
8294
        _global_py_pool, args))
 
8295
    
 
8296
    ;
7646
8297
  }
7647
8298
  {
7648
8299
    Py_XDECREF(_global_py_pool);
7773
8424
  }
7774
8425
  {
7775
8426
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
7776
 
        _global_py_pool, args));
 
8427
        _global_py_pool, args))
 
8428
    
 
8429
    ;
7777
8430
  }
7778
8431
  {
7779
8432
    Py_XDECREF(_global_py_pool);
7896
8549
  }
7897
8550
  {
7898
8551
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg7, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
7899
 
        _global_py_pool, args));
 
8552
        _global_py_pool, args))
 
8553
    
 
8554
    ;
7900
8555
  }
7901
8556
  {
7902
8557
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg8, SWIGTYPE_p_void,
7903
 
        _global_py_pool, args));
 
8558
        _global_py_pool, args))
 
8559
    
 
8560
    ;
7904
8561
  }
7905
8562
  {
7906
8563
    Py_XDECREF(_global_py_pool);
8015
8672
  }
8016
8673
  {
8017
8674
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
8018
 
        _global_py_pool, args));
 
8675
        _global_py_pool, args))
 
8676
    
 
8677
    ;
8019
8678
  }
8020
8679
  {
8021
8680
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
8022
 
        _global_py_pool, args));
 
8681
        _global_py_pool, args))
 
8682
    
 
8683
    ;
8023
8684
  }
8024
8685
  {
8025
8686
    Py_XDECREF(_global_py_pool);
8076
8737
}
8077
8738
 
8078
8739
static PyMethodDef SwigMethods[] = {
8079
 
         { (char *)"svn_swig_py_make_editor", _wrap_svn_swig_py_make_editor, METH_VARARGS, (char *)"\n"
8080
 
                "svn_swig_py_make_editor(svn_delta_editor_t editor, void edit_baton, PyObject py_editor, \n"
8081
 
                "    apr_pool_t pool)\n"
8082
 
                ""},
 
8740
         { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
 
8741
         { (char *)"svn_swig_py_make_editor", _wrap_svn_swig_py_make_editor, METH_VARARGS, (char *)"svn_swig_py_make_editor(PyObject py_editor, apr_pool_t pool)"},
 
8742
         { (char *)"svn_txdelta_window_t_ops_get", _wrap_svn_txdelta_window_t_ops_get, METH_VARARGS, (char *)"svn_txdelta_window_t_ops_get(PyObject window_ob) -> PyObject"},
8083
8743
         { (char *)"svn_delta_version", _wrap_svn_delta_version, METH_VARARGS, (char *)"svn_delta_version() -> svn_version_t"},
8084
8744
         { (char *)"svn_txdelta_op_t_action_code_set", _wrap_svn_txdelta_op_t_action_code_set, METH_VARARGS, (char *)"svn_txdelta_op_t_action_code_set(svn_txdelta_op_t self, enum svn_delta_action action_code)"},
8085
8745
         { (char *)"svn_txdelta_op_t_action_code_get", _wrap_svn_txdelta_op_t_action_code_get, METH_VARARGS, (char *)"svn_txdelta_op_t_action_code_get(svn_txdelta_op_t self) -> enum svn_delta_action"},
8100
8760
         { (char *)"svn_txdelta_window_t_num_ops_get", _wrap_svn_txdelta_window_t_num_ops_get, METH_VARARGS, (char *)"svn_txdelta_window_t_num_ops_get(svn_txdelta_window_t self) -> int"},
8101
8761
         { (char *)"svn_txdelta_window_t_src_ops_set", _wrap_svn_txdelta_window_t_src_ops_set, METH_VARARGS, (char *)"svn_txdelta_window_t_src_ops_set(svn_txdelta_window_t self, int src_ops)"},
8102
8762
         { (char *)"svn_txdelta_window_t_src_ops_get", _wrap_svn_txdelta_window_t_src_ops_get, METH_VARARGS, (char *)"svn_txdelta_window_t_src_ops_get(svn_txdelta_window_t self) -> int"},
8103
 
         { (char *)"svn_txdelta_window_t_ops_set", _wrap_svn_txdelta_window_t_ops_set, METH_VARARGS, (char *)"svn_txdelta_window_t_ops_set(svn_txdelta_window_t self, svn_txdelta_op_t ops)"},
8104
 
         { (char *)"svn_txdelta_window_t_ops_get", _wrap_svn_txdelta_window_t_ops_get, METH_VARARGS, (char *)"svn_txdelta_window_t_ops_get(svn_txdelta_window_t self) -> svn_txdelta_op_t"},
8105
8763
         { (char *)"svn_txdelta_window_t_new_data_get", _wrap_svn_txdelta_window_t_new_data_get, METH_VARARGS, (char *)"svn_txdelta_window_t_new_data_get(svn_txdelta_window_t self) -> svn_string_t"},
8106
8764
         { (char *)"new_svn_txdelta_window_t", _wrap_new_svn_txdelta_window_t, METH_VARARGS, (char *)"new_svn_txdelta_window_t() -> svn_txdelta_window_t"},
8107
8765
         { (char *)"delete_svn_txdelta_window_t", _wrap_delete_svn_txdelta_window_t, METH_VARARGS, (char *)"delete_svn_txdelta_window_t(svn_txdelta_window_t self)"},
8111
8769
                "svn_txdelta_compose_windows(svn_txdelta_window_t window_A, svn_txdelta_window_t window_B, \n"
8112
8770
                "    apr_pool_t pool) -> svn_txdelta_window_t\n"
8113
8771
                ""},
8114
 
         { (char *)"svn_txdelta_apply_instructions", _wrap_svn_txdelta_apply_instructions, METH_VARARGS, (char *)"\n"
8115
 
                "svn_txdelta_apply_instructions(svn_txdelta_window_t window, char sbuf, char tbuf, \n"
8116
 
                "    apr_size_t tlen)\n"
8117
 
                ""},
 
8772
         { (char *)"svn_txdelta_apply_instructions", _wrap_svn_txdelta_apply_instructions, METH_VARARGS, (char *)"svn_txdelta_apply_instructions(svn_txdelta_window_t window, char sbuf, char tbuf)"},
8118
8773
         { (char *)"svn_txdelta_run", _wrap_svn_txdelta_run, METH_VARARGS, (char *)"\n"
8119
8774
                "svn_txdelta_run(svn_stream_t source, svn_stream_t target, svn_txdelta_window_handler_t handler, \n"
8120
8775
                "    void handler_baton, \n"
8121
 
                "    svn_checksum_kind_t checksum_kind, svn_checksum_t checksum, \n"
8122
 
                "    svn_cancel_func_t cancel_func, \n"
8123
 
                "    apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t\n"
 
8776
                "    svn_checksum_kind_t checksum_kind, svn_cancel_func_t cancel_func, \n"
 
8777
                "    apr_pool_t result_pool, \n"
 
8778
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
8124
8779
                ""},
8125
8780
         { (char *)"svn_txdelta_stream_create", _wrap_svn_txdelta_stream_create, METH_VARARGS, (char *)"\n"
8126
8781
                "svn_txdelta_stream_create(void baton, svn_txdelta_next_window_fn_t next_window, \n"
8127
8782
                "    svn_txdelta_md5_digest_fn_t md5_digest, apr_pool_t pool) -> svn_txdelta_stream_t\n"
8128
8783
                ""},
8129
 
         { (char *)"svn_txdelta_next_window", _wrap_svn_txdelta_next_window, METH_VARARGS, (char *)"\n"
8130
 
                "svn_txdelta_next_window(svn_txdelta_window_t window, svn_txdelta_stream_t stream, \n"
8131
 
                "    apr_pool_t pool) -> svn_error_t\n"
8132
 
                ""},
 
8784
         { (char *)"svn_txdelta_next_window", _wrap_svn_txdelta_next_window, METH_VARARGS, (char *)"svn_txdelta_next_window(svn_txdelta_stream_t stream, apr_pool_t pool) -> svn_error_t"},
8133
8785
         { (char *)"svn_txdelta_md5_digest", _wrap_svn_txdelta_md5_digest, METH_VARARGS, (char *)"svn_txdelta_md5_digest(svn_txdelta_stream_t stream) -> unsigned char"},
8134
 
         { (char *)"svn_txdelta", _wrap_svn_txdelta, METH_VARARGS, (char *)"\n"
8135
 
                "svn_txdelta(svn_txdelta_stream_t stream, svn_stream_t source, svn_stream_t target, \n"
8136
 
                "    apr_pool_t pool)\n"
8137
 
                ""},
 
8786
         { (char *)"svn_txdelta", _wrap_svn_txdelta, METH_VARARGS, (char *)"svn_txdelta(svn_stream_t source, svn_stream_t target, apr_pool_t pool)"},
8138
8787
         { (char *)"svn_txdelta_target_push", _wrap_svn_txdelta_target_push, METH_VARARGS, (char *)"\n"
8139
8788
                "svn_txdelta_target_push(svn_txdelta_window_handler_t handler, void handler_baton, \n"
8140
8789
                "    svn_stream_t source, apr_pool_t pool) -> svn_stream_t\n"
8145
8794
                ""},
8146
8795
         { (char *)"svn_txdelta_send_stream", _wrap_svn_txdelta_send_stream, METH_VARARGS, (char *)"\n"
8147
8796
                "svn_txdelta_send_stream(svn_stream_t stream, svn_txdelta_window_handler_t handler, \n"
8148
 
                "    void handler_baton, unsigned char digest, \n"
8149
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
8797
                "    void handler_baton, apr_pool_t pool) -> svn_error_t\n"
8150
8798
                ""},
8151
8799
         { (char *)"svn_txdelta_send_txstream", _wrap_svn_txdelta_send_txstream, METH_VARARGS, (char *)"\n"
8152
8800
                "svn_txdelta_send_txstream(svn_txdelta_stream_t txstream, svn_txdelta_window_handler_t handler, \n"
8153
8801
                "    void handler_baton, apr_pool_t pool) -> svn_error_t\n"
8154
8802
                ""},
8155
8803
         { (char *)"svn_txdelta_apply", _wrap_svn_txdelta_apply, METH_VARARGS, (char *)"\n"
8156
 
                "svn_txdelta_apply(svn_stream_t source, svn_stream_t target, unsigned char result_digest, \n"
8157
 
                "    char error_info, apr_pool_t pool, \n"
8158
 
                "    svn_txdelta_window_handler_t handler, \n"
8159
 
                "    void handler_baton)\n"
8160
 
                ""},
8161
 
         { (char *)"svn_txdelta_to_svndiff2", _wrap_svn_txdelta_to_svndiff2, METH_VARARGS, (char *)"\n"
8162
 
                "svn_txdelta_to_svndiff2(svn_txdelta_window_handler_t handler, void handler_baton, \n"
8163
 
                "    svn_stream_t output, int svndiff_version, \n"
8164
 
                "    apr_pool_t pool)\n"
8165
 
                ""},
8166
 
         { (char *)"svn_txdelta_to_svndiff", _wrap_svn_txdelta_to_svndiff, METH_VARARGS, (char *)"\n"
8167
 
                "svn_txdelta_to_svndiff(svn_stream_t output, apr_pool_t pool, svn_txdelta_window_handler_t handler, \n"
8168
 
                "    void handler_baton)\n"
8169
 
                ""},
 
8804
                "svn_txdelta_apply(svn_stream_t source, svn_stream_t target, char error_info, \n"
 
8805
                "    apr_pool_t pool)\n"
 
8806
                ""},
 
8807
         { (char *)"svn_txdelta_to_svndiff3", _wrap_svn_txdelta_to_svndiff3, METH_VARARGS, (char *)"\n"
 
8808
                "svn_txdelta_to_svndiff3(svn_stream_t output, int svndiff_version, int compression_level, \n"
 
8809
                "    apr_pool_t pool)\n"
 
8810
                ""},
 
8811
         { (char *)"svn_txdelta_to_svndiff2", _wrap_svn_txdelta_to_svndiff2, METH_VARARGS, (char *)"svn_txdelta_to_svndiff2(svn_stream_t output, int svndiff_version, apr_pool_t pool)"},
 
8812
         { (char *)"svn_txdelta_to_svndiff", _wrap_svn_txdelta_to_svndiff, METH_VARARGS, (char *)"svn_txdelta_to_svndiff(svn_stream_t output, apr_pool_t pool)"},
8170
8813
         { (char *)"svn_txdelta_parse_svndiff", _wrap_svn_txdelta_parse_svndiff, METH_VARARGS, (char *)"\n"
8171
8814
                "svn_txdelta_parse_svndiff(svn_txdelta_window_handler_t handler, void handler_baton, \n"
8172
8815
                "    svn_boolean_t error_on_early_close, apr_pool_t pool) -> svn_stream_t\n"
8173
8816
                ""},
8174
 
         { (char *)"svn_txdelta_read_svndiff_window", _wrap_svn_txdelta_read_svndiff_window, METH_VARARGS, (char *)"\n"
8175
 
                "svn_txdelta_read_svndiff_window(svn_txdelta_window_t window, svn_stream_t stream, int svndiff_version, \n"
8176
 
                "    apr_pool_t pool) -> svn_error_t\n"
8177
 
                ""},
 
8817
         { (char *)"svn_txdelta_read_svndiff_window", _wrap_svn_txdelta_read_svndiff_window, METH_VARARGS, (char *)"svn_txdelta_read_svndiff_window(svn_stream_t stream, int svndiff_version, apr_pool_t pool) -> svn_error_t"},
8178
8818
         { (char *)"svn_txdelta_skip_svndiff_window", _wrap_svn_txdelta_skip_svndiff_window, METH_VARARGS, (char *)"svn_txdelta_skip_svndiff_window(apr_file_t file, int svndiff_version, apr_pool_t pool) -> svn_error_t"},
8179
8819
         { (char *)"svn_delta_editor_t_set_target_revision_set", _wrap_svn_delta_editor_t_set_target_revision_set, METH_VARARGS, (char *)"svn_delta_editor_t_set_target_revision_set(svn_delta_editor_t self, svn_error_t set_target_revision)"},
8180
8820
         { (char *)"svn_delta_editor_t_set_target_revision_get", _wrap_svn_delta_editor_t_set_target_revision_get, METH_VARARGS, (char *)"svn_delta_editor_t_set_target_revision_get(svn_delta_editor_t self) -> svn_error_t"},
8215
8855
         { (char *)"svn_delta_noop_window_handler", _wrap_svn_delta_noop_window_handler, METH_VARARGS, (char *)"svn_delta_noop_window_handler(svn_txdelta_window_t window, void baton) -> svn_error_t"},
8216
8856
         { (char *)"svn_delta_get_cancellation_editor", _wrap_svn_delta_get_cancellation_editor, METH_VARARGS, (char *)"\n"
8217
8857
                "svn_delta_get_cancellation_editor(svn_cancel_func_t cancel_func, svn_delta_editor_t wrapped_editor, \n"
8218
 
                "    void wrapped_baton, svn_delta_editor_t editor, \n"
8219
 
                "    void edit_baton, apr_pool_t pool) -> svn_error_t\n"
 
8858
                "    void wrapped_baton, apr_pool_t pool) -> svn_error_t\n"
8220
8859
                ""},
8221
8860
         { (char *)"svn_delta_depth_filter_editor", _wrap_svn_delta_depth_filter_editor, METH_VARARGS, (char *)"\n"
8222
 
                "svn_delta_depth_filter_editor(svn_delta_editor_t editor, void edit_baton, svn_delta_editor_t wrapped_editor, \n"
8223
 
                "    void wrapped_edit_baton, \n"
 
8861
                "svn_delta_depth_filter_editor(svn_delta_editor_t wrapped_editor, void wrapped_edit_baton, \n"
8224
8862
                "    svn_depth_t requested_depth, svn_boolean_t has_target, \n"
8225
8863
                "    apr_pool_t pool) -> svn_error_t\n"
8226
8864
                ""},
8230
8868
                "    apr_pool_t pool) -> svn_error_t\n"
8231
8869
                ""},
8232
8870
         { (char *)"svn_compat_wrap_file_rev_handler", _wrap_svn_compat_wrap_file_rev_handler, METH_VARARGS, (char *)"\n"
8233
 
                "svn_compat_wrap_file_rev_handler(svn_file_rev_handler_t handler2, void handler2_baton, \n"
8234
 
                "    svn_file_rev_handler_old_t handler, void handler_baton, \n"
 
8871
                "svn_compat_wrap_file_rev_handler(svn_file_rev_handler_old_t handler, void handler_baton, \n"
8235
8872
                "    apr_pool_t pool)\n"
8236
8873
                ""},
8237
8874
         { (char *)"svn_txdelta_stream_t_swigregister", svn_txdelta_stream_t_swigregister, METH_VARARGS, NULL},
8238
8875
         { (char *)"svn_delta_editor_invoke_set_target_revision", _wrap_svn_delta_editor_invoke_set_target_revision, METH_VARARGS, (char *)"\n"
8239
8876
                "svn_delta_editor_invoke_set_target_revision(svn_delta_editor_t _obj, void edit_baton, svn_revnum_t target_revision, \n"
8240
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
8877
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
8241
8878
                ""},
8242
8879
         { (char *)"svn_delta_editor_invoke_open_root", _wrap_svn_delta_editor_invoke_open_root, METH_VARARGS, (char *)"\n"
8243
8880
                "svn_delta_editor_invoke_open_root(svn_delta_editor_t _obj, void edit_baton, svn_revnum_t base_revision, \n"
8244
 
                "    apr_pool_t dir_pool, void root_baton) -> svn_error_t\n"
 
8881
                "    apr_pool_t result_pool) -> svn_error_t\n"
8245
8882
                ""},
8246
8883
         { (char *)"svn_delta_editor_invoke_delete_entry", _wrap_svn_delta_editor_invoke_delete_entry, METH_VARARGS, (char *)"\n"
8247
8884
                "svn_delta_editor_invoke_delete_entry(svn_delta_editor_t _obj, char path, svn_revnum_t revision, \n"
8248
 
                "    void parent_baton, apr_pool_t pool) -> svn_error_t\n"
 
8885
                "    void parent_baton, apr_pool_t scratch_pool) -> svn_error_t\n"
8249
8886
                ""},
8250
8887
         { (char *)"svn_delta_editor_invoke_add_directory", _wrap_svn_delta_editor_invoke_add_directory, METH_VARARGS, (char *)"\n"
8251
8888
                "svn_delta_editor_invoke_add_directory(svn_delta_editor_t _obj, char path, void parent_baton, \n"
8252
8889
                "    char copyfrom_path, svn_revnum_t copyfrom_revision, \n"
8253
 
                "    apr_pool_t dir_pool, void child_baton) -> svn_error_t\n"
 
8890
                "    apr_pool_t result_pool) -> svn_error_t\n"
8254
8891
                ""},
8255
8892
         { (char *)"svn_delta_editor_invoke_open_directory", _wrap_svn_delta_editor_invoke_open_directory, METH_VARARGS, (char *)"\n"
8256
8893
                "svn_delta_editor_invoke_open_directory(svn_delta_editor_t _obj, char path, void parent_baton, \n"
8257
 
                "    svn_revnum_t base_revision, apr_pool_t dir_pool, \n"
8258
 
                "    void child_baton) -> svn_error_t\n"
 
8894
                "    svn_revnum_t base_revision, apr_pool_t result_pool) -> svn_error_t\n"
8259
8895
                ""},
8260
8896
         { (char *)"svn_delta_editor_invoke_change_dir_prop", _wrap_svn_delta_editor_invoke_change_dir_prop, METH_VARARGS, (char *)"\n"
8261
8897
                "svn_delta_editor_invoke_change_dir_prop(svn_delta_editor_t _obj, void dir_baton, char name, \n"
8262
 
                "    svn_string_t value, apr_pool_t pool) -> svn_error_t\n"
 
8898
                "    svn_string_t value, apr_pool_t scratch_pool) -> svn_error_t\n"
8263
8899
                ""},
8264
 
         { (char *)"svn_delta_editor_invoke_close_directory", _wrap_svn_delta_editor_invoke_close_directory, METH_VARARGS, (char *)"svn_delta_editor_invoke_close_directory(svn_delta_editor_t _obj, void dir_baton, apr_pool_t pool) -> svn_error_t"},
 
8900
         { (char *)"svn_delta_editor_invoke_close_directory", _wrap_svn_delta_editor_invoke_close_directory, METH_VARARGS, (char *)"svn_delta_editor_invoke_close_directory(svn_delta_editor_t _obj, void dir_baton, apr_pool_t scratch_pool) -> svn_error_t"},
8265
8901
         { (char *)"svn_delta_editor_invoke_absent_directory", _wrap_svn_delta_editor_invoke_absent_directory, METH_VARARGS, (char *)"\n"
8266
8902
                "svn_delta_editor_invoke_absent_directory(svn_delta_editor_t _obj, char path, void parent_baton, \n"
8267
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
8903
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
8268
8904
                ""},
8269
8905
         { (char *)"svn_delta_editor_invoke_add_file", _wrap_svn_delta_editor_invoke_add_file, METH_VARARGS, (char *)"\n"
8270
8906
                "svn_delta_editor_invoke_add_file(svn_delta_editor_t _obj, char path, void parent_baton, \n"
8271
8907
                "    char copyfrom_path, svn_revnum_t copyfrom_revision, \n"
8272
 
                "    apr_pool_t file_pool, void file_baton) -> svn_error_t\n"
 
8908
                "    apr_pool_t result_pool) -> svn_error_t\n"
8273
8909
                ""},
8274
8910
         { (char *)"svn_delta_editor_invoke_open_file", _wrap_svn_delta_editor_invoke_open_file, METH_VARARGS, (char *)"\n"
8275
8911
                "svn_delta_editor_invoke_open_file(svn_delta_editor_t _obj, char path, void parent_baton, \n"
8276
 
                "    svn_revnum_t base_revision, apr_pool_t file_pool, \n"
8277
 
                "    void file_baton) -> svn_error_t\n"
 
8912
                "    svn_revnum_t base_revision, apr_pool_t result_pool) -> svn_error_t\n"
8278
8913
                ""},
8279
8914
         { (char *)"svn_delta_editor_invoke_apply_textdelta", _wrap_svn_delta_editor_invoke_apply_textdelta, METH_VARARGS, (char *)"\n"
8280
8915
                "svn_delta_editor_invoke_apply_textdelta(svn_delta_editor_t _obj, void file_baton, char base_checksum, \n"
8281
 
                "    apr_pool_t pool, svn_txdelta_window_handler_t handler, \n"
8282
 
                "    void handler_baton) -> svn_error_t\n"
 
8916
                "    apr_pool_t result_pool) -> svn_error_t\n"
8283
8917
                ""},
8284
8918
         { (char *)"svn_delta_editor_invoke_change_file_prop", _wrap_svn_delta_editor_invoke_change_file_prop, METH_VARARGS, (char *)"\n"
8285
8919
                "svn_delta_editor_invoke_change_file_prop(svn_delta_editor_t _obj, void file_baton, char name, \n"
8286
 
                "    svn_string_t value, apr_pool_t pool) -> svn_error_t\n"
 
8920
                "    svn_string_t value, apr_pool_t scratch_pool) -> svn_error_t\n"
8287
8921
                ""},
8288
8922
         { (char *)"svn_delta_editor_invoke_close_file", _wrap_svn_delta_editor_invoke_close_file, METH_VARARGS, (char *)"\n"
8289
8923
                "svn_delta_editor_invoke_close_file(svn_delta_editor_t _obj, void file_baton, char text_checksum, \n"
8290
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
8924
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
8291
8925
                ""},
8292
8926
         { (char *)"svn_delta_editor_invoke_absent_file", _wrap_svn_delta_editor_invoke_absent_file, METH_VARARGS, (char *)"\n"
8293
8927
                "svn_delta_editor_invoke_absent_file(svn_delta_editor_t _obj, char path, void parent_baton, \n"
8294
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
8928
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
8295
8929
                ""},
8296
 
         { (char *)"svn_delta_editor_invoke_close_edit", _wrap_svn_delta_editor_invoke_close_edit, METH_VARARGS, (char *)"svn_delta_editor_invoke_close_edit(svn_delta_editor_t _obj, void edit_baton, apr_pool_t pool) -> svn_error_t"},
8297
 
         { (char *)"svn_delta_editor_invoke_abort_edit", _wrap_svn_delta_editor_invoke_abort_edit, METH_VARARGS, (char *)"svn_delta_editor_invoke_abort_edit(svn_delta_editor_t _obj, void edit_baton, apr_pool_t pool) -> svn_error_t"},
 
8930
         { (char *)"svn_delta_editor_invoke_close_edit", _wrap_svn_delta_editor_invoke_close_edit, METH_VARARGS, (char *)"svn_delta_editor_invoke_close_edit(svn_delta_editor_t _obj, void edit_baton, apr_pool_t scratch_pool) -> svn_error_t"},
 
8931
         { (char *)"svn_delta_editor_invoke_abort_edit", _wrap_svn_delta_editor_invoke_abort_edit, METH_VARARGS, (char *)"svn_delta_editor_invoke_abort_edit(svn_delta_editor_t _obj, void edit_baton, apr_pool_t scratch_pool) -> svn_error_t"},
8298
8932
         { (char *)"svn_txdelta_invoke_window_handler", _wrap_svn_txdelta_invoke_window_handler, METH_VARARGS, (char *)"\n"
8299
8933
                "svn_txdelta_invoke_window_handler(svn_txdelta_window_handler_t _obj, svn_txdelta_window_t window, \n"
8300
8934
                "    void baton) -> svn_error_t\n"
8301
8935
                ""},
8302
 
         { (char *)"svn_txdelta_invoke_next_window_fn", _wrap_svn_txdelta_invoke_next_window_fn, METH_VARARGS, (char *)"\n"
8303
 
                "svn_txdelta_invoke_next_window_fn(svn_txdelta_next_window_fn_t _obj, svn_txdelta_window_t window, \n"
8304
 
                "    void baton, apr_pool_t pool) -> svn_error_t\n"
8305
 
                ""},
 
8936
         { (char *)"svn_txdelta_invoke_next_window_fn", _wrap_svn_txdelta_invoke_next_window_fn, METH_VARARGS, (char *)"svn_txdelta_invoke_next_window_fn(svn_txdelta_next_window_fn_t _obj, void baton, apr_pool_t pool) -> svn_error_t"},
8306
8937
         { (char *)"svn_txdelta_invoke_md5_digest_fn", _wrap_svn_txdelta_invoke_md5_digest_fn, METH_VARARGS, (char *)"svn_txdelta_invoke_md5_digest_fn(svn_txdelta_md5_digest_fn_t _obj, void baton) -> unsigned char"},
8307
8938
         { (char *)"svn_delta_invoke_path_driver_cb_func", _wrap_svn_delta_invoke_path_driver_cb_func, METH_VARARGS, (char *)"\n"
8308
 
                "svn_delta_invoke_path_driver_cb_func(svn_delta_path_driver_cb_func_t _obj, void dir_baton, \n"
8309
 
                "    void parent_baton, void callback_baton, char path, \n"
8310
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
8939
                "svn_delta_invoke_path_driver_cb_func(svn_delta_path_driver_cb_func_t _obj, void parent_baton, \n"
 
8940
                "    void callback_baton, char path, apr_pool_t pool) -> svn_error_t\n"
8311
8941
                ""},
8312
8942
         { (char *)"svn_file_invoke_rev_handler", _wrap_svn_file_invoke_rev_handler, METH_VARARGS, (char *)"\n"
8313
8943
                "svn_file_invoke_rev_handler(svn_file_rev_handler_t _obj, void baton, char path, \n"
8314
8944
                "    svn_revnum_t rev, apr_hash_t rev_props, svn_boolean_t result_of_merge, \n"
8315
 
                "    svn_txdelta_window_handler_t delta_handler, \n"
8316
 
                "    void delta_baton, apr_array_header_t prop_diffs, \n"
 
8945
                "    apr_array_header_t prop_diffs, \n"
8317
8946
                "    apr_pool_t pool) -> svn_error_t\n"
8318
8947
                ""},
8319
8948
         { (char *)"svn_file_invoke_rev_handler_old", _wrap_svn_file_invoke_rev_handler_old, METH_VARARGS, (char *)"\n"
8320
8949
                "svn_file_invoke_rev_handler_old(svn_file_rev_handler_old_t _obj, void baton, char path, \n"
8321
8950
                "    svn_revnum_t rev, apr_hash_t rev_props, \n"
8322
 
                "    svn_txdelta_window_handler_t delta_handler, void delta_baton, \n"
8323
 
                "    apr_array_header_t prop_diffs, \n"
8324
 
                "    apr_pool_t pool) -> svn_error_t\n"
 
8951
                "    apr_array_header_t prop_diffs, apr_pool_t pool) -> svn_error_t\n"
8325
8952
                ""},
8326
8953
         { (char *)"svn_txdelta_window_handler_t_swigregister", svn_txdelta_window_handler_t_swigregister, METH_VARARGS, NULL},
8327
8954
         { (char *)"svn_txdelta_next_window_fn_t_swigregister", svn_txdelta_next_window_fn_t_swigregister, METH_VARARGS, NULL},
8392
9019
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};
8393
9020
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};
8394
9021
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};
 
9022
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};
8395
9023
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};
8396
9024
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};
8397
9025
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};
8408
9036
static swig_type_info _swigt__p_svn_opt_subcommand_desc2_t = {"_p_svn_opt_subcommand_desc2_t", "struct svn_opt_subcommand_desc2_t *|svn_opt_subcommand_desc2_t *", 0, 0, (void*)0, 0};
8409
9037
static swig_type_info _swigt__p_svn_opt_subcommand_desc_t = {"_p_svn_opt_subcommand_desc_t", "struct svn_opt_subcommand_desc_t *|svn_opt_subcommand_desc_t *", 0, 0, (void*)0, 0};
8410
9038
static swig_type_info _swigt__p_svn_prop_kind = {"_p_svn_prop_kind", "svn_prop_kind_t *|enum svn_prop_kind *", 0, 0, (void*)0, 0};
 
9039
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};
8411
9040
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};
8412
9041
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};
8413
9042
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};
 
9043
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};
8414
9044
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};
8415
9045
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};
8416
9046
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};
8417
9047
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};
8418
9048
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};
8419
9049
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0};
 
9050
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|svn_linenum_t *", 0, 0, (void*)0, 0};
8420
9051
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
8421
9052
 
8422
9053
static swig_type_info *swig_type_initial[] = {
8477
9108
  &_swigt__p_svn_dirent_t,
8478
9109
  &_swigt__p_svn_errno_t,
8479
9110
  &_swigt__p_svn_error_t,
 
9111
  &_swigt__p_svn_io_dirent2_t,
8480
9112
  &_swigt__p_svn_io_dirent_t,
8481
9113
  &_swigt__p_svn_io_file_del_t,
8482
9114
  &_swigt__p_svn_location_segment_t,
8493
9125
  &_swigt__p_svn_opt_subcommand_desc2_t,
8494
9126
  &_swigt__p_svn_opt_subcommand_desc_t,
8495
9127
  &_swigt__p_svn_prop_kind,
 
9128
  &_swigt__p_svn_stream_mark_t,
8496
9129
  &_swigt__p_svn_stream_t,
8497
9130
  &_swigt__p_svn_string_t,
8498
9131
  &_swigt__p_svn_stringbuf_t,
 
9132
  &_swigt__p_svn_tristate_t,
8499
9133
  &_swigt__p_svn_txdelta_op_t,
8500
9134
  &_swigt__p_svn_txdelta_stream_t,
8501
9135
  &_swigt__p_svn_txdelta_window_t,
8502
9136
  &_swigt__p_svn_version_checklist_t,
8503
9137
  &_swigt__p_svn_version_t,
8504
9138
  &_swigt__p_unsigned_char,
 
9139
  &_swigt__p_unsigned_long,
8505
9140
  &_swigt__p_void,
8506
9141
};
8507
9142
 
8562
9197
static swig_cast_info _swigc__p_svn_dirent_t[] = {  {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
8563
9198
static swig_cast_info _swigc__p_svn_errno_t[] = {  {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
8564
9199
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
9200
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
8565
9201
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
8566
9202
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}};
8567
9203
static swig_cast_info _swigc__p_svn_location_segment_t[] = {  {&_swigt__p_svn_location_segment_t, 0, 0, 0},{0, 0, 0, 0}};
8578
9214
static swig_cast_info _swigc__p_svn_opt_subcommand_desc2_t[] = {  {&_swigt__p_svn_opt_subcommand_desc2_t, 0, 0, 0},{0, 0, 0, 0}};
8579
9215
static swig_cast_info _swigc__p_svn_opt_subcommand_desc_t[] = {  {&_swigt__p_svn_opt_subcommand_desc_t, 0, 0, 0},{0, 0, 0, 0}};
8580
9216
static swig_cast_info _swigc__p_svn_prop_kind[] = {  {&_swigt__p_svn_prop_kind, 0, 0, 0},{0, 0, 0, 0}};
 
9217
static swig_cast_info _swigc__p_svn_stream_mark_t[] = {  {&_swigt__p_svn_stream_mark_t, 0, 0, 0},{0, 0, 0, 0}};
8581
9218
static swig_cast_info _swigc__p_svn_stream_t[] = {  {&_swigt__p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
8582
9219
static swig_cast_info _swigc__p_svn_string_t[] = {  {&_swigt__p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
8583
9220
static swig_cast_info _swigc__p_svn_stringbuf_t[] = {  {&_swigt__p_svn_stringbuf_t, 0, 0, 0},{0, 0, 0, 0}};
 
9221
static swig_cast_info _swigc__p_svn_tristate_t[] = {  {&_swigt__p_svn_tristate_t, 0, 0, 0},{0, 0, 0, 0}};
8584
9222
static swig_cast_info _swigc__p_svn_txdelta_op_t[] = {  {&_swigt__p_svn_txdelta_op_t, 0, 0, 0},{0, 0, 0, 0}};
8585
9223
static swig_cast_info _swigc__p_svn_txdelta_stream_t[] = {  {&_swigt__p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
8586
9224
static swig_cast_info _swigc__p_svn_txdelta_window_t[] = {  {&_swigt__p_svn_txdelta_window_t, 0, 0, 0},{0, 0, 0, 0}};
8587
9225
static swig_cast_info _swigc__p_svn_version_checklist_t[] = {  {&_swigt__p_svn_version_checklist_t, 0, 0, 0},{0, 0, 0, 0}};
8588
9226
static swig_cast_info _swigc__p_svn_version_t[] = {  {&_swigt__p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
8589
9227
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
 
9228
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
8590
9229
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
8591
9230
 
8592
9231
static swig_cast_info *swig_cast_initial[] = {
8647
9286
  _swigc__p_svn_dirent_t,
8648
9287
  _swigc__p_svn_errno_t,
8649
9288
  _swigc__p_svn_error_t,
 
9289
  _swigc__p_svn_io_dirent2_t,
8650
9290
  _swigc__p_svn_io_dirent_t,
8651
9291
  _swigc__p_svn_io_file_del_t,
8652
9292
  _swigc__p_svn_location_segment_t,
8663
9303
  _swigc__p_svn_opt_subcommand_desc2_t,
8664
9304
  _swigc__p_svn_opt_subcommand_desc_t,
8665
9305
  _swigc__p_svn_prop_kind,
 
9306
  _swigc__p_svn_stream_mark_t,
8666
9307
  _swigc__p_svn_stream_t,
8667
9308
  _swigc__p_svn_string_t,
8668
9309
  _swigc__p_svn_stringbuf_t,
 
9310
  _swigc__p_svn_tristate_t,
8669
9311
  _swigc__p_svn_txdelta_op_t,
8670
9312
  _swigc__p_svn_txdelta_stream_t,
8671
9313
  _swigc__p_svn_txdelta_window_t,
8672
9314
  _swigc__p_svn_version_checklist_t,
8673
9315
  _swigc__p_svn_version_t,
8674
9316
  _swigc__p_unsigned_char,
 
9317
  _swigc__p_unsigned_long,
8675
9318
  _swigc__p_void,
8676
9319
};
8677
9320
 
8950
9593
  
8951
9594
  SWIGINTERN PyObject *
8952
9595
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
 
9596
#if PY_VERSION_HEX >= 0x03000000
 
9597
    return PyUnicode_InternFromString("<Swig global variables>");
 
9598
#else
8953
9599
    return PyString_FromString("<Swig global variables>");
 
9600
#endif
8954
9601
  }
8955
9602
  
8956
9603
  SWIGINTERN PyObject *
8957
9604
  swig_varlink_str(swig_varlinkobject *v) {
 
9605
#if PY_VERSION_HEX >= 0x03000000
 
9606
    PyObject *str = PyUnicode_InternFromString("(");
 
9607
    PyObject *tail;
 
9608
    PyObject *joined;
 
9609
    swig_globalvar *var;
 
9610
    for (var = v->vars; var; var=var->next) {
 
9611
      tail = PyUnicode_FromString(var->name);
 
9612
      joined = PyUnicode_Concat(str, tail);
 
9613
      Py_DecRef(str);
 
9614
      Py_DecRef(tail);
 
9615
      str = joined;
 
9616
      if (var->next) {
 
9617
        tail = PyUnicode_InternFromString(", ");
 
9618
        joined = PyUnicode_Concat(str, tail);
 
9619
        Py_DecRef(str);
 
9620
        Py_DecRef(tail);
 
9621
        str = joined;
 
9622
      }
 
9623
    }
 
9624
    tail = PyUnicode_InternFromString(")");
 
9625
    joined = PyUnicode_Concat(str, tail);
 
9626
    Py_DecRef(str);
 
9627
    Py_DecRef(tail);
 
9628
    str = joined;
 
9629
#else
8958
9630
    PyObject *str = PyString_FromString("(");
8959
 
    swig_globalvar  *var;
 
9631
    swig_globalvar *var;
8960
9632
    for (var = v->vars; var; var=var->next) {
8961
9633
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
8962
9634
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
8963
9635
    }
8964
9636
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
 
9637
#endif
8965
9638
    return str;
8966
9639
  }
8967
9640
  
8968
9641
  SWIGINTERN int
8969
9642
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
 
9643
    char *tmp;
8970
9644
    PyObject *str = swig_varlink_str(v);
8971
9645
    fprintf(fp,"Swig global variables ");
8972
 
    fprintf(fp,"%s\n", PyString_AsString(str));
 
9646
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
 
9647
    SWIG_Python_str_DelForPy3(tmp);
8973
9648
    Py_DECREF(str);
8974
9649
    return 0;
8975
9650
  }
9023
9698
  swig_varlink_type(void) {
9024
9699
    static char varlink__doc__[] = "Swig var link object";
9025
9700
    static PyTypeObject varlink_type;
9026
 
    static int type_init = 0;  
 
9701
    static int type_init = 0;
9027
9702
    if (!type_init) {
9028
 
      const PyTypeObject tmp
9029
 
      = {
 
9703
      const PyTypeObject tmp = {
 
9704
        /* PyObject header changed in Python 3 */
 
9705
#if PY_VERSION_HEX >= 0x03000000
 
9706
        PyVarObject_HEAD_INIT(NULL, 0)
 
9707
#else
9030
9708
        PyObject_HEAD_INIT(NULL)
9031
 
        0,                                  /* Number of items in variable part (ob_size) */
9032
 
        (char *)"swigvarlink",              /* Type name (tp_name) */
9033
 
        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
9034
 
        0,                                  /* Itemsize (tp_itemsize) */
9035
 
        (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
9036
 
        (printfunc) swig_varlink_print,     /* Print (tp_print) */
9037
 
        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
9038
 
        (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
 
9709
        0,                                  /* ob_size */
 
9710
#endif
 
9711
        (char *)"swigvarlink",              /* tp_name */
 
9712
        sizeof(swig_varlinkobject),         /* tp_basicsize */
 
9713
        0,                                  /* tp_itemsize */
 
9714
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
 
9715
        (printfunc) swig_varlink_print,     /* tp_print */
 
9716
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
 
9717
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
9039
9718
        0,                                  /* tp_compare */
9040
9719
        (reprfunc) swig_varlink_repr,       /* tp_repr */
9041
9720
        0,                                  /* tp_as_number */
9043
9722
        0,                                  /* tp_as_mapping */
9044
9723
        0,                                  /* tp_hash */
9045
9724
        0,                                  /* tp_call */
9046
 
        (reprfunc)swig_varlink_str,        /* tp_str */
 
9725
        (reprfunc) swig_varlink_str,        /* tp_str */
9047
9726
        0,                                  /* tp_getattro */
9048
9727
        0,                                  /* tp_setattro */
9049
9728
        0,                                  /* tp_as_buffer */
9059
9738
#if PY_VERSION_HEX >= 0x02030000
9060
9739
        0,                                  /* tp_del */
9061
9740
#endif
 
9741
#if PY_VERSION_HEX >= 0x02060000
 
9742
        0,                                  /* tp_version */
 
9743
#endif
9062
9744
#ifdef COUNT_ALLOCS
9063
9745
        0,0,0,0                             /* tp_alloc -> tp_next */
9064
9746
#endif
9065
9747
      };
9066
9748
      varlink_type = tmp;
 
9749
      type_init = 1;
 
9750
#if PY_VERSION_HEX < 0x02020000
9067
9751
      varlink_type.ob_type = &PyType_Type;
9068
 
      type_init = 1;
 
9752
#else
 
9753
      if (PyType_Ready(&varlink_type) < 0)
 
9754
      return NULL;
 
9755
#endif
9069
9756
    }
9070
9757
    return &varlink_type;
9071
9758
  }
9116
9803
    for (i = 0; constants[i].type; ++i) {
9117
9804
      switch(constants[i].type) {
9118
9805
      case SWIG_PY_POINTER:
9119
 
        obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
 
9806
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
9120
9807
        break;
9121
9808
      case SWIG_PY_BINARY:
9122
9809
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
9156
9843
          }
9157
9844
        }
9158
9845
        if (ci) {
9159
 
          size_t shift = (ci->ptype) - types;
9160
 
          swig_type_info *ty = types_initial[shift];
9161
 
          size_t ldoc = (c - methods[i].ml_doc);
9162
 
          size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
9163
 
          char *ndoc = (char*)malloc(ldoc + lptr + 10);
9164
 
          if (ndoc) {
9165
 
            char *buff = ndoc;
9166
 
            void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
9167
 
            if (ptr) {
 
9846
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
 
9847
          if (ptr) {
 
9848
            size_t shift = (ci->ptype) - types;
 
9849
            swig_type_info *ty = types_initial[shift];
 
9850
            size_t ldoc = (c - methods[i].ml_doc);
 
9851
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
 
9852
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
 
9853
            if (ndoc) {
 
9854
              char *buff = ndoc;
9168
9855
              strncpy(buff, methods[i].ml_doc, ldoc);
9169
9856
              buff += ldoc;
9170
9857
              strncpy(buff, "swig_ptr: ", 10);
9189
9876
#ifdef __cplusplus
9190
9877
extern "C"
9191
9878
#endif
9192
 
SWIGEXPORT void SWIG_init(void) {
9193
 
  PyObject *m, *d;
 
9879
 
 
9880
SWIGEXPORT 
 
9881
#if PY_VERSION_HEX >= 0x03000000
 
9882
PyObject*
 
9883
#else
 
9884
void
 
9885
#endif
 
9886
SWIG_init(void) {
 
9887
  PyObject *m, *d, *md;
 
9888
#if PY_VERSION_HEX >= 0x03000000
 
9889
  static struct PyModuleDef SWIG_module = {
 
9890
# if PY_VERSION_HEX >= 0x03020000
 
9891
    PyModuleDef_HEAD_INIT,
 
9892
# else
 
9893
    {
 
9894
      PyObject_HEAD_INIT(NULL)
 
9895
      NULL, /* m_init */
 
9896
      0,    /* m_index */
 
9897
      NULL, /* m_copy */
 
9898
    },
 
9899
# endif
 
9900
    (char *) SWIG_name,
 
9901
    NULL,
 
9902
    -1,
 
9903
    SwigMethods,
 
9904
    NULL,
 
9905
    NULL,
 
9906
    NULL,
 
9907
    NULL
 
9908
  };
 
9909
#endif
 
9910
  
 
9911
#if defined(SWIGPYTHON_BUILTIN)
 
9912
  static SwigPyClientData SwigPyObject_clientdata = {
 
9913
    0, 0, 0, 0, 0, 0, 0
 
9914
  };
 
9915
  static PyGetSetDef this_getset_def = {
 
9916
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
 
9917
  };
 
9918
  static SwigPyGetSet thisown_getset_closure = {
 
9919
    (PyCFunction) SwigPyObject_own,
 
9920
    (PyCFunction) SwigPyObject_own
 
9921
  };
 
9922
  static PyGetSetDef thisown_getset_def = {
 
9923
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
 
9924
  };
 
9925
  PyObject *metatype_args;
 
9926
  PyTypeObject *builtin_pytype;
 
9927
  int builtin_base_count;
 
9928
  swig_type_info *builtin_basetype;
 
9929
  PyObject *tuple;
 
9930
  PyGetSetDescrObject *static_getset;
 
9931
  PyTypeObject *metatype;
 
9932
  SwigPyClientData *cd;
 
9933
  PyObject *public_interface, *public_symbol;
 
9934
  PyObject *this_descr;
 
9935
  PyObject *thisown_descr;
 
9936
  int i;
 
9937
  
 
9938
  (void)builtin_pytype;
 
9939
  (void)builtin_base_count;
 
9940
  (void)builtin_basetype;
 
9941
  (void)tuple;
 
9942
  (void)static_getset;
 
9943
  
 
9944
  /* metatype is used to implement static member variables. */
 
9945
  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
 
9946
  assert(metatype_args);
 
9947
  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
 
9948
  assert(metatype);
 
9949
  Py_DECREF(metatype_args);
 
9950
  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
 
9951
  assert(PyType_Ready(metatype) >= 0);
 
9952
#endif
9194
9953
  
9195
9954
  /* Fix SwigMethods to carry the callback ptrs when needed */
9196
9955
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
9197
9956
  
 
9957
#if PY_VERSION_HEX >= 0x03000000
 
9958
  m = PyModule_Create(&SWIG_module);
 
9959
#else
9198
9960
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
9199
 
  d = PyModule_GetDict(m);
 
9961
#endif
 
9962
  md = d = PyModule_GetDict(m);
9200
9963
  
9201
9964
  SWIG_InitializeModule(0);
 
9965
  
 
9966
#ifdef SWIGPYTHON_BUILTIN
 
9967
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
 
9968
  assert(SwigPyObject_stype);
 
9969
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
 
9970
  if (!cd) {
 
9971
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
 
9972
    SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
 
9973
  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
 
9974
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
 
9975
# if PY_VERSION_HEX >= 0x03000000
 
9976
    return NULL;
 
9977
# else
 
9978
    return;
 
9979
# endif
 
9980
  }
 
9981
  
 
9982
  /* All objects have a 'this' attribute */
 
9983
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
 
9984
  (void)this_descr;
 
9985
  
 
9986
  /* All objects have a 'thisown' attribute */
 
9987
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
 
9988
  (void)thisown_descr;
 
9989
  
 
9990
  public_interface = PyList_New(0);
 
9991
  public_symbol = 0;
 
9992
  (void)public_symbol;
 
9993
  
 
9994
  PyDict_SetItemString(md, "__all__", public_interface);
 
9995
  Py_DECREF(public_interface);
 
9996
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
 
9997
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
 
9998
  for (i = 0; swig_const_table[i].name != 0; ++i)
 
9999
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
 
10000
#endif
 
10001
  
9202
10002
  SWIG_InstallConstants(d,swig_const_table);
9203
10003
  
9204
 
  
 
10004
  SWIG_Python_SetConstant(d, "SVN_DELTA_COMPRESSION_LEVEL_NONE",SWIG_From_long((long)(0)));
 
10005
  SWIG_Python_SetConstant(d, "SVN_DELTA_COMPRESSION_LEVEL_MAX",SWIG_From_long((long)(9)));
 
10006
  SWIG_Python_SetConstant(d, "SVN_DELTA_COMPRESSION_LEVEL_DEFAULT",SWIG_From_long((long)(5)));
9205
10007
  SWIG_Python_SetConstant(d, "svn_txdelta_source",SWIG_From_long((long)(svn_txdelta_source)));
9206
10008
  SWIG_Python_SetConstant(d, "svn_txdelta_target",SWIG_From_long((long)(svn_txdelta_target)));
9207
10009
  SWIG_Python_SetConstant(d, "svn_txdelta_new",SWIG_From_long((long)(svn_txdelta_new)));
 
10010
#if PY_VERSION_HEX >= 0x03000000
 
10011
  return m;
 
10012
#else
 
10013
  return;
 
10014
#endif
9208
10015
}
9209
10016