source: nikanabo/current/xdelta/diy/xdelta3_wrap.c @ 185

Last change on this file since 185 was 185, checked in by geyser, 14 years ago
File size: 69.6 KB
Line 
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.25
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11#define SWIGPYTHON
12/***********************************************************************
13 *
14 *  This section contains generic SWIG labels for method/variable
15 *  declarations/attributes, and other compiler dependent labels.
16 *
17 ************************************************************************/
18
19/* template workaround for compilers that cannot correctly implement the C++ standard */
20#ifndef SWIGTEMPLATEDISAMBIGUATOR
21#  if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22#    define SWIGTEMPLATEDISAMBIGUATOR template
23#  else
24#    define SWIGTEMPLATEDISAMBIGUATOR
25#  endif
26#endif
27
28/* inline attribute */
29#ifndef SWIGINLINE
30# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
31#   define SWIGINLINE inline
32# else
33#   define SWIGINLINE
34# endif
35#endif
36
37/* attribute recognised by some compilers to avoid 'unused' warnings */
38#ifndef SWIGUNUSED
39# if defined(__GNUC__) || defined(__ICC)
40#   define SWIGUNUSED __attribute__ ((unused))
41# else
42#   define SWIGUNUSED
43# endif
44#endif
45
46/* internal SWIG method */
47#ifndef SWIGINTERN
48# define SWIGINTERN static SWIGUNUSED
49#endif
50
51/* internal inline SWIG method */
52#ifndef SWIGINTERNINLINE
53# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
54#endif
55
56/* exporting methods for Windows DLLs */
57#ifndef SWIGEXPORT
58# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
59#   if defined(STATIC_LINKED)
60#     define SWIGEXPORT
61#   else
62#     define SWIGEXPORT __declspec(dllexport)
63#   endif
64# else
65#   define SWIGEXPORT
66# endif
67#endif
68
69/* calling conventions for Windows */
70#ifndef SWIGSTDCALL
71# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
72#   define SWIGSTDCALL __stdcall
73# else
74#   define SWIGSTDCALL
75# endif
76#endif
77
78
79
80#include <Python.h>
81
82/***********************************************************************
83 * swigrun.swg
84 *
85 *     This file contains generic CAPI SWIG runtime support for pointer
86 *     type checking.
87 *
88 ************************************************************************/
89
90/* This should only be incremented when either the layout of swig_type_info changes,
91   or for whatever reason, the runtime changes incompatibly */
92#define SWIG_RUNTIME_VERSION "2"
93
94/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
95#ifdef SWIG_TYPE_TABLE
96# define SWIG_QUOTE_STRING(x) #x
97# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
98# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
99#else
100# define SWIG_TYPE_TABLE_NAME
101#endif
102
103/*
104  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
105  creating a static or dynamic library from the swig runtime code.
106  In 99.9% of the cases, swig just needs to declare them as 'static'.
107 
108  But only do this if is strictly necessary, ie, if you have problems
109  with your compiler or so.
110*/
111
112#ifndef SWIGRUNTIME
113# define SWIGRUNTIME SWIGINTERN
114#endif
115
116#ifndef SWIGRUNTIMEINLINE
117# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
118#endif
119
120#include <string.h>
121
122#ifdef __cplusplus
123extern "C" {
124#endif
125
126typedef void *(*swig_converter_func)(void *);
127typedef struct swig_type_info *(*swig_dycast_func)(void **);
128
129/* Structure to store inforomation on one type */
130typedef struct swig_type_info {
131  const char             *name;                 /* mangled name of this type */
132  const char             *str;                  /* human readable name of this type */
133  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
134  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
135  void                   *clientdata;           /* language specific type data */
136} swig_type_info;
137
138/* Structure to store a type and conversion function used for casting */
139typedef struct swig_cast_info {
140  swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
141  swig_converter_func     converter;            /* function to cast the void pointers */
142  struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
143  struct swig_cast_info  *prev;                 /* pointer to the previous cast */
144} swig_cast_info;
145
146/* Structure used to store module information
147 * Each module generates one structure like this, and the runtime collects
148 * all of these structures and stores them in a circularly linked list.*/
149typedef struct swig_module_info {
150  swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
151  size_t                 size;                  /* Number of types in this module */
152  struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
153  swig_type_info         **type_initial;        /* Array of initially generated type structures */
154  swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
155  void                    *clientdata;          /* Language specific module data */
156} swig_module_info;
157
158
159/*
160  Compare two type names skipping the space characters, therefore
161  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
162
163  Return 0 when the two name types are equivalent, as in
164  strncmp, but skipping ' '.
165*/
166SWIGRUNTIME int
167SWIG_TypeNameComp(const char *f1, const char *l1,
168                  const char *f2, const char *l2) {
169  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
170    while ((*f1 == ' ') && (f1 != l1)) ++f1;
171    while ((*f2 == ' ') && (f2 != l2)) ++f2;
172    if (*f1 != *f2) return (int)(*f1 - *f2);
173  }
174  return (l1 - f1) - (l2 - f2);
175}
176
177/*
178  Check type equivalence in a name list like <name1>|<name2>|...
179  Return 0 if not equal, 1 if equal
180*/
181SWIGRUNTIME int
182SWIG_TypeEquiv(const char *nb, const char *tb) {
183  int equiv = 0;
184  const char* te = tb + strlen(tb);
185  const char* ne = nb;
186  while (!equiv && *ne) {
187    for (nb = ne; *ne; ++ne) {
188      if (*ne == '|') break;
189    }
190    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
191    if (*ne) ++ne;
192  }
193  return equiv;
194}
195
196/*
197  Check type equivalence in a name list like <name1>|<name2>|...
198  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
199*/
200SWIGRUNTIME int
201SWIG_TypeCompare(const char *nb, const char *tb) {
202  int equiv = 0;
203  const char* te = tb + strlen(tb);
204  const char* ne = nb;
205  while (!equiv && *ne) {
206    for (nb = ne; *ne; ++ne) {
207      if (*ne == '|') break;
208    }
209    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
210    if (*ne) ++ne;
211  }
212  return equiv;
213}
214
215
216/* think of this as a c++ template<> or a scheme macro */
217#define SWIG_TypeCheck_Template(comparison, ty)         \
218  if (ty) {                                             \
219    swig_cast_info *iter = ty->cast;                    \
220    while (iter) {                                      \
221      if (comparison) {                                 \
222        if (iter == ty->cast) return iter;              \
223        /* Move iter to the top of the linked list */   \
224        iter->prev->next = iter->next;                  \
225        if (iter->next)                                 \
226          iter->next->prev = iter->prev;                \
227        iter->next = ty->cast;                          \
228        iter->prev = 0;                                 \
229        if (ty->cast) ty->cast->prev = iter;            \
230        ty->cast = iter;                                \
231        return iter;                                    \
232      }                                                 \
233      iter = iter->next;                                \
234    }                                                   \
235  }                                                     \
236  return 0
237
238/*
239  Check the typename
240*/
241SWIGRUNTIME swig_cast_info *
242SWIG_TypeCheck(const char *c, swig_type_info *ty) {
243  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
244}
245
246/* Same as previous function, except strcmp is replaced with a pointer comparison */
247SWIGRUNTIME swig_cast_info *
248SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
249  SWIG_TypeCheck_Template(iter->type == from, into);
250}
251
252/*
253  Cast a pointer up an inheritance hierarchy
254*/
255SWIGRUNTIMEINLINE void *
256SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
257  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
258}
259
260/*
261   Dynamic pointer casting. Down an inheritance hierarchy
262*/
263SWIGRUNTIME swig_type_info *
264SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
265  swig_type_info *lastty = ty;
266  if (!ty || !ty->dcast) return ty;
267  while (ty && (ty->dcast)) {
268    ty = (*ty->dcast)(ptr);
269    if (ty) lastty = ty;
270  }
271  return lastty;
272}
273
274/*
275  Return the name associated with this type
276*/
277SWIGRUNTIMEINLINE const char *
278SWIG_TypeName(const swig_type_info *ty) {
279  return ty->name;
280}
281
282/*
283  Return the pretty name associated with this type,
284  that is an unmangled type name in a form presentable to the user.
285*/
286SWIGRUNTIME const char *
287SWIG_TypePrettyName(const swig_type_info *type) {
288  /* The "str" field contains the equivalent pretty names of the
289     type, separated by vertical-bar characters.  We choose
290     to print the last name, as it is often (?) the most
291     specific. */
292  if (type->str != NULL) {
293    const char *last_name = type->str;
294    const char *s;
295    for (s = type->str; *s; s++)
296      if (*s == '|') last_name = s+1;
297    return last_name;
298  }
299  else
300    return type->name;
301}
302
303/*
304   Set the clientdata field for a type
305*/
306SWIGRUNTIME void
307SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
308  if (!ti->clientdata) {
309    swig_cast_info *cast = ti->cast;
310    /* if (ti->clientdata == clientdata) return; */
311    ti->clientdata = clientdata;
312   
313    while (cast) {
314      if (!cast->converter)
315        SWIG_TypeClientData(cast->type, clientdata);
316      cast = cast->next;
317    }
318  }
319}
320
321/*
322  Search for a swig_type_info structure only by mangled name
323  Search is a O(log #types)
324 
325  We start searching at module start, and finish searching when start == end. 
326  Note: if start == end at the beginning of the function, we go all the way around
327  the circular list.
328*/
329SWIGRUNTIME swig_type_info *
330SWIG_MangledTypeQueryModule(swig_module_info *start, 
331                            swig_module_info *end, 
332                            const char *name) {
333  swig_module_info *iter = start;
334  do {
335    if (iter->size) {
336      register size_t l = 0;
337      register size_t r = iter->size - 1;
338      do {
339        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
340        register size_t i = (l + r) >> 1; 
341        const char *iname = iter->types[i]->name;
342        if (iname) {
343          register int compare = strcmp(name, iname);
344          if (compare == 0) {       
345            return iter->types[i];
346          } else if (compare < 0) {
347            if (i) {
348              r = i - 1;
349            } else {
350              break;
351            }
352          } else if (compare > 0) {
353            l = i + 1;
354          }
355        } else {
356          break; /* should never happen */
357        }
358      } while (l <= r);
359    }
360    iter = iter->next;
361  } while (iter != end);
362  return 0;
363}
364
365/*
366  Search for a swig_type_info structure for either a mangled name or a human readable name.
367  It first searches the mangled names of the types, which is a O(log #types)
368  If a type is not found it then searches the human readable names, which is O(#types).
369 
370  We start searching at module start, and finish searching when start == end. 
371  Note: if start == end at the beginning of the function, we go all the way around
372  the circular list.
373*/
374SWIGRUNTIME swig_type_info *
375SWIG_TypeQueryModule(swig_module_info *start, 
376                     swig_module_info *end, 
377                     const char *name) {
378  /* STEP 1: Search the name field using binary search */
379  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
380  if (ret) {
381    return ret;
382  } else {
383    /* STEP 2: If the type hasn't been found, do a complete search
384       of the str field (the human readable name) */
385    swig_module_info *iter = start;
386    do {
387      register size_t i = 0;
388      for (; i < iter->size; ++i) {
389        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
390          return iter->types[i];
391      }
392      iter = iter->next;
393    } while (iter != end);
394  }
395 
396  /* neither found a match */
397  return 0;
398}
399
400
401/*
402   Pack binary data into a string
403*/
404SWIGRUNTIME char *
405SWIG_PackData(char *c, void *ptr, size_t sz) {
406  static const char hex[17] = "0123456789abcdef";
407  register const unsigned char *u = (unsigned char *) ptr;
408  register const unsigned char *eu =  u + sz;
409  for (; u != eu; ++u) {
410    register unsigned char uu = *u;
411    *(c++) = hex[(uu & 0xf0) >> 4];
412    *(c++) = hex[uu & 0xf];
413  }
414  return c;
415}
416
417/*
418   Unpack binary data from a string
419*/
420SWIGRUNTIME const char *
421SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
422  register unsigned char *u = (unsigned char *) ptr;
423  register const unsigned char *eu = u + sz;
424  for (; u != eu; ++u) {
425    register char d = *(c++);
426    register unsigned char uu = 0;
427    if ((d >= '0') && (d <= '9'))
428      uu = ((d - '0') << 4);
429    else if ((d >= 'a') && (d <= 'f'))
430      uu = ((d - ('a'-10)) << 4);
431    else 
432      return (char *) 0;
433    d = *(c++);
434    if ((d >= '0') && (d <= '9'))
435      uu |= (d - '0');
436    else if ((d >= 'a') && (d <= 'f'))
437      uu |= (d - ('a'-10));
438    else 
439      return (char *) 0;
440    *u = uu;
441  }
442  return c;
443}
444
445/*
446   Pack 'void *' into a string buffer.
447*/
448SWIGRUNTIME char *
449SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
450  char *r = buff;
451  if ((2*sizeof(void *) + 2) > bsz) return 0;
452  *(r++) = '_';
453  r = SWIG_PackData(r,&ptr,sizeof(void *));
454  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
455  strcpy(r,name);
456  return buff;
457}
458
459SWIGRUNTIME const char *
460SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
461  if (*c != '_') {
462    if (strcmp(c,"NULL") == 0) {
463      *ptr = (void *) 0;
464      return name;
465    } else {
466      return 0;
467    }
468  }
469  return SWIG_UnpackData(++c,ptr,sizeof(void *));
470}
471
472SWIGRUNTIME char *
473SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
474  char *r = buff;
475  size_t lname = (name ? strlen(name) : 0);
476  if ((2*sz + 2 + lname) > bsz) return 0;
477  *(r++) = '_';
478  r = SWIG_PackData(r,ptr,sz);
479  if (lname) {
480    strncpy(r,name,lname+1);
481  } else {
482    *r = 0;
483  }
484  return buff;
485}
486
487SWIGRUNTIME const char *
488SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
489  if (*c != '_') {
490    if (strcmp(c,"NULL") == 0) {
491      memset(ptr,0,sz);
492      return name;
493    } else {
494      return 0;
495    }
496  }
497  return SWIG_UnpackData(++c,ptr,sz);
498}
499
500#ifdef __cplusplus
501}
502#endif
503
504/* -----------------------------------------------------------------------------
505 * SWIG API. Portion that goes into the runtime
506 * ----------------------------------------------------------------------------- */
507
508#ifdef __cplusplus
509extern "C" {
510#endif
511
512/* -----------------------------------------------------------------------------
513 * for internal method declarations
514 * ----------------------------------------------------------------------------- */
515
516#ifndef SWIGINTERN
517#  define SWIGINTERN static SWIGUNUSED
518#endif
519
520#ifndef SWIGINTERNINLINE
521#  define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
522#endif
523
524/*
525  Exception handling in wrappers
526*/
527#define SWIG_fail                goto fail
528#define SWIG_arg_fail(arg)       SWIG_Python_ArgFail(arg)
529#define SWIG_append_errmsg(msg)   SWIG_Python_AddErrMesg(msg,0)
530#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
531#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
532#define SWIG_null_ref(type)       SWIG_Python_NullRef(type)
533
534/*
535  Contract support
536*/
537#define SWIG_contract_assert(expr, msg) \
538 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
539
540/* -----------------------------------------------------------------------------
541 * Constant declarations
542 * ----------------------------------------------------------------------------- */
543
544/* Constant Types */
545#define SWIG_PY_INT     1
546#define SWIG_PY_FLOAT   2
547#define SWIG_PY_STRING  3
548#define SWIG_PY_POINTER 4
549#define SWIG_PY_BINARY  5
550
551/* Constant information structure */
552typedef struct swig_const_info {
553    int type;
554    char *name;
555    long lvalue;
556    double dvalue;
557    void   *pvalue;
558    swig_type_info **ptype;
559} swig_const_info;
560
561
562/* -----------------------------------------------------------------------------
563 * Alloc. memory flags
564 * ----------------------------------------------------------------------------- */
565#define SWIG_OLDOBJ  1
566#define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
567#define SWIG_PYSTR   SWIG_NEWOBJ + 1
568
569#ifdef __cplusplus
570}
571#endif
572
573
574/***********************************************************************
575 * pyrun.swg
576 *
577 *     This file contains the runtime support for Python modules
578 *     and includes code for managing global variables and pointer
579 *     type checking.
580 *
581 * Author : David Beazley (beazley@cs.uchicago.edu)
582 ************************************************************************/
583
584/* Common SWIG API */
585#define SWIG_ConvertPtr(obj, pp, type, flags)    SWIG_Python_ConvertPtr(obj, pp, type, flags)
586#define SWIG_NewPointerObj(p, type, flags)       SWIG_Python_NewPointerObj(p, type, flags)
587#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
588 
589
590/* Python-specific SWIG API */
591#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags)   SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
592#define SWIG_NewPackedObj(ptr, sz, type)              SWIG_Python_NewPackedObj(ptr, sz, type)
593
594/* Runtime API */
595#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
596#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
597
598/* -----------------------------------------------------------------------------
599 * Pointer declarations
600 * ----------------------------------------------------------------------------- */
601/*
602  Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
603  C/C++ pointers in the python side. Very useful for debugging, but
604  not always safe.
605*/
606#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
607#  define SWIG_COBJECT_TYPES
608#endif
609
610/* Flags for pointer conversion */
611#define SWIG_POINTER_EXCEPTION     0x1
612#define SWIG_POINTER_DISOWN        0x2
613
614
615/* Add PyOS_snprintf for old Pythons */
616#if PY_VERSION_HEX < 0x02020000
617#define PyOS_snprintf snprintf
618#endif
619
620#ifdef __cplusplus
621extern "C" {
622#endif
623
624/* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627#ifndef SWIG_BUFFER_SIZE
628#define SWIG_BUFFER_SIZE 1024
629#endif
630
631#if defined(SWIG_COBJECT_TYPES)
632#if !defined(SWIG_COBJECT_PYTHON)
633/* -----------------------------------------------------------------------------
634 * Implements a simple Swig Object type, and use it instead of PyCObject
635 * ----------------------------------------------------------------------------- */
636
637typedef struct {
638  PyObject_HEAD
639  void *ptr;
640  const char *desc;
641} PySwigObject;
642
643/* Declarations for objects of type PySwigObject */
644
645SWIGRUNTIME int
646PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
647{
648  char result[SWIG_BUFFER_SIZE];
649  flags = flags;
650  if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651    fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652    return 0; 
653  } else {
654    return 1; 
655  }
656}
657 
658SWIGRUNTIME PyObject *
659PySwigObject_repr(PySwigObject *v)
660{
661  char result[SWIG_BUFFER_SIZE];
662  return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663    PyString_FromFormat("<Swig Object at %s>", result) : 0;
664}
665
666SWIGRUNTIME PyObject *
667PySwigObject_str(PySwigObject *v)
668{
669  char result[SWIG_BUFFER_SIZE];
670  return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671    PyString_FromString(result) : 0;
672}
673
674SWIGRUNTIME PyObject *
675PySwigObject_long(PySwigObject *v)
676{
677  return PyLong_FromVoidPtr(v->ptr);
678}
679
680SWIGRUNTIME PyObject *
681PySwigObject_format(const char* fmt, PySwigObject *v)
682{
683  PyObject *res = NULL;
684  PyObject *args = PyTuple_New(1);
685  if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
686    PyObject *ofmt = PyString_FromString(fmt);
687    if (ofmt) {
688      res = PyString_Format(ofmt,args);
689      Py_DECREF(ofmt);
690    }
691    Py_DECREF(args);
692  } 
693  return res;
694}
695
696SWIGRUNTIME PyObject *
697PySwigObject_oct(PySwigObject *v)
698{
699  return PySwigObject_format("%o",v);
700}
701
702SWIGRUNTIME PyObject *
703PySwigObject_hex(PySwigObject *v)
704{
705  return PySwigObject_format("%x",v);
706}
707
708SWIGRUNTIME int
709PySwigObject_compare(PySwigObject *v, PySwigObject *w)
710{
711  int c = strcmp(v->desc, w->desc);
712  if (c) {
713    return (c > 0) ? 1 : -1;
714  } else {
715    void *i = v->ptr;
716    void *j = w->ptr;
717    return (i < j) ? -1 : ((i > j) ? 1 : 0);
718  }
719}
720
721SWIGRUNTIME void
722PySwigObject_dealloc(PySwigObject *self)
723{
724  PyObject_DEL(self);
725}
726
727SWIGRUNTIME PyTypeObject*
728PySwigObject_type(void) {
729  static char pyswigobject_type__doc__[] = 
730    "Swig object carries a C/C++ instance pointer";
731 
732  static PyNumberMethods PySwigObject_as_number = {
733    (binaryfunc)0, /*nb_add*/
734    (binaryfunc)0, /*nb_subtract*/
735    (binaryfunc)0, /*nb_multiply*/
736    (binaryfunc)0, /*nb_divide*/
737    (binaryfunc)0, /*nb_remainder*/
738    (binaryfunc)0, /*nb_divmod*/
739    (ternaryfunc)0,/*nb_power*/
740    (unaryfunc)0,  /*nb_negative*/
741    (unaryfunc)0,  /*nb_positive*/
742    (unaryfunc)0,  /*nb_absolute*/
743    (inquiry)0,    /*nb_nonzero*/
744    0,             /*nb_invert*/
745    0,             /*nb_lshift*/
746    0,             /*nb_rshift*/
747    0,             /*nb_and*/
748    0,             /*nb_xor*/
749    0,             /*nb_or*/
750    (coercion)0,   /*nb_coerce*/
751    (unaryfunc)PySwigObject_long, /*nb_int*/
752    (unaryfunc)PySwigObject_long, /*nb_long*/
753    (unaryfunc)0,                 /*nb_float*/
754    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
755    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
756#if PY_VERSION_HEX >= 0x02000000
757    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
758#endif
759  };
760
761  static PyTypeObject pyswigobject_type
762#if !defined(__cplusplus)
763  ; 
764  static int type_init = 0;
765  if (!type_init) {
766    PyTypeObject tmp
767#endif
768    = {
769    PyObject_HEAD_INIT(&PyType_Type)
770    0,                                  /*ob_size*/
771    (char *)"PySwigObject",             /*tp_name*/
772    sizeof(PySwigObject),               /*tp_basicsize*/
773    0,                                  /*tp_itemsize*/
774    /* methods */
775    (destructor)PySwigObject_dealloc,   /*tp_dealloc*/
776    (printfunc)PySwigObject_print,      /*tp_print*/
777    (getattrfunc)0,                     /*tp_getattr*/
778    (setattrfunc)0,                     /*tp_setattr*/
779    (cmpfunc)PySwigObject_compare,      /*tp_compare*/
780    (reprfunc)PySwigObject_repr,        /*tp_repr*/
781    &PySwigObject_as_number,            /*tp_as_number*/
782    0,                                  /*tp_as_sequence*/
783    0,                                  /*tp_as_mapping*/
784    (hashfunc)0,                        /*tp_hash*/
785    (ternaryfunc)0,                     /*tp_call*/
786    (reprfunc)PySwigObject_str,         /*tp_str*/
787    /* Space for future expansion */
788    0,0,0,0,
789    pyswigobject_type__doc__,           /* Documentation string */
790#if PY_VERSION_HEX >= 0x02000000
791    0,                                  /* tp_traverse */
792    0,                                  /* tp_clear */
793#endif
794#if PY_VERSION_HEX >= 0x02010000
795    0,                                  /* tp_richcompare */
796    0,                                  /* tp_weaklistoffset */
797#endif
798#if PY_VERSION_HEX >= 0x02020000
799    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
800#endif
801#if PY_VERSION_HEX >= 0x02030000
802    0,                                  /* tp_del */
803#endif
804#ifdef COUNT_ALLOCS
805    0,0,0,0                             /* tp_alloc -> tp_next */
806#endif
807    };
808#if !defined(__cplusplus)
809    pyswigobject_type = tmp;
810    type_init = 1;
811  }
812#endif
813  return &pyswigobject_type;
814}
815
816SWIGRUNTIME PyObject *
817PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
818{
819  PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
820  if (self) {
821    self->ptr = ptr;
822    self->desc = desc;
823  }
824  return (PyObject *)self;
825}
826
827SWIGRUNTIMEINLINE void *
828PySwigObject_AsVoidPtr(PyObject *self)
829{
830  return ((PySwigObject *)self)->ptr;
831}
832
833SWIGRUNTIMEINLINE const char *
834PySwigObject_GetDesc(PyObject *self)
835{
836  return ((PySwigObject *)self)->desc;
837}
838
839SWIGRUNTIMEINLINE int
840PySwigObject_Check(PyObject *op) {
841  return ((op)->ob_type == PySwigObject_type()) 
842    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
843}
844
845/* -----------------------------------------------------------------------------
846 * Implements a simple Swig Packed type, and use it instead of string
847 * ----------------------------------------------------------------------------- */
848
849typedef struct {
850  PyObject_HEAD
851  void *pack;
852  const char *desc;
853  size_t size;
854} PySwigPacked;
855
856SWIGRUNTIME int
857PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
858{
859  char result[SWIG_BUFFER_SIZE];
860  flags = flags;
861  fputs("<Swig Packed ", fp); 
862  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863    fputs("at ", fp); 
864    fputs(result, fp); 
865  }
866  fputs(v->desc,fp); 
867  fputs(">", fp);
868  return 0; 
869}
870 
871SWIGRUNTIME PyObject *
872PySwigPacked_repr(PySwigPacked *v)
873{
874  char result[SWIG_BUFFER_SIZE];
875  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
876    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
877  } else {
878    return PyString_FromFormat("<Swig Packed %s>", v->desc);
879  } 
880}
881
882SWIGRUNTIME PyObject *
883PySwigPacked_str(PySwigPacked *v)
884{
885  char result[SWIG_BUFFER_SIZE];
886  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
887    return PyString_FromFormat("%s%s", result, v->desc);
888  } else {
889    return PyString_FromFormat("%s", v->desc);
890  } 
891}
892
893SWIGRUNTIME int
894PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
895{
896  int c = strcmp(v->desc, w->desc);
897  if (c) {
898    return (c > 0) ? 1 : -1;
899  } else {
900    size_t i = v->size;
901    size_t j = w->size;
902    int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
903    return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
904  }
905}
906
907SWIGRUNTIME void
908PySwigPacked_dealloc(PySwigPacked *self)
909{
910  free(self->pack);
911  PyObject_DEL(self);
912}
913
914SWIGRUNTIME PyTypeObject*
915PySwigPacked_type(void) {
916  static char pyswigpacked_type__doc__[] = 
917    "Swig object carries a C/C++ instance pointer";
918  static PyTypeObject pyswigpacked_type
919#if !defined(__cplusplus)
920  ;
921  static int type_init = 0; 
922  if (!type_init) {
923    PyTypeObject tmp
924#endif
925    = {
926    PyObject_HEAD_INIT(&PyType_Type)
927    0,                                  /*ob_size*/
928    (char *)"PySwigPacked",             /*tp_name*/
929    sizeof(PySwigPacked),               /*tp_basicsize*/
930    0,                                  /*tp_itemsize*/
931    /* methods */
932    (destructor)PySwigPacked_dealloc,   /*tp_dealloc*/
933    (printfunc)PySwigPacked_print,      /*tp_print*/
934    (getattrfunc)0,                     /*tp_getattr*/
935    (setattrfunc)0,                     /*tp_setattr*/
936    (cmpfunc)PySwigPacked_compare,      /*tp_compare*/
937    (reprfunc)PySwigPacked_repr,        /*tp_repr*/
938    0,                                  /*tp_as_number*/
939    0,                                  /*tp_as_sequence*/
940    0,                                  /*tp_as_mapping*/
941    (hashfunc)0,                        /*tp_hash*/
942    (ternaryfunc)0,                     /*tp_call*/
943    (reprfunc)PySwigPacked_str,         /*tp_str*/
944    /* Space for future expansion */
945    0,0,0,0,
946    pyswigpacked_type__doc__,           /* Documentation string */
947#if PY_VERSION_HEX >= 0x02000000
948    0,                                  /* tp_traverse */
949    0,                                  /* tp_clear */
950#endif
951#if PY_VERSION_HEX >= 0x02010000
952    0,                                  /* tp_richcompare */
953    0,                                  /* tp_weaklistoffset */
954#endif
955#if PY_VERSION_HEX >= 0x02020000         
956    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
957#endif
958#if PY_VERSION_HEX >= 0x02030000
959    0,                                  /* tp_del */
960#endif
961#ifdef COUNT_ALLOCS
962    0,0,0,0                             /* tp_alloc -> tp_next */
963#endif
964    };
965#if !defined(__cplusplus)
966    pyswigpacked_type = tmp;
967    type_init = 1;
968  }
969#endif
970  return &pyswigpacked_type;
971}
972
973SWIGRUNTIME PyObject *
974PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
975{
976  PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
977  if (self == NULL) {
978    return NULL;
979  } else {
980    void *pack = malloc(size);
981    if (pack) {
982      memcpy(pack, ptr, size);
983      self->pack = pack;
984      self->desc = desc;
985      self->size = size;
986      return (PyObject *) self;
987    }
988    return NULL;
989  }
990}
991
992SWIGRUNTIMEINLINE const char *
993PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
994{
995  PySwigPacked *self = (PySwigPacked *)obj;
996  if (self->size != size) return 0;
997  memcpy(ptr, self->pack, size);
998  return self->desc;
999}
1000
1001SWIGRUNTIMEINLINE const char *
1002PySwigPacked_GetDesc(PyObject *self)
1003{
1004  return ((PySwigPacked *)self)->desc;
1005}
1006
1007SWIGRUNTIMEINLINE int
1008PySwigPacked_Check(PyObject *op) {
1009  return ((op)->ob_type == PySwigPacked_type()) 
1010    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1011}
1012
1013#else
1014/* -----------------------------------------------------------------------------
1015 * Use the old Python PyCObject instead of PySwigObject
1016 * ----------------------------------------------------------------------------- */
1017
1018#define PySwigObject_GetDesc(obj)                  PyCObject_GetDesc(obj)
1019#define PySwigObject_Check(obj)            PyCObject_Check(obj)
1020#define PySwigObject_AsVoidPtr(obj)        PyCObject_AsVoidPtr(obj)
1021#define PySwigObject_FromVoidPtrAndDesc(p, d)  PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1022
1023#endif
1024
1025#endif
1026
1027/* -----------------------------------------------------------------------------
1028 * errors manipulation
1029 * ----------------------------------------------------------------------------- */
1030
1031SWIGRUNTIME void
1032SWIG_Python_TypeError(const char *type, PyObject *obj)
1033{
1034  if (type) {
1035#if defined(SWIG_COBJECT_TYPES)
1036    if (obj && PySwigObject_Check(obj)) {
1037      const char *otype = (const char *) PySwigObject_GetDesc(obj);
1038      if (otype) {
1039        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1040                     type, otype);
1041        return;
1042      }
1043    } else 
1044#endif     
1045    {
1046      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
1047      if (otype) {
1048        PyObject *str = PyObject_Str(obj);
1049        const char *cstr = str ? PyString_AsString(str) : 0;
1050        if (cstr) {
1051          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1052                       type, otype, cstr);
1053        } else {
1054          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1055                       type, otype);
1056        }
1057        Py_XDECREF(str);
1058        return;
1059      }
1060    }   
1061    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1062  } else {
1063    PyErr_Format(PyExc_TypeError, "unexpected type is received");
1064  }
1065}
1066
1067SWIGRUNTIMEINLINE void
1068SWIG_Python_NullRef(const char *type)
1069{
1070  if (type) {
1071    PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1072  } else {
1073    PyErr_Format(PyExc_TypeError, "null reference was received");
1074  }
1075}
1076
1077SWIGRUNTIME int
1078SWIG_Python_AddErrMesg(const char* mesg, int infront)
1079{
1080  if (PyErr_Occurred()) {
1081    PyObject *type = 0;
1082    PyObject *value = 0;
1083    PyObject *traceback = 0;
1084    PyErr_Fetch(&type, &value, &traceback);
1085    if (value) {
1086      PyObject *old_str = PyObject_Str(value);
1087      Py_XINCREF(type);
1088      PyErr_Clear();
1089      if (infront) {
1090        PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1091      } else {
1092        PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1093      }
1094      Py_DECREF(old_str);
1095    }
1096    return 1;
1097  } else {
1098    return 0;
1099  }
1100}
1101
1102SWIGRUNTIME int
1103SWIG_Python_ArgFail(int argnum)
1104{
1105  if (PyErr_Occurred()) {
1106    /* add information about failing argument */
1107    char mesg[256];
1108    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1109    return SWIG_Python_AddErrMesg(mesg, 1);
1110  } else {
1111    return 0;
1112  }
1113}
1114
1115
1116/* -----------------------------------------------------------------------------
1117 * pointers/data manipulation
1118 * ----------------------------------------------------------------------------- */
1119
1120/* Convert a pointer value */
1121SWIGRUNTIME int
1122SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1123  swig_cast_info *tc;
1124  const char *c = 0;
1125  static PyObject *SWIG_this = 0;
1126  int    newref = 0;
1127  PyObject  *pyobj = 0;
1128  void *vptr;
1129 
1130  if (!obj) return 0;
1131  if (obj == Py_None) {
1132    *ptr = 0;
1133    return 0;
1134  }
1135
1136#ifdef SWIG_COBJECT_TYPES
1137  if (!(PySwigObject_Check(obj))) {
1138    if (!SWIG_this)
1139      SWIG_this = PyString_FromString("this");
1140    pyobj = obj;
1141    obj = PyObject_GetAttr(obj,SWIG_this);
1142    newref = 1;
1143    if (!obj) goto type_error;
1144    if (!PySwigObject_Check(obj)) {
1145      Py_DECREF(obj);
1146      goto type_error;
1147    }
1148  } 
1149  vptr = PySwigObject_AsVoidPtr(obj);
1150  c = (const char *) PySwigObject_GetDesc(obj);
1151  if (newref) { Py_DECREF(obj); }
1152  goto type_check;
1153#else
1154  if (!(PyString_Check(obj))) {
1155    if (!SWIG_this)
1156      SWIG_this = PyString_FromString("this");
1157    pyobj = obj;
1158    obj = PyObject_GetAttr(obj,SWIG_this);
1159    newref = 1;
1160    if (!obj) goto type_error;
1161    if (!PyString_Check(obj)) {
1162      Py_DECREF(obj);
1163      goto type_error;
1164    }
1165  } 
1166  c = PyString_AS_STRING(obj);
1167  /* Pointer values must start with leading underscore */
1168  c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1169  if (newref) { Py_DECREF(obj); }
1170  if (!c) goto type_error;
1171#endif
1172
1173type_check:
1174  if (ty) {
1175    tc = SWIG_TypeCheck(c,ty);
1176    if (!tc) goto type_error;
1177    *ptr = SWIG_TypeCast(tc,vptr);
1178  } else {
1179    *ptr = vptr;
1180  }
1181  if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1182    PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1183  }
1184  return 0;
1185
1186type_error:
1187  PyErr_Clear();
1188  if (pyobj && !obj) {   
1189    obj = pyobj;
1190    if (PyCFunction_Check(obj)) {
1191      /* here we get the method pointer for callbacks */
1192      char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1193      c = doc ? strstr(doc, "swig_ptr: ") : 0;
1194      if (c) {
1195        c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1196        if (!c) goto type_error;
1197        goto type_check;
1198      }
1199    }
1200  }
1201  if (flags & SWIG_POINTER_EXCEPTION) {
1202    if (ty) {
1203      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204    } else {
1205      SWIG_Python_TypeError("C/C++ pointer", obj);
1206    }
1207  }
1208  return -1;
1209}
1210
1211/* Convert a pointer value, signal an exception on a type mismatch */
1212SWIGRUNTIME void *
1213SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1214  void *result;
1215  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1216    PyErr_Clear();
1217    if (flags & SWIG_POINTER_EXCEPTION) {
1218      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1219      SWIG_Python_ArgFail(argnum);
1220    }
1221  }
1222  return result;
1223}
1224
1225/* Convert a packed value value */
1226SWIGRUNTIME int
1227SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1228  swig_cast_info *tc;
1229  const char *c = 0;
1230
1231#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1232  c = PySwigPacked_UnpackData(obj, ptr, sz);
1233#else
1234  if ((!obj) || (!PyString_Check(obj))) goto type_error;
1235  c = PyString_AS_STRING(obj);
1236  /* Pointer values must start with leading underscore */
1237  c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1238#endif
1239  if (!c) goto type_error;
1240  if (ty) {
1241    tc = SWIG_TypeCheck(c,ty);
1242    if (!tc) goto type_error;
1243  }
1244  return 0;
1245
1246type_error:
1247  PyErr_Clear();
1248  if (flags & SWIG_POINTER_EXCEPTION) {
1249    if (ty) {
1250      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1251    } else {
1252      SWIG_Python_TypeError("C/C++ packed data", obj);
1253    }
1254  }
1255  return -1;
1256} 
1257
1258/* Create a new array object */
1259SWIGRUNTIME PyObject *
1260SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1261  PyObject *robj = 0;
1262  if (!type) {
1263    if (!PyErr_Occurred()) {
1264      PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1265    }
1266    return robj;
1267  }
1268  if (!ptr) {
1269    Py_INCREF(Py_None);
1270    return Py_None;
1271  }
1272#ifdef SWIG_COBJECT_TYPES
1273  robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1274#else
1275  {
1276    char result[SWIG_BUFFER_SIZE];
1277    robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1278      PyString_FromString(result) : 0;
1279  }
1280#endif
1281  if (!robj || (robj == Py_None)) return robj;
1282  if (type->clientdata) {
1283    PyObject *inst;
1284    PyObject *args = Py_BuildValue((char*)"(O)", robj);
1285    Py_DECREF(robj);
1286    inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1287    Py_DECREF(args);
1288    if (inst) {
1289      if (own) {
1290        PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1291      }
1292      robj = inst;
1293    }
1294  }
1295  return robj;
1296}
1297
1298SWIGRUNTIME PyObject *
1299SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1300  PyObject *robj = 0;
1301  if (!ptr) {
1302    Py_INCREF(Py_None);
1303    return Py_None;
1304  }
1305#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1306  robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1307#else
1308  {
1309    char result[SWIG_BUFFER_SIZE];
1310    robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1311      PyString_FromString(result) : 0;
1312  }
1313#endif
1314  return robj;
1315}
1316
1317/* -----------------------------------------------------------------------------*
1318 *  Get type list
1319 * -----------------------------------------------------------------------------*/
1320
1321#ifdef SWIG_LINK_RUNTIME
1322void *SWIG_ReturnGlobalTypeList(void *);
1323#endif
1324
1325SWIGRUNTIME swig_module_info *
1326SWIG_Python_GetModule(void) {
1327  static void *type_pointer = (void *)0;
1328  /* first check if module already created */
1329  if (!type_pointer) {
1330#ifdef SWIG_LINK_RUNTIME
1331    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1332#else
1333    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1334                                    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1335    if (PyErr_Occurred()) {
1336      PyErr_Clear();
1337      type_pointer = (void *)0;
1338    }
1339  }
1340#endif
1341  return (swig_module_info *) type_pointer;
1342}
1343
1344SWIGRUNTIME void
1345SWIG_Python_SetModule(swig_module_info *swig_module) {
1346  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1347
1348  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1349                                   swig_empty_runtime_method_table);
1350  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1351  if (pointer && module) {
1352    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1353  }
1354}
1355
1356#ifdef __cplusplus
1357}
1358#endif
1359
1360
1361/* -------- TYPES TABLE (BEGIN) -------- */
1362
1363#define SWIGTYPE_p_char swig_types[0]
1364#define SWIGTYPE_p_p_char swig_types[1]
1365#define SWIGTYPE_p_unsigned_int swig_types[2]
1366#define SWIGTYPE_ptrdiff_t swig_types[3]
1367#define SWIGTYPE_size_t swig_types[4]
1368static swig_type_info *swig_types[5];
1369static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
1370#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1371#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1372
1373/* -------- TYPES TABLE (END) -------- */
1374
1375
1376/*-----------------------------------------------
1377              @(target):= _xdelta3.so
1378  ------------------------------------------------*/
1379#define SWIG_init    init_xdelta3
1380
1381#define SWIG_name    "_xdelta3"
1382
1383#include "xdelta3.h"
1384
1385int xd3_main_cmdline (int ARGC, char **ARGV);
1386
1387#undef SWIG_init
1388#undef SWIG_name
1389
1390#define SWIG_init    initxdelta3
1391#define SWIG_name    "xdelta3"
1392
1393
1394
1395/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1396SWIGINTERN int
1397SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1398{
1399  static swig_type_info* pchar_info = 0;
1400  char* vptr = 0;
1401  if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1402  if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1403    if (cptr) *cptr = vptr;
1404    if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1405    return SWIG_OLDOBJ;
1406  } else {
1407    PyErr_Clear();
1408    if (PyString_Check(obj)) {
1409      if (cptr) {
1410        *cptr = PyString_AS_STRING(obj);
1411        if (psize) {
1412          *psize = PyString_GET_SIZE(obj) + 1;
1413        }
1414      }
1415      return SWIG_PYSTR;
1416    }
1417  }
1418  if (cptr) {
1419    SWIG_type_error("char *", obj);
1420  }
1421  return 0;
1422}
1423
1424
1425#include <limits.h>
1426
1427
1428SWIGINTERN int
1429  SWIG_CheckLongInRange(long value, long min_value, long max_value,
1430                        const char *errmsg)
1431{
1432  if (value < min_value) {
1433    if (errmsg) {
1434      PyErr_Format(PyExc_OverflowError, 
1435                   "value %ld is less than '%s' minimum %ld", 
1436                   value, errmsg, min_value);
1437    }
1438    return 0;   
1439  } else if (value > max_value) {
1440    if (errmsg) {
1441      PyErr_Format(PyExc_OverflowError,
1442                   "value %ld is greater than '%s' maximum %ld", 
1443                   value, errmsg, max_value);
1444    }
1445    return 0;
1446  }
1447  return 1;
1448}
1449
1450
1451SWIGINTERN int
1452  SWIG_AsVal_long(PyObject * obj, long* val)
1453{
1454  if (PyInt_Check(obj)) {
1455    if (val) *val = PyInt_AS_LONG(obj);
1456    return 1;
1457  }
1458  if (PyLong_Check(obj)) {
1459    long v = PyLong_AsLong(obj);
1460    if (!PyErr_Occurred()) {
1461      if (val) *val = v;
1462      return 1;
1463    } else {
1464      if (!val) PyErr_Clear();
1465      return 0;
1466    }
1467  }
1468  if (val) {
1469    SWIG_type_error("long", obj);
1470  }
1471  return 0;
1472 }
1473
1474
1475#if INT_MAX != LONG_MAX
1476SWIGINTERN int
1477  SWIG_AsVal_int(PyObject *obj, int *val)
1478{ 
1479  const char* errmsg = val ? "int" : (char*)0;
1480  long v;
1481  if (SWIG_AsVal_long(obj, &v)) {
1482    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1483      if (val) *val = (int)(v);
1484      return 1;
1485    } else {
1486      return 0;
1487    }
1488  } else {
1489    PyErr_Clear();
1490  }
1491  if (val) {
1492    SWIG_type_error(errmsg, obj);
1493  }
1494  return 0;   
1495}
1496#else
1497SWIGINTERNINLINE int
1498  SWIG_AsVal_int(PyObject *obj, int *val)
1499{
1500  return SWIG_AsVal_long(obj,(long*)val);
1501}
1502#endif
1503
1504
1505SWIGINTERNINLINE int
1506SWIG_As_int(PyObject* obj)
1507{
1508  int v;
1509  if (!SWIG_AsVal_int(obj, &v)) {
1510    /*
1511      this is needed to make valgrind/purify happier.
1512     */
1513    memset((void*)&v, 0, sizeof(int));
1514  }
1515  return v;
1516}
1517
1518
1519SWIGINTERNINLINE int
1520SWIG_AsCharPtr(PyObject *obj, char **val)
1521{
1522  if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
1523    return 1;
1524  }
1525  if (val) {
1526    PyErr_Clear();
1527    SWIG_type_error("char *", obj);
1528  }
1529  return 0;
1530}
1531
1532
1533SWIGINTERNINLINE int
1534  SWIG_CheckUnsignedLongInRange(unsigned long value,
1535                                unsigned long max_value,
1536                                const char *errmsg) 
1537{
1538  if (value > max_value) {
1539    if (errmsg) {
1540      PyErr_Format(PyExc_OverflowError,
1541                   "value %lu is greater than '%s' minimum %lu",
1542                   value, errmsg, max_value);
1543    }
1544    return 0;
1545  }
1546  return 1;
1547 }
1548
1549
1550SWIGINTERN int
1551  SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) 
1552{
1553  if (PyInt_Check(obj)) {
1554    long v = PyInt_AS_LONG(obj);
1555    if (v >= 0) {
1556      if (val) *val = v;
1557      return 1;
1558    }   
1559  }
1560  if (PyLong_Check(obj)) {
1561    unsigned long v = PyLong_AsUnsignedLong(obj);
1562    if (!PyErr_Occurred()) {
1563      if (val) *val = v;
1564      return 1;
1565    } else {
1566      if (!val) PyErr_Clear();
1567      return 0;
1568    }
1569  } 
1570  if (val) {
1571    SWIG_type_error("unsigned long", obj);
1572  }
1573  return 0;
1574}
1575
1576
1577#if UINT_MAX != ULONG_MAX
1578SWIGINTERN int
1579  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1580{ 
1581  const char* errmsg = val ? "unsigned int" : (char*)0;
1582  unsigned long v;
1583  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1584    if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1585      if (val) *val = (unsigned int)(v);
1586      return 1;
1587    }
1588  } else {
1589    PyErr_Clear();
1590  }
1591  if (val) {
1592    SWIG_type_error(errmsg, obj);
1593  }
1594  return 0;   
1595}
1596#else
1597SWIGINTERNINLINE unsigned int
1598  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1599{
1600  return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1601}
1602#endif
1603
1604 
1605SWIGINTERNINLINE int
1606SWIG_Check_unsigned_SS_int(PyObject* obj)
1607{
1608  return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1609}
1610
1611 
1612SWIGINTERNINLINE int
1613SWIG_Check_int(PyObject* obj)
1614{
1615  return SWIG_AsVal_int(obj, (int*)0);
1616}
1617
1618
1619SWIGINTERN PyObject*
1620t_output_helper(PyObject* target, PyObject* o) {
1621  if (!target) {
1622    target = o;
1623  } else if (target == Py_None) { 
1624    Py_DECREF(target);
1625    target = o;
1626  } else {
1627    if (!PyList_Check(target)) {
1628      PyObject *o2 = target;
1629      target = PyList_New(1);
1630      PyList_SetItem(target, 0, o2);
1631    }
1632    PyList_Append(target,o);
1633    Py_DECREF(o);
1634    }
1635  return target;
1636}
1637
1638
1639  /*@/usr/share/swig/1.3.25/python/pymacros.swg,66,SWIG_define@*/
1640#define SWIG_From_int PyInt_FromLong
1641/*@@*/
1642
1643
1644SWIGINTERN char**
1645  SWIG_AsArgcArgv(PyObject* input,
1646                  swig_type_info* ppchar_info,
1647                  size_t* argc, int* owner)
1648{ 
1649  char **argv = 0;
1650  size_t i = 0;
1651  if (SWIG_ConvertPtr(input, (void **)&argv, ppchar_info, 0) == -1) {
1652    PyErr_Clear();
1653    int list = PyList_Check(input);
1654    if (list || PyTuple_Check(input)) {
1655      *argc = list ? PyList_Size(input) : PyTuple_Size(input);
1656      argv = ((char**) malloc((*argc + 1)*sizeof(char*)));
1657      *owner = 1;
1658      for (; i < *argc; ++i) {
1659        PyObject *obj = list ? PyList_GetItem(input,i) : PyTuple_GetItem(input,i);
1660        if (!SWIG_AsCharPtr(obj, &(argv[i]))) {
1661          PyErr_Clear();
1662          PyErr_SetString(PyExc_TypeError,"list or tuple must contain strings only");
1663        }
1664      }
1665      argv[i] = 0;
1666      return argv;
1667    } else {
1668      *argc = 0;
1669      PyErr_SetString(PyExc_TypeError,"a list or tuple is expected");
1670      return 0;
1671    }
1672  } else {
1673    /* seems dangerous, but the user asked for it... */
1674    while (argv[i] != 0) ++i;
1675    *argc = i;
1676    owner = 0;
1677    return argv;
1678  }
1679}
1680
1681#ifdef __cplusplus
1682extern "C" {
1683#endif
1684static PyObject *_wrap_xd3_encode_memory(PyObject *self, PyObject *args) {
1685    PyObject *resultobj = NULL;
1686    char *arg1 = (char *) 0 ;
1687    unsigned int arg2 ;
1688    char *arg3 = (char *) 0 ;
1689    unsigned int arg4 ;
1690    char *arg5 = (char *) 0 ;
1691    unsigned int *arg6 = (unsigned int *) 0 ;
1692    unsigned int arg7 ;
1693    int arg8 ;
1694    int result;
1695    char *buf1 ;
1696    size_t size1 ;
1697    char *buf3 ;
1698    size_t size3 ;
1699    unsigned int alloc_size7 ;
1700    PyObject * obj0 = 0 ;
1701    PyObject * obj1 = 0 ;
1702    PyObject * obj2 = 0 ;
1703    PyObject * obj3 = 0 ;
1704   
1705    {
1706        arg8 = 0;
1707    }
1708    {
1709       
1710    }
1711    if(!PyArg_ParseTuple(args,(char *)"OOO|O:xd3_encode_memory",&obj0,&obj1,&obj2,&obj3)) goto fail;
1712    {
1713        int res = SWIG_AsCharPtrAndSize(obj0, &buf1, &size1);
1714        if (!res) {
1715            SWIG_arg_fail(1);SWIG_fail;
1716        }
1717        arg1 = (char *) buf1;
1718        arg2 = (unsigned int) size1 - 1;
1719    }
1720    {
1721        int res = SWIG_AsCharPtrAndSize(obj1, &buf3, &size3);
1722        if (!res) {
1723            SWIG_arg_fail(3);SWIG_fail;
1724        }
1725        arg3 = (char *) buf3;
1726        arg4 = (unsigned int) size3 - 1;
1727    }
1728    {
1729        arg7 = alloc_size7 = PyInt_AsLong(obj2);
1730    }
1731    if (obj3) {
1732        {
1733            arg8 = (int)(SWIG_As_int(obj3)); 
1734            if (SWIG_arg_fail(8)) SWIG_fail;
1735        }
1736    }
1737    {
1738        // alloc_size input is #7th position in xd3_xxcode_memory()
1739        arg5 = malloc(alloc_size7);
1740        arg6 = &alloc_size7;
1741    }
1742    result = (int)xd3_encode_memory((char const *)arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8);
1743   
1744    {
1745        resultobj = SWIG_From_int((int)(result)); 
1746    }
1747    {
1748        if (result == 0) {
1749            PyObject *o;
1750            // alloc_size7 now carries actual size
1751            o = PyString_FromStringAndSize(arg5,alloc_size7);
1752            resultobj = t_output_helper(resultobj,o);
1753        } else {
1754            resultobj = t_output_helper(resultobj,Py_None);
1755        }
1756        free(arg5);
1757    }
1758    return resultobj;
1759    fail:
1760    return NULL;
1761}
1762
1763
1764static PyObject *_wrap_xd3_decode_memory(PyObject *self, PyObject *args) {
1765    PyObject *resultobj = NULL;
1766    char *arg1 = (char *) 0 ;
1767    unsigned int arg2 ;
1768    char *arg3 = (char *) 0 ;
1769    unsigned int arg4 ;
1770    char *arg5 = (char *) 0 ;
1771    unsigned int *arg6 = (unsigned int *) 0 ;
1772    unsigned int arg7 ;
1773    int arg8 ;
1774    int result;
1775    char *buf1 ;
1776    size_t size1 ;
1777    char *buf3 ;
1778    size_t size3 ;
1779    unsigned int alloc_size7 ;
1780    PyObject * obj0 = 0 ;
1781    PyObject * obj1 = 0 ;
1782    PyObject * obj2 = 0 ;
1783    PyObject * obj3 = 0 ;
1784   
1785    {
1786        arg8 = 0;
1787    }
1788    {
1789       
1790    }
1791    if(!PyArg_ParseTuple(args,(char *)"OOO|O:xd3_decode_memory",&obj0,&obj1,&obj2,&obj3)) goto fail;
1792    {
1793        int res = SWIG_AsCharPtrAndSize(obj0, &buf1, &size1);
1794        if (!res) {
1795            SWIG_arg_fail(1);SWIG_fail;
1796        }
1797        arg1 = (char *) buf1;
1798        arg2 = (unsigned int) size1 - 1;
1799    }
1800    {
1801        int res = SWIG_AsCharPtrAndSize(obj1, &buf3, &size3);
1802        if (!res) {
1803            SWIG_arg_fail(3);SWIG_fail;
1804        }
1805        arg3 = (char *) buf3;
1806        arg4 = (unsigned int) size3 - 1;
1807    }
1808    {
1809        arg7 = alloc_size7 = PyInt_AsLong(obj2);
1810    }
1811    if (obj3) {
1812        {
1813            arg8 = (int)(SWIG_As_int(obj3)); 
1814            if (SWIG_arg_fail(8)) SWIG_fail;
1815        }
1816    }
1817    {
1818        // alloc_size input is #7th position in xd3_xxcode_memory()
1819        arg5 = malloc(alloc_size7);
1820        arg6 = &alloc_size7;
1821    }
1822    result = (int)xd3_decode_memory((char const *)arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8);
1823   
1824    {
1825        resultobj = SWIG_From_int((int)(result)); 
1826    }
1827    {
1828        if (result == 0) {
1829            PyObject *o;
1830            // alloc_size7 now carries actual size
1831            o = PyString_FromStringAndSize(arg5,alloc_size7);
1832            resultobj = t_output_helper(resultobj,o);
1833        } else {
1834            resultobj = t_output_helper(resultobj,Py_None);
1835        }
1836        free(arg5);
1837    }
1838    return resultobj;
1839    fail:
1840    return NULL;
1841}
1842
1843
1844static PyObject *_wrap_xd3_main_cmdline(PyObject *self, PyObject *args) {
1845    PyObject *resultobj = NULL;
1846    int arg1 ;
1847    char **arg2 = (char **) 0 ;
1848    int result;
1849    int owner1 ;
1850    PyObject * obj0 = 0 ;
1851   
1852    if(!PyArg_ParseTuple(args,(char *)"O:xd3_main_cmdline",&obj0)) goto fail;
1853    {
1854        size_t argc = 0;
1855        char **argv = SWIG_AsArgcArgv(obj0, SWIGTYPE_p_p_char, &argc, &owner1);
1856        if (PyErr_Occurred()) {
1857            arg1 = 0; arg2 = 0;
1858            if (SWIG_arg_fail(1)) SWIG_fail;
1859        } else {
1860            arg1 = (int) argc;
1861            arg2 = (char **) argv;
1862        }
1863    }
1864    result = (int)xd3_main_cmdline(arg1,arg2);
1865   
1866    {
1867        resultobj = SWIG_From_int((int)(result)); 
1868    }
1869    {
1870        if (owner1) free((char*)arg2);
1871    }
1872    return resultobj;
1873    fail:
1874    {
1875        if (owner1) free((char*)arg2);
1876    }
1877    return NULL;
1878}
1879
1880
1881static PyMethodDef SwigMethods[] = {
1882         { (char *)"xd3_encode_memory", _wrap_xd3_encode_memory, METH_VARARGS, NULL},
1883         { (char *)"xd3_decode_memory", _wrap_xd3_decode_memory, METH_VARARGS, NULL},
1884         { (char *)"xd3_main_cmdline", _wrap_xd3_main_cmdline, METH_VARARGS, NULL},
1885         { NULL, NULL, 0, NULL }
1886};
1887
1888
1889/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
1890
1891static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
1892static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, 0};
1893static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, 0};
1894static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
1895static swig_type_info _swigt__size_t = {"_size_t", "size_t", 0, 0, 0};
1896
1897static swig_type_info *swig_type_initial[] = {
1898  &_swigt__p_char,
1899  &_swigt__p_p_char,
1900  &_swigt__p_unsigned_int,
1901  &_swigt__ptrdiff_t,
1902  &_swigt__size_t,
1903};
1904
1905static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
1906static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
1907static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
1908static swig_cast_info _swigc__ptrdiff_t[] = {  {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
1909static swig_cast_info _swigc__size_t[] = {  {&_swigt__size_t, 0, 0, 0},{0, 0, 0, 0}};
1910
1911static swig_cast_info *swig_cast_initial[] = {
1912  _swigc__p_char,
1913  _swigc__p_p_char,
1914  _swigc__p_unsigned_int,
1915  _swigc__ptrdiff_t,
1916  _swigc__size_t,
1917};
1918
1919
1920/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
1921
1922static swig_const_info swig_const_table[] = {
1923{0, 0, 0, 0.0, 0, 0}};
1924
1925#ifdef __cplusplus
1926}
1927#endif
1928/*************************************************************************
1929 * Type initialization:
1930 * This problem is tough by the requirement that no dynamic
1931 * memory is used. Also, since swig_type_info structures store pointers to
1932 * swig_cast_info structures and swig_cast_info structures store pointers back
1933 * to swig_type_info structures, we need some lookup code at initialization.
1934 * The idea is that swig generates all the structures that are needed.
1935 * The runtime then collects these partially filled structures.
1936 * The SWIG_InitializeModule function takes these initial arrays out of
1937 * swig_module, and does all the lookup, filling in the swig_module.types
1938 * array with the correct data and linking the correct swig_cast_info
1939 * structures together.
1940
1941 * The generated swig_type_info structures are assigned staticly to an initial
1942 * array. We just loop though that array, and handle each type individually.
1943 * First we lookup if this type has been already loaded, and if so, use the
1944 * loaded structure instead of the generated one. Then we have to fill in the
1945 * cast linked list. The cast data is initially stored in something like a
1946 * two-dimensional array. Each row corresponds to a type (there are the same
1947 * number of rows as there are in the swig_type_initial array). Each entry in
1948 * a column is one of the swig_cast_info structures for that type.
1949 * The cast_initial array is actually an array of arrays, because each row has
1950 * a variable number of columns. So to actually build the cast linked list,
1951 * we find the array of casts associated with the type, and loop through it
1952 * adding the casts to the list. The one last trick we need to do is making
1953 * sure the type pointer in the swig_cast_info struct is correct.
1954
1955 * First off, we lookup the cast->type name to see if it is already loaded.
1956 * There are three cases to handle:
1957 *  1) If the cast->type has already been loaded AND the type we are adding
1958 *     casting info to has not been loaded (it is in this module), THEN we
1959 *     replace the cast->type pointer with the type pointer that has already
1960 *     been loaded.
1961 *  2) If BOTH types (the one we are adding casting info to, and the
1962 *     cast->type) are loaded, THEN the cast info has already been loaded by
1963 *     the previous module so we just ignore it.
1964 *  3) Finally, if cast->type has not already been loaded, then we add that
1965 *     swig_cast_info to the linked list (because the cast->type) pointer will
1966 *     be correct.
1967**/
1968
1969#ifdef __cplusplus
1970extern "C" {
1971#endif
1972   
1973    SWIGRUNTIME void
1974    SWIG_InitializeModule(void *clientdata) {
1975        swig_type_info *type, *ret;
1976        swig_cast_info *cast;
1977        size_t i;
1978        swig_module_info *module_head;
1979        static int init_run = 0;
1980       
1981        clientdata = clientdata;
1982       
1983        if (init_run) return;
1984        init_run = 1;
1985       
1986        /* Initialize the swig_module */
1987        swig_module.type_initial = swig_type_initial;
1988        swig_module.cast_initial = swig_cast_initial;
1989       
1990        /* Try and load any already created modules */
1991        module_head = SWIG_GetModule(clientdata);
1992        if (module_head) {
1993            swig_module.next = module_head->next;
1994            module_head->next = &swig_module;
1995        } else {
1996            /* This is the first module loaded */
1997            swig_module.next = &swig_module;
1998            SWIG_SetModule(clientdata, &swig_module);
1999        }
2000       
2001        /* Now work on filling in swig_module.types */
2002        for (i = 0; i < swig_module.size; ++i) {
2003            type = 0;
2004           
2005            /* if there is another module already loaded */
2006            if (swig_module.next != &swig_module) {
2007                type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
2008            }
2009            if (type) {
2010                /* Overwrite clientdata field */
2011                if (swig_module.type_initial[i]->clientdata) type->clientdata = swig_module.type_initial[i]->clientdata;
2012            } else {
2013                type = swig_module.type_initial[i];
2014            }
2015           
2016            /* Insert casting types */
2017            cast = swig_module.cast_initial[i];
2018            while (cast->type) {
2019                /* Don't need to add information already in the list */
2020                ret = 0;
2021                if (swig_module.next != &swig_module) {
2022                    ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
2023                }
2024                if (ret && type == swig_module.type_initial[i]) {
2025                    cast->type = ret;
2026                    ret = 0;
2027                }
2028               
2029                if (!ret) {
2030                    if (type->cast) {
2031                        type->cast->prev = cast;
2032                        cast->next = type->cast;
2033                    }
2034                    type->cast = cast;
2035                }
2036               
2037                cast++;
2038            }
2039           
2040            /* Set entry in modules->types array equal to the type */
2041            swig_module.types[i] = type;
2042        }
2043    }
2044   
2045    /* This function will propagate the clientdata field of type to
2046    * any new swig_type_info structures that have been added into the list
2047    * of equivalent types.  It is like calling
2048    * SWIG_TypeClientData(type, clientdata) a second time.
2049    */
2050    SWIGRUNTIME void
2051    SWIG_PropagateClientData(void) {
2052        size_t i;
2053        swig_cast_info *equiv;
2054        static int init_run = 0;
2055       
2056        if (init_run) return;
2057        init_run = 1;
2058       
2059        for (i = 0; i < swig_module.size; i++) {
2060            if (swig_module.types[i]->clientdata) {
2061                equiv = swig_module.types[i]->cast;
2062                while (equiv) {
2063                    if (!equiv->converter) {
2064                        if (equiv->type && !equiv->type->clientdata)
2065                        SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
2066                    }
2067                    equiv = equiv->next;
2068                }
2069            }
2070        }
2071    }
2072   
2073#ifdef __cplusplus
2074}
2075#endif
2076
2077
2078
2079#ifdef __cplusplus
2080extern "C" {
2081#endif
2082   
2083    /* Python-specific SWIG API */
2084#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
2085#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
2086#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
2087   
2088    /* -----------------------------------------------------------------------------
2089     * global variable support code.
2090     * ----------------------------------------------------------------------------- */
2091   
2092    typedef struct swig_globalvar {
2093        char       *name;                  /* Name of global variable */
2094        PyObject *(*get_attr)(void);       /* Return the current value */
2095        int       (*set_attr)(PyObject *); /* Set the value */
2096        struct swig_globalvar *next;
2097    } swig_globalvar;
2098   
2099    typedef struct swig_varlinkobject {
2100        PyObject_HEAD
2101        swig_globalvar *vars;
2102    } swig_varlinkobject;
2103   
2104    SWIGINTERN PyObject *
2105    swig_varlink_repr(swig_varlinkobject *v) {
2106        v = v;
2107        return PyString_FromString("<Swig global variables>");
2108    }
2109   
2110    SWIGINTERN int
2111    swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
2112        swig_globalvar  *var;
2113        flags = flags;
2114        fprintf(fp,"Swig global variables { ");
2115        for (var = v->vars; var; var=var->next) {
2116            fprintf(fp,"%s", var->name);
2117            if (var->next) fprintf(fp,", ");
2118        }
2119        fprintf(fp," }\n");
2120        return 0;
2121    }
2122   
2123    SWIGINTERN PyObject *
2124    swig_varlink_getattr(swig_varlinkobject *v, char *n) {
2125        swig_globalvar *var = v->vars;
2126        while (var) {
2127            if (strcmp(var->name,n) == 0) {
2128                return (*var->get_attr)();
2129            }
2130            var = var->next;
2131        }
2132        PyErr_SetString(PyExc_NameError,"Unknown C global variable");
2133        return NULL;
2134    }
2135   
2136    SWIGINTERN int
2137    swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
2138        swig_globalvar *var = v->vars;
2139        while (var) {
2140            if (strcmp(var->name,n) == 0) {
2141                return (*var->set_attr)(p);
2142            }
2143            var = var->next;
2144        }
2145        PyErr_SetString(PyExc_NameError,"Unknown C global variable");
2146        return 1;
2147    }
2148   
2149    SWIGINTERN PyTypeObject*
2150    swig_varlink_type(void) {
2151        static char varlink__doc__[] = "Swig var link object";
2152        static PyTypeObject varlink_type
2153#if !defined(__cplusplus)
2154        ;
2155        static int type_init = 0; 
2156        if (!type_init) {
2157            PyTypeObject tmp
2158#endif
2159            = {
2160                PyObject_HEAD_INIT(&PyType_Type)
2161                0,                                  /* Number of items in variable part (ob_size) */
2162                (char *)"swigvarlink",              /* Type name (tp_name) */
2163                sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
2164                0,                                  /* Itemsize (tp_itemsize) */
2165                0,                                  /* Deallocator (tp_dealloc) */ 
2166                (printfunc) swig_varlink_print,     /* Print (tp_print) */
2167                (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
2168                (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
2169                0,                                  /* tp_compare */
2170                (reprfunc) swig_varlink_repr,       /* tp_repr */
2171                0,                                  /* tp_as_number */
2172                0,                                  /* tp_as_sequence */
2173                0,                                  /* tp_as_mapping */
2174                0,                                  /* tp_hash */
2175                0,                                  /* tp_call */
2176                0,                                  /* tp_str */
2177                0,                                  /* tp_getattro */
2178                0,                                  /* tp_setattro */
2179                0,                                  /* tp_as_buffer */
2180                0,                                  /* tp_flags */
2181                varlink__doc__,                     /* tp_doc */
2182#if PY_VERSION_HEX >= 0x02000000
2183                0,                                  /* tp_traverse */
2184                0,                                  /* tp_clear */
2185#endif
2186#if PY_VERSION_HEX >= 0x02010000
2187                0,                                  /* tp_richcompare */
2188                0,                                  /* tp_weaklistoffset */
2189#endif
2190#if PY_VERSION_HEX >= 0x02020000
2191                0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
2192#endif
2193#if PY_VERSION_HEX >= 0x02030000
2194                0,                                  /* tp_del */
2195#endif
2196#ifdef COUNT_ALLOCS
2197                0,0,0,0                             /* tp_alloc -> tp_next */
2198#endif
2199            };
2200#if !defined(__cplusplus)
2201            varlink_type = tmp;
2202            type_init = 1;
2203        }
2204#endif
2205        return &varlink_type;
2206    }
2207   
2208    /* Create a variable linking object for use later */
2209    SWIGINTERN PyObject *
2210    SWIG_Python_newvarlink(void) {
2211        swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
2212        if (result) {
2213            result->vars = 0;
2214        }
2215        return ((PyObject*) result);
2216    }
2217   
2218    SWIGINTERN void 
2219    SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
2220        swig_varlinkobject *v = (swig_varlinkobject *) p;
2221        swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
2222        if (gv) {
2223            size_t size = strlen(name)+1;
2224            gv->name = (char *)malloc(size);
2225            if (gv->name) {
2226                strncpy(gv->name,name,size);
2227                gv->get_attr = get_attr;
2228                gv->set_attr = set_attr;
2229                gv->next = v->vars;
2230            }
2231        }
2232        v->vars = gv;
2233    }
2234   
2235    /* -----------------------------------------------------------------------------
2236     * constants/methods manipulation
2237     * ----------------------------------------------------------------------------- */
2238   
2239    /* Install Constants */
2240    SWIGINTERN void
2241    SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
2242        PyObject *obj = 0;
2243        size_t i;
2244        for (i = 0; constants[i].type; ++i) {
2245            switch(constants[i].type) {
2246                case SWIG_PY_INT:
2247                obj = PyInt_FromLong(constants[i].lvalue);
2248                break;
2249                case SWIG_PY_FLOAT:
2250                obj = PyFloat_FromDouble(constants[i].dvalue);
2251                break;
2252                case SWIG_PY_STRING:
2253                if (constants[i].pvalue) {
2254                    obj = PyString_FromString((char *) constants[i].pvalue);
2255                } else {
2256                    Py_INCREF(Py_None);
2257                    obj = Py_None;
2258                }
2259                break;
2260                case SWIG_PY_POINTER:
2261                obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
2262                break;
2263                case SWIG_PY_BINARY:
2264                obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
2265                break;
2266                default:
2267                obj = 0;
2268                break;
2269            }
2270            if (obj) {
2271                PyDict_SetItemString(d,constants[i].name,obj);
2272                Py_DECREF(obj);
2273            }
2274        }
2275    }
2276   
2277    /* -----------------------------------------------------------------------------*/
2278    /* Fix SwigMethods to carry the callback ptrs when needed */
2279    /* -----------------------------------------------------------------------------*/
2280   
2281    SWIGINTERN void
2282    SWIG_Python_FixMethods(PyMethodDef *methods,
2283    swig_const_info *const_table,
2284    swig_type_info **types,
2285    swig_type_info **types_initial) {
2286        size_t i;
2287        for (i = 0; methods[i].ml_name; ++i) {
2288            char *c = methods[i].ml_doc;
2289            if (c && (c = strstr(c, "swig_ptr: "))) {
2290                int j;
2291                swig_const_info *ci = 0;
2292                char *name = c + 10;
2293                for (j = 0; const_table[j].type; ++j) {
2294                    if (strncmp(const_table[j].name, name, 
2295                    strlen(const_table[j].name)) == 0) {
2296                        ci = &(const_table[j]);
2297                        break;
2298                    }
2299                }
2300                if (ci) {
2301                    size_t shift = (ci->ptype) - types;
2302                    swig_type_info *ty = types_initial[shift];
2303                    size_t ldoc = (c - methods[i].ml_doc);
2304                    size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
2305                    char *ndoc = (char*)malloc(ldoc + lptr + 10);
2306                    if (ndoc) {
2307                        char *buff = ndoc;
2308                        void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
2309                        if (ptr) {
2310                            strncpy(buff, methods[i].ml_doc, ldoc);
2311                            buff += ldoc;
2312                            strncpy(buff, "swig_ptr: ", 10);
2313                            buff += 10;
2314                            SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
2315                            methods[i].ml_doc = ndoc;
2316                        }
2317                    }
2318                }
2319            }
2320        }
2321    }
2322   
2323    /* -----------------------------------------------------------------------------*
2324     *  Initialize type list
2325     * -----------------------------------------------------------------------------*/
2326   
2327#if PY_MAJOR_VERSION < 2
2328    /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2329    is copied out of Python/modsupport.c in python version 2.3.4 */
2330    SWIGINTERN int
2331    PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2332    {
2333        PyObject *dict;
2334        if (!PyModule_Check(m)) {
2335            PyErr_SetString(PyExc_TypeError,
2336            "PyModule_AddObject() needs module as first arg");
2337            return -1;
2338        }
2339        if (!o) {
2340            PyErr_SetString(PyExc_TypeError,
2341            "PyModule_AddObject() needs non-NULL value");
2342            return -1;
2343        }
2344       
2345        dict = PyModule_GetDict(m);
2346        if (dict == NULL) {
2347            /* Internal error -- modules must have a dict! */
2348            PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2349            PyModule_GetName(m));
2350            return -1;
2351        }
2352        if (PyDict_SetItemString(dict, name, o))
2353        return -1;
2354        Py_DECREF(o);
2355        return 0;
2356    }
2357#endif
2358   
2359#ifdef __cplusplus
2360}
2361#endif
2362
2363/* -----------------------------------------------------------------------------*
2364 *  Partial Init method
2365 * -----------------------------------------------------------------------------*/
2366
2367#ifdef __cplusplus
2368extern "C"
2369#endif
2370SWIGEXPORT void SWIG_init(void) {
2371    static PyObject *SWIG_globals = 0; 
2372    PyObject *m, *d;
2373    if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
2374   
2375    /* Fix SwigMethods to carry the callback ptrs when needed */
2376    SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
2377   
2378    m = Py_InitModule((char *) SWIG_name, SwigMethods);
2379    d = PyModule_GetDict(m);
2380   
2381    SWIG_InitializeModule(0);
2382    SWIG_InstallConstants(d,swig_const_table);
2383   
2384    {
2385        PyDict_SetItemString(d,"XD3_SEC_DJW", SWIG_From_int((int)(XD3_SEC_DJW))); 
2386    }
2387    {
2388        PyDict_SetItemString(d,"XD3_SEC_FGK", SWIG_From_int((int)(XD3_SEC_FGK))); 
2389    }
2390    {
2391        PyDict_SetItemString(d,"XD3_SEC_NODATA", SWIG_From_int((int)(XD3_SEC_NODATA))); 
2392    }
2393    {
2394        PyDict_SetItemString(d,"XD3_SEC_NOINST", SWIG_From_int((int)(XD3_SEC_NOINST))); 
2395    }
2396    {
2397        PyDict_SetItemString(d,"XD3_SEC_NOADDR", SWIG_From_int((int)(XD3_SEC_NOADDR))); 
2398    }
2399    {
2400        PyDict_SetItemString(d,"XD3_ADLER32", SWIG_From_int((int)(XD3_ADLER32))); 
2401    }
2402    {
2403        PyDict_SetItemString(d,"XD3_ADLER32_NOVER", SWIG_From_int((int)(XD3_ADLER32_NOVER))); 
2404    }
2405    {
2406        PyDict_SetItemString(d,"XD3_ALT_CODE_TABLE", SWIG_From_int((int)(XD3_ALT_CODE_TABLE))); 
2407    }
2408    {
2409        PyDict_SetItemString(d,"XD3_NOCOMPRESS", SWIG_From_int((int)(XD3_NOCOMPRESS))); 
2410    }
2411    {
2412        PyDict_SetItemString(d,"XD3_BEGREEDY", SWIG_From_int((int)(XD3_BEGREEDY))); 
2413    }
2414    {
2415        PyDict_SetItemString(d,"XD3_COMPLEVEL_SHIFT", SWIG_From_int((int)(XD3_COMPLEVEL_SHIFT))); 
2416    }
2417    {
2418        PyDict_SetItemString(d,"XD3_COMPLEVEL_MASK", SWIG_From_int((int)(XD3_COMPLEVEL_MASK))); 
2419    }
2420    {
2421        PyDict_SetItemString(d,"XD3_COMPLEVEL_1", SWIG_From_int((int)(XD3_COMPLEVEL_1))); 
2422    }
2423    {
2424        PyDict_SetItemString(d,"XD3_COMPLEVEL_3", SWIG_From_int((int)(XD3_COMPLEVEL_3))); 
2425    }
2426    {
2427        PyDict_SetItemString(d,"XD3_COMPLEVEL_6", SWIG_From_int((int)(XD3_COMPLEVEL_6))); 
2428    }
2429    {
2430        PyDict_SetItemString(d,"XD3_COMPLEVEL_9", SWIG_From_int((int)(XD3_COMPLEVEL_9))); 
2431    }
2432}
2433
Note: See TracBrowser for help on using the repository browser.