source: tags/4.6.0/src/C++/pbs_wrap.cxx

Last change on this file was 301, checked in by bas, 9 years ago

added C++ directory used for Torque version 4.2 and greater

File size: 305.4 KB
Line 
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 2.0.7
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#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14/* -----------------------------------------------------------------------------
15 *  This section contains generic SWIG labels for method/variable
16 *  declarations/attributes, and other compiler dependent labels.
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# elif defined(__HP_aCC)
24/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
25/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
26#  define SWIGTEMPLATEDISAMBIGUATOR template
27# else
28#  define SWIGTEMPLATEDISAMBIGUATOR
29# endif
30#endif
31
32/* inline attribute */
33#ifndef SWIGINLINE
34# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35#   define SWIGINLINE inline
36# else
37#   define SWIGINLINE
38# endif
39#endif
40
41/* attribute recognised by some compilers to avoid 'unused' warnings */
42#ifndef SWIGUNUSED
43# if defined(__GNUC__)
44#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45#     define SWIGUNUSED __attribute__ ((__unused__))
46#   else
47#     define SWIGUNUSED
48#   endif
49# elif defined(__ICC)
50#   define SWIGUNUSED __attribute__ ((__unused__))
51# else
52#   define SWIGUNUSED
53# endif
54#endif
55
56#ifndef SWIG_MSC_UNSUPPRESS_4505
57# if defined(_MSC_VER)
58#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
59# endif
60#endif
61
62#ifndef SWIGUNUSEDPARM
63# ifdef __cplusplus
64#   define SWIGUNUSEDPARM(p)
65# else
66#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
67# endif
68#endif
69
70/* internal SWIG method */
71#ifndef SWIGINTERN
72# define SWIGINTERN static SWIGUNUSED
73#endif
74
75/* internal inline SWIG method */
76#ifndef SWIGINTERNINLINE
77# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
78#endif
79
80/* exporting methods */
81#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
82#  ifndef GCC_HASCLASSVISIBILITY
83#    define GCC_HASCLASSVISIBILITY
84#  endif
85#endif
86
87#ifndef SWIGEXPORT
88# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89#   if defined(STATIC_LINKED)
90#     define SWIGEXPORT
91#   else
92#     define SWIGEXPORT __declspec(dllexport)
93#   endif
94# else
95#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
96#     define SWIGEXPORT __attribute__ ((visibility("default")))
97#   else
98#     define SWIGEXPORT
99#   endif
100# endif
101#endif
102
103/* calling conventions for Windows */
104#ifndef SWIGSTDCALL
105# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
106#   define SWIGSTDCALL __stdcall
107# else
108#   define SWIGSTDCALL
109# endif
110#endif
111
112/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
113#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
114# define _CRT_SECURE_NO_DEPRECATE
115#endif
116
117/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
118#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
119# define _SCL_SECURE_NO_DEPRECATE
120#endif
121
122
123
124/* Python.h has to appear first */
125#include <Python.h>
126
127/* -----------------------------------------------------------------------------
128 * swigrun.swg
129 *
130 * This file contains generic C API SWIG runtime support for pointer
131 * type checking.
132 * ----------------------------------------------------------------------------- */
133
134/* This should only be incremented when either the layout of swig_type_info changes,
135   or for whatever reason, the runtime changes incompatibly */
136#define SWIG_RUNTIME_VERSION "4"
137
138/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
139#ifdef SWIG_TYPE_TABLE
140# define SWIG_QUOTE_STRING(x) #x
141# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
142# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
143#else
144# define SWIG_TYPE_TABLE_NAME
145#endif
146
147/*
148  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'.
151 
152  But only do this if strictly necessary, ie, if you have problems
153  with your compiler or suchlike.
154*/
155
156#ifndef SWIGRUNTIME
157# define SWIGRUNTIME SWIGINTERN
158#endif
159
160#ifndef SWIGRUNTIMEINLINE
161# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
162#endif
163
164/*  Generic buffer size */
165#ifndef SWIG_BUFFER_SIZE
166# define SWIG_BUFFER_SIZE 1024
167#endif
168
169/* Flags for pointer conversions */
170#define SWIG_POINTER_DISOWN        0x1
171#define SWIG_CAST_NEW_MEMORY       0x2
172
173/* Flags for new pointer objects */
174#define SWIG_POINTER_OWN           0x1
175
176
177/*
178   Flags/methods for returning states.
179   
180   The SWIG conversion methods, as ConvertPtr, return an integer
181   that tells if the conversion was successful or not. And if not,
182   an error code can be returned (see swigerrors.swg for the codes).
183   
184   Use the following macros/flags to set or process the returning
185   states.
186   
187   In old versions of SWIG, code such as the following was usually written:
188
189     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
190       // success code
191     } else {
192       //fail code
193     }
194
195   Now you can be more explicit:
196
197    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
198    if (SWIG_IsOK(res)) {
199      // success code
200    } else {
201      // fail code
202    }
203
204   which is the same really, but now you can also do
205
206    Type *ptr;
207    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
208    if (SWIG_IsOK(res)) {
209      // success code
210      if (SWIG_IsNewObj(res) {
211        ...
212        delete *ptr;
213      } else {
214        ...
215      }
216    } else {
217      // fail code
218    }
219   
220   I.e., now SWIG_ConvertPtr can return new objects and you can
221   identify the case and take care of the deallocation. Of course that
222   also requires SWIG_ConvertPtr to return new result values, such as
223
224      int SWIG_ConvertPtr(obj, ptr,...) {         
225        if (<obj is ok>) {                             
226          if (<need new object>) {                     
227            *ptr = <ptr to new allocated object>;
228            return SWIG_NEWOBJ;               
229          } else {                                     
230            *ptr = <ptr to old object>;       
231            return SWIG_OLDOBJ;               
232          }                                   
233        } else {                                       
234          return SWIG_BADOBJ;                 
235        }                                             
236      }
237
238   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
239   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
240   SWIG errors code.
241
242   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
243   allows to return the 'cast rank', for example, if you have this
244
245       int food(double)
246       int fooi(int);
247
248   and you call
249 
250      food(1)   // cast rank '1'  (1 -> 1.0)
251      fooi(1)   // cast rank '0'
252
253   just use the SWIG_AddCast()/SWIG_CheckState()
254*/
255
256#define SWIG_OK                    (0)
257#define SWIG_ERROR                 (-1)
258#define SWIG_IsOK(r)               (r >= 0)
259#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError) 
260
261/* The CastRankLimit says how many bits are used for the cast rank */
262#define SWIG_CASTRANKLIMIT         (1 << 8)
263/* The NewMask denotes the object was created (using new/malloc) */
264#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
265/* The TmpMask is for in/out typemaps that use temporal objects */
266#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
267/* Simple returning values */
268#define SWIG_BADOBJ                (SWIG_ERROR)
269#define SWIG_OLDOBJ                (SWIG_OK)
270#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
271#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
272/* Check, add and del mask methods */
273#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
274#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
275#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
276#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
277#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
278#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
279
280/* Cast-Rank Mode */
281#if defined(SWIG_CASTRANK_MODE)
282#  ifndef SWIG_TypeRank
283#    define SWIG_TypeRank             unsigned long
284#  endif
285#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
286#    define SWIG_MAXCASTRANK          (2)
287#  endif
288#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
289#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
290SWIGINTERNINLINE int SWIG_AddCast(int r) { 
291  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
292}
293SWIGINTERNINLINE int SWIG_CheckState(int r) { 
294  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
295}
296#else /* no cast-rank mode */
297#  define SWIG_AddCast
298#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
299#endif
300
301
302#include <string.h>
303
304#ifdef __cplusplus
305extern "C" {
306#endif
307
308typedef void *(*swig_converter_func)(void *, int *);
309typedef struct swig_type_info *(*swig_dycast_func)(void **);
310
311/* Structure to store information on one type */
312typedef struct swig_type_info {
313  const char             *name;                 /* mangled name of this type */
314  const char             *str;                  /* human readable name of this type */
315  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
316  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
317  void                   *clientdata;           /* language specific type data */
318  int                    owndata;               /* flag if the structure owns the clientdata */
319} swig_type_info;
320
321/* Structure to store a type and conversion function used for casting */
322typedef struct swig_cast_info {
323  swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
324  swig_converter_func     converter;            /* function to cast the void pointers */
325  struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
326  struct swig_cast_info  *prev;                 /* pointer to the previous cast */
327} swig_cast_info;
328
329/* Structure used to store module information
330 * Each module generates one structure like this, and the runtime collects
331 * all of these structures and stores them in a circularly linked list.*/
332typedef struct swig_module_info {
333  swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
334  size_t                 size;                  /* Number of types in this module */
335  struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
336  swig_type_info         **type_initial;        /* Array of initially generated type structures */
337  swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
338  void                    *clientdata;          /* Language specific module data */
339} swig_module_info;
340
341/*
342  Compare two type names skipping the space characters, therefore
343  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
344
345  Return 0 when the two name types are equivalent, as in
346  strncmp, but skipping ' '.
347*/
348SWIGRUNTIME int
349SWIG_TypeNameComp(const char *f1, const char *l1,
350                  const char *f2, const char *l2) {
351  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
352    while ((*f1 == ' ') && (f1 != l1)) ++f1;
353    while ((*f2 == ' ') && (f2 != l2)) ++f2;
354    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
355  }
356  return (int)((l1 - f1) - (l2 - f2));
357}
358
359/*
360  Check type equivalence in a name list like <name1>|<name2>|...
361  Return 0 if not equal, 1 if equal
362*/
363SWIGRUNTIME int
364SWIG_TypeEquiv(const char *nb, const char *tb) {
365  int equiv = 0;
366  const char* te = tb + strlen(tb);
367  const char* ne = nb;
368  while (!equiv && *ne) {
369    for (nb = ne; *ne; ++ne) {
370      if (*ne == '|') break;
371    }
372    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
373    if (*ne) ++ne;
374  }
375  return equiv;
376}
377
378/*
379  Check type equivalence in a name list like <name1>|<name2>|...
380  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
381*/
382SWIGRUNTIME int
383SWIG_TypeCompare(const char *nb, const char *tb) {
384  int equiv = 0;
385  const char* te = tb + strlen(tb);
386  const char* ne = nb;
387  while (!equiv && *ne) {
388    for (nb = ne; *ne; ++ne) {
389      if (*ne == '|') break;
390    }
391    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
392    if (*ne) ++ne;
393  }
394  return equiv;
395}
396
397
398/*
399  Check the typename
400*/
401SWIGRUNTIME swig_cast_info *
402SWIG_TypeCheck(const char *c, swig_type_info *ty) {
403  if (ty) {
404    swig_cast_info *iter = ty->cast;
405    while (iter) {
406      if (strcmp(iter->type->name, c) == 0) {
407        if (iter == ty->cast)
408          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
425/*
426  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
427*/
428SWIGRUNTIME swig_cast_info *
429SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
430  if (ty) {
431    swig_cast_info *iter = ty->cast;
432    while (iter) {
433      if (iter->type == from) {
434        if (iter == ty->cast)
435          return iter;
436        /* Move iter to the top of the linked list */
437        iter->prev->next = iter->next;
438        if (iter->next)
439          iter->next->prev = iter->prev;
440        iter->next = ty->cast;
441        iter->prev = 0;
442        if (ty->cast) ty->cast->prev = iter;
443        ty->cast = iter;
444        return iter;
445      }
446      iter = iter->next;
447    }
448  }
449  return 0;
450}
451
452/*
453  Cast a pointer up an inheritance hierarchy
454*/
455SWIGRUNTIMEINLINE void *
456SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
457  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
458}
459
460/*
461   Dynamic pointer casting. Down an inheritance hierarchy
462*/
463SWIGRUNTIME swig_type_info *
464SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
465  swig_type_info *lastty = ty;
466  if (!ty || !ty->dcast) return ty;
467  while (ty && (ty->dcast)) {
468    ty = (*ty->dcast)(ptr);
469    if (ty) lastty = ty;
470  }
471  return lastty;
472}
473
474/*
475  Return the name associated with this type
476*/
477SWIGRUNTIMEINLINE const char *
478SWIG_TypeName(const swig_type_info *ty) {
479  return ty->name;
480}
481
482/*
483  Return the pretty name associated with this type,
484  that is an unmangled type name in a form presentable to the user.
485*/
486SWIGRUNTIME const char *
487SWIG_TypePrettyName(const swig_type_info *type) {
488  /* The "str" field contains the equivalent pretty names of the
489     type, separated by vertical-bar characters.  We choose
490     to print the last name, as it is often (?) the most
491     specific. */
492  if (!type) return NULL;
493  if (type->str != NULL) {
494    const char *last_name = type->str;
495    const char *s;
496    for (s = type->str; *s; s++)
497      if (*s == '|') last_name = s+1;
498    return last_name;
499  }
500  else
501    return type->name;
502}
503
504/*
505   Set the clientdata field for a type
506*/
507SWIGRUNTIME void
508SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
509  swig_cast_info *cast = ti->cast;
510  /* if (ti->clientdata == clientdata) return; */
511  ti->clientdata = clientdata;
512 
513  while (cast) {
514    if (!cast->converter) {
515      swig_type_info *tc = cast->type;
516      if (!tc->clientdata) {
517        SWIG_TypeClientData(tc, clientdata);
518      }
519    }   
520    cast = cast->next;
521  }
522}
523SWIGRUNTIME void
524SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
525  SWIG_TypeClientData(ti, clientdata);
526  ti->owndata = 1;
527}
528 
529/*
530  Search for a swig_type_info structure only by mangled name
531  Search is a O(log #types)
532 
533  We start searching at module start, and finish searching when start == end. 
534  Note: if start == end at the beginning of the function, we go all the way around
535  the circular list.
536*/
537SWIGRUNTIME swig_type_info *
538SWIG_MangledTypeQueryModule(swig_module_info *start, 
539                            swig_module_info *end, 
540                            const char *name) {
541  swig_module_info *iter = start;
542  do {
543    if (iter->size) {
544      register size_t l = 0;
545      register size_t r = iter->size - 1;
546      do {
547        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
548        register size_t i = (l + r) >> 1; 
549        const char *iname = iter->types[i]->name;
550        if (iname) {
551          register int compare = strcmp(name, iname);
552          if (compare == 0) {       
553            return iter->types[i];
554          } else if (compare < 0) {
555            if (i) {
556              r = i - 1;
557            } else {
558              break;
559            }
560          } else if (compare > 0) {
561            l = i + 1;
562          }
563        } else {
564          break; /* should never happen */
565        }
566      } while (l <= r);
567    }
568    iter = iter->next;
569  } while (iter != end);
570  return 0;
571}
572
573/*
574  Search for a swig_type_info structure for either a mangled name or a human readable name.
575  It first searches the mangled names of the types, which is a O(log #types)
576  If a type is not found it then searches the human readable names, which is O(#types).
577 
578  We start searching at module start, and finish searching when start == end. 
579  Note: if start == end at the beginning of the function, we go all the way around
580  the circular list.
581*/
582SWIGRUNTIME swig_type_info *
583SWIG_TypeQueryModule(swig_module_info *start, 
584                     swig_module_info *end, 
585                     const char *name) {
586  /* STEP 1: Search the name field using binary search */
587  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
588  if (ret) {
589    return ret;
590  } else {
591    /* STEP 2: If the type hasn't been found, do a complete search
592       of the str field (the human readable name) */
593    swig_module_info *iter = start;
594    do {
595      register size_t i = 0;
596      for (; i < iter->size; ++i) {
597        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
598          return iter->types[i];
599      }
600      iter = iter->next;
601    } while (iter != end);
602  }
603 
604  /* neither found a match */
605  return 0;
606}
607
608/*
609   Pack binary data into a string
610*/
611SWIGRUNTIME char *
612SWIG_PackData(char *c, void *ptr, size_t sz) {
613  static const char hex[17] = "0123456789abcdef";
614  register const unsigned char *u = (unsigned char *) ptr;
615  register const unsigned char *eu =  u + sz;
616  for (; u != eu; ++u) {
617    register unsigned char uu = *u;
618    *(c++) = hex[(uu & 0xf0) >> 4];
619    *(c++) = hex[uu & 0xf];
620  }
621  return c;
622}
623
624/*
625   Unpack binary data from a string
626*/
627SWIGRUNTIME const char *
628SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
629  register unsigned char *u = (unsigned char *) ptr;
630  register const unsigned char *eu = u + sz;
631  for (; u != eu; ++u) {
632    register char d = *(c++);
633    register unsigned char uu;
634    if ((d >= '0') && (d <= '9'))
635      uu = ((d - '0') << 4);
636    else if ((d >= 'a') && (d <= 'f'))
637      uu = ((d - ('a'-10)) << 4);
638    else 
639      return (char *) 0;
640    d = *(c++);
641    if ((d >= '0') && (d <= '9'))
642      uu |= (d - '0');
643    else if ((d >= 'a') && (d <= 'f'))
644      uu |= (d - ('a'-10));
645    else 
646      return (char *) 0;
647    *u = uu;
648  }
649  return c;
650}
651
652/*
653   Pack 'void *' into a string buffer.
654*/
655SWIGRUNTIME char *
656SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
657  char *r = buff;
658  if ((2*sizeof(void *) + 2) > bsz) return 0;
659  *(r++) = '_';
660  r = SWIG_PackData(r,&ptr,sizeof(void *));
661  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
662  strcpy(r,name);
663  return buff;
664}
665
666SWIGRUNTIME const char *
667SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
668  if (*c != '_') {
669    if (strcmp(c,"NULL") == 0) {
670      *ptr = (void *) 0;
671      return name;
672    } else {
673      return 0;
674    }
675  }
676  return SWIG_UnpackData(++c,ptr,sizeof(void *));
677}
678
679SWIGRUNTIME char *
680SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
681  char *r = buff;
682  size_t lname = (name ? strlen(name) : 0);
683  if ((2*sz + 2 + lname) > bsz) return 0;
684  *(r++) = '_';
685  r = SWIG_PackData(r,ptr,sz);
686  if (lname) {
687    strncpy(r,name,lname+1);
688  } else {
689    *r = 0;
690  }
691  return buff;
692}
693
694SWIGRUNTIME const char *
695SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
696  if (*c != '_') {
697    if (strcmp(c,"NULL") == 0) {
698      memset(ptr,0,sz);
699      return name;
700    } else {
701      return 0;
702    }
703  }
704  return SWIG_UnpackData(++c,ptr,sz);
705}
706
707#ifdef __cplusplus
708}
709#endif
710
711/*  Errors in SWIG */
712#define  SWIG_UnknownError         -1
713#define  SWIG_IOError              -2
714#define  SWIG_RuntimeError         -3
715#define  SWIG_IndexError           -4
716#define  SWIG_TypeError            -5
717#define  SWIG_DivisionByZero       -6
718#define  SWIG_OverflowError        -7
719#define  SWIG_SyntaxError          -8
720#define  SWIG_ValueError           -9
721#define  SWIG_SystemError          -10
722#define  SWIG_AttributeError       -11
723#define  SWIG_MemoryError          -12
724#define  SWIG_NullReferenceError   -13
725
726
727
728/* Compatibility macros for Python 3 */
729#if PY_VERSION_HEX >= 0x03000000
730
731#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
732#define PyInt_Check(x) PyLong_Check(x)
733#define PyInt_AsLong(x) PyLong_AsLong(x)
734#define PyInt_FromLong(x) PyLong_FromLong(x)
735#define PyInt_FromSize_t(x) PyLong_FromSize_t(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 */
764SWIGINTERN char*
765SWIG_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
789SWIGINTERN PyObject*
790SWIG_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}
798
799/* Add PyOS_snprintf for old Pythons */
800#if PY_VERSION_HEX < 0x02020000
801# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
802#  define PyOS_snprintf _snprintf
803# else
804#  define PyOS_snprintf snprintf
805# endif
806#endif
807
808/* A crude PyString_FromFormat implementation for old Pythons */
809#if PY_VERSION_HEX < 0x02020000
810
811#ifndef SWIG_PYBUFFER_SIZE
812# define SWIG_PYBUFFER_SIZE 1024
813#endif
814
815static PyObject *
816PyString_FromFormat(const char *fmt, ...) {
817  va_list ap;
818  char buf[SWIG_PYBUFFER_SIZE * 2];
819  int res;
820  va_start(ap, fmt);
821  res = vsnprintf(buf, sizeof(buf), fmt, ap);
822  va_end(ap);
823  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
824}
825#endif
826
827/* Add PyObject_Del for old Pythons */
828#if PY_VERSION_HEX < 0x01060000
829# define PyObject_Del(op) PyMem_DEL((op))
830#endif
831#ifndef PyObject_DEL
832# define PyObject_DEL PyObject_Del
833#endif
834
835/* A crude PyExc_StopIteration exception for old Pythons */
836#if PY_VERSION_HEX < 0x02020000
837# ifndef PyExc_StopIteration
838#  define PyExc_StopIteration PyExc_RuntimeError
839# endif
840# ifndef PyObject_GenericGetAttr
841#  define PyObject_GenericGetAttr 0
842# endif
843#endif
844
845/* Py_NotImplemented is defined in 2.1 and up. */
846#if PY_VERSION_HEX < 0x02010000
847# ifndef Py_NotImplemented
848#  define Py_NotImplemented PyExc_RuntimeError
849# endif
850#endif
851
852/* A crude PyString_AsStringAndSize implementation for old Pythons */
853#if PY_VERSION_HEX < 0x02010000
854# ifndef PyString_AsStringAndSize
855#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
856# endif
857#endif
858
859/* PySequence_Size for old Pythons */
860#if PY_VERSION_HEX < 0x02000000
861# ifndef PySequence_Size
862#  define PySequence_Size PySequence_Length
863# endif
864#endif
865
866/* PyBool_FromLong for old Pythons */
867#if PY_VERSION_HEX < 0x02030000
868static
869PyObject *PyBool_FromLong(long ok)
870{
871  PyObject *result = ok ? Py_True : Py_False;
872  Py_INCREF(result);
873  return result;
874}
875#endif
876
877/* Py_ssize_t for old Pythons */
878/* This code is as recommended by: */
879/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
880#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
881typedef int Py_ssize_t;
882# define PY_SSIZE_T_MAX INT_MAX
883# define PY_SSIZE_T_MIN INT_MIN
884typedef inquiry lenfunc;
885typedef intargfunc ssizeargfunc;
886typedef intintargfunc ssizessizeargfunc;
887typedef intobjargproc ssizeobjargproc;
888typedef intintobjargproc ssizessizeobjargproc;
889typedef getreadbufferproc readbufferproc;
890typedef getwritebufferproc writebufferproc;
891typedef getsegcountproc segcountproc;
892typedef getcharbufferproc charbufferproc;
893static 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
917typedef 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
928typedef 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)
941#endif
942
943/* -----------------------------------------------------------------------------
944 * error manipulation
945 * ----------------------------------------------------------------------------- */
946
947SWIGRUNTIME PyObject*
948SWIG_Python_ErrorType(int code) {
949  PyObject* type = 0;
950  switch(code) {
951  case SWIG_MemoryError:
952    type = PyExc_MemoryError;
953    break;
954  case SWIG_IOError:
955    type = PyExc_IOError;
956    break;
957  case SWIG_RuntimeError:
958    type = PyExc_RuntimeError;
959    break;
960  case SWIG_IndexError:
961    type = PyExc_IndexError;
962    break;
963  case SWIG_TypeError:
964    type = PyExc_TypeError;
965    break;
966  case SWIG_DivisionByZero:
967    type = PyExc_ZeroDivisionError;
968    break;
969  case SWIG_OverflowError:
970    type = PyExc_OverflowError;
971    break;
972  case SWIG_SyntaxError:
973    type = PyExc_SyntaxError;
974    break;
975  case SWIG_ValueError:
976    type = PyExc_ValueError;
977    break;
978  case SWIG_SystemError:
979    type = PyExc_SystemError;
980    break;
981  case SWIG_AttributeError:
982    type = PyExc_AttributeError;
983    break;
984  default:
985    type = PyExc_RuntimeError;
986  }
987  return type;
988}
989
990
991SWIGRUNTIME void
992SWIG_Python_AddErrorMsg(const char* mesg)
993{
994  PyObject *type = 0;
995  PyObject *value = 0;
996  PyObject *traceback = 0;
997
998  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
999  if (value) {
1000    char *tmp;
1001    PyObject *old_str = PyObject_Str(value);
1002    PyErr_Clear();
1003    Py_XINCREF(type);
1004
1005    PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1006    SWIG_Python_str_DelForPy3(tmp);
1007    Py_DECREF(old_str);
1008    Py_DECREF(value);
1009  } else {
1010    PyErr_SetString(PyExc_RuntimeError, mesg);
1011  }
1012}
1013
1014#if defined(SWIG_PYTHON_NO_THREADS)
1015#  if defined(SWIG_PYTHON_THREADS)
1016#    undef SWIG_PYTHON_THREADS
1017#  endif
1018#endif
1019#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1020#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1021#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1022#      define SWIG_PYTHON_USE_GIL
1023#    endif
1024#  endif
1025#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1026#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
1027#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
1028#    endif
1029#    ifdef __cplusplus /* C++ code */
1030       class SWIG_Python_Thread_Block {
1031         bool status;
1032         PyGILState_STATE state;
1033       public:
1034         void end() { if (status) { PyGILState_Release(state); status = false;} }
1035         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1036         ~SWIG_Python_Thread_Block() { end(); }
1037       };
1038       class SWIG_Python_Thread_Allow {
1039         bool status;
1040         PyThreadState *save;
1041       public:
1042         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1043         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1044         ~SWIG_Python_Thread_Allow() { end(); }
1045       };
1046#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
1047#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
1048#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
1049#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
1050#    else /* C code */
1051#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1052#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
1053#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1054#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
1055#    endif
1056#  else /* Old thread way, not implemented, user must provide it */
1057#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1058#      define SWIG_PYTHON_INITIALIZE_THREADS
1059#    endif
1060#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1061#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1062#    endif
1063#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1064#      define SWIG_PYTHON_THREAD_END_BLOCK
1065#    endif
1066#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1067#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1068#    endif
1069#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1070#      define SWIG_PYTHON_THREAD_END_ALLOW
1071#    endif
1072#  endif
1073#else /* No thread support */
1074#  define SWIG_PYTHON_INITIALIZE_THREADS
1075#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1076#  define SWIG_PYTHON_THREAD_END_BLOCK
1077#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1078#  define SWIG_PYTHON_THREAD_END_ALLOW
1079#endif
1080
1081/* -----------------------------------------------------------------------------
1082 * Python API portion that goes into the runtime
1083 * ----------------------------------------------------------------------------- */
1084
1085#ifdef __cplusplus
1086extern "C" {
1087#endif
1088
1089/* -----------------------------------------------------------------------------
1090 * Constant declarations
1091 * ----------------------------------------------------------------------------- */
1092
1093/* Constant Types */
1094#define SWIG_PY_POINTER 4
1095#define SWIG_PY_BINARY  5
1096
1097/* Constant information structure */
1098typedef struct swig_const_info {
1099  int type;
1100  char *name;
1101  long lvalue;
1102  double dvalue;
1103  void   *pvalue;
1104  swig_type_info **ptype;
1105} swig_const_info;
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
1113SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1114{
1115  return PyInstanceMethod_New(func);
1116}
1117#else
1118SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1119{
1120  return NULL;
1121}
1122#endif
1123
1124#ifdef __cplusplus
1125}
1126#endif
1127
1128
1129/* -----------------------------------------------------------------------------
1130 * pyrun.swg
1131 *
1132 * This file contains the runtime support for Python modules
1133 * and includes code for managing global variables and pointer
1134 * type checking.
1135 *
1136 * ----------------------------------------------------------------------------- */
1137
1138/* Common SWIG API */
1139
1140/* for raw pointers */
1141#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1142#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1143#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
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
1153#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
1154#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
1155#define swig_owntype                                    int
1156
1157/* for raw packed data */
1158#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1159#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1160
1161/* for class or struct pointers */
1162#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1163#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1164
1165/* for C or C++ function pointers */
1166#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1167#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1168
1169/* for C++ member pointers, ie, member methods */
1170#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1171#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1172
1173
1174/* Runtime API */
1175
1176#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1177#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1178#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
1179
1180#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                           
1181#define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg                           
1182#define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)                       
1183#define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1184#define SWIG_fail                                       goto fail                                         
1185
1186
1187/* Runtime API implementation */
1188
1189/* Error manipulation */
1190
1191SWIGINTERN void 
1192SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1193  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
1194  PyErr_SetObject(errtype, obj);
1195  Py_DECREF(obj);
1196  SWIG_PYTHON_THREAD_END_BLOCK;
1197}
1198
1199SWIGINTERN void 
1200SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1201  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1202  PyErr_SetString(errtype, msg);
1203  SWIG_PYTHON_THREAD_END_BLOCK;
1204}
1205
1206#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1207
1208/* Set a constant value */
1209
1210#if defined(SWIGPYTHON_BUILTIN)
1211
1212SWIGINTERN void
1213SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1214  PyObject *s = PyString_InternFromString(key);
1215  PyList_Append(seq, s);
1216  Py_DECREF(s);
1217}
1218
1219SWIGINTERN void
1220SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
1221#if PY_VERSION_HEX < 0x02030000
1222  PyDict_SetItemString(d, (char *)name, obj);
1223#else
1224  PyDict_SetItemString(d, name, obj);
1225#endif
1226  Py_DECREF(obj);
1227  if (public_interface)
1228    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1229}
1230
1231#else
1232
1233SWIGINTERN void
1234SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
1235#if PY_VERSION_HEX < 0x02030000
1236  PyDict_SetItemString(d, (char *)name, obj);
1237#else
1238  PyDict_SetItemString(d, name, obj);
1239#endif
1240  Py_DECREF(obj);                           
1241}
1242
1243#endif
1244
1245/* Append a value to the result obj */
1246
1247SWIGINTERN PyObject*
1248SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1249#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1250  if (!result) {
1251    result = obj;
1252  } else if (result == Py_None) {
1253    Py_DECREF(result);
1254    result = obj;
1255  } else {
1256    if (!PyList_Check(result)) {
1257      PyObject *o2 = result;
1258      result = PyList_New(1);
1259      PyList_SetItem(result, 0, o2);
1260    }
1261    PyList_Append(result,obj);
1262    Py_DECREF(obj);
1263  }
1264  return result;
1265#else
1266  PyObject*   o2;
1267  PyObject*   o3;
1268  if (!result) {
1269    result = obj;
1270  } else if (result == Py_None) {
1271    Py_DECREF(result);
1272    result = obj;
1273  } else {
1274    if (!PyTuple_Check(result)) {
1275      o2 = result;
1276      result = PyTuple_New(1);
1277      PyTuple_SET_ITEM(result, 0, o2);
1278    }
1279    o3 = PyTuple_New(1);
1280    PyTuple_SET_ITEM(o3, 0, obj);
1281    o2 = result;
1282    result = PySequence_Concat(o2, o3);
1283    Py_DECREF(o2);
1284    Py_DECREF(o3);
1285  }
1286  return result;
1287#endif
1288}
1289
1290/* Unpack the argument tuple */
1291
1292SWIGINTERN int
1293SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1294{
1295  if (!args) {
1296    if (!min && !max) {
1297      return 1;
1298    } else {
1299      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
1300                   name, (min == max ? "" : "at least "), (int)min);
1301      return 0;
1302    }
1303  } 
1304  if (!PyTuple_Check(args)) {
1305    if (min <= 1 && max >= 1) {
1306      register int i;
1307      objs[0] = args;
1308      for (i = 1; i < max; ++i) {
1309        objs[i] = 0;
1310      }
1311      return 2;
1312    }
1313    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1314    return 0;
1315  } else {
1316    register Py_ssize_t l = PyTuple_GET_SIZE(args);
1317    if (l < min) {
1318      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
1319                   name, (min == max ? "" : "at least "), (int)min, (int)l);
1320      return 0;
1321    } else if (l > max) {
1322      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
1323                   name, (min == max ? "" : "at most "), (int)max, (int)l);
1324      return 0;
1325    } else {
1326      register int i;
1327      for (i = 0; i < l; ++i) {
1328        objs[i] = PyTuple_GET_ITEM(args, i);
1329      }
1330      for (; l < max; ++l) {
1331        objs[l] = 0;
1332      }
1333      return i + 1;
1334    }   
1335  }
1336}
1337
1338/* A functor is a function object with one single object argument */
1339#if PY_VERSION_HEX >= 0x02020000
1340#define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1341#else
1342#define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1343#endif
1344
1345/*
1346  Helper for static pointer initialization for both C and C++ code, for example
1347  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1348*/
1349#ifdef __cplusplus
1350#define SWIG_STATIC_POINTER(var)  var
1351#else
1352#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1353#endif
1354
1355/* -----------------------------------------------------------------------------
1356 * Pointer declarations
1357 * ----------------------------------------------------------------------------- */
1358
1359/* Flags for new pointer objects */
1360#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1361#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1362
1363#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1364
1365#define SWIG_BUILTIN_TP_INIT        (SWIG_POINTER_OWN << 2)
1366#define SWIG_BUILTIN_INIT           (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1367
1368#ifdef __cplusplus
1369extern "C" {
1370#endif
1371
1372/*  How to access Py_None */
1373#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1374#  ifndef SWIG_PYTHON_NO_BUILD_NONE
1375#    ifndef SWIG_PYTHON_BUILD_NONE
1376#      define SWIG_PYTHON_BUILD_NONE
1377#    endif
1378#  endif
1379#endif
1380
1381#ifdef SWIG_PYTHON_BUILD_NONE
1382#  ifdef Py_None
1383#   undef Py_None
1384#   define Py_None SWIG_Py_None()
1385#  endif
1386SWIGRUNTIMEINLINE PyObject * 
1387_SWIG_Py_None(void)
1388{
1389  PyObject *none = Py_BuildValue((char*)"");
1390  Py_DECREF(none);
1391  return none;
1392}
1393SWIGRUNTIME PyObject * 
1394SWIG_Py_None(void)
1395{
1396  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1397  return none;
1398}
1399#endif
1400
1401/* The python void return value */
1402
1403SWIGRUNTIMEINLINE PyObject * 
1404SWIG_Py_Void(void)
1405{
1406  PyObject *none = Py_None;
1407  Py_INCREF(none);
1408  return none;
1409}
1410
1411/* SwigPyClientData */
1412
1413typedef struct {
1414  PyObject *klass;
1415  PyObject *newraw;
1416  PyObject *newargs;
1417  PyObject *destroy;
1418  int delargs;
1419  int implicitconv;
1420  PyTypeObject *pytype;
1421} SwigPyClientData;
1422
1423SWIGRUNTIMEINLINE int 
1424SWIG_Python_CheckImplicit(swig_type_info *ty)
1425{
1426  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1427  return data ? data->implicitconv : 0;
1428}
1429
1430SWIGRUNTIMEINLINE PyObject *
1431SWIG_Python_ExceptionType(swig_type_info *desc) {
1432  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1433  PyObject *klass = data ? data->klass : 0;
1434  return (klass ? klass : PyExc_RuntimeError);
1435}
1436
1437
1438SWIGRUNTIME SwigPyClientData * 
1439SwigPyClientData_New(PyObject* obj)
1440{
1441  if (!obj) {
1442    return 0;
1443  } else {
1444    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1445    /* the klass element */
1446    data->klass = obj;
1447    Py_INCREF(data->klass);
1448    /* the newraw method and newargs arguments used to create a new raw instance */
1449    if (PyClass_Check(obj)) {
1450      data->newraw = 0;
1451      data->newargs = obj;
1452      Py_INCREF(obj);
1453    } else {
1454#if (PY_VERSION_HEX < 0x02020000)
1455      data->newraw = 0;
1456#else
1457      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1458#endif
1459      if (data->newraw) {
1460        Py_INCREF(data->newraw);
1461        data->newargs = PyTuple_New(1);
1462        PyTuple_SetItem(data->newargs, 0, obj);
1463      } else {
1464        data->newargs = obj;
1465      }
1466      Py_INCREF(data->newargs);
1467    }
1468    /* the destroy method, aka as the C++ delete method */
1469    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1470    if (PyErr_Occurred()) {
1471      PyErr_Clear();
1472      data->destroy = 0;
1473    }
1474    if (data->destroy) {
1475      int flags;
1476      Py_INCREF(data->destroy);
1477      flags = PyCFunction_GET_FLAGS(data->destroy);
1478#ifdef METH_O
1479      data->delargs = !(flags & (METH_O));
1480#else
1481      data->delargs = 0;
1482#endif
1483    } else {
1484      data->delargs = 0;
1485    }
1486    data->implicitconv = 0;
1487    data->pytype = 0;
1488    return data;
1489  }
1490}
1491
1492SWIGRUNTIME void 
1493SwigPyClientData_Del(SwigPyClientData *data) {
1494  Py_XDECREF(data->newraw);
1495  Py_XDECREF(data->newargs);
1496  Py_XDECREF(data->destroy);
1497}
1498
1499/* =============== SwigPyObject =====================*/
1500
1501typedef struct {
1502  PyObject_HEAD
1503  void *ptr;
1504  swig_type_info *ty;
1505  int own;
1506  PyObject *next;
1507#ifdef SWIGPYTHON_BUILTIN
1508  PyObject *dict;
1509#endif
1510} SwigPyObject;
1511
1512SWIGRUNTIME PyObject *
1513SwigPyObject_long(SwigPyObject *v)
1514{
1515  return PyLong_FromVoidPtr(v->ptr);
1516}
1517
1518SWIGRUNTIME PyObject *
1519SwigPyObject_format(const char* fmt, SwigPyObject *v)
1520{
1521  PyObject *res = NULL;
1522  PyObject *args = PyTuple_New(1);
1523  if (args) {
1524    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1525      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1526      if (ofmt) {
1527#if PY_VERSION_HEX >= 0x03000000
1528        res = PyUnicode_Format(ofmt,args);
1529#else
1530        res = PyString_Format(ofmt,args);
1531#endif
1532        Py_DECREF(ofmt);
1533      }
1534      Py_DECREF(args);
1535    }
1536  }
1537  return res;
1538}
1539
1540SWIGRUNTIME PyObject *
1541SwigPyObject_oct(SwigPyObject *v)
1542{
1543  return SwigPyObject_format("%o",v);
1544}
1545
1546SWIGRUNTIME PyObject *
1547SwigPyObject_hex(SwigPyObject *v)
1548{
1549  return SwigPyObject_format("%x",v);
1550}
1551
1552SWIGRUNTIME PyObject *
1553#ifdef METH_NOARGS
1554SwigPyObject_repr(SwigPyObject *v)
1555#else
1556SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1557#endif
1558{
1559  const char *name = SWIG_TypePrettyName(v->ty);
1560  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1561  if (v->next) {
1562# ifdef METH_NOARGS
1563    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1564# else
1565    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1566# endif
1567# if PY_VERSION_HEX >= 0x03000000
1568    PyObject *joined = PyUnicode_Concat(repr, nrep);
1569    Py_DecRef(repr);
1570    Py_DecRef(nrep);
1571    repr = joined;
1572# else
1573    PyString_ConcatAndDel(&repr,nrep);
1574# endif
1575  }
1576  return repr; 
1577}
1578
1579SWIGRUNTIME int
1580SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1581{
1582  char *str;
1583#ifdef METH_NOARGS
1584  PyObject *repr = SwigPyObject_repr(v);
1585#else
1586  PyObject *repr = SwigPyObject_repr(v, NULL);
1587#endif
1588  if (repr) {
1589    str = SWIG_Python_str_AsChar(repr); 
1590    fputs(str, fp);
1591    SWIG_Python_str_DelForPy3(str);
1592    Py_DECREF(repr);
1593    return 0; 
1594  } else {
1595    return 1; 
1596  }
1597}
1598
1599SWIGRUNTIME PyObject *
1600SwigPyObject_str(SwigPyObject *v)
1601{
1602  char result[SWIG_BUFFER_SIZE];
1603  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1604    SWIG_Python_str_FromChar(result) : 0;
1605}
1606
1607SWIGRUNTIME int
1608SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1609{
1610  void *i = v->ptr;
1611  void *j = w->ptr;
1612  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1613}
1614
1615/* Added for Python 3.x, would it also be useful for Python 2.x? */
1616SWIGRUNTIME PyObject*
1617SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1618{
1619  PyObject* res;
1620  if( op != Py_EQ && op != Py_NE ) {
1621    Py_INCREF(Py_NotImplemented);
1622    return Py_NotImplemented;
1623  }
1624  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1625  return res; 
1626}
1627
1628
1629SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1630
1631#ifdef SWIGPYTHON_BUILTIN
1632static swig_type_info *SwigPyObject_stype = 0;
1633SWIGRUNTIME PyTypeObject*
1634SwigPyObject_type(void) {
1635    SwigPyClientData *cd;
1636    assert(SwigPyObject_stype);
1637    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1638    assert(cd);
1639    assert(cd->pytype);
1640    return cd->pytype;
1641}
1642#else
1643SWIGRUNTIME PyTypeObject*
1644SwigPyObject_type(void) {
1645  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1646  return type;
1647}
1648#endif
1649
1650SWIGRUNTIMEINLINE int
1651SwigPyObject_Check(PyObject *op) {
1652#ifdef SWIGPYTHON_BUILTIN
1653  PyTypeObject *target_tp = SwigPyObject_type();
1654  if (PyType_IsSubtype(op->ob_type, target_tp))
1655    return 1;
1656  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1657#else
1658  return (Py_TYPE(op) == SwigPyObject_type())
1659    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1660#endif
1661}
1662
1663SWIGRUNTIME PyObject *
1664SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1665
1666SWIGRUNTIME void
1667SwigPyObject_dealloc(PyObject *v)
1668{
1669  SwigPyObject *sobj = (SwigPyObject *) v;
1670  PyObject *next = sobj->next;
1671  if (sobj->own == SWIG_POINTER_OWN) {
1672    swig_type_info *ty = sobj->ty;
1673    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1674    PyObject *destroy = data ? data->destroy : 0;
1675    if (destroy) {
1676      /* destroy is always a VARARGS method */
1677      PyObject *res;
1678      if (data->delargs) {
1679        /* we need to create a temporary object to carry the destroy operation */
1680        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1681        res = SWIG_Python_CallFunctor(destroy, tmp);
1682        Py_DECREF(tmp);
1683      } else {
1684        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1685        PyObject *mself = PyCFunction_GET_SELF(destroy);
1686        res = ((*meth)(mself, v));
1687      }
1688      Py_XDECREF(res);
1689    } 
1690#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1691    else {
1692      const char *name = SWIG_TypePrettyName(ty);
1693      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1694    }
1695#endif
1696  } 
1697  Py_XDECREF(next);
1698  PyObject_DEL(v);
1699}
1700
1701SWIGRUNTIME PyObject* 
1702SwigPyObject_append(PyObject* v, PyObject* next)
1703{
1704  SwigPyObject *sobj = (SwigPyObject *) v;
1705#ifndef METH_O
1706  PyObject *tmp = 0;
1707  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1708  next = tmp;
1709#endif
1710  if (!SwigPyObject_Check(next)) {
1711    return NULL;
1712  }
1713  sobj->next = next;
1714  Py_INCREF(next);
1715  return SWIG_Py_Void();
1716}
1717
1718SWIGRUNTIME PyObject* 
1719#ifdef METH_NOARGS
1720SwigPyObject_next(PyObject* v)
1721#else
1722SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1723#endif
1724{
1725  SwigPyObject *sobj = (SwigPyObject *) v;
1726  if (sobj->next) {   
1727    Py_INCREF(sobj->next);
1728    return sobj->next;
1729  } else {
1730    return SWIG_Py_Void();
1731  }
1732}
1733
1734SWIGINTERN PyObject*
1735#ifdef METH_NOARGS
1736SwigPyObject_disown(PyObject *v)
1737#else
1738SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1739#endif
1740{
1741  SwigPyObject *sobj = (SwigPyObject *)v;
1742  sobj->own = 0;
1743  return SWIG_Py_Void();
1744}
1745
1746SWIGINTERN PyObject*
1747#ifdef METH_NOARGS
1748SwigPyObject_acquire(PyObject *v)
1749#else
1750SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1751#endif
1752{
1753  SwigPyObject *sobj = (SwigPyObject *)v;
1754  sobj->own = SWIG_POINTER_OWN;
1755  return SWIG_Py_Void();
1756}
1757
1758SWIGINTERN PyObject*
1759SwigPyObject_own(PyObject *v, PyObject *args)
1760{
1761  PyObject *val = 0;
1762#if (PY_VERSION_HEX < 0x02020000)
1763  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1764#elif (PY_VERSION_HEX < 0x02050000)
1765  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
1766#else
1767  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
1768#endif
1769    {
1770      return NULL;
1771    } 
1772  else
1773    {
1774      SwigPyObject *sobj = (SwigPyObject *)v;
1775      PyObject *obj = PyBool_FromLong(sobj->own);
1776      if (val) {
1777#ifdef METH_NOARGS
1778        if (PyObject_IsTrue(val)) {
1779          SwigPyObject_acquire(v);
1780        } else {
1781          SwigPyObject_disown(v);
1782        }
1783#else
1784        if (PyObject_IsTrue(val)) {
1785          SwigPyObject_acquire(v,args);
1786        } else {
1787          SwigPyObject_disown(v,args);
1788        }
1789#endif
1790      } 
1791      return obj;
1792    }
1793}
1794
1795#ifdef METH_O
1796static PyMethodDef
1797swigobject_methods[] = {
1798  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1799  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1800  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1801  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
1802  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1803  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1804  {0, 0, 0, 0} 
1805};
1806#else
1807static PyMethodDef
1808swigobject_methods[] = {
1809  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1810  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1811  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1812  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1813  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1814  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1815  {0, 0, 0, 0} 
1816};
1817#endif
1818
1819#if PY_VERSION_HEX < 0x02020000
1820SWIGINTERN PyObject *
1821SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1822{
1823  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1824}
1825#endif
1826
1827SWIGRUNTIME PyTypeObject*
1828SwigPyObject_TypeOnce(void) {
1829  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1830
1831  static PyNumberMethods SwigPyObject_as_number = {
1832    (binaryfunc)0, /*nb_add*/
1833    (binaryfunc)0, /*nb_subtract*/
1834    (binaryfunc)0, /*nb_multiply*/
1835    /* nb_divide removed in Python 3 */
1836#if PY_VERSION_HEX < 0x03000000
1837    (binaryfunc)0, /*nb_divide*/
1838#endif
1839    (binaryfunc)0, /*nb_remainder*/
1840    (binaryfunc)0, /*nb_divmod*/
1841    (ternaryfunc)0,/*nb_power*/
1842    (unaryfunc)0,  /*nb_negative*/
1843    (unaryfunc)0,  /*nb_positive*/
1844    (unaryfunc)0,  /*nb_absolute*/
1845    (inquiry)0,    /*nb_nonzero*/
1846    0,             /*nb_invert*/
1847    0,             /*nb_lshift*/
1848    0,             /*nb_rshift*/
1849    0,             /*nb_and*/
1850    0,             /*nb_xor*/
1851    0,             /*nb_or*/
1852#if PY_VERSION_HEX < 0x03000000
1853    0,   /*nb_coerce*/
1854#endif
1855    (unaryfunc)SwigPyObject_long, /*nb_int*/
1856#if PY_VERSION_HEX < 0x03000000
1857    (unaryfunc)SwigPyObject_long, /*nb_long*/
1858#else
1859    0, /*nb_reserved*/
1860#endif
1861    (unaryfunc)0,                 /*nb_float*/
1862#if PY_VERSION_HEX < 0x03000000
1863    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
1864    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
1865#endif
1866#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1867    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1868#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1869    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1870#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1871    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1872#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1873    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1874#endif
1875  };
1876
1877  static PyTypeObject swigpyobject_type;
1878  static int type_init = 0;
1879  if (!type_init) {
1880    const PyTypeObject tmp = {
1881      /* PyObject header changed in Python 3 */
1882#if PY_VERSION_HEX >= 0x03000000
1883      PyVarObject_HEAD_INIT(NULL, 0)
1884#else
1885      PyObject_HEAD_INIT(NULL)
1886      0,                                    /* ob_size */
1887#endif
1888      (char *)"SwigPyObject",               /* tp_name */
1889      sizeof(SwigPyObject),                 /* tp_basicsize */
1890      0,                                    /* tp_itemsize */
1891      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
1892      (printfunc)SwigPyObject_print,        /* tp_print */
1893#if PY_VERSION_HEX < 0x02020000
1894      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
1895#else
1896      (getattrfunc)0,                       /* tp_getattr */
1897#endif
1898      (setattrfunc)0,                       /* tp_setattr */
1899#if PY_VERSION_HEX >= 0x03000000
1900    0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1901#else
1902      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
1903#endif
1904      (reprfunc)SwigPyObject_repr,          /* tp_repr */
1905      &SwigPyObject_as_number,              /* tp_as_number */
1906      0,                                    /* tp_as_sequence */
1907      0,                                    /* tp_as_mapping */
1908      (hashfunc)0,                          /* tp_hash */
1909      (ternaryfunc)0,                       /* tp_call */
1910      (reprfunc)SwigPyObject_str,           /* tp_str */
1911      PyObject_GenericGetAttr,              /* tp_getattro */
1912      0,                                    /* tp_setattro */
1913      0,                                    /* tp_as_buffer */
1914      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
1915      swigobject_doc,                       /* tp_doc */
1916      0,                                    /* tp_traverse */
1917      0,                                    /* tp_clear */
1918      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1919      0,                                    /* tp_weaklistoffset */
1920#if PY_VERSION_HEX >= 0x02020000
1921      0,                                    /* tp_iter */
1922      0,                                    /* tp_iternext */
1923      swigobject_methods,                   /* tp_methods */
1924      0,                                    /* tp_members */
1925      0,                                    /* tp_getset */
1926      0,                                    /* tp_base */
1927      0,                                    /* tp_dict */
1928      0,                                    /* tp_descr_get */
1929      0,                                    /* tp_descr_set */
1930      0,                                    /* tp_dictoffset */
1931      0,                                    /* tp_init */
1932      0,                                    /* tp_alloc */
1933      0,                                    /* tp_new */
1934      0,                                    /* tp_free */
1935      0,                                    /* tp_is_gc */
1936      0,                                    /* tp_bases */
1937      0,                                    /* tp_mro */
1938      0,                                    /* tp_cache */
1939      0,                                    /* tp_subclasses */
1940      0,                                    /* tp_weaklist */
1941#endif
1942#if PY_VERSION_HEX >= 0x02030000
1943      0,                                    /* tp_del */
1944#endif
1945#if PY_VERSION_HEX >= 0x02060000
1946      0,                                    /* tp_version */
1947#endif
1948#ifdef COUNT_ALLOCS
1949      0,0,0,0                               /* tp_alloc -> tp_next */
1950#endif
1951    };
1952    swigpyobject_type = tmp;
1953    type_init = 1;
1954#if PY_VERSION_HEX < 0x02020000
1955    swigpyobject_type.ob_type = &PyType_Type;
1956#else
1957    if (PyType_Ready(&swigpyobject_type) < 0)
1958      return NULL;
1959#endif
1960  }
1961  return &swigpyobject_type;
1962}
1963
1964SWIGRUNTIME PyObject *
1965SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1966{
1967  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1968  if (sobj) {
1969    sobj->ptr  = ptr;
1970    sobj->ty   = ty;
1971    sobj->own  = own;
1972    sobj->next = 0;
1973  }
1974  return (PyObject *)sobj;
1975}
1976
1977/* -----------------------------------------------------------------------------
1978 * Implements a simple Swig Packed type, and use it instead of string
1979 * ----------------------------------------------------------------------------- */
1980
1981typedef struct {
1982  PyObject_HEAD
1983  void *pack;
1984  swig_type_info *ty;
1985  size_t size;
1986} SwigPyPacked;
1987
1988SWIGRUNTIME int
1989SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1990{
1991  char result[SWIG_BUFFER_SIZE];
1992  fputs("<Swig Packed ", fp); 
1993  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1994    fputs("at ", fp); 
1995    fputs(result, fp); 
1996  }
1997  fputs(v->ty->name,fp); 
1998  fputs(">", fp);
1999  return 0; 
2000}
2001 
2002SWIGRUNTIME PyObject *
2003SwigPyPacked_repr(SwigPyPacked *v)
2004{
2005  char result[SWIG_BUFFER_SIZE];
2006  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2007    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2008  } else {
2009    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2010  } 
2011}
2012
2013SWIGRUNTIME PyObject *
2014SwigPyPacked_str(SwigPyPacked *v)
2015{
2016  char result[SWIG_BUFFER_SIZE];
2017  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2018    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2019  } else {
2020    return SWIG_Python_str_FromChar(v->ty->name);
2021  } 
2022}
2023
2024SWIGRUNTIME int
2025SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2026{
2027  size_t i = v->size;
2028  size_t j = w->size;
2029  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2030  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2031}
2032
2033SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2034
2035SWIGRUNTIME PyTypeObject*
2036SwigPyPacked_type(void) {
2037  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2038  return type;
2039}
2040
2041SWIGRUNTIMEINLINE int
2042SwigPyPacked_Check(PyObject *op) {
2043  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
2044    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2045}
2046
2047SWIGRUNTIME void
2048SwigPyPacked_dealloc(PyObject *v)
2049{
2050  if (SwigPyPacked_Check(v)) {
2051    SwigPyPacked *sobj = (SwigPyPacked *) v;
2052    free(sobj->pack);
2053  }
2054  PyObject_DEL(v);
2055}
2056
2057SWIGRUNTIME PyTypeObject*
2058SwigPyPacked_TypeOnce(void) {
2059  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2060  static PyTypeObject swigpypacked_type;
2061  static int type_init = 0;
2062  if (!type_init) {
2063    const PyTypeObject tmp = {
2064      /* PyObject header changed in Python 3 */
2065#if PY_VERSION_HEX>=0x03000000
2066      PyVarObject_HEAD_INIT(NULL, 0)
2067#else
2068      PyObject_HEAD_INIT(NULL)
2069      0,                                    /* ob_size */
2070#endif
2071      (char *)"SwigPyPacked",               /* tp_name */
2072      sizeof(SwigPyPacked),                 /* tp_basicsize */
2073      0,                                    /* tp_itemsize */
2074      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
2075      (printfunc)SwigPyPacked_print,        /* tp_print */
2076      (getattrfunc)0,                       /* tp_getattr */
2077      (setattrfunc)0,                       /* tp_setattr */
2078#if PY_VERSION_HEX>=0x03000000
2079      0, /* tp_reserved in 3.0.1 */
2080#else
2081      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
2082#endif
2083      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
2084      0,                                    /* tp_as_number */
2085      0,                                    /* tp_as_sequence */
2086      0,                                    /* tp_as_mapping */
2087      (hashfunc)0,                          /* tp_hash */
2088      (ternaryfunc)0,                       /* tp_call */
2089      (reprfunc)SwigPyPacked_str,           /* tp_str */
2090      PyObject_GenericGetAttr,              /* tp_getattro */
2091      0,                                    /* tp_setattro */
2092      0,                                    /* tp_as_buffer */
2093      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
2094      swigpacked_doc,                       /* tp_doc */
2095      0,                                    /* tp_traverse */
2096      0,                                    /* tp_clear */
2097      0,                                    /* tp_richcompare */
2098      0,                                    /* tp_weaklistoffset */
2099#if PY_VERSION_HEX >= 0x02020000
2100      0,                                    /* tp_iter */
2101      0,                                    /* tp_iternext */
2102      0,                                    /* tp_methods */
2103      0,                                    /* tp_members */
2104      0,                                    /* tp_getset */
2105      0,                                    /* tp_base */
2106      0,                                    /* tp_dict */
2107      0,                                    /* tp_descr_get */
2108      0,                                    /* tp_descr_set */
2109      0,                                    /* tp_dictoffset */
2110      0,                                    /* tp_init */
2111      0,                                    /* tp_alloc */
2112      0,                                    /* tp_new */
2113      0,                                    /* tp_free */
2114      0,                                    /* tp_is_gc */
2115      0,                                    /* tp_bases */
2116      0,                                    /* tp_mro */
2117      0,                                    /* tp_cache */
2118      0,                                    /* tp_subclasses */
2119      0,                                    /* tp_weaklist */
2120#endif
2121#if PY_VERSION_HEX >= 0x02030000
2122      0,                                    /* tp_del */
2123#endif
2124#if PY_VERSION_HEX >= 0x02060000
2125      0,                                    /* tp_version */
2126#endif
2127#ifdef COUNT_ALLOCS
2128      0,0,0,0                               /* tp_alloc -> tp_next */
2129#endif
2130    };
2131    swigpypacked_type = tmp;
2132    type_init = 1;
2133#if PY_VERSION_HEX < 0x02020000
2134    swigpypacked_type.ob_type = &PyType_Type;
2135#else
2136    if (PyType_Ready(&swigpypacked_type) < 0)
2137      return NULL;
2138#endif
2139  }
2140  return &swigpypacked_type;
2141}
2142
2143SWIGRUNTIME PyObject *
2144SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2145{
2146  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2147  if (sobj) {
2148    void *pack = malloc(size);
2149    if (pack) {
2150      memcpy(pack, ptr, size);
2151      sobj->pack = pack;
2152      sobj->ty   = ty;
2153      sobj->size = size;
2154    } else {
2155      PyObject_DEL((PyObject *) sobj);
2156      sobj = 0;
2157    }
2158  }
2159  return (PyObject *) sobj;
2160}
2161
2162SWIGRUNTIME swig_type_info *
2163SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2164{
2165  if (SwigPyPacked_Check(obj)) {
2166    SwigPyPacked *sobj = (SwigPyPacked *)obj;
2167    if (sobj->size != size) return 0;
2168    memcpy(ptr, sobj->pack, size);
2169    return sobj->ty;
2170  } else {
2171    return 0;
2172  }
2173}
2174
2175/* -----------------------------------------------------------------------------
2176 * pointers/data manipulation
2177 * ----------------------------------------------------------------------------- */
2178
2179SWIGRUNTIMEINLINE PyObject *
2180_SWIG_This(void)
2181{
2182    return SWIG_Python_str_FromChar("this");
2183}
2184
2185static PyObject *swig_this = NULL;
2186
2187SWIGRUNTIME PyObject *
2188SWIG_This(void)
2189{
2190  if (swig_this == NULL)
2191    swig_this = _SWIG_This();
2192  return swig_this;
2193}
2194
2195/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2196
2197/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2198#if PY_VERSION_HEX>=0x03000000
2199#define SWIG_PYTHON_SLOW_GETSET_THIS
2200#endif
2201
2202SWIGRUNTIME SwigPyObject *
2203SWIG_Python_GetSwigThis(PyObject *pyobj) 
2204{
2205  PyObject *obj;
2206
2207  if (SwigPyObject_Check(pyobj))
2208    return (SwigPyObject *) pyobj;
2209
2210#ifdef SWIGPYTHON_BUILTIN
2211  (void)obj;
2212# ifdef PyWeakref_CheckProxy
2213  if (PyWeakref_CheckProxy(pyobj)) {
2214    pyobj = PyWeakref_GET_OBJECT(pyobj);
2215    if (pyobj && SwigPyObject_Check(pyobj))
2216      return (SwigPyObject*) pyobj;
2217  }
2218# endif
2219  return NULL;
2220#else
2221
2222  obj = 0;
2223
2224#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2225  if (PyInstance_Check(pyobj)) {
2226    obj = _PyInstance_Lookup(pyobj, SWIG_This());     
2227  } else {
2228    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2229    if (dictptr != NULL) {
2230      PyObject *dict = *dictptr;
2231      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2232    } else {
2233#ifdef PyWeakref_CheckProxy
2234      if (PyWeakref_CheckProxy(pyobj)) {
2235        PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2236        return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2237      }
2238#endif
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    }
2247  }
2248#else
2249  obj = PyObject_GetAttr(pyobj,SWIG_This());
2250  if (obj) {
2251    Py_DECREF(obj);
2252  } else {
2253    if (PyErr_Occurred()) PyErr_Clear();
2254    return 0;
2255  }
2256#endif
2257  if (obj && !SwigPyObject_Check(obj)) {
2258    /* a PyObject is called 'this', try to get the 'real this'
2259       SwigPyObject from it */ 
2260    return SWIG_Python_GetSwigThis(obj);
2261  }
2262  return (SwigPyObject *)obj;
2263#endif
2264}
2265
2266/* Acquire a pointer value */
2267
2268SWIGRUNTIME int
2269SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2270  if (own == SWIG_POINTER_OWN) {
2271    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2272    if (sobj) {
2273      int oldown = sobj->own;
2274      sobj->own = own;
2275      return oldown;
2276    }
2277  }
2278  return 0;
2279}
2280
2281/* Convert a pointer value */
2282
2283SWIGRUNTIME int
2284SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2285  int res;
2286  SwigPyObject *sobj;
2287
2288  if (!obj)
2289    return SWIG_ERROR;
2290  if (obj == Py_None) {
2291    if (ptr)
2292      *ptr = 0;
2293    return SWIG_OK;
2294  }
2295
2296  res = SWIG_ERROR;
2297
2298  sobj = SWIG_Python_GetSwigThis(obj);
2299  if (own)
2300    *own = 0;
2301  while (sobj) {
2302    void *vptr = sobj->ptr;
2303    if (ty) {
2304      swig_type_info *to = sobj->ty;
2305      if (to == ty) {
2306        /* no type cast needed */
2307        if (ptr) *ptr = vptr;
2308        break;
2309      } else {
2310        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2311        if (!tc) {
2312          sobj = (SwigPyObject *)sobj->next;
2313        } else {
2314          if (ptr) {
2315            int newmemory = 0;
2316            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2317            if (newmemory == SWIG_CAST_NEW_MEMORY) {
2318              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2319              if (own)
2320                *own = *own | SWIG_CAST_NEW_MEMORY;
2321            }
2322          }
2323          break;
2324        }
2325      }
2326    } else {
2327      if (ptr) *ptr = vptr;
2328      break;
2329    }
2330  }
2331  if (sobj) {
2332    if (own)
2333      *own = *own | sobj->own;
2334    if (flags & SWIG_POINTER_DISOWN) {
2335      sobj->own = 0;
2336    }
2337    res = SWIG_OK;
2338  } else {
2339    if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2340      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2341      if (data && !data->implicitconv) {
2342        PyObject *klass = data->klass;
2343        if (klass) {
2344          PyObject *impconv;
2345          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2346          impconv = SWIG_Python_CallFunctor(klass, obj);
2347          data->implicitconv = 0;
2348          if (PyErr_Occurred()) {
2349            PyErr_Clear();
2350            impconv = 0;
2351          }
2352          if (impconv) {
2353            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2354            if (iobj) {
2355              void *vptr;
2356              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2357              if (SWIG_IsOK(res)) {
2358                if (ptr) {
2359                  *ptr = vptr;
2360                  /* transfer the ownership to 'ptr' */
2361                  iobj->own = 0;
2362                  res = SWIG_AddCast(res);
2363                  res = SWIG_AddNewMask(res);
2364                } else {
2365                  res = SWIG_AddCast(res);                 
2366                }
2367              }
2368            }
2369            Py_DECREF(impconv);
2370          }
2371        }
2372      }
2373    }
2374  }
2375  return res;
2376}
2377
2378/* Convert a function ptr value */
2379
2380SWIGRUNTIME int
2381SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2382  if (!PyCFunction_Check(obj)) {
2383    return SWIG_ConvertPtr(obj, ptr, ty, 0);
2384  } else {
2385    void *vptr = 0;
2386   
2387    /* here we get the method pointer for callbacks */
2388    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2389    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2390    if (desc)
2391      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2392    if (!desc) 
2393      return SWIG_ERROR;
2394    if (ty) {
2395      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2396      if (tc) {
2397        int newmemory = 0;
2398        *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2399        assert(!newmemory); /* newmemory handling not yet implemented */
2400      } else {
2401        return SWIG_ERROR;
2402      }
2403    } else {
2404      *ptr = vptr;
2405    }
2406    return SWIG_OK;
2407  }
2408}
2409
2410/* Convert a packed value value */
2411
2412SWIGRUNTIME int
2413SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2414  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2415  if (!to) return SWIG_ERROR;
2416  if (ty) {
2417    if (to != ty) {
2418      /* check type cast? */
2419      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2420      if (!tc) return SWIG_ERROR;
2421    }
2422  }
2423  return SWIG_OK;
2424} 
2425
2426/* -----------------------------------------------------------------------------
2427 * Create a new pointer object
2428 * ----------------------------------------------------------------------------- */
2429
2430/*
2431  Create a new instance object, without calling __init__, and set the
2432  'this' attribute.
2433*/
2434
2435SWIGRUNTIME PyObject* 
2436SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2437{
2438#if (PY_VERSION_HEX >= 0x02020000)
2439  PyObject *inst = 0;
2440  PyObject *newraw = data->newraw;
2441  if (newraw) {
2442    inst = PyObject_Call(newraw, data->newargs, NULL);
2443    if (inst) {
2444#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2445      PyObject **dictptr = _PyObject_GetDictPtr(inst);
2446      if (dictptr != NULL) {
2447        PyObject *dict = *dictptr;
2448        if (dict == NULL) {
2449          dict = PyDict_New();
2450          *dictptr = dict;
2451          PyDict_SetItem(dict, SWIG_This(), swig_this);
2452        }
2453      }
2454#else
2455      PyObject *key = SWIG_This();
2456      PyObject_SetAttr(inst, key, swig_this);
2457#endif
2458    }
2459  } else {
2460#if PY_VERSION_HEX >= 0x03000000
2461    inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2462    PyObject_SetAttr(inst, SWIG_This(), swig_this);
2463    Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2464#else
2465    PyObject *dict = PyDict_New();
2466    PyDict_SetItem(dict, SWIG_This(), swig_this);
2467    inst = PyInstance_NewRaw(data->newargs, dict);
2468    Py_DECREF(dict);
2469#endif
2470  }
2471  return inst;
2472#else
2473#if (PY_VERSION_HEX >= 0x02010000)
2474  PyObject *inst;
2475  PyObject *dict = PyDict_New();
2476  PyDict_SetItem(dict, SWIG_This(), swig_this);
2477  inst = PyInstance_NewRaw(data->newargs, dict);
2478  Py_DECREF(dict);
2479  return (PyObject *) inst;
2480#else
2481  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2482  if (inst == NULL) {
2483    return NULL;
2484  }
2485  inst->in_class = (PyClassObject *)data->newargs;
2486  Py_INCREF(inst->in_class);
2487  inst->in_dict = PyDict_New();
2488  if (inst->in_dict == NULL) {
2489    Py_DECREF(inst);
2490    return NULL;
2491  }
2492#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2493  inst->in_weakreflist = NULL;
2494#endif
2495#ifdef Py_TPFLAGS_GC
2496  PyObject_GC_Init(inst);
2497#endif
2498  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2499  return (PyObject *) inst;
2500#endif
2501#endif
2502}
2503
2504SWIGRUNTIME void
2505SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2506{
2507 PyObject *dict;
2508#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2509 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2510 if (dictptr != NULL) {
2511   dict = *dictptr;
2512   if (dict == NULL) {
2513     dict = PyDict_New();
2514     *dictptr = dict;
2515   }
2516   PyDict_SetItem(dict, SWIG_This(), swig_this);
2517   return;
2518 }
2519#endif
2520 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2521 PyDict_SetItem(dict, SWIG_This(), swig_this);
2522 Py_DECREF(dict);
2523} 
2524
2525
2526SWIGINTERN PyObject *
2527SWIG_Python_InitShadowInstance(PyObject *args) {
2528  PyObject *obj[2];
2529  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2530    return NULL;
2531  } else {
2532    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2533    if (sthis) {
2534      SwigPyObject_append((PyObject*) sthis, obj[1]);
2535    } else {
2536      SWIG_Python_SetSwigThis(obj[0], obj[1]);
2537    }
2538    return SWIG_Py_Void();
2539  }
2540}
2541
2542/* Create a new pointer object */
2543
2544SWIGRUNTIME PyObject *
2545SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2546  SwigPyClientData *clientdata;
2547  PyObject * robj;
2548  int own;
2549
2550  if (!ptr)
2551    return SWIG_Py_Void();
2552
2553  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2554  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2555  if (clientdata && clientdata->pytype) {
2556    SwigPyObject *newobj;
2557    if (flags & SWIG_BUILTIN_TP_INIT) {
2558      newobj = (SwigPyObject*) self;
2559      if (newobj->ptr) {
2560        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2561        while (newobj->next)
2562          newobj = (SwigPyObject *) newobj->next;
2563        newobj->next = next_self;
2564        newobj = (SwigPyObject *)next_self;
2565      }
2566    } else {
2567      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2568    }
2569    if (newobj) {
2570      newobj->ptr = ptr;
2571      newobj->ty = type;
2572      newobj->own = own;
2573      newobj->next = 0;
2574#ifdef SWIGPYTHON_BUILTIN
2575      newobj->dict = 0;
2576#endif
2577      return (PyObject*) newobj;
2578    }
2579    return SWIG_Py_Void();
2580  }
2581
2582  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2583
2584  robj = SwigPyObject_New(ptr, type, own);
2585  if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2586    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2587    if (inst) {
2588      Py_DECREF(robj);
2589      robj = inst;
2590    }
2591  }
2592  return robj;
2593}
2594
2595/* Create a new packed object */
2596
2597SWIGRUNTIMEINLINE PyObject *
2598SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2599  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2600}
2601
2602/* -----------------------------------------------------------------------------*
2603 *  Get type list
2604 * -----------------------------------------------------------------------------*/
2605
2606#ifdef SWIG_LINK_RUNTIME
2607void *SWIG_ReturnGlobalTypeList(void *);
2608#endif
2609
2610SWIGRUNTIME swig_module_info *
2611SWIG_Python_GetModule(void) {
2612  static void *type_pointer = (void *)0;
2613  /* first check if module already created */
2614  if (!type_pointer) {
2615#ifdef SWIG_LINK_RUNTIME
2616    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2617#else
2618# ifdef SWIGPY_USE_CAPSULE
2619    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2620# else
2621    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2622                                    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2623# endif
2624    if (PyErr_Occurred()) {
2625      PyErr_Clear();
2626      type_pointer = (void *)0;
2627    }
2628#endif
2629  }
2630  return (swig_module_info *) type_pointer;
2631}
2632
2633#if PY_MAJOR_VERSION < 2
2634/* PyModule_AddObject function was introduced in Python 2.0.  The following function
2635   is copied out of Python/modsupport.c in python version 2.3.4 */
2636SWIGINTERN int
2637PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2638{
2639  PyObject *dict;
2640  if (!PyModule_Check(m)) {
2641    PyErr_SetString(PyExc_TypeError,
2642                    "PyModule_AddObject() needs module as first arg");
2643    return SWIG_ERROR;
2644  }
2645  if (!o) {
2646    PyErr_SetString(PyExc_TypeError,
2647                    "PyModule_AddObject() needs non-NULL value");
2648    return SWIG_ERROR;
2649  }
2650 
2651  dict = PyModule_GetDict(m);
2652  if (dict == NULL) {
2653    /* Internal error -- modules must have a dict! */
2654    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2655                 PyModule_GetName(m));
2656    return SWIG_ERROR;
2657  }
2658  if (PyDict_SetItemString(dict, name, o))
2659    return SWIG_ERROR;
2660  Py_DECREF(o);
2661  return SWIG_OK;
2662}
2663#endif
2664
2665SWIGRUNTIME void
2666#ifdef SWIGPY_USE_CAPSULE
2667SWIG_Python_DestroyModule(PyObject *obj)
2668#else
2669SWIG_Python_DestroyModule(void *vptr)
2670#endif
2671{
2672#ifdef SWIGPY_USE_CAPSULE
2673  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2674#else
2675  swig_module_info *swig_module = (swig_module_info *) vptr;
2676#endif
2677  swig_type_info **types = swig_module->types;
2678  size_t i;
2679  for (i =0; i < swig_module->size; ++i) {
2680    swig_type_info *ty = types[i];
2681    if (ty->owndata) {
2682      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2683      if (data) SwigPyClientData_Del(data);
2684    }
2685  }
2686  Py_DECREF(SWIG_This());
2687  swig_this = NULL;
2688}
2689
2690SWIGRUNTIME void
2691SWIG_Python_SetModule(swig_module_info *swig_module) {
2692#if PY_VERSION_HEX >= 0x03000000
2693 /* Add a dummy module object into sys.modules */
2694  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2695#else
2696  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2697  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2698#endif
2699#ifdef SWIGPY_USE_CAPSULE
2700  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2701  if (pointer && module) {
2702    PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2703  } else {
2704    Py_XDECREF(pointer);
2705  }
2706#else
2707  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2708  if (pointer && module) {
2709    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2710  } else {
2711    Py_XDECREF(pointer);
2712  }
2713#endif
2714}
2715
2716/* The python cached type query */
2717SWIGRUNTIME PyObject *
2718SWIG_Python_TypeCache(void) {
2719  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2720  return cache;
2721}
2722
2723SWIGRUNTIME swig_type_info *
2724SWIG_Python_TypeQuery(const char *type)
2725{
2726  PyObject *cache = SWIG_Python_TypeCache();
2727  PyObject *key = SWIG_Python_str_FromChar(type); 
2728  PyObject *obj = PyDict_GetItem(cache, key);
2729  swig_type_info *descriptor;
2730  if (obj) {
2731#ifdef SWIGPY_USE_CAPSULE
2732    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2733#else
2734    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2735#endif
2736  } else {
2737    swig_module_info *swig_module = SWIG_Python_GetModule();
2738    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2739    if (descriptor) {
2740#ifdef SWIGPY_USE_CAPSULE
2741      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2742#else
2743      obj = PyCObject_FromVoidPtr(descriptor, NULL);
2744#endif
2745      PyDict_SetItem(cache, key, obj);
2746      Py_DECREF(obj);
2747    }
2748  }
2749  Py_DECREF(key);
2750  return descriptor;
2751}
2752
2753/*
2754   For backward compatibility only
2755*/
2756#define SWIG_POINTER_EXCEPTION  0
2757#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2758#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2759
2760SWIGRUNTIME int
2761SWIG_Python_AddErrMesg(const char* mesg, int infront)
2762{ 
2763  if (PyErr_Occurred()) {
2764    PyObject *type = 0;
2765    PyObject *value = 0;
2766    PyObject *traceback = 0;
2767    PyErr_Fetch(&type, &value, &traceback);
2768    if (value) {
2769      char *tmp;
2770      PyObject *old_str = PyObject_Str(value);
2771      Py_XINCREF(type);
2772      PyErr_Clear();
2773      if (infront) {
2774        PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2775      } else {
2776        PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2777      }
2778      SWIG_Python_str_DelForPy3(tmp);
2779      Py_DECREF(old_str);
2780    }
2781    return 1;
2782  } else {
2783    return 0;
2784  }
2785}
2786 
2787SWIGRUNTIME int
2788SWIG_Python_ArgFail(int argnum)
2789{
2790  if (PyErr_Occurred()) {
2791    /* add information about failing argument */
2792    char mesg[256];
2793    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2794    return SWIG_Python_AddErrMesg(mesg, 1);
2795  } else {
2796    return 0;
2797  }
2798}
2799
2800SWIGRUNTIMEINLINE const char *
2801SwigPyObject_GetDesc(PyObject *self)
2802{
2803  SwigPyObject *v = (SwigPyObject *)self;
2804  swig_type_info *ty = v ? v->ty : 0;
2805  return ty ? ty->str : "";
2806}
2807
2808SWIGRUNTIME void
2809SWIG_Python_TypeError(const char *type, PyObject *obj)
2810{
2811  if (type) {
2812#if defined(SWIG_COBJECT_TYPES)
2813    if (obj && SwigPyObject_Check(obj)) {
2814      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2815      if (otype) {
2816        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2817                     type, otype);
2818        return;
2819      }
2820    } else 
2821#endif     
2822    {
2823      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
2824      if (otype) {
2825        PyObject *str = PyObject_Str(obj);
2826        const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2827        if (cstr) {
2828          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2829                       type, otype, cstr);
2830          SWIG_Python_str_DelForPy3(cstr);
2831        } else {
2832          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2833                       type, otype);
2834        }
2835        Py_XDECREF(str);
2836        return;
2837      }
2838    }   
2839    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2840  } else {
2841    PyErr_Format(PyExc_TypeError, "unexpected type is received");
2842  }
2843}
2844
2845
2846/* Convert a pointer value, signal an exception on a type mismatch */
2847SWIGRUNTIME void *
2848SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2849  void *result;
2850  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2851    PyErr_Clear();
2852#if SWIG_POINTER_EXCEPTION
2853    if (flags) {
2854      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2855      SWIG_Python_ArgFail(argnum);
2856    }
2857#endif
2858  }
2859  return result;
2860}
2861
2862#ifdef SWIGPYTHON_BUILTIN
2863SWIGRUNTIME int
2864SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2865  PyTypeObject *tp = obj->ob_type;
2866  PyObject *descr;
2867  PyObject *encoded_name;
2868  descrsetfunc f;
2869  int res;
2870
2871# ifdef Py_USING_UNICODE
2872  if (PyString_Check(name)) {
2873    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2874    if (!name)
2875      return -1;
2876  } else if (!PyUnicode_Check(name))
2877# else
2878  if (!PyString_Check(name))
2879# endif
2880  {
2881    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2882    return -1;
2883  } else {
2884    Py_INCREF(name);
2885  }
2886
2887  if (!tp->tp_dict) {
2888    if (PyType_Ready(tp) < 0)
2889      goto done;
2890  }
2891
2892  res = -1;
2893  descr = _PyType_Lookup(tp, name);
2894  f = NULL;
2895  if (descr != NULL)
2896    f = descr->ob_type->tp_descr_set;
2897  if (!f) {
2898    if (PyString_Check(name)) {
2899      encoded_name = name;
2900      Py_INCREF(name);
2901    } else {
2902      encoded_name = PyUnicode_AsUTF8String(name);
2903    }
2904    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2905    Py_DECREF(encoded_name);
2906  } else {
2907    res = f(descr, obj, value);
2908  }
2909 
2910  done:
2911  Py_DECREF(name);
2912  return res;
2913}
2914#endif
2915
2916
2917#ifdef __cplusplus
2918}
2919#endif
2920
2921
2922
2923#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2924
2925#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2926
2927
2928
2929/* -------- TYPES TABLE (BEGIN) -------- */
2930
2931#define SWIGTYPE_p_attrl swig_types[0]
2932#define SWIGTYPE_p_attrlArray swig_types[1]
2933#define SWIGTYPE_p_attropl swig_types[2]
2934#define SWIGTYPE_p_batch_status swig_types[3]
2935#define SWIGTYPE_p_char swig_types[4]
2936#define SWIGTYPE_p_getter_setter swig_types[5]
2937#define SWIGTYPE_p_int swig_types[6]
2938#define SWIGTYPE_p_job_data swig_types[7]
2939#define SWIGTYPE_p_long swig_types[8]
2940#define SWIGTYPE_p_p_char swig_types[9]
2941#define SWIGTYPE_p_p_memmgr swig_types[10]
2942#define SWIGTYPE_p_pthread_mutex_t swig_types[11]
2943#define SWIGTYPE_p_sockaddr swig_types[12]
2944static swig_type_info *swig_types[14];
2945static swig_module_info swig_module = {swig_types, 13, 0, 0, 0, 0};
2946#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2947#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2948
2949/* -------- TYPES TABLE (END) -------- */
2950
2951#if (PY_VERSION_HEX <= 0x02000000)
2952# if !defined(SWIG_PYTHON_CLASSIC)
2953#  error "This python version requires swig to be run with the '-classic' option"
2954# endif
2955#endif
2956
2957/*-----------------------------------------------
2958              @(target):= _pbs.so
2959  ------------------------------------------------*/
2960#if PY_VERSION_HEX >= 0x03000000
2961#  define SWIG_init    PyInit__pbs
2962
2963#else
2964#  define SWIG_init    init_pbs
2965
2966#endif
2967#define SWIG_name    "_pbs"
2968
2969#define SWIGVERSION 0x020007
2970#define SWIG_VERSION SWIGVERSION
2971
2972
2973#define SWIG_as_voidptr(a) (void *)((const void *)(a))
2974#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2975
2976
2977
2978#include "pbs_ifl.h"
2979#include "pbs_error.h"
2980#include "rm.h"
2981#include "log.h"
2982
2983#define SARA_DEBUG 0
2984
2985//extern int pbs_errno;
2986
2987
2988
2989int Get_List_Size(PyObject *src)
2990{
2991  if (PyList_Check(src))
2992    return(PyList_Size(src));
2993
2994  /* check if valid NULL pointer */
2995  if ( PyString_Check(src) ) {
2996    if ( ! strcmp(PyString_AsString(src), "NULL") )
2997      return(0);
2998  }
2999  return(-1);
3000
3001} // end Get_List_Size()
3002
3003
3004
3005
3006// The default constructor for struct attrl
3007//
3008struct attrl *new_attrl(int number)
3009{
3010  struct attrl *ptr;
3011  struct attrl *prev, *current;
3012  int i;
3013
3014  /*
3015    allocate memory as a one block is handy for Python scripts
3016    and fill in the next fields so it also works for the C-library
3017  */
3018  printf("basje \n");
3019  ptr = (struct attrl *) malloc(number * sizeof(struct attrl));
3020
3021  prev = NULL;
3022  current = ptr + (number - 1);
3023  for (i=0; i < number; i++)
3024  { 
3025    printf("constructor called\n");
3026    current->name     = (char *) malloc(MAXNAMLEN * sizeof(char));
3027    current->resource = (char *) malloc(MAXNAMLEN * sizeof(char));
3028    current->value    = (char *) malloc(MAXNAMLEN * sizeof(char));
3029
3030    bzero( (void*) current->name, sizeof(current->name));
3031    bzero( (void*) current->resource, sizeof(current->resource));
3032    bzero( (void*) current->value, sizeof(current->value));
3033
3034    current->next     = prev;
3035    prev = current;
3036    current--;
3037  }
3038  return (struct attrl *)ptr;
3039
3040} // end new_attrl()
3041
3042
3043
3044// The default constructor for struct attropl
3045//
3046struct attropl *new_attropl(int number)
3047{
3048  struct attropl *ptr;
3049  struct attropl *prev, *current;
3050  int i;
3051
3052  /*
3053    allocate memory as a one block is handy for Python scripts
3054    and fill in the next fields so it also works for the C-library
3055  */
3056  ptr = (struct attropl *) malloc(number * sizeof(struct attropl));
3057
3058  prev = NULL;
3059  current = ptr + (number - 1);
3060  for (i=0; i < number; i++)
3061  { 
3062    printf("constructor called\n");
3063    current->name     = (char *) malloc(MAXNAMLEN * sizeof(char));
3064    current->resource = (char *) malloc(MAXNAMLEN * sizeof(char));
3065    current->value    = (char *) malloc(MAXNAMLEN * sizeof(char));
3066
3067    bzero( (void*) current->name, sizeof(current->name));
3068    bzero( (void*) current->resource, sizeof(current->resource));
3069    bzero( (void*) current->value, sizeof(current->value));
3070    // current->op = 0;
3071
3072    current->next     = prev;
3073    prev = current;
3074    current--;
3075  }
3076  return (struct attropl *)ptr;
3077
3078} // end new_attropl()
3079
3080/* Not used only returned */
3081struct batch_status *new_batch_status()
3082{
3083   struct batch_status *ptr;
3084
3085   ptr = (struct batch_status *) malloc(sizeof(struct batch_status));
3086   return (struct batch_status *)ptr;
3087} // end new struct batch_status
3088
3089int get_error()
3090{
3091   char *errmsg;
3092
3093   errmsg = pbse_to_txt(pbs_errno);
3094   if (SARA_DEBUG)
3095   {
3096      printf("Bas = %d\n", pbs_errno);
3097      printf("Bas = %d, text = %s\n", pbs_errno, errmsg);
3098   }
3099   return (pbs_errno);
3100}
3101
3102
3103
3104
3105#include <limits.h>
3106#if !defined(SWIG_NO_LLONG_MAX)
3107# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3108#   define LLONG_MAX __LONG_LONG_MAX__
3109#   define LLONG_MIN (-LLONG_MAX - 1LL)
3110#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3111# endif
3112#endif
3113
3114
3115SWIGINTERN int
3116SWIG_AsVal_double (PyObject *obj, double *val)
3117{
3118  int res = SWIG_TypeError;
3119  if (PyFloat_Check(obj)) {
3120    if (val) *val = PyFloat_AsDouble(obj);
3121    return SWIG_OK;
3122  } else if (PyInt_Check(obj)) {
3123    if (val) *val = PyInt_AsLong(obj);
3124    return SWIG_OK;
3125  } else if (PyLong_Check(obj)) {
3126    double v = PyLong_AsDouble(obj);
3127    if (!PyErr_Occurred()) {
3128      if (val) *val = v;
3129      return SWIG_OK;
3130    } else {
3131      PyErr_Clear();
3132    }
3133  }
3134#ifdef SWIG_PYTHON_CAST_MODE
3135  {
3136    int dispatch = 0;
3137    double d = PyFloat_AsDouble(obj);
3138    if (!PyErr_Occurred()) {
3139      if (val) *val = d;
3140      return SWIG_AddCast(SWIG_OK);
3141    } else {
3142      PyErr_Clear();
3143    }
3144    if (!dispatch) {
3145      long v = PyLong_AsLong(obj);
3146      if (!PyErr_Occurred()) {
3147        if (val) *val = v;
3148        return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3149      } else {
3150        PyErr_Clear();
3151      }
3152    }
3153  }
3154#endif
3155  return res;
3156}
3157
3158
3159#include <float.h>
3160
3161
3162#include <math.h>
3163
3164
3165SWIGINTERNINLINE int
3166SWIG_CanCastAsInteger(double *d, double min, double max) {
3167  double x = *d;
3168  if ((min <= x && x <= max)) {
3169   double fx = floor(x);
3170   double cx = ceil(x);
3171   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3172   if ((errno == EDOM) || (errno == ERANGE)) {
3173     errno = 0;
3174   } else {
3175     double summ, reps, diff;
3176     if (rd < x) {
3177       diff = x - rd;
3178     } else if (rd > x) {
3179       diff = rd - x;
3180     } else {
3181       return 1;
3182     }
3183     summ = rd + x;
3184     reps = diff/summ;
3185     if (reps < 8*DBL_EPSILON) {
3186       *d = rd;
3187       return 1;
3188     }
3189   }
3190  }
3191  return 0;
3192}
3193
3194
3195SWIGINTERN int
3196SWIG_AsVal_long (PyObject *obj, long* val)
3197{
3198  if (PyInt_Check(obj)) {
3199    if (val) *val = PyInt_AsLong(obj);
3200    return SWIG_OK;
3201  } else if (PyLong_Check(obj)) {
3202    long v = PyLong_AsLong(obj);
3203    if (!PyErr_Occurred()) {
3204      if (val) *val = v;
3205      return SWIG_OK;
3206    } else {
3207      PyErr_Clear();
3208    }
3209  }
3210#ifdef SWIG_PYTHON_CAST_MODE
3211  {
3212    int dispatch = 0;
3213    long v = PyInt_AsLong(obj);
3214    if (!PyErr_Occurred()) {
3215      if (val) *val = v;
3216      return SWIG_AddCast(SWIG_OK);
3217    } else {
3218      PyErr_Clear();
3219    }
3220    if (!dispatch) {
3221      double d;
3222      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3223      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3224        if (val) *val = (long)(d);
3225        return res;
3226      }
3227    }
3228  }
3229#endif
3230  return SWIG_TypeError;
3231}
3232
3233
3234SWIGINTERN int
3235SWIG_AsVal_int (PyObject * obj, int *val)
3236{
3237  long v;
3238  int res = SWIG_AsVal_long (obj, &v);
3239  if (SWIG_IsOK(res)) {
3240    if ((v < INT_MIN || v > INT_MAX)) {
3241      return SWIG_OverflowError;
3242    } else {
3243      if (val) *val = (int)(v);
3244    }
3245  } 
3246  return res;
3247}
3248
3249
3250SWIGINTERNINLINE PyObject*
3251  SWIG_From_int  (int value)
3252{
3253  return PyInt_FromLong((long) value);
3254}
3255
3256
3257typedef struct attrl attrlArray;
3258
3259
3260SWIGINTERN int
3261SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
3262{
3263  if (PyInt_Check(obj)) {
3264    long v = PyInt_AsLong(obj);
3265    if (v >= 0) {
3266      if (val) *val = v;
3267      return SWIG_OK;
3268    } else {
3269      return SWIG_OverflowError;
3270    }
3271  } else if (PyLong_Check(obj)) {
3272    unsigned long v = PyLong_AsUnsignedLong(obj);
3273    if (!PyErr_Occurred()) {
3274      if (val) *val = v;
3275      return SWIG_OK;
3276    } else {
3277      PyErr_Clear();
3278    }
3279  }
3280#ifdef SWIG_PYTHON_CAST_MODE
3281  {
3282    int dispatch = 0;
3283    unsigned long v = PyLong_AsUnsignedLong(obj);
3284    if (!PyErr_Occurred()) {
3285      if (val) *val = v;
3286      return SWIG_AddCast(SWIG_OK);
3287    } else {
3288      PyErr_Clear();
3289    }
3290    if (!dispatch) {
3291      double d;
3292      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3293      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3294        if (val) *val = (unsigned long)(d);
3295        return res;
3296      }
3297    }
3298  }
3299#endif
3300  return SWIG_TypeError;
3301}
3302
3303
3304SWIGINTERNINLINE int
3305SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3306{
3307  unsigned long v;
3308  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3309  if (SWIG_IsOK(res) && val) *val = (size_t)(v);
3310  return res;
3311}
3312
3313SWIGINTERN attrlArray *new_attrlArray(size_t nelements){
3314    return (struct attrl *)malloc((nelements)*sizeof(struct attrl));
3315  }
3316SWIGINTERN void delete_attrlArray(attrlArray *self){
3317    free((char*)self);
3318  }
3319SWIGINTERN struct attrl attrlArray___getitem__(attrlArray *self,size_t index){
3320    return self[index];
3321  }
3322SWIGINTERN void attrlArray___setitem__(attrlArray *self,size_t index,struct attrl value){
3323    self[index] = value;
3324  }
3325SWIGINTERN struct attrl *attrlArray_cast(attrlArray *self){
3326    return self;
3327  }
3328SWIGINTERN attrlArray *attrlArray_frompointer(struct attrl *t){
3329    return (attrlArray *)(t);
3330  }
3331
3332SWIGINTERN swig_type_info*
3333SWIG_pchar_descriptor(void)
3334{
3335  static int init = 0;
3336  static swig_type_info* info = 0;
3337  if (!init) {
3338    info = SWIG_TypeQuery("_p_char");
3339    init = 1;
3340  }
3341  return info;
3342}
3343
3344
3345SWIGINTERNINLINE PyObject *
3346SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3347{
3348  if (carray) {
3349    if (size > INT_MAX) {
3350      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3351      return pchar_descriptor ? 
3352        SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3353    } else {
3354#if PY_VERSION_HEX >= 0x03000000
3355      return PyUnicode_FromStringAndSize(carray, (int)(size));
3356#else
3357      return PyString_FromStringAndSize(carray, (int)(size));
3358#endif
3359    }
3360  } else {
3361    return SWIG_Py_Void();
3362  }
3363}
3364
3365
3366SWIGINTERNINLINE PyObject * 
3367SWIG_FromCharPtr(const char *cptr)
3368{ 
3369  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3370}
3371
3372
3373SWIGINTERN int
3374SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3375{
3376#if PY_VERSION_HEX>=0x03000000
3377  if (PyUnicode_Check(obj))
3378#else 
3379  if (PyString_Check(obj))
3380#endif
3381  {
3382    char *cstr; Py_ssize_t len;
3383#if PY_VERSION_HEX>=0x03000000
3384    if (!alloc && cptr) {
3385        /* We can't allow converting without allocation, since the internal
3386           representation of string in Python 3 is UCS-2/UCS-4 but we require
3387           a UTF-8 representation.
3388           TODO(bhy) More detailed explanation */
3389        return SWIG_RuntimeError;
3390    }
3391    obj = PyUnicode_AsUTF8String(obj);
3392    PyBytes_AsStringAndSize(obj, &cstr, &len);
3393    if(alloc) *alloc = SWIG_NEWOBJ;
3394#else
3395    PyString_AsStringAndSize(obj, &cstr, &len);
3396#endif
3397    if (cptr) {
3398      if (alloc) {
3399        /*
3400           In python the user should not be able to modify the inner
3401           string representation. To warranty that, if you define
3402           SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3403           buffer is always returned.
3404
3405           The default behavior is just to return the pointer value,
3406           so, be careful.
3407        */ 
3408#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3409        if (*alloc != SWIG_OLDOBJ) 
3410#else
3411        if (*alloc == SWIG_NEWOBJ) 
3412#endif
3413          {
3414            *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3415            *alloc = SWIG_NEWOBJ;
3416          }
3417        else {
3418          *cptr = cstr;
3419          *alloc = SWIG_OLDOBJ;
3420        }
3421      } else {
3422        #if PY_VERSION_HEX>=0x03000000
3423        assert(0); /* Should never reach here in Python 3 */
3424        #endif
3425        *cptr = SWIG_Python_str_AsChar(obj);
3426      }
3427    }
3428    if (psize) *psize = len + 1;
3429#if PY_VERSION_HEX>=0x03000000
3430    Py_XDECREF(obj);
3431#endif
3432    return SWIG_OK;
3433  } else {
3434    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3435    if (pchar_descriptor) {
3436      void* vptr = 0;
3437      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3438        if (cptr) *cptr = (char *) vptr;
3439        if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3440        if (alloc) *alloc = SWIG_OLDOBJ;
3441        return SWIG_OK;
3442      }
3443    }
3444  }
3445  return SWIG_TypeError;
3446}
3447
3448
3449
3450
3451SWIGINTERN char *attrl___str__(struct attrl *self){
3452    static char temp[4 * 255] ;
3453    snprintf(temp, sizeof(temp), "(%s,%s,%s)", 
3454      self->name, self->resource, self->value);
3455   
3456    return &temp[0];
3457  }
3458SWIGINTERN void delete_attrl(struct attrl *self){
3459    if (SARA_DEBUG)
3460       printf("Bas free attrl\n");
3461
3462    /*
3463        free(self);
3464    */
3465  }
3466SWIGINTERN char *attropl___str__(struct attropl *self){
3467    static char temp[4 * 255] ;
3468    snprintf(temp, sizeof(temp), "(%s,%s,%s)", 
3469      self->name, self->resource, self->value);
3470   
3471    return &temp[0];
3472  }
3473SWIGINTERN void delete_attropl(struct attropl *self){
3474    if (SARA_DEBUG)
3475       printf("Bas free attropl\n");
3476
3477    /*
3478        free(self);
3479    */
3480  }
3481
3482SWIGINTERN int
3483SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3484{
3485  unsigned long v;
3486  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3487  if (SWIG_IsOK(res)) {
3488    if ((v > UINT_MAX)) {
3489      return SWIG_OverflowError;
3490    } else {
3491      if (val) *val = (unsigned int)(v);
3492    }
3493  } 
3494  return res;
3495}
3496
3497
3498SWIGINTERNINLINE PyObject*
3499  SWIG_From_bool  (bool value)
3500{
3501  return PyBool_FromLong(value ? 1 : 0);
3502}
3503
3504
3505SWIGINTERN int
3506SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3507{ 
3508  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3509  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3510  if (SWIG_IsOK(res)) {
3511    if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3512    if (csize <= size) {
3513      if (val) {
3514        if (csize) memcpy(val, cptr, csize*sizeof(char));
3515        if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3516      }
3517      if (alloc == SWIG_NEWOBJ) {
3518        free((char*)cptr);
3519        res = SWIG_DelNewMask(res);
3520      }     
3521      return res;
3522    }
3523    if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3524  }
3525  return SWIG_TypeError;
3526}
3527
3528#ifdef __cplusplus
3529extern "C" {
3530#endif
3531SWIGINTERN PyObject *_wrap_new_attrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3532  PyObject *resultobj = 0;
3533  int arg1 ;
3534  int val1 ;
3535  int ecode1 = 0 ;
3536  PyObject * obj0 = 0 ;
3537  struct attrl *result = 0 ;
3538 
3539  if (!PyArg_ParseTuple(args,(char *)"O:new_attrl",&obj0)) SWIG_fail;
3540  ecode1 = SWIG_AsVal_int(obj0, &val1);
3541  if (!SWIG_IsOK(ecode1)) {
3542    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_attrl" "', argument " "1"" of type '" "int""'");
3543  } 
3544  arg1 = (int)(val1);
3545  result = (struct attrl *)new_attrl(arg1);
3546  {
3547    PyObject      *obj_batch;
3548    struct attrl  *ptr;
3549    int           i=0, len=0;
3550   
3551    if (SARA_DEBUG) printf("Converteren c (struct attrl *) -> python:\n");
3552   
3553    ptr = result;
3554    while (ptr != NULL) {
3555      len++;
3556      ptr = ptr->next;
3557    }
3558    resultobj = PyList_New(len);
3559   
3560    if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3561   
3562    if (SARA_DEBUG) printf("\t<Contents>\n");
3563    ptr = result;
3564    for (i=0; i < len; i++) {
3565      obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attrl,1); 
3566      PyList_SetItem(resultobj, i, obj_batch);
3567      if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3568      ptr = ptr->next;
3569    }
3570    if (SARA_DEBUG) printf("\t</Contents>\n");
3571  }
3572  return resultobj;
3573fail:
3574  return NULL;
3575}
3576
3577
3578SWIGINTERN PyObject *_wrap_new_attropl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3579  PyObject *resultobj = 0;
3580  int arg1 ;
3581  int val1 ;
3582  int ecode1 = 0 ;
3583  PyObject * obj0 = 0 ;
3584  struct attropl *result = 0 ;
3585 
3586  if (!PyArg_ParseTuple(args,(char *)"O:new_attropl",&obj0)) SWIG_fail;
3587  ecode1 = SWIG_AsVal_int(obj0, &val1);
3588  if (!SWIG_IsOK(ecode1)) {
3589    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_attropl" "', argument " "1"" of type '" "int""'");
3590  } 
3591  arg1 = (int)(val1);
3592  result = (struct attropl *)new_attropl(arg1);
3593  {
3594    PyObject          *obj_batch;
3595    struct attropl    *ptr;
3596    int               i=0, len=0;
3597   
3598    if (SARA_DEBUG) printf("Converteren c (struct attropl *) -> python:\n");
3599   
3600    ptr = result;
3601    while (ptr != NULL) {
3602      len++;
3603      ptr = ptr->next;
3604    }
3605    resultobj = PyList_New(len);
3606    if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3607   
3608    if (SARA_DEBUG) printf("\t<Contents>\n");
3609    ptr = result;
3610    for (i=0; i < len; i++) {
3611      obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attropl,1); 
3612      PyList_SetItem(resultobj, i, obj_batch); 
3613      ptr = ptr->next;
3614    }
3615    if (SARA_DEBUG) printf("\t</Contents>\n");
3616  }
3617  return resultobj;
3618fail:
3619  return NULL;
3620}
3621
3622
3623SWIGINTERN PyObject *_wrap_new_batch_status(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3624  PyObject *resultobj = 0;
3625  struct batch_status *result = 0 ;
3626 
3627  if (!PyArg_ParseTuple(args,(char *)":new_batch_status")) SWIG_fail;
3628  result = (struct batch_status *)new_batch_status();
3629  {
3630    PyObject              *obj_batch;
3631    struct batch_status   *ptr;
3632    int                   i=0, len=0;
3633   
3634    // printf("Ja we are in bussniss\n");
3635    if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
3636   
3637    // Deterime length of list
3638    //
3639    ptr = result;
3640    while (ptr != NULL) {
3641      len++;
3642      ptr = ptr->next;
3643    }
3644    resultobj = PyList_New(len);
3645   
3646    if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3647   
3648    // Make a list of batch_status pointers
3649    //
3650    if (SARA_DEBUG) printf("\t<Contents>\n");
3651    ptr = result;
3652    for (i=0; i < len; i++) {
3653      obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0); 
3654      PyList_SetItem(resultobj, i, obj_batch);
3655      if (SARA_DEBUG)  {
3656        printf("\t\t- %s\n", ptr->name);
3657      }
3658      ptr = ptr->next;
3659    }
3660   
3661    if (SARA_DEBUG) printf("\t</Contents>\n");
3662  }
3663  return resultobj;
3664fail:
3665  return NULL;
3666}
3667
3668
3669SWIGINTERN PyObject *_wrap_get_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3670  PyObject *resultobj = 0;
3671  int result;
3672 
3673  if (!PyArg_ParseTuple(args,(char *)":get_error")) SWIG_fail;
3674  result = (int)get_error();
3675  resultobj = SWIG_From_int((int)(result));
3676  return resultobj;
3677fail:
3678  return NULL;
3679}
3680
3681
3682SWIGINTERN PyObject *_wrap_new_attrlArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3683  PyObject *resultobj = 0;
3684  size_t arg1 ;
3685  size_t val1 ;
3686  int ecode1 = 0 ;
3687  PyObject * obj0 = 0 ;
3688  attrlArray *result = 0 ;
3689 
3690  if (!PyArg_ParseTuple(args,(char *)"O:new_attrlArray",&obj0)) SWIG_fail;
3691  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
3692  if (!SWIG_IsOK(ecode1)) {
3693    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_attrlArray" "', argument " "1"" of type '" "size_t""'");
3694  } 
3695  arg1 = (size_t)(val1);
3696  result = (attrlArray *)new_attrlArray(arg1);
3697  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_attrlArray, SWIG_POINTER_NEW |  0 );
3698  return resultobj;
3699fail:
3700  return NULL;
3701}
3702
3703
3704SWIGINTERN PyObject *_wrap_delete_attrlArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3705  PyObject *resultobj = 0;
3706  attrlArray *arg1 = (attrlArray *) 0 ;
3707  void *argp1 = 0 ;
3708  int res1 = 0 ;
3709  PyObject * obj0 = 0 ;
3710 
3711  if (!PyArg_ParseTuple(args,(char *)"O:delete_attrlArray",&obj0)) SWIG_fail;
3712  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrlArray, SWIG_POINTER_DISOWN |  0 );
3713  if (!SWIG_IsOK(res1)) {
3714    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_attrlArray" "', argument " "1"" of type '" "attrlArray *""'"); 
3715  }
3716  arg1 = (attrlArray *)(argp1);
3717  delete_attrlArray(arg1);
3718  resultobj = SWIG_Py_Void();
3719  return resultobj;
3720fail:
3721  return NULL;
3722}
3723
3724
3725SWIGINTERN PyObject *_wrap_attrlArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3726  PyObject *resultobj = 0;
3727  attrlArray *arg1 = (attrlArray *) 0 ;
3728  size_t arg2 ;
3729  void *argp1 = 0 ;
3730  int res1 = 0 ;
3731  size_t val2 ;
3732  int ecode2 = 0 ;
3733  PyObject * obj0 = 0 ;
3734  PyObject * obj1 = 0 ;
3735  struct attrl result;
3736 
3737  if (!PyArg_ParseTuple(args,(char *)"OO:attrlArray___getitem__",&obj0,&obj1)) SWIG_fail;
3738  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrlArray, 0 |  0 );
3739  if (!SWIG_IsOK(res1)) {
3740    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrlArray___getitem__" "', argument " "1"" of type '" "attrlArray *""'"); 
3741  }
3742  arg1 = (attrlArray *)(argp1);
3743  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
3744  if (!SWIG_IsOK(ecode2)) {
3745    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "attrlArray___getitem__" "', argument " "2"" of type '" "size_t""'");
3746  } 
3747  arg2 = (size_t)(val2);
3748  result = attrlArray___getitem__(arg1,arg2);
3749  resultobj = SWIG_NewPointerObj((struct attrl *)memcpy((struct attrl *)malloc(sizeof(struct attrl)),&result,sizeof(struct attrl)), SWIGTYPE_p_attrl, SWIG_POINTER_OWN |  0 );
3750  return resultobj;
3751fail:
3752  return NULL;
3753}
3754
3755
3756SWIGINTERN PyObject *_wrap_attrlArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3757  PyObject *resultobj = 0;
3758  attrlArray *arg1 = (attrlArray *) 0 ;
3759  size_t arg2 ;
3760  struct attrl arg3 ;
3761  void *argp1 = 0 ;
3762  int res1 = 0 ;
3763  size_t val2 ;
3764  int ecode2 = 0 ;
3765  void *argp3 ;
3766  int res3 = 0 ;
3767  PyObject * obj0 = 0 ;
3768  PyObject * obj1 = 0 ;
3769  PyObject * obj2 = 0 ;
3770 
3771  if (!PyArg_ParseTuple(args,(char *)"OOO:attrlArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
3772  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrlArray, 0 |  0 );
3773  if (!SWIG_IsOK(res1)) {
3774    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrlArray___setitem__" "', argument " "1"" of type '" "attrlArray *""'"); 
3775  }
3776  arg1 = (attrlArray *)(argp1);
3777  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
3778  if (!SWIG_IsOK(ecode2)) {
3779    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "attrlArray___setitem__" "', argument " "2"" of type '" "size_t""'");
3780  } 
3781  arg2 = (size_t)(val2);
3782  {
3783    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_attrl,  0 );
3784    if (!SWIG_IsOK(res3)) {
3785      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "attrlArray___setitem__" "', argument " "3"" of type '" "struct attrl""'"); 
3786    } 
3787    if (!argp3) {
3788      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "attrlArray___setitem__" "', argument " "3"" of type '" "struct attrl""'");
3789    } else {
3790      arg3 = *((struct attrl *)(argp3));
3791    }
3792  }
3793  attrlArray___setitem__(arg1,arg2,arg3);
3794  resultobj = SWIG_Py_Void();
3795  return resultobj;
3796fail:
3797  return NULL;
3798}
3799
3800
3801SWIGINTERN PyObject *_wrap_attrlArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3802  PyObject *resultobj = 0;
3803  attrlArray *arg1 = (attrlArray *) 0 ;
3804  void *argp1 = 0 ;
3805  int res1 = 0 ;
3806  PyObject * obj0 = 0 ;
3807  struct attrl *result = 0 ;
3808 
3809  if (!PyArg_ParseTuple(args,(char *)"O:attrlArray_cast",&obj0)) SWIG_fail;
3810  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrlArray, 0 |  0 );
3811  if (!SWIG_IsOK(res1)) {
3812    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrlArray_cast" "', argument " "1"" of type '" "attrlArray *""'"); 
3813  }
3814  arg1 = (attrlArray *)(argp1);
3815  result = (struct attrl *)attrlArray_cast(arg1);
3816  {
3817    PyObject      *obj_batch;
3818    struct attrl  *ptr;
3819    int           i=0, len=0;
3820   
3821    if (SARA_DEBUG) printf("Converteren c (struct attrl *) -> python:\n");
3822   
3823    ptr = result;
3824    while (ptr != NULL) {
3825      len++;
3826      ptr = ptr->next;
3827    }
3828    resultobj = PyList_New(len);
3829   
3830    if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3831   
3832    if (SARA_DEBUG) printf("\t<Contents>\n");
3833    ptr = result;
3834    for (i=0; i < len; i++) {
3835      obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attrl,1); 
3836      PyList_SetItem(resultobj, i, obj_batch);
3837      if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3838      ptr = ptr->next;
3839    }
3840    if (SARA_DEBUG) printf("\t</Contents>\n");
3841  }
3842  return resultobj;
3843fail:
3844  return NULL;
3845}
3846
3847
3848SWIGINTERN PyObject *_wrap_attrlArray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3849  PyObject *resultobj = 0;
3850  struct attrl *arg1 = (struct attrl *) 0 ;
3851  void *argp1 = 0 ;
3852  int res1 = 0 ;
3853  PyObject * obj0 = 0 ;
3854  attrlArray *result = 0 ;
3855 
3856  if (!PyArg_ParseTuple(args,(char *)"O:attrlArray_frompointer",&obj0)) SWIG_fail;
3857  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
3858  if (!SWIG_IsOK(res1)) {
3859    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrlArray_frompointer" "', argument " "1"" of type '" "struct attrl *""'"); 
3860  }
3861  arg1 = (struct attrl *)(argp1);
3862  result = (attrlArray *)attrlArray_frompointer(arg1);
3863  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_attrlArray, 0 |  0 );
3864  return resultobj;
3865fail:
3866  return NULL;
3867}
3868
3869
3870SWIGINTERN PyObject *attrlArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3871  PyObject *obj;
3872  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
3873  SWIG_TypeNewClientData(SWIGTYPE_p_attrlArray, SWIG_NewClientData(obj));
3874  return SWIG_Py_Void();
3875}
3876
3877SWIGINTERN PyObject *_wrap_attrl_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3878  PyObject *resultobj = 0;
3879  struct attrl *arg1 = (struct attrl *) 0 ;
3880  struct attrl *arg2 = (struct attrl *) 0 ;
3881  void *argp1 = 0 ;
3882  int res1 = 0 ;
3883  void *argp2 = 0 ;
3884  int res2 = 0 ;
3885  PyObject * obj0 = 0 ;
3886  PyObject * obj1 = 0 ;
3887 
3888  if (!PyArg_ParseTuple(args,(char *)"OO:attrl_next_set",&obj0,&obj1)) SWIG_fail;
3889  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
3890  if (!SWIG_IsOK(res1)) {
3891    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_next_set" "', argument " "1"" of type '" "struct attrl *""'"); 
3892  }
3893  arg1 = (struct attrl *)(argp1);
3894  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_attrl, SWIG_POINTER_DISOWN |  0 );
3895  if (!SWIG_IsOK(res2)) {
3896    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "attrl_next_set" "', argument " "2"" of type '" "struct attrl *""'"); 
3897  }
3898  arg2 = (struct attrl *)(argp2);
3899  if (arg1) (arg1)->next = arg2;
3900  resultobj = SWIG_Py_Void();
3901  return resultobj;
3902fail:
3903  return NULL;
3904}
3905
3906
3907SWIGINTERN PyObject *_wrap_attrl_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3908  PyObject *resultobj = 0;
3909  struct attrl *arg1 = (struct attrl *) 0 ;
3910  void *argp1 = 0 ;
3911  int res1 = 0 ;
3912  PyObject * obj0 = 0 ;
3913  struct attrl *result = 0 ;
3914 
3915  if (!PyArg_ParseTuple(args,(char *)"O:attrl_next_get",&obj0)) SWIG_fail;
3916  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
3917  if (!SWIG_IsOK(res1)) {
3918    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_next_get" "', argument " "1"" of type '" "struct attrl *""'"); 
3919  }
3920  arg1 = (struct attrl *)(argp1);
3921  result = (struct attrl *) ((arg1)->next);
3922  {
3923    PyObject      *obj_batch;
3924    struct attrl  *ptr;
3925    int           i=0, len=0;
3926   
3927    if (SARA_DEBUG) printf("Converteren c (struct attrl *) -> python:\n");
3928   
3929    ptr = result;
3930    while (ptr != NULL) {
3931      len++;
3932      ptr = ptr->next;
3933    }
3934    resultobj = PyList_New(len);
3935   
3936    if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3937   
3938    if (SARA_DEBUG) printf("\t<Contents>\n");
3939    ptr = result;
3940    for (i=0; i < len; i++) {
3941      obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attrl,1); 
3942      PyList_SetItem(resultobj, i, obj_batch);
3943      if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3944      ptr = ptr->next;
3945    }
3946    if (SARA_DEBUG) printf("\t</Contents>\n");
3947  }
3948  return resultobj;
3949fail:
3950  return NULL;
3951}
3952
3953
3954SWIGINTERN PyObject *_wrap_attrl_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3955  PyObject *resultobj = 0;
3956  struct attrl *arg1 = (struct attrl *) 0 ;
3957  char *arg2 = (char *) 0 ;
3958  void *argp1 = 0 ;
3959  int res1 = 0 ;
3960  int res2 ;
3961  char *buf2 = 0 ;
3962  int alloc2 = 0 ;
3963  PyObject * obj0 = 0 ;
3964  PyObject * obj1 = 0 ;
3965 
3966  if (!PyArg_ParseTuple(args,(char *)"OO:attrl_name_set",&obj0,&obj1)) SWIG_fail;
3967  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
3968  if (!SWIG_IsOK(res1)) {
3969    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_name_set" "', argument " "1"" of type '" "struct attrl *""'"); 
3970  }
3971  arg1 = (struct attrl *)(argp1);
3972  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3973  if (!SWIG_IsOK(res2)) {
3974    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "attrl_name_set" "', argument " "2"" of type '" "char *""'");
3975  }
3976  arg2 = (char *)(buf2);
3977  if (arg1->name) free((char*)arg1->name);
3978  if (arg2) {
3979    size_t size = strlen((const char *)(arg2)) + 1;
3980    arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
3981  } else {
3982    arg1->name = 0;
3983  }
3984  resultobj = SWIG_Py_Void();
3985  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3986  return resultobj;
3987fail:
3988  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3989  return NULL;
3990}
3991
3992
3993SWIGINTERN PyObject *_wrap_attrl_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3994  PyObject *resultobj = 0;
3995  struct attrl *arg1 = (struct attrl *) 0 ;
3996  void *argp1 = 0 ;
3997  int res1 = 0 ;
3998  PyObject * obj0 = 0 ;
3999  char *result = 0 ;
4000 
4001  if (!PyArg_ParseTuple(args,(char *)"O:attrl_name_get",&obj0)) SWIG_fail;
4002  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
4003  if (!SWIG_IsOK(res1)) {
4004    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_name_get" "', argument " "1"" of type '" "struct attrl *""'"); 
4005  }
4006  arg1 = (struct attrl *)(argp1);
4007  result = (char *) ((arg1)->name);
4008  resultobj = SWIG_FromCharPtr((const char *)result);
4009  return resultobj;
4010fail:
4011  return NULL;
4012}
4013
4014
4015SWIGINTERN PyObject *_wrap_attrl_resource_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4016  PyObject *resultobj = 0;
4017  struct attrl *arg1 = (struct attrl *) 0 ;
4018  char *arg2 = (char *) 0 ;
4019  void *argp1 = 0 ;
4020  int res1 = 0 ;
4021  int res2 ;
4022  char *buf2 = 0 ;
4023  int alloc2 = 0 ;
4024  PyObject * obj0 = 0 ;
4025  PyObject * obj1 = 0 ;
4026 
4027  if (!PyArg_ParseTuple(args,(char *)"OO:attrl_resource_set",&obj0,&obj1)) SWIG_fail;
4028  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
4029  if (!SWIG_IsOK(res1)) {
4030    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_resource_set" "', argument " "1"" of type '" "struct attrl *""'"); 
4031  }
4032  arg1 = (struct attrl *)(argp1);
4033  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4034  if (!SWIG_IsOK(res2)) {
4035    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "attrl_resource_set" "', argument " "2"" of type '" "char *""'");
4036  }
4037  arg2 = (char *)(buf2);
4038  if (arg1->resource) free((char*)arg1->resource);
4039  if (arg2) {
4040    size_t size = strlen((const char *)(arg2)) + 1;
4041    arg1->resource = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4042  } else {
4043    arg1->resource = 0;
4044  }
4045  resultobj = SWIG_Py_Void();
4046  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4047  return resultobj;
4048fail:
4049  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4050  return NULL;
4051}
4052
4053
4054SWIGINTERN PyObject *_wrap_attrl_resource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4055  PyObject *resultobj = 0;
4056  struct attrl *arg1 = (struct attrl *) 0 ;
4057  void *argp1 = 0 ;
4058  int res1 = 0 ;
4059  PyObject * obj0 = 0 ;
4060  char *result = 0 ;
4061 
4062  if (!PyArg_ParseTuple(args,(char *)"O:attrl_resource_get",&obj0)) SWIG_fail;
4063  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
4064  if (!SWIG_IsOK(res1)) {
4065    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_resource_get" "', argument " "1"" of type '" "struct attrl *""'"); 
4066  }
4067  arg1 = (struct attrl *)(argp1);
4068  result = (char *) ((arg1)->resource);
4069  resultobj = SWIG_FromCharPtr((const char *)result);
4070  return resultobj;
4071fail:
4072  return NULL;
4073}
4074
4075
4076SWIGINTERN PyObject *_wrap_attrl_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4077  PyObject *resultobj = 0;
4078  struct attrl *arg1 = (struct attrl *) 0 ;
4079  char *arg2 = (char *) 0 ;
4080  void *argp1 = 0 ;
4081  int res1 = 0 ;
4082  int res2 ;
4083  char *buf2 = 0 ;
4084  int alloc2 = 0 ;
4085  PyObject * obj0 = 0 ;
4086  PyObject * obj1 = 0 ;
4087 
4088  if (!PyArg_ParseTuple(args,(char *)"OO:attrl_value_set",&obj0,&obj1)) SWIG_fail;
4089  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
4090  if (!SWIG_IsOK(res1)) {
4091    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_value_set" "', argument " "1"" of type '" "struct attrl *""'"); 
4092  }
4093  arg1 = (struct attrl *)(argp1);
4094  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4095  if (!SWIG_IsOK(res2)) {
4096    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "attrl_value_set" "', argument " "2"" of type '" "char *""'");
4097  }
4098  arg2 = (char *)(buf2);
4099  if (arg1->value) free((char*)arg1->value);
4100  if (arg2) {
4101    size_t size = strlen((const char *)(arg2)) + 1;
4102    arg1->value = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4103  } else {
4104    arg1->value = 0;
4105  }
4106  resultobj = SWIG_Py_Void();
4107  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4108  return resultobj;
4109fail:
4110  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4111  return NULL;
4112}
4113
4114
4115SWIGINTERN PyObject *_wrap_attrl_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4116  PyObject *resultobj = 0;
4117  struct attrl *arg1 = (struct attrl *) 0 ;
4118  void *argp1 = 0 ;
4119  int res1 = 0 ;
4120  PyObject * obj0 = 0 ;
4121  char *result = 0 ;
4122 
4123  if (!PyArg_ParseTuple(args,(char *)"O:attrl_value_get",&obj0)) SWIG_fail;
4124  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
4125  if (!SWIG_IsOK(res1)) {
4126    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_value_get" "', argument " "1"" of type '" "struct attrl *""'"); 
4127  }
4128  arg1 = (struct attrl *)(argp1);
4129  result = (char *) ((arg1)->value);
4130  resultobj = SWIG_FromCharPtr((const char *)result);
4131  return resultobj;
4132fail:
4133  return NULL;
4134}
4135
4136
4137SWIGINTERN PyObject *_wrap_attrl_op_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4138  PyObject *resultobj = 0;
4139  struct attrl *arg1 = (struct attrl *) 0 ;
4140  enum batch_op arg2 ;
4141  void *argp1 = 0 ;
4142  int res1 = 0 ;
4143  int val2 ;
4144  int ecode2 = 0 ;
4145  PyObject * obj0 = 0 ;
4146  PyObject * obj1 = 0 ;
4147 
4148  if (!PyArg_ParseTuple(args,(char *)"OO:attrl_op_set",&obj0,&obj1)) SWIG_fail;
4149  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
4150  if (!SWIG_IsOK(res1)) {
4151    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_op_set" "', argument " "1"" of type '" "struct attrl *""'"); 
4152  }
4153  arg1 = (struct attrl *)(argp1);
4154  ecode2 = SWIG_AsVal_int(obj1, &val2);
4155  if (!SWIG_IsOK(ecode2)) {
4156    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "attrl_op_set" "', argument " "2"" of type '" "enum batch_op""'");
4157  } 
4158  arg2 = (enum batch_op)(val2);
4159  if (arg1) (arg1)->op = arg2;
4160  resultobj = SWIG_Py_Void();
4161  return resultobj;
4162fail:
4163  return NULL;
4164}
4165
4166
4167SWIGINTERN PyObject *_wrap_attrl_op_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4168  PyObject *resultobj = 0;
4169  struct attrl *arg1 = (struct attrl *) 0 ;
4170  void *argp1 = 0 ;
4171  int res1 = 0 ;
4172  PyObject * obj0 = 0 ;
4173  enum batch_op result;
4174 
4175  if (!PyArg_ParseTuple(args,(char *)"O:attrl_op_get",&obj0)) SWIG_fail;
4176  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
4177  if (!SWIG_IsOK(res1)) {
4178    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl_op_get" "', argument " "1"" of type '" "struct attrl *""'"); 
4179  }
4180  arg1 = (struct attrl *)(argp1);
4181  result = (enum batch_op) ((arg1)->op);
4182  resultobj = SWIG_From_int((int)(result));
4183  return resultobj;
4184fail:
4185  return NULL;
4186}
4187
4188
4189SWIGINTERN PyObject *_wrap_attrl___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4190  PyObject *resultobj = 0;
4191  struct attrl *arg1 = (struct attrl *) 0 ;
4192  void *argp1 = 0 ;
4193  int res1 = 0 ;
4194  PyObject * obj0 = 0 ;
4195  char *result = 0 ;
4196 
4197  if (!PyArg_ParseTuple(args,(char *)"O:attrl___str__",&obj0)) SWIG_fail;
4198  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, 0 |  0 );
4199  if (!SWIG_IsOK(res1)) {
4200    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attrl___str__" "', argument " "1"" of type '" "struct attrl *""'"); 
4201  }
4202  arg1 = (struct attrl *)(argp1);
4203  result = (char *)attrl___str__(arg1);
4204  resultobj = SWIG_FromCharPtr((const char *)result);
4205  return resultobj;
4206fail:
4207  return NULL;
4208}
4209
4210
4211SWIGINTERN PyObject *_wrap_delete_attrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4212  PyObject *resultobj = 0;
4213  struct attrl *arg1 = (struct attrl *) 0 ;
4214  void *argp1 = 0 ;
4215  int res1 = 0 ;
4216  PyObject * obj0 = 0 ;
4217 
4218  if (!PyArg_ParseTuple(args,(char *)"O:delete_attrl",&obj0)) SWIG_fail;
4219  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attrl, SWIG_POINTER_DISOWN |  0 );
4220  if (!SWIG_IsOK(res1)) {
4221    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_attrl" "', argument " "1"" of type '" "struct attrl *""'"); 
4222  }
4223  arg1 = (struct attrl *)(argp1);
4224  delete_attrl(arg1);
4225  resultobj = SWIG_Py_Void();
4226  return resultobj;
4227fail:
4228  return NULL;
4229}
4230
4231
4232SWIGINTERN PyObject *attrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4233  PyObject *obj;
4234  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4235  SWIG_TypeNewClientData(SWIGTYPE_p_attrl, SWIG_NewClientData(obj));
4236  return SWIG_Py_Void();
4237}
4238
4239SWIGINTERN PyObject *_wrap_attropl_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4240  PyObject *resultobj = 0;
4241  struct attropl *arg1 = (struct attropl *) 0 ;
4242  struct attropl *arg2 = (struct attropl *) 0 ;
4243  void *argp1 = 0 ;
4244  int res1 = 0 ;
4245  void *argp2 = 0 ;
4246  int res2 = 0 ;
4247  PyObject * obj0 = 0 ;
4248  PyObject * obj1 = 0 ;
4249 
4250  if (!PyArg_ParseTuple(args,(char *)"OO:attropl_next_set",&obj0,&obj1)) SWIG_fail;
4251  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4252  if (!SWIG_IsOK(res1)) {
4253    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_next_set" "', argument " "1"" of type '" "struct attropl *""'"); 
4254  }
4255  arg1 = (struct attropl *)(argp1);
4256  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_attropl, SWIG_POINTER_DISOWN |  0 );
4257  if (!SWIG_IsOK(res2)) {
4258    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "attropl_next_set" "', argument " "2"" of type '" "struct attropl *""'"); 
4259  }
4260  arg2 = (struct attropl *)(argp2);
4261  if (arg1) (arg1)->next = arg2;
4262  resultobj = SWIG_Py_Void();
4263  return resultobj;
4264fail:
4265  return NULL;
4266}
4267
4268
4269SWIGINTERN PyObject *_wrap_attropl_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4270  PyObject *resultobj = 0;
4271  struct attropl *arg1 = (struct attropl *) 0 ;
4272  void *argp1 = 0 ;
4273  int res1 = 0 ;
4274  PyObject * obj0 = 0 ;
4275  struct attropl *result = 0 ;
4276 
4277  if (!PyArg_ParseTuple(args,(char *)"O:attropl_next_get",&obj0)) SWIG_fail;
4278  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4279  if (!SWIG_IsOK(res1)) {
4280    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_next_get" "', argument " "1"" of type '" "struct attropl *""'"); 
4281  }
4282  arg1 = (struct attropl *)(argp1);
4283  result = (struct attropl *) ((arg1)->next);
4284  {
4285    PyObject          *obj_batch;
4286    struct attropl    *ptr;
4287    int               i=0, len=0;
4288   
4289    if (SARA_DEBUG) printf("Converteren c (struct attropl *) -> python:\n");
4290   
4291    ptr = result;
4292    while (ptr != NULL) {
4293      len++;
4294      ptr = ptr->next;
4295    }
4296    resultobj = PyList_New(len);
4297    if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
4298   
4299    if (SARA_DEBUG) printf("\t<Contents>\n");
4300    ptr = result;
4301    for (i=0; i < len; i++) {
4302      obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attropl,1); 
4303      PyList_SetItem(resultobj, i, obj_batch); 
4304      ptr = ptr->next;
4305    }
4306    if (SARA_DEBUG) printf("\t</Contents>\n");
4307  }
4308  return resultobj;
4309fail:
4310  return NULL;
4311}
4312
4313
4314SWIGINTERN PyObject *_wrap_attropl_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4315  PyObject *resultobj = 0;
4316  struct attropl *arg1 = (struct attropl *) 0 ;
4317  char *arg2 = (char *) 0 ;
4318  void *argp1 = 0 ;
4319  int res1 = 0 ;
4320  int res2 ;
4321  char *buf2 = 0 ;
4322  int alloc2 = 0 ;
4323  PyObject * obj0 = 0 ;
4324  PyObject * obj1 = 0 ;
4325 
4326  if (!PyArg_ParseTuple(args,(char *)"OO:attropl_name_set",&obj0,&obj1)) SWIG_fail;
4327  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4328  if (!SWIG_IsOK(res1)) {
4329    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_name_set" "', argument " "1"" of type '" "struct attropl *""'"); 
4330  }
4331  arg1 = (struct attropl *)(argp1);
4332  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4333  if (!SWIG_IsOK(res2)) {
4334    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "attropl_name_set" "', argument " "2"" of type '" "char *""'");
4335  }
4336  arg2 = (char *)(buf2);
4337  if (arg1->name) free((char*)arg1->name);
4338  if (arg2) {
4339    size_t size = strlen((const char *)(arg2)) + 1;
4340    arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4341  } else {
4342    arg1->name = 0;
4343  }
4344  resultobj = SWIG_Py_Void();
4345  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4346  return resultobj;
4347fail:
4348  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4349  return NULL;
4350}
4351
4352
4353SWIGINTERN PyObject *_wrap_attropl_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4354  PyObject *resultobj = 0;
4355  struct attropl *arg1 = (struct attropl *) 0 ;
4356  void *argp1 = 0 ;
4357  int res1 = 0 ;
4358  PyObject * obj0 = 0 ;
4359  char *result = 0 ;
4360 
4361  if (!PyArg_ParseTuple(args,(char *)"O:attropl_name_get",&obj0)) SWIG_fail;
4362  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4363  if (!SWIG_IsOK(res1)) {
4364    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_name_get" "', argument " "1"" of type '" "struct attropl *""'"); 
4365  }
4366  arg1 = (struct attropl *)(argp1);
4367  result = (char *) ((arg1)->name);
4368  resultobj = SWIG_FromCharPtr((const char *)result);
4369  return resultobj;
4370fail:
4371  return NULL;
4372}
4373
4374
4375SWIGINTERN PyObject *_wrap_attropl_resource_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4376  PyObject *resultobj = 0;
4377  struct attropl *arg1 = (struct attropl *) 0 ;
4378  char *arg2 = (char *) 0 ;
4379  void *argp1 = 0 ;
4380  int res1 = 0 ;
4381  int res2 ;
4382  char *buf2 = 0 ;
4383  int alloc2 = 0 ;
4384  PyObject * obj0 = 0 ;
4385  PyObject * obj1 = 0 ;
4386 
4387  if (!PyArg_ParseTuple(args,(char *)"OO:attropl_resource_set",&obj0,&obj1)) SWIG_fail;
4388  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4389  if (!SWIG_IsOK(res1)) {
4390    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_resource_set" "', argument " "1"" of type '" "struct attropl *""'"); 
4391  }
4392  arg1 = (struct attropl *)(argp1);
4393  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4394  if (!SWIG_IsOK(res2)) {
4395    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "attropl_resource_set" "', argument " "2"" of type '" "char *""'");
4396  }
4397  arg2 = (char *)(buf2);
4398  if (arg1->resource) free((char*)arg1->resource);
4399  if (arg2) {
4400    size_t size = strlen((const char *)(arg2)) + 1;
4401    arg1->resource = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4402  } else {
4403    arg1->resource = 0;
4404  }
4405  resultobj = SWIG_Py_Void();
4406  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4407  return resultobj;
4408fail:
4409  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4410  return NULL;
4411}
4412
4413
4414SWIGINTERN PyObject *_wrap_attropl_resource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4415  PyObject *resultobj = 0;
4416  struct attropl *arg1 = (struct attropl *) 0 ;
4417  void *argp1 = 0 ;
4418  int res1 = 0 ;
4419  PyObject * obj0 = 0 ;
4420  char *result = 0 ;
4421 
4422  if (!PyArg_ParseTuple(args,(char *)"O:attropl_resource_get",&obj0)) SWIG_fail;
4423  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4424  if (!SWIG_IsOK(res1)) {
4425    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_resource_get" "', argument " "1"" of type '" "struct attropl *""'"); 
4426  }
4427  arg1 = (struct attropl *)(argp1);
4428  result = (char *) ((arg1)->resource);
4429  resultobj = SWIG_FromCharPtr((const char *)result);
4430  return resultobj;
4431fail:
4432  return NULL;
4433}
4434
4435
4436SWIGINTERN PyObject *_wrap_attropl_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4437  PyObject *resultobj = 0;
4438  struct attropl *arg1 = (struct attropl *) 0 ;
4439  char *arg2 = (char *) 0 ;
4440  void *argp1 = 0 ;
4441  int res1 = 0 ;
4442  int res2 ;
4443  char *buf2 = 0 ;
4444  int alloc2 = 0 ;
4445  PyObject * obj0 = 0 ;
4446  PyObject * obj1 = 0 ;
4447 
4448  if (!PyArg_ParseTuple(args,(char *)"OO:attropl_value_set",&obj0,&obj1)) SWIG_fail;
4449  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4450  if (!SWIG_IsOK(res1)) {
4451    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_value_set" "', argument " "1"" of type '" "struct attropl *""'"); 
4452  }
4453  arg1 = (struct attropl *)(argp1);
4454  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4455  if (!SWIG_IsOK(res2)) {
4456    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "attropl_value_set" "', argument " "2"" of type '" "char *""'");
4457  }
4458  arg2 = (char *)(buf2);
4459  if (arg1->value) free((char*)arg1->value);
4460  if (arg2) {
4461    size_t size = strlen((const char *)(arg2)) + 1;
4462    arg1->value = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4463  } else {
4464    arg1->value = 0;
4465  }
4466  resultobj = SWIG_Py_Void();
4467  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4468  return resultobj;
4469fail:
4470  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4471  return NULL;
4472}
4473
4474
4475SWIGINTERN PyObject *_wrap_attropl_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476  PyObject *resultobj = 0;
4477  struct attropl *arg1 = (struct attropl *) 0 ;
4478  void *argp1 = 0 ;
4479  int res1 = 0 ;
4480  PyObject * obj0 = 0 ;
4481  char *result = 0 ;
4482 
4483  if (!PyArg_ParseTuple(args,(char *)"O:attropl_value_get",&obj0)) SWIG_fail;
4484  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4485  if (!SWIG_IsOK(res1)) {
4486    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_value_get" "', argument " "1"" of type '" "struct attropl *""'"); 
4487  }
4488  arg1 = (struct attropl *)(argp1);
4489  result = (char *) ((arg1)->value);
4490  resultobj = SWIG_FromCharPtr((const char *)result);
4491  return resultobj;
4492fail:
4493  return NULL;
4494}
4495
4496
4497SWIGINTERN PyObject *_wrap_attropl_op_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4498  PyObject *resultobj = 0;
4499  struct attropl *arg1 = (struct attropl *) 0 ;
4500  enum batch_op arg2 ;
4501  void *argp1 = 0 ;
4502  int res1 = 0 ;
4503  int val2 ;
4504  int ecode2 = 0 ;
4505  PyObject * obj0 = 0 ;
4506  PyObject * obj1 = 0 ;
4507 
4508  if (!PyArg_ParseTuple(args,(char *)"OO:attropl_op_set",&obj0,&obj1)) SWIG_fail;
4509  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4510  if (!SWIG_IsOK(res1)) {
4511    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_op_set" "', argument " "1"" of type '" "struct attropl *""'"); 
4512  }
4513  arg1 = (struct attropl *)(argp1);
4514  ecode2 = SWIG_AsVal_int(obj1, &val2);
4515  if (!SWIG_IsOK(ecode2)) {
4516    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "attropl_op_set" "', argument " "2"" of type '" "enum batch_op""'");
4517  } 
4518  arg2 = (enum batch_op)(val2);
4519  if (arg1) (arg1)->op = arg2;
4520  resultobj = SWIG_Py_Void();
4521  return resultobj;
4522fail:
4523  return NULL;
4524}
4525
4526
4527SWIGINTERN PyObject *_wrap_attropl_op_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4528  PyObject *resultobj = 0;
4529  struct attropl *arg1 = (struct attropl *) 0 ;
4530  void *argp1 = 0 ;
4531  int res1 = 0 ;
4532  PyObject * obj0 = 0 ;
4533  enum batch_op result;
4534 
4535  if (!PyArg_ParseTuple(args,(char *)"O:attropl_op_get",&obj0)) SWIG_fail;
4536  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4537  if (!SWIG_IsOK(res1)) {
4538    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl_op_get" "', argument " "1"" of type '" "struct attropl *""'"); 
4539  }
4540  arg1 = (struct attropl *)(argp1);
4541  result = (enum batch_op) ((arg1)->op);
4542  resultobj = SWIG_From_int((int)(result));
4543  return resultobj;
4544fail:
4545  return NULL;
4546}
4547
4548
4549SWIGINTERN PyObject *_wrap_attropl___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4550  PyObject *resultobj = 0;
4551  struct attropl *arg1 = (struct attropl *) 0 ;
4552  void *argp1 = 0 ;
4553  int res1 = 0 ;
4554  PyObject * obj0 = 0 ;
4555  char *result = 0 ;
4556 
4557  if (!PyArg_ParseTuple(args,(char *)"O:attropl___str__",&obj0)) SWIG_fail;
4558  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, 0 |  0 );
4559  if (!SWIG_IsOK(res1)) {
4560    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "attropl___str__" "', argument " "1"" of type '" "struct attropl *""'"); 
4561  }
4562  arg1 = (struct attropl *)(argp1);
4563  result = (char *)attropl___str__(arg1);
4564  resultobj = SWIG_FromCharPtr((const char *)result);
4565  return resultobj;
4566fail:
4567  return NULL;
4568}
4569
4570
4571SWIGINTERN PyObject *_wrap_delete_attropl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4572  PyObject *resultobj = 0;
4573  struct attropl *arg1 = (struct attropl *) 0 ;
4574  void *argp1 = 0 ;
4575  int res1 = 0 ;
4576  PyObject * obj0 = 0 ;
4577 
4578  if (!PyArg_ParseTuple(args,(char *)"O:delete_attropl",&obj0)) SWIG_fail;
4579  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_attropl, SWIG_POINTER_DISOWN |  0 );
4580  if (!SWIG_IsOK(res1)) {
4581    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_attropl" "', argument " "1"" of type '" "struct attropl *""'"); 
4582  }
4583  arg1 = (struct attropl *)(argp1);
4584  delete_attropl(arg1);
4585  resultobj = SWIG_Py_Void();
4586  return resultobj;
4587fail:
4588  return NULL;
4589}
4590
4591
4592SWIGINTERN PyObject *attropl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4593  PyObject *obj;
4594  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4595  SWIG_TypeNewClientData(SWIGTYPE_p_attropl, SWIG_NewClientData(obj));
4596  return SWIG_Py_Void();
4597}
4598
4599SWIGINTERN PyObject *_wrap_batch_status_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4600  PyObject *resultobj = 0;
4601  struct batch_status *arg1 = (struct batch_status *) 0 ;
4602  struct batch_status *arg2 = (struct batch_status *) 0 ;
4603  void *argp1 = 0 ;
4604  int res1 = 0 ;
4605  void *argp2 = 0 ;
4606  int res2 = 0 ;
4607  PyObject * obj0 = 0 ;
4608  PyObject * obj1 = 0 ;
4609 
4610  if (!PyArg_ParseTuple(args,(char *)"OO:batch_status_next_set",&obj0,&obj1)) SWIG_fail;
4611  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_batch_status, 0 |  0 );
4612  if (!SWIG_IsOK(res1)) {
4613    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "batch_status_next_set" "', argument " "1"" of type '" "struct batch_status *""'"); 
4614  }
4615  arg1 = (struct batch_status *)(argp1);
4616  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_batch_status, SWIG_POINTER_DISOWN |  0 );
4617  if (!SWIG_IsOK(res2)) {
4618    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "batch_status_next_set" "', argument " "2"" of type '" "struct batch_status *""'"); 
4619  }
4620  arg2 = (struct batch_status *)(argp2);
4621  if (arg1) (arg1)->next = arg2;
4622  resultobj = SWIG_Py_Void();
4623  return resultobj;
4624fail:
4625  return NULL;
4626}
4627
4628
4629SWIGINTERN PyObject *_wrap_batch_status_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630  PyObject *resultobj = 0;
4631  struct batch_status *arg1 = (struct batch_status *) 0 ;
4632  void *argp1 = 0 ;
4633  int res1 = 0 ;
4634  PyObject * obj0 = 0 ;
4635  struct batch_status *result = 0 ;
4636 
4637  if (!PyArg_ParseTuple(args,(char *)"O:batch_status_next_get",&obj0)) SWIG_fail;
4638  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_batch_status, 0 |  0 );
4639  if (!SWIG_IsOK(res1)) {
4640    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "batch_status_next_get" "', argument " "1"" of type '" "struct batch_status *""'"); 
4641  }
4642  arg1 = (struct batch_status *)(argp1);
4643  result = (struct batch_status *) ((arg1)->next);
4644  {
4645    PyObject              *obj_batch;
4646    struct batch_status   *ptr;
4647    int                   i=0, len=0;
4648   
4649    // printf("Ja we are in bussniss\n");
4650    if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
4651   
4652    // Deterime length of list
4653    //
4654    ptr = result;
4655    while (ptr != NULL) {
4656      len++;
4657      ptr = ptr->next;
4658    }
4659    resultobj = PyList_New(len);
4660   
4661    if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
4662   
4663    // Make a list of batch_status pointers
4664    //
4665    if (SARA_DEBUG) printf("\t<Contents>\n");
4666    ptr = result;
4667    for (i=0; i < len; i++) {
4668      obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0); 
4669      PyList_SetItem(resultobj, i, obj_batch);
4670      if (SARA_DEBUG)  {
4671        printf("\t\t- %s\n", ptr->name);
4672      }
4673      ptr = ptr->next;
4674    }
4675   
4676    if (SARA_DEBUG) printf("\t</Contents>\n");
4677  }
4678  return resultobj;
4679fail:
4680  return NULL;
4681}
4682
4683
4684SWIGINTERN PyObject *_wrap_batch_status_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4685  PyObject *resultobj = 0;
4686  struct batch_status *arg1 = (struct batch_status *) 0 ;
4687  char *arg2 = (char *) 0 ;
4688  void *argp1 = 0 ;
4689  int res1 = 0 ;
4690  int res2 ;
4691  char *buf2 = 0 ;
4692  int alloc2 = 0 ;
4693  PyObject * obj0 = 0 ;
4694  PyObject * obj1 = 0 ;
4695 
4696  if (!PyArg_ParseTuple(args,(char *)"OO:batch_status_name_set",&obj0,&obj1)) SWIG_fail;
4697  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_batch_status, 0 |  0 );
4698  if (!SWIG_IsOK(res1)) {
4699    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "batch_status_name_set" "', argument " "1"" of type '" "struct batch_status *""'"); 
4700  }
4701  arg1 = (struct batch_status *)(argp1);
4702  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4703  if (!SWIG_IsOK(res2)) {
4704    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "batch_status_name_set" "', argument " "2"" of type '" "char *""'");
4705  }
4706  arg2 = (char *)(buf2);
4707  if (arg1->name) free((char*)arg1->name);
4708  if (arg2) {
4709    size_t size = strlen((const char *)(arg2)) + 1;
4710    arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4711  } else {
4712    arg1->name = 0;
4713  }
4714  resultobj = SWIG_Py_Void();
4715  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4716  return resultobj;
4717fail:
4718  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4719  return NULL;
4720}
4721
4722
4723SWIGINTERN PyObject *_wrap_batch_status_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4724  PyObject *resultobj = 0;
4725  struct batch_status *arg1 = (struct batch_status *) 0 ;
4726  void *argp1 = 0 ;
4727  int res1 = 0 ;
4728  PyObject * obj0 = 0 ;
4729  char *result = 0 ;
4730 
4731  if (!PyArg_ParseTuple(args,(char *)"O:batch_status_name_get",&obj0)) SWIG_fail;
4732  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_batch_status, 0 |  0 );
4733  if (!SWIG_IsOK(res1)) {
4734    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "batch_status_name_get" "', argument " "1"" of type '" "struct batch_status *""'"); 
4735  }
4736  arg1 = (struct batch_status *)(argp1);
4737  result = (char *) ((arg1)->name);
4738  resultobj = SWIG_FromCharPtr((const char *)result);
4739  return resultobj;
4740fail:
4741  return NULL;
4742}
4743
4744
4745SWIGINTERN PyObject *_wrap_batch_status_attribs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4746  PyObject *resultobj = 0;
4747  struct batch_status *arg1 = (struct batch_status *) 0 ;
4748  struct attrl *arg2 = (struct attrl *) 0 ;
4749  void *argp1 = 0 ;
4750  int res1 = 0 ;
4751  void *argp2 = 0 ;
4752  int res2 = 0 ;
4753  PyObject * obj0 = 0 ;
4754  PyObject * obj1 = 0 ;
4755 
4756  if (!PyArg_ParseTuple(args,(char *)"OO:batch_status_attribs_set",&obj0,&obj1)) SWIG_fail;
4757  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_batch_status, 0 |  0 );
4758  if (!SWIG_IsOK(res1)) {
4759    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "batch_status_attribs_set" "', argument " "1"" of type '" "struct batch_status *""'"); 
4760  }
4761  arg1 = (struct batch_status *)(argp1);
4762  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_attrl, SWIG_POINTER_DISOWN |  0 );
4763  if (!SWIG_IsOK(res2)) {
4764    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "batch_status_attribs_set" "', argument " "2"" of type '" "struct attrl *""'"); 
4765  }
4766  arg2 = (struct attrl *)(argp2);
4767  if (arg1) (arg1)->attribs = arg2;
4768  resultobj = SWIG_Py_Void();
4769  return resultobj;
4770fail:
4771  return NULL;
4772}
4773
4774
4775SWIGINTERN PyObject *_wrap_batch_status_attribs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4776  PyObject *resultobj = 0;
4777  struct batch_status *arg1 = (struct batch_status *) 0 ;
4778  void *argp1 = 0 ;
4779  int res1 = 0 ;
4780  PyObject * obj0 = 0 ;
4781  struct attrl *result = 0 ;
4782 
4783  if (!PyArg_ParseTuple(args,(char *)"O:batch_status_attribs_get",&obj0)) SWIG_fail;
4784  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_batch_status, 0 |  0 );
4785  if (!SWIG_IsOK(res1)) {
4786    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "batch_status_attribs_get" "', argument " "1"" of type '" "struct batch_status *""'"); 
4787  }
4788  arg1 = (struct batch_status *)(argp1);
4789  result = (struct attrl *) ((arg1)->attribs);
4790  {
4791    PyObject      *obj_batch;
4792    struct attrl  *ptr;
4793    int           i=0, len=0;
4794   
4795    if (SARA_DEBUG) printf("Converteren c (struct attrl *) -> python:\n");
4796   
4797    ptr = result;
4798    while (ptr != NULL) {
4799      len++;
4800      ptr = ptr->next;
4801    }
4802    resultobj = PyList_New(len);
4803   
4804    if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
4805   
4806    if (SARA_DEBUG) printf("\t<Contents>\n");
4807    ptr = result;
4808    for (i=0; i < len; i++) {
4809      obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attrl,1); 
4810      PyList_SetItem(resultobj, i, obj_batch);
4811      if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
4812      ptr = ptr->next;
4813    }
4814    if (SARA_DEBUG) printf("\t</Contents>\n");
4815  }
4816  return resultobj;
4817fail:
4818  return NULL;
4819}
4820
4821
4822SWIGINTERN PyObject *_wrap_batch_status_text_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4823  PyObject *resultobj = 0;
4824  struct batch_status *arg1 = (struct batch_status *) 0 ;
4825  char *arg2 = (char *) 0 ;
4826  void *argp1 = 0 ;
4827  int res1 = 0 ;
4828  int res2 ;
4829  char *buf2 = 0 ;
4830  int alloc2 = 0 ;
4831  PyObject * obj0 = 0 ;
4832  PyObject * obj1 = 0 ;
4833 
4834  if (!PyArg_ParseTuple(args,(char *)"OO:batch_status_text_set",&obj0,&obj1)) SWIG_fail;
4835  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_batch_status, 0 |  0 );
4836  if (!SWIG_IsOK(res1)) {
4837    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "batch_status_text_set" "', argument " "1"" of type '" "struct batch_status *""'"); 
4838  }
4839  arg1 = (struct batch_status *)(argp1);
4840  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4841  if (!SWIG_IsOK(res2)) {
4842    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "batch_status_text_set" "', argument " "2"" of type '" "char *""'");
4843  }
4844  arg2 = (char *)(buf2);
4845  if (arg1->text) free((char*)arg1->text);
4846  if (arg2) {
4847    size_t size = strlen((const char *)(arg2)) + 1;
4848    arg1->text = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4849  } else {
4850    arg1->text = 0;
4851  }
4852  resultobj = SWIG_Py_Void();
4853  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4854  return resultobj;
4855fail:
4856  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4857  return NULL;
4858}
4859
4860
4861SWIGINTERN PyObject *_wrap_batch_status_text_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4862  PyObject *resultobj = 0;
4863  struct batch_status *arg1 = (struct batch_status *) 0 ;
4864  void *argp1 = 0 ;
4865  int res1 = 0 ;
4866  PyObject * obj0 = 0 ;
4867  char *result = 0 ;
4868 
4869  if (!PyArg_ParseTuple(args,(char *)"O:batch_status_text_get",&obj0)) SWIG_fail;
4870  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_batch_status, 0 |  0 );
4871  if (!SWIG_IsOK(res1)) {
4872    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "batch_status_text_get" "', argument " "1"" of type '" "struct batch_status *""'"); 
4873  }
4874  arg1 = (struct batch_status *)(argp1);
4875  result = (char *) ((arg1)->text);
4876  resultobj = SWIG_FromCharPtr((const char *)result);
4877  return resultobj;
4878fail:
4879  return NULL;
4880}
4881
4882
4883SWIGINTERN PyObject *batch_status_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4884  PyObject *obj;
4885  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4886  SWIG_TypeNewClientData(SWIGTYPE_p_batch_status, SWIG_NewClientData(obj));
4887  return SWIG_Py_Void();
4888}
4889
4890SWIGINTERN int Swig_var_pbs_server_set(PyObject *_val) {
4891  {
4892    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
4893    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
4894    if (!SWIG_IsOK(res)) {
4895      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""pbs_server""' of type '""char *""'");
4896    }
4897    if (pbs_server) free((char*)pbs_server);
4898    if (alloc == SWIG_NEWOBJ) {
4899      pbs_server = cptr;
4900    } else {
4901      pbs_server = csize ? (char *)(char *)memcpy((char *)malloc((csize)*sizeof(char)), cptr, sizeof(char)*(csize)) : 0;
4902    }
4903  }
4904  return 0;
4905fail:
4906  return 1;
4907}
4908
4909
4910SWIGINTERN PyObject *Swig_var_pbs_server_get(void) {
4911  PyObject *pyobj = 0;
4912 
4913  pyobj = SWIG_FromCharPtr(pbs_server);
4914  return pyobj;
4915}
4916
4917
4918SWIGINTERN PyObject *_wrap_avail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4919  PyObject *resultobj = 0;
4920  int arg1 ;
4921  char *arg2 = (char *) 0 ;
4922  int val1 ;
4923  int ecode1 = 0 ;
4924  int res2 ;
4925  char *buf2 = 0 ;
4926  int alloc2 = 0 ;
4927  PyObject * obj0 = 0 ;
4928  PyObject * obj1 = 0 ;
4929  char *result = 0 ;
4930 
4931  if (!PyArg_ParseTuple(args,(char *)"OO:avail",&obj0,&obj1)) SWIG_fail;
4932  ecode1 = SWIG_AsVal_int(obj0, &val1);
4933  if (!SWIG_IsOK(ecode1)) {
4934    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "avail" "', argument " "1"" of type '" "int""'");
4935  } 
4936  arg1 = (int)(val1);
4937  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4938  if (!SWIG_IsOK(res2)) {
4939    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avail" "', argument " "2"" of type '" "char *""'");
4940  }
4941  arg2 = (char *)(buf2);
4942  result = (char *)avail(arg1,arg2);
4943  resultobj = SWIG_FromCharPtr((const char *)result);
4944  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4945  return resultobj;
4946fail:
4947  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4948  return NULL;
4949}
4950
4951
4952SWIGINTERN PyObject *_wrap_pbs_asyrunjob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4953  PyObject *resultobj = 0;
4954  int arg1 ;
4955  char *arg2 = (char *) 0 ;
4956  char *arg3 = (char *) 0 ;
4957  char *arg4 = (char *) 0 ;
4958  int val1 ;
4959  int ecode1 = 0 ;
4960  int res2 ;
4961  char *buf2 = 0 ;
4962  int alloc2 = 0 ;
4963  int res3 ;
4964  char *buf3 = 0 ;
4965  int alloc3 = 0 ;
4966  int res4 ;
4967  char *buf4 = 0 ;
4968  int alloc4 = 0 ;
4969  PyObject * obj0 = 0 ;
4970  PyObject * obj1 = 0 ;
4971  PyObject * obj2 = 0 ;
4972  PyObject * obj3 = 0 ;
4973  int result;
4974 
4975  if (!PyArg_ParseTuple(args,(char *)"OOOO:pbs_asyrunjob",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4976  ecode1 = SWIG_AsVal_int(obj0, &val1);
4977  if (!SWIG_IsOK(ecode1)) {
4978    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_asyrunjob" "', argument " "1"" of type '" "int""'");
4979  } 
4980  arg1 = (int)(val1);
4981  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4982  if (!SWIG_IsOK(res2)) {
4983    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_asyrunjob" "', argument " "2"" of type '" "char *""'");
4984  }
4985  arg2 = (char *)(buf2);
4986  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4987  if (!SWIG_IsOK(res3)) {
4988    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pbs_asyrunjob" "', argument " "3"" of type '" "char *""'");
4989  }
4990  arg3 = (char *)(buf3);
4991  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
4992  if (!SWIG_IsOK(res4)) {
4993    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pbs_asyrunjob" "', argument " "4"" of type '" "char *""'");
4994  }
4995  arg4 = (char *)(buf4);
4996  result = (int)pbs_asyrunjob(arg1,arg2,arg3,arg4);
4997  resultobj = SWIG_From_int((int)(result));
4998  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4999  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5000  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5001  return resultobj;
5002fail:
5003  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5004  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5005  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5006  return NULL;
5007}
5008
5009
5010SWIGINTERN PyObject *_wrap_pbs_alterjob_async(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5011  PyObject *resultobj = 0;
5012  int arg1 ;
5013  char *arg2 = (char *) 0 ;
5014  struct attrl *arg3 = (struct attrl *) 0 ;
5015  char *arg4 = (char *) 0 ;
5016  int val1 ;
5017  int ecode1 = 0 ;
5018  int res2 ;
5019  char *buf2 = 0 ;
5020  int alloc2 = 0 ;
5021  int res4 ;
5022  char *buf4 = 0 ;
5023  int alloc4 = 0 ;
5024  PyObject * obj0 = 0 ;
5025  PyObject * obj1 = 0 ;
5026  PyObject * obj2 = 0 ;
5027  PyObject * obj3 = 0 ;
5028  int result;
5029 
5030  if (!PyArg_ParseTuple(args,(char *)"OOOO:pbs_alterjob_async",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5031  ecode1 = SWIG_AsVal_int(obj0, &val1);
5032  if (!SWIG_IsOK(ecode1)) {
5033    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_alterjob_async" "', argument " "1"" of type '" "int""'");
5034  } 
5035  arg1 = (int)(val1);
5036  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5037  if (!SWIG_IsOK(res2)) {
5038    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_alterjob_async" "', argument " "2"" of type '" "char *""'");
5039  }
5040  arg2 = (char *)(buf2);
5041  {
5042    PyObject      *py_obj;
5043    struct attrl  *ptr, *prev;
5044    char          s[255];
5045    int           i=0, size=0;
5046   
5047    // printf("Python --> C\n");
5048   
5049    if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
5050   
5051    size = Get_List_Size(obj2);
5052    if (SARA_DEBUG) printf("\tSize of attrl List: %d\n", size);
5053   
5054    if ( size == -1 ) {
5055      PyErr_SetString(PyExc_TypeError, "not a list");
5056      return NULL; 
5057    }
5058   
5059    if (SARA_DEBUG) printf("\t<Contents>\n");
5060   
5061    arg3 = prev = NULL;
5062    for ( i=0; i < size; i++ ) {
5063      py_obj = PyList_GetItem(obj2, i);
5064      if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
5065        sprintf(s,"list item %d has wrong type", i);
5066        PyErr_SetString(PyExc_TypeError, s);
5067        return NULL;
5068       
5069        // This will skipp the wrong entry
5070        // continue;
5071      }
5072     
5073      /*
5074           * Make first entry head of C linked list
5075          */ 
5076      if ( i == 0) {
5077        arg3 = ptr;
5078        ptr->next = prev;
5079      }
5080      else {
5081        prev->next = ptr;
5082        ptr->next = NULL;
5083      }
5084      if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
5085     
5086      prev = ptr;
5087     
5088    } // end for
5089    if (SARA_DEBUG) printf("\t</Contents>\n");
5090  }
5091  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5092  if (!SWIG_IsOK(res4)) {
5093    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pbs_alterjob_async" "', argument " "4"" of type '" "char *""'");
5094  }
5095  arg4 = (char *)(buf4);
5096  result = (int)pbs_alterjob_async(arg1,arg2,arg3,arg4);
5097  resultobj = SWIG_From_int((int)(result));
5098  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5099  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5100  return resultobj;
5101fail:
5102  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5103  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5104  return NULL;
5105}
5106
5107
5108SWIGINTERN PyObject *_wrap_pbs_alterjob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5109  PyObject *resultobj = 0;
5110  int arg1 ;
5111  char *arg2 = (char *) 0 ;
5112  struct attrl *arg3 = (struct attrl *) 0 ;
5113  char *arg4 = (char *) 0 ;
5114  int val1 ;
5115  int ecode1 = 0 ;
5116  int res2 ;
5117  char *buf2 = 0 ;
5118  int alloc2 = 0 ;
5119  int res4 ;
5120  char *buf4 = 0 ;
5121  int alloc4 = 0 ;
5122  PyObject * obj0 = 0 ;
5123  PyObject * obj1 = 0 ;
5124  PyObject * obj2 = 0 ;
5125  PyObject * obj3 = 0 ;
5126  int result;
5127 
5128  if (!PyArg_ParseTuple(args,(char *)"OOOO:pbs_alterjob",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5129  ecode1 = SWIG_AsVal_int(obj0, &val1);
5130  if (!SWIG_IsOK(ecode1)) {
5131    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_alterjob" "', argument " "1"" of type '" "int""'");
5132  } 
5133  arg1 = (int)(val1);
5134  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5135  if (!SWIG_IsOK(res2)) {
5136    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_alterjob" "', argument " "2"" of type '" "char *""'");
5137  }
5138  arg2 = (char *)(buf2);
5139  {
5140    PyObject      *py_obj;
5141    struct attrl  *ptr, *prev;
5142    char          s[255];
5143    int           i=0, size=0;
5144   
5145    // printf("Python --> C\n");
5146   
5147    if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
5148   
5149    size = Get_List_Size(obj2);
5150    if (SARA_DEBUG) printf("\tSize of attrl List: %d\n", size);
5151   
5152    if ( size == -1 ) {
5153      PyErr_SetString(PyExc_TypeError, "not a list");
5154      return NULL; 
5155    }
5156   
5157    if (SARA_DEBUG) printf("\t<Contents>\n");
5158   
5159    arg3 = prev = NULL;
5160    for ( i=0; i < size; i++ ) {
5161      py_obj = PyList_GetItem(obj2, i);
5162      if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
5163        sprintf(s,"list item %d has wrong type", i);
5164        PyErr_SetString(PyExc_TypeError, s);
5165        return NULL;
5166       
5167        // This will skipp the wrong entry
5168        // continue;
5169      }
5170     
5171      /*
5172           * Make first entry head of C linked list
5173          */ 
5174      if ( i == 0) {
5175        arg3 = ptr;
5176        ptr->next = prev;
5177      }
5178      else {
5179        prev->next = ptr;
5180        ptr->next = NULL;
5181      }
5182      if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
5183     
5184      prev = ptr;
5185     
5186    } // end for
5187    if (SARA_DEBUG) printf("\t</Contents>\n");
5188  }
5189  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5190  if (!SWIG_IsOK(res4)) {
5191    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pbs_alterjob" "', argument " "4"" of type '" "char *""'");
5192  }
5193  arg4 = (char *)(buf4);
5194  result = (int)pbs_alterjob(arg1,arg2,arg3,arg4);
5195  resultobj = SWIG_From_int((int)(result));
5196  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5197  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5198  return resultobj;
5199fail:
5200  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5201  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5202  return NULL;
5203}
5204
5205
5206SWIGINTERN PyObject *_wrap_pbs_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5207  PyObject *resultobj = 0;
5208  char *arg1 = (char *) 0 ;
5209  int res1 ;
5210  char *buf1 = 0 ;
5211  int alloc1 = 0 ;
5212  PyObject * obj0 = 0 ;
5213  int result;
5214 
5215  if (!PyArg_ParseTuple(args,(char *)"O:pbs_connect",&obj0)) SWIG_fail;
5216  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5217  if (!SWIG_IsOK(res1)) {
5218    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pbs_connect" "', argument " "1"" of type '" "char *""'");
5219  }
5220  arg1 = (char *)(buf1);
5221  result = (int)pbs_connect(arg1);
5222  resultobj = SWIG_From_int((int)(result));
5223  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5224  return resultobj;
5225fail:
5226  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5227  return NULL;
5228}
5229
5230
5231SWIGINTERN PyObject *_wrap_pbs_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5232  PyObject *resultobj = 0;
5233  char *result = 0 ;
5234 
5235  if (!PyArg_ParseTuple(args,(char *)":pbs_default")) SWIG_fail;
5236  result = (char *)pbs_default();
5237  resultobj = SWIG_FromCharPtr((const char *)result);
5238  return resultobj;
5239fail:
5240  return NULL;
5241}
5242
5243
5244SWIGINTERN PyObject *_wrap_pbs_fbserver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5245  PyObject *resultobj = 0;
5246  char *result = 0 ;
5247 
5248  if (!PyArg_ParseTuple(args,(char *)":pbs_fbserver")) SWIG_fail;
5249  result = (char *)pbs_fbserver();
5250  resultobj = SWIG_FromCharPtr((const char *)result);
5251  return resultobj;
5252fail:
5253  return NULL;
5254}
5255
5256
5257SWIGINTERN PyObject *_wrap_pbs_get_server_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5258  PyObject *resultobj = 0;
5259  char *result = 0 ;
5260 
5261  if (!PyArg_ParseTuple(args,(char *)":pbs_get_server_list")) SWIG_fail;
5262  result = (char *)pbs_get_server_list();
5263  resultobj = SWIG_FromCharPtr((const char *)result);
5264  return resultobj;
5265fail:
5266  return NULL;
5267}
5268
5269
5270SWIGINTERN PyObject *_wrap_pbs_deljob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5271  PyObject *resultobj = 0;
5272  int arg1 ;
5273  char *arg2 = (char *) 0 ;
5274  char *arg3 = (char *) 0 ;
5275  int val1 ;
5276  int ecode1 = 0 ;
5277  int res2 ;
5278  char *buf2 = 0 ;
5279  int alloc2 = 0 ;
5280  int res3 ;
5281  char *buf3 = 0 ;
5282  int alloc3 = 0 ;
5283  PyObject * obj0 = 0 ;
5284  PyObject * obj1 = 0 ;
5285  PyObject * obj2 = 0 ;
5286  int result;
5287 
5288  if (!PyArg_ParseTuple(args,(char *)"OOO:pbs_deljob",&obj0,&obj1,&obj2)) SWIG_fail;
5289  ecode1 = SWIG_AsVal_int(obj0, &val1);
5290  if (!SWIG_IsOK(ecode1)) {
5291    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_deljob" "', argument " "1"" of type '" "int""'");
5292  } 
5293  arg1 = (int)(val1);
5294  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5295  if (!SWIG_IsOK(res2)) {
5296    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_deljob" "', argument " "2"" of type '" "char *""'");
5297  }
5298  arg2 = (char *)(buf2);
5299  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5300  if (!SWIG_IsOK(res3)) {
5301    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pbs_deljob" "', argument " "3"" of type '" "char *""'");
5302  }
5303  arg3 = (char *)(buf3);
5304  result = (int)pbs_deljob(arg1,arg2,arg3);
5305  resultobj = SWIG_From_int((int)(result));
5306  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5307  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5308  return resultobj;
5309fail:
5310  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5311  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5312  return NULL;
5313}
5314
5315
5316SWIGINTERN PyObject *_wrap_pbs_disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5317  PyObject *resultobj = 0;
5318  int arg1 ;
5319  int val1 ;
5320  int ecode1 = 0 ;
5321  PyObject * obj0 = 0 ;
5322  int result;
5323 
5324  if (!PyArg_ParseTuple(args,(char *)"O:pbs_disconnect",&obj0)) SWIG_fail;
5325  ecode1 = SWIG_AsVal_int(obj0, &val1);
5326  if (!SWIG_IsOK(ecode1)) {
5327    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_disconnect" "', argument " "1"" of type '" "int""'");
5328  } 
5329  arg1 = (int)(val1);
5330  result = (int)pbs_disconnect(arg1);
5331  resultobj = SWIG_From_int((int)(result));
5332  return resultobj;
5333fail:
5334  return NULL;
5335}
5336
5337
5338SWIGINTERN PyObject *_wrap_pbs_geterrmsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5339  PyObject *resultobj = 0;
5340  int arg1 ;
5341  int val1 ;
5342  int ecode1 = 0 ;
5343  PyObject * obj0 = 0 ;
5344  char *result = 0 ;
5345 
5346  if (!PyArg_ParseTuple(args,(char *)"O:pbs_geterrmsg",&obj0)) SWIG_fail;
5347  ecode1 = SWIG_AsVal_int(obj0, &val1);
5348  if (!SWIG_IsOK(ecode1)) {
5349    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_geterrmsg" "', argument " "1"" of type '" "int""'");
5350  } 
5351  arg1 = (int)(val1);
5352  result = (char *)pbs_geterrmsg(arg1);
5353  resultobj = SWIG_FromCharPtr((const char *)result);
5354  return resultobj;
5355fail:
5356  return NULL;
5357}
5358
5359
5360SWIGINTERN PyObject *_wrap_pbs_holdjob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5361  PyObject *resultobj = 0;
5362  int arg1 ;
5363  char *arg2 = (char *) 0 ;
5364  char *arg3 = (char *) 0 ;
5365  char *arg4 = (char *) 0 ;
5366  int val1 ;
5367  int ecode1 = 0 ;
5368  int res2 ;
5369  char *buf2 = 0 ;
5370  int alloc2 = 0 ;
5371  int res3 ;
5372  char *buf3 = 0 ;
5373  int alloc3 = 0 ;
5374  int res4 ;
5375  char *buf4 = 0 ;
5376  int alloc4 = 0 ;
5377  PyObject * obj0 = 0 ;
5378  PyObject * obj1 = 0 ;
5379  PyObject * obj2 = 0 ;
5380  PyObject * obj3 = 0 ;
5381  int result;
5382 
5383  if (!PyArg_ParseTuple(args,(char *)"OOOO:pbs_holdjob",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5384  ecode1 = SWIG_AsVal_int(obj0, &val1);
5385  if (!SWIG_IsOK(ecode1)) {
5386    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_holdjob" "', argument " "1"" of type '" "int""'");
5387  } 
5388  arg1 = (int)(val1);
5389  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5390  if (!SWIG_IsOK(res2)) {
5391    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_holdjob" "', argument " "2"" of type '" "char *""'");
5392  }
5393  arg2 = (char *)(buf2);
5394  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5395  if (!SWIG_IsOK(res3)) {
5396    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pbs_holdjob" "', argument " "3"" of type '" "char *""'");
5397  }
5398  arg3 = (char *)(buf3);
5399  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5400  if (!SWIG_IsOK(res4)) {
5401    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pbs_holdjob" "', argument " "4"" of type '" "char *""'");
5402  }
5403  arg4 = (char *)(buf4);
5404  result = (int)pbs_holdjob(arg1,arg2,arg3,arg4);
5405  resultobj = SWIG_From_int((int)(result));
5406  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5407  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5408  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5409  return resultobj;
5410fail:
5411  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5412  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5413  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5414  return NULL;
5415}
5416
5417
5418SWIGINTERN PyObject *_wrap_pbs_checkpointjob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5419  PyObject *resultobj = 0;
5420  int arg1 ;
5421  char *arg2 = (char *) 0 ;
5422  char *arg3 = (char *) 0 ;
5423  int val1 ;
5424  int ecode1 = 0 ;
5425  int res2 ;
5426  char *buf2 = 0 ;
5427  int alloc2 = 0 ;
5428  int res3 ;
5429  char *buf3 = 0 ;
5430  int alloc3 = 0 ;
5431  PyObject * obj0 = 0 ;
5432  PyObject * obj1 = 0 ;
5433  PyObject * obj2 = 0 ;
5434  int result;
5435 
5436  if (!PyArg_ParseTuple(args,(char *)"OOO:pbs_checkpointjob",&obj0,&obj1,&obj2)) SWIG_fail;
5437  ecode1 = SWIG_AsVal_int(obj0, &val1);
5438  if (!SWIG_IsOK(ecode1)) {
5439    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_checkpointjob" "', argument " "1"" of type '" "int""'");
5440  } 
5441  arg1 = (int)(val1);
5442  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5443  if (!SWIG_IsOK(res2)) {
5444    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_checkpointjob" "', argument " "2"" of type '" "char *""'");
5445  }
5446  arg2 = (char *)(buf2);
5447  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5448  if (!SWIG_IsOK(res3)) {
5449    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pbs_checkpointjob" "', argument " "3"" of type '" "char *""'");
5450  }
5451  arg3 = (char *)(buf3);
5452  result = (int)pbs_checkpointjob(arg1,arg2,arg3);
5453  resultobj = SWIG_From_int((int)(result));
5454  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5455  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5456  return resultobj;
5457fail:
5458  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5459  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5460  return NULL;
5461}
5462
5463
5464SWIGINTERN PyObject *_wrap_pbs_locjob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5465  PyObject *resultobj = 0;
5466  int arg1 ;
5467  char *arg2 = (char *) 0 ;
5468  char *arg3 = (char *) 0 ;
5469  int val1 ;
5470  int ecode1 = 0 ;
5471  int res2 ;
5472  char *buf2 = 0 ;
5473  int alloc2 = 0 ;
5474  int res3 ;
5475  char *buf3 = 0 ;
5476  int alloc3 = 0 ;
5477  PyObject * obj0 = 0 ;
5478  PyObject * obj1 = 0 ;
5479  PyObject * obj2 = 0 ;
5480  char *result = 0 ;
5481 
5482  if (!PyArg_ParseTuple(args,(char *)"OOO:pbs_locjob",&obj0,&obj1,&obj2)) SWIG_fail;
5483  ecode1 = SWIG_AsVal_int(obj0, &val1);
5484  if (!SWIG_IsOK(ecode1)) {
5485    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_locjob" "', argument " "1"" of type '" "int""'");
5486  } 
5487  arg1 = (int)(val1);
5488  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5489  if (!SWIG_IsOK(res2)) {
5490    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_locjob" "', argument " "2"" of type '" "char *""'");
5491  }
5492  arg2 = (char *)(buf2);
5493  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5494  if (!SWIG_IsOK(res3)) {
5495    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pbs_locjob" "', argument " "3"" of type '" "char *""'");
5496  }
5497  arg3 = (char *)(buf3);
5498  result = (char *)pbs_locjob(arg1,arg2,arg3);
5499  resultobj = SWIG_FromCharPtr((const char *)result);
5500  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5501  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5502  return resultobj;
5503fail:
5504  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5505  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5506  return NULL;
5507}
5508
5509
5510SWIGINTERN PyObject *_wrap_pbs_manager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5511  PyObject *resultobj = 0;
5512  int arg1 ;
5513  int arg2 ;
5514  int arg3 ;
5515  char *arg4 = (char *) 0 ;
5516  struct attropl *arg5 = (struct attropl *) 0 ;
5517  char *arg6 = (char *) 0 ;
5518  int val1 ;
5519  int ecode1 = 0 ;
5520  int val2 ;
5521  int ecode2 = 0 ;
5522  int val3 ;
5523  int ecode3 = 0 ;
5524  int res4 ;
5525  char *buf4 = 0 ;
5526  int alloc4 = 0 ;
5527  int res6 ;
5528  char *buf6 = 0 ;
5529  int alloc6 = 0 ;
5530  PyObject * obj0 = 0 ;
5531  PyObject * obj1 = 0 ;
5532  PyObject * obj2 = 0 ;
5533  PyObject * obj3 = 0 ;
5534  PyObject * obj4 = 0 ;
5535  PyObject * obj5 = 0 ;
5536  int result;
5537 
5538  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:pbs_manager",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5539  ecode1 = SWIG_AsVal_int(obj0, &val1);
5540  if (!SWIG_IsOK(ecode1)) {
5541    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_manager" "', argument " "1"" of type '" "int""'");
5542  } 
5543  arg1 = (int)(val1);
5544  ecode2 = SWIG_AsVal_int(obj1, &val2);
5545  if (!SWIG_IsOK(ecode2)) {
5546    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pbs_manager" "', argument " "2"" of type '" "int""'");
5547  } 
5548  arg2 = (int)(val2);
5549  ecode3 = SWIG_AsVal_int(obj2, &val3);
5550  if (!SWIG_IsOK(ecode3)) {
5551    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pbs_manager" "', argument " "3"" of type '" "int""'");
5552  } 
5553  arg3 = (int)(val3);
5554  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5555  if (!SWIG_IsOK(res4)) {
5556    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pbs_manager" "', argument " "4"" of type '" "char *""'");
5557  }
5558  arg4 = (char *)(buf4);
5559  {
5560    PyObject          *py_obj;
5561    struct attropl    *ptr, *prev;
5562    char              s[255];
5563    int               i=0, size=0;
5564   
5565    // printf("Python --> C\n");
5566   
5567    if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
5568   
5569    size = Get_List_Size(obj4);
5570   
5571    if (SARA_DEBUG) printf("\tSize attropl List: %d\n", size);
5572   
5573    if ( size == -1 ) {
5574      PyErr_SetString(PyExc_TypeError, "not a list");
5575      return NULL; 
5576    }
5577    //printf("Size = %d\n", size);
5578   
5579    if (SARA_DEBUG) printf("\t<Contents>\n");
5580   
5581    arg5 = prev = NULL;
5582    for ( i=0; i < size; i++ ) {
5583      py_obj = PyList_GetItem(obj4, i);
5584      if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
5585        sprintf(s,"list item %d has wrong type", i);
5586        PyErr_SetString(PyExc_TypeError, s);
5587        return NULL;
5588       
5589        // This will skipp the wrong entry
5590        // continue;
5591      }
5592     
5593      /*
5594           * Make first entry head of C linked list
5595          */ 
5596      if ( i == 0) {
5597        arg5 = ptr;
5598        ptr->next = prev;
5599      }
5600      else {
5601        prev->next = ptr;
5602        ptr->next = NULL;
5603      }
5604      prev = ptr;
5605     
5606    } // end for
5607    if (SARA_DEBUG) printf("\t</Contents>\n");
5608  }
5609  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5610  if (!SWIG_IsOK(res6)) {
5611    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "pbs_manager" "', argument " "6"" of type '" "char *""'");
5612  }
5613  arg6 = (char *)(buf6);
5614  result = (int)pbs_manager(arg1,arg2,arg3,arg4,arg5,arg6);
5615  resultobj = SWIG_From_int((int)(result));
5616  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5617  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5618  return resultobj;
5619fail:
5620  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5621  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5622  return NULL;
5623}
5624
5625
5626SWIGINTERN PyObject *_wrap_pbs_movejob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5627  PyObject *resultobj = 0;
5628  int arg1 ;
5629  char *arg2 = (char *) 0 ;
5630  char *arg3 = (char *) 0 ;
5631  char *arg4 = (char *) 0 ;
5632  int val1 ;
5633  int ecode1 = 0 ;
5634  int res2 ;
5635  char *buf2 = 0 ;
5636  int alloc2 = 0 ;
5637  int res3 ;
5638  char *buf3 = 0 ;
5639  int alloc3 = 0 ;
5640  int res4 ;
5641  char *buf4 = 0 ;
5642  int alloc4 = 0 ;
5643  PyObject * obj0 = 0 ;
5644  PyObject * obj1 = 0 ;
5645  PyObject * obj2 = 0 ;
5646  PyObject * obj3 = 0 ;
5647  int result;
5648 
5649  if (!PyArg_ParseTuple(args,(char *)"OOOO:pbs_movejob",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5650  ecode1 = SWIG_AsVal_int(obj0, &val1);
5651  if (!SWIG_IsOK(ecode1)) {
5652    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_movejob" "', argument " "1"" of type '" "int""'");
5653  } 
5654  arg1 = (int)(val1);
5655  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5656  if (!SWIG_IsOK(res2)) {
5657    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_movejob" "', argument " "2"" of type '" "char *""'");
5658  }
5659  arg2 = (char *)(buf2);
5660  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5661  if (!SWIG_IsOK(res3)) {
5662    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pbs_movejob" "', argument " "3"" of type '" "char *""'");
5663  }
5664  arg3 = (char *)(buf3);
5665  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5666  if (!SWIG_IsOK(res4)) {
5667    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pbs_movejob" "', argument " "4"" of type '" "char *""'");
5668  }
5669  arg4 = (char *)(buf4);
5670  result = (int)pbs_movejob(arg1,arg2,arg3,arg4);
5671  resultobj = SWIG_From_int((int)(result));
5672  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5673  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5674  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5675  return resultobj;
5676fail:
5677  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5678  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5679  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5680  return NULL;
5681}
5682
5683
5684SWIGINTERN PyObject *_wrap_pbs_msgjob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5685  PyObject *resultobj = 0;
5686  int arg1 ;
5687  char *arg2 = (char *) 0 ;
5688  int arg3 ;
5689  char *arg4 = (char *) 0 ;
5690  char *arg5 = (char *) 0 ;
5691  int val1 ;
5692  int ecode1 = 0 ;
5693  int res2 ;
5694  char *buf2 = 0 ;
5695  int alloc2 = 0 ;
5696  int val3 ;
5697  int ecode3 = 0 ;
5698  int res4 ;
5699  char *buf4 = 0 ;
5700  int alloc4 = 0 ;
5701  int res5 ;
5702  char *buf5 = 0 ;
5703  int alloc5 = 0 ;
5704  PyObject * obj0 = 0 ;
5705  PyObject * obj1 = 0 ;
5706  PyObject * obj2 = 0 ;
5707  PyObject * obj3 = 0 ;
5708  PyObject * obj4 = 0 ;
5709  int result;
5710 
5711  if (!PyArg_ParseTuple(args,(char *)"OOOOO:pbs_msgjob",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5712  ecode1 = SWIG_AsVal_int(obj0, &val1);
5713  if (!SWIG_IsOK(ecode1)) {
5714    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_msgjob" "', argument " "1"" of type '" "int""'");
5715  } 
5716  arg1 = (int)(val1);
5717  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5718  if (!SWIG_IsOK(res2)) {
5719    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_msgjob" "', argument " "2"" of type '" "char *""'");
5720  }
5721  arg2 = (char *)(buf2);
5722  ecode3 = SWIG_AsVal_int(obj2, &val3);
5723  if (!SWIG_IsOK(ecode3)) {
5724    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pbs_msgjob" "', argument " "3"" of type '" "int""'");
5725  } 
5726  arg3 = (int)(val3);
5727  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5728  if (!SWIG_IsOK(res4)) {
5729    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pbs_msgjob" "', argument " "4"" of type '" "char *""'");
5730  }
5731  arg4 = (char *)(buf4);
5732  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5733  if (!SWIG_IsOK(res5)) {
5734    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "pbs_msgjob" "', argument " "5"" of type '" "char *""'");
5735  }
5736  arg5 = (char *)(buf5);
5737  result = (int)pbs_msgjob(arg1,arg2,arg3,arg4,arg5);
5738  resultobj = SWIG_From_int((int)(result));
5739  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5740  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5741  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5742  return resultobj;
5743fail:
5744  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5745  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5746  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5747  return NULL;
5748}
5749
5750
5751SWIGINTERN PyObject *_wrap_pbs_orderjob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5752  PyObject *resultobj = 0;
5753  int arg1 ;
5754  char *arg2 = (char *) 0 ;
5755  char *arg3 = (char *) 0 ;
5756  char *arg4 = (char *) 0 ;
5757  int val1 ;
5758  int ecode1 = 0 ;
5759  int res2 ;
5760  char *buf2 = 0 ;
5761  int alloc2 = 0 ;
5762  int res3 ;
5763  char *buf3 = 0 ;
5764  int alloc3 = 0 ;
5765  int res4 ;
5766  char *buf4 = 0 ;
5767  int alloc4 = 0 ;
5768  PyObject * obj0 = 0 ;
5769  PyObject * obj1 = 0 ;
5770  PyObject * obj2 = 0 ;
5771  PyObject * obj3 = 0 ;
5772  int result;
5773 
5774  if (!PyArg_ParseTuple(args,(char *)"OOOO:pbs_orderjob",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5775  ecode1 = SWIG_AsVal_int(obj0, &val1);
5776  if (!SWIG_IsOK(ecode1)) {
5777    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pbs_orderjob" "', argument " "1"" of type '" "int""'");
5778  } 
5779  arg1 = (int)(val1);
5780  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5781  if (!SWIG_IsOK(res2)) {
5782    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pbs_orderjob" "', argument " "2"" of type '" "char *""'");
5783  }
5784  arg2 = (char *)(buf2);
5785  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5786  if (!SWIG_IsOK(res3)) {
5787    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pbs_orderjob" "', argument " "3"" of type '" "char *""'");
5788  }
5789  arg3 = (char *)(buf3);
5790  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5791  if (!SWIG_IsOK(res4)) {
5792    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pbs_orderjob" "', argument " "4"" of type '" "char *""'");
5793  }
5794  arg4 = (char *)(buf4);
5795  result = (int)pbs_orderjob(arg1,arg2,arg3,arg4);
5796  resultobj = SWIG_From_int((int)(result));
5797  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5798  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5799  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5800  return resultobj;
5801fail:
5802  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5803  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5804  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5805  return NULL;
5806}
5807
5808
5809SWIGINTERN PyObject *_wrap_pbs_rescquery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5810  PyObject *resultobj =