source: trunk/pbs_swig/distro/src/pbs_wrap.c @ 93

Last change on this file since 93 was 93, checked in by bas, 18 years ago

distro/src/PBSQuery.py:

  • Changed dict() to {} (requires python 2.2)

distro/src/pbs.py, distro/src/pbs_wrap.c:

  • Generated with swig 1.3.24 and python 2.1
  • Property svn:keywords set to Id
File size: 147.7 KB
Line 
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.22
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11#define SWIGPYTHON
12
13#include "Python.h"
14
15/*************************************************************** -*- c -*-
16 * python/precommon.swg
17 *
18 * Rename all exported symbols from common.swg, to avoid symbol
19 * clashes if multiple interpreters are included
20 *
21 ************************************************************************/
22
23#define SWIG_TypeRegister    SWIG_Python_TypeRegister
24#define SWIG_TypeCheck       SWIG_Python_TypeCheck
25#define SWIG_TypeCast        SWIG_Python_TypeCast
26#define SWIG_TypeDynamicCast SWIG_Python_TypeDynamicCast
27#define SWIG_TypeName        SWIG_Python_TypeName
28#define SWIG_TypePrettyName  SWIG_Python_TypePrettyName
29#define SWIG_TypeQuery       SWIG_Python_TypeQuery
30#define SWIG_TypeClientData  SWIG_Python_TypeClientData
31#define SWIG_PackData        SWIG_Python_PackData
32#define SWIG_UnpackData      SWIG_Python_UnpackData
33
34
35/***********************************************************************
36 * common.swg
37 *
38 *     This file contains generic SWIG runtime support for pointer
39 *     type checking as well as a few commonly used macros to control
40 *     external linkage.
41 *
42 * Author : David Beazley (beazley@cs.uchicago.edu)
43 *
44 * Copyright (c) 1999-2000, The University of Chicago
45 *
46 * This file may be freely redistributed without license or fee provided
47 * this copyright message remains intact.
48 ************************************************************************/
49
50#include <string.h>
51
52#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
53#  if defined(_MSC_VER) || defined(__GNUC__)
54#    if defined(STATIC_LINKED)
55#      define SWIGEXPORT(a) a
56#      define SWIGIMPORT(a) extern a
57#    else
58#      define SWIGEXPORT(a) __declspec(dllexport) a
59#      define SWIGIMPORT(a) extern a
60#    endif
61#  else
62#    if defined(__BORLANDC__)
63#      define SWIGEXPORT(a) a _export
64#      define SWIGIMPORT(a) a _export
65#    else
66#      define SWIGEXPORT(a) a
67#      define SWIGIMPORT(a) a
68#    endif
69#  endif
70#else
71#  define SWIGEXPORT(a) a
72#  define SWIGIMPORT(a) a
73#endif
74
75#ifdef SWIG_GLOBAL
76#  define SWIGRUNTIME(a) SWIGEXPORT(a)
77#else
78#  define SWIGRUNTIME(a) static a
79#endif
80
81#ifdef __cplusplus
82extern "C" {
83#endif
84
85typedef void *(*swig_converter_func)(void *);
86typedef struct swig_type_info *(*swig_dycast_func)(void **);
87
88typedef struct swig_type_info {
89  const char             *name;
90  swig_converter_func     converter;
91  const char             *str;
92  void                   *clientdata;
93  swig_dycast_func        dcast;
94  struct swig_type_info  *next;
95  struct swig_type_info  *prev;
96} swig_type_info;
97
98#ifdef SWIG_NOINCLUDE
99
100SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
101SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
102SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
103SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
104SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
105SWIGIMPORT(const char *)     SWIG_TypePrettyName(const swig_type_info *);
106SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
107SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
108SWIGIMPORT(char *)           SWIG_PackData(char *, void *, int);
109SWIGIMPORT(char *)           SWIG_UnpackData(char *, void *, int);
110
111#else
112
113static swig_type_info *swig_type_list = 0;
114static swig_type_info **swig_type_list_handle = &swig_type_list;
115
116/* Register a type mapping with the type-checking */
117SWIGRUNTIME(swig_type_info *)
118SWIG_TypeRegister(swig_type_info *ti) {
119  swig_type_info *tc, *head, *ret, *next;
120  /* Check to see if this type has already been registered */
121  tc = *swig_type_list_handle;
122  while (tc) {
123    if (strcmp(tc->name, ti->name) == 0) {
124      /* Already exists in the table.  Just add additional types to the list */
125      if (tc->clientdata) ti->clientdata = tc->clientdata;
126      head = tc;
127      next = tc->next;
128      goto l1;
129    }
130    tc = tc->prev;
131  }
132  head = ti;
133  next = 0;
134
135  /* Place in list */
136  ti->prev = *swig_type_list_handle;
137  *swig_type_list_handle = ti;
138
139  /* Build linked lists */
140  l1:
141  ret = head;
142  tc = ti + 1;
143  /* Patch up the rest of the links */
144  while (tc->name) {
145    head->next = tc;
146    tc->prev = head;
147    head = tc;
148    tc++;
149  }
150  if (next) next->prev = head;
151  head->next = next;
152  return ret;
153}
154
155/* Check the typename */
156SWIGRUNTIME(swig_type_info *) 
157SWIG_TypeCheck(char *c, swig_type_info *ty) {
158  swig_type_info *s;
159  if (!ty) return 0;        /* Void pointer */
160  s = ty->next;             /* First element always just a name */
161  do {
162    if (strcmp(s->name,c) == 0) {
163      if (s == ty->next) return s;
164      /* Move s to the top of the linked list */
165      s->prev->next = s->next;
166      if (s->next) {
167        s->next->prev = s->prev;
168      }
169      /* Insert s as second element in the list */
170      s->next = ty->next;
171      if (ty->next) ty->next->prev = s;
172      ty->next = s;
173      s->prev = ty;
174      return s;
175    }
176    s = s->next;
177  } while (s && (s != ty->next));
178  return 0;
179}
180
181/* Cast a pointer up an inheritance hierarchy */
182SWIGRUNTIME(void *) 
183SWIG_TypeCast(swig_type_info *ty, void *ptr) {
184  if ((!ty) || (!ty->converter)) return ptr;
185  return (*ty->converter)(ptr);
186}
187
188/* Dynamic pointer casting. Down an inheritance hierarchy */
189SWIGRUNTIME(swig_type_info *) 
190SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
191  swig_type_info *lastty = ty;
192  if (!ty || !ty->dcast) return ty;
193  while (ty && (ty->dcast)) {
194    ty = (*ty->dcast)(ptr);
195    if (ty) lastty = ty;
196  }
197  return lastty;
198}
199
200/* Return the name associated with this type */
201SWIGRUNTIME(const char *)
202SWIG_TypeName(const swig_type_info *ty) {
203  return ty->name;
204}
205
206/* Return the pretty name associated with this type,
207   that is an unmangled type name in a form presentable to the user.
208*/
209SWIGRUNTIME(const char *)
210SWIG_TypePrettyName(const swig_type_info *type) {
211  /* The "str" field contains the equivalent pretty names of the
212     type, separated by vertical-bar characters.  We choose
213     to print the last name, as it is often (?) the most
214     specific. */
215  if (type->str != NULL) {
216    const char *last_name = type->str;
217    const char *s;
218    for (s = type->str; *s; s++)
219      if (*s == '|') last_name = s+1;
220    return last_name;
221  }
222  else
223    return type->name;
224}
225
226/*
227   Compare two type names skipping the space characters, therefore
228   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
229
230   Return 0 when the two name types are equivalent, as in
231   strncmp, but skipping ' '.
232*/
233static int
234SWIG_TypeNameComp(const char *f1, const char *l1,
235                  const char *f2, const char *l2) {
236  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
237    while ((*f1 == ' ') && (f1 != l1)) ++f1;
238    while ((*f2 == ' ') && (f2 != l2)) ++f2;
239    if (*f1 != *f2) return *f1 - *f2;
240  }
241  return (l1 - f1) - (l2 - f2);
242}
243
244/*
245  Check type equivalence in a name list like <name1>|<name2>|...
246*/
247static int
248SWIG_TypeEquiv(const char *nb, const char *tb) {
249  int equiv = 0;
250  const char* te = tb + strlen(tb);
251  const char* ne = nb;
252  while (!equiv && *ne) {
253    for (nb = ne; *ne; ++ne) {
254      if (*ne == '|') break;
255    }
256    equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
257    if (*ne) ++ne;
258  }
259  return equiv;
260}
261 
262
263/* Search for a swig_type_info structure */
264SWIGRUNTIME(swig_type_info *)
265SWIG_TypeQuery(const char *name) {
266  swig_type_info *ty = *swig_type_list_handle;
267  while (ty) {
268    if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
269    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
270    ty = ty->prev;
271  }
272  return 0;
273}
274
275/* Set the clientdata field for a type */
276SWIGRUNTIME(void)
277SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
278  swig_type_info *tc, *equiv;
279  if (ti->clientdata == clientdata) return;
280  ti->clientdata = clientdata;
281  equiv = ti->next;
282  while (equiv) {
283    if (!equiv->converter) {
284      tc = *swig_type_list_handle;
285      while (tc) {
286        if ((strcmp(tc->name, equiv->name) == 0))
287          SWIG_TypeClientData(tc,clientdata);
288        tc = tc->prev;
289      }
290    }
291    equiv = equiv->next;
292  }
293}
294
295/* Pack binary data into a string */
296SWIGRUNTIME(char *)
297SWIG_PackData(char *c, void *ptr, int sz) {
298  static char hex[17] = "0123456789abcdef";
299  unsigned char *u = (unsigned char *) ptr;
300  const unsigned char *eu =  u + sz;
301  register unsigned char uu;
302  for (; u != eu; ++u) {
303    uu = *u;
304    *(c++) = hex[(uu & 0xf0) >> 4];
305    *(c++) = hex[uu & 0xf];
306  }
307  return c;
308}
309
310/* Unpack binary data from a string */
311SWIGRUNTIME(char *)
312SWIG_UnpackData(char *c, void *ptr, int sz) {
313  register unsigned char uu = 0;
314  register int d;
315  unsigned char *u = (unsigned char *) ptr;
316  const unsigned char *eu =  u + sz;
317  for (; u != eu; ++u) {
318    d = *(c++);
319    if ((d >= '0') && (d <= '9'))
320      uu = ((d - '0') << 4);
321    else if ((d >= 'a') && (d <= 'f'))
322      uu = ((d - ('a'-10)) << 4);
323    d = *(c++);
324    if ((d >= '0') && (d <= '9'))
325      uu |= (d - '0');
326    else if ((d >= 'a') && (d <= 'f'))
327      uu |= (d - ('a'-10));
328    *u = uu;
329  }
330  return c;
331}
332
333#endif
334
335#ifdef __cplusplus
336}
337#endif
338
339/***********************************************************************
340 * pyrun.swg
341 *
342 *     This file contains the runtime support for Python modules
343 *     and includes code for managing global variables and pointer
344 *     type checking.
345 *
346 * Author : David Beazley (beazley@cs.uchicago.edu)
347 ************************************************************************/
348
349#ifdef __cplusplus
350extern "C" {
351#endif
352
353#define SWIG_PY_INT     1
354#define SWIG_PY_FLOAT   2
355#define SWIG_PY_STRING  3
356#define SWIG_PY_POINTER 4
357#define SWIG_PY_BINARY  5
358
359/* Flags for pointer conversion */
360
361#define SWIG_POINTER_EXCEPTION     0x1
362#define SWIG_POINTER_DISOWN        0x2
363
364/* Exception handling in wrappers */
365#define SWIG_fail   goto fail
366
367/* Constant information structure */
368typedef struct swig_const_info {
369    int type;
370    char *name;
371    long lvalue;
372    double dvalue;
373    void   *pvalue;
374    swig_type_info **ptype;
375} swig_const_info;
376
377/* Common SWIG API */
378#define SWIG_ConvertPtr(obj, pp, type, flags) \
379  SWIG_Python_ConvertPtr(obj, pp, type, flags)
380#define SWIG_NewPointerObj(p, type, flags) \
381  SWIG_Python_NewPointerObj(p, type, flags)
382#define SWIG_MustGetPtr(p, type, argnum, flags) \
383  SWIG_Python_MustGetPtr(p, type, argnum, flags)
384 
385/* Python-specific SWIG API */
386#define SWIG_newvarlink() \
387  SWIG_Python_newvarlink()
388#define SWIG_addvarlink(p, name, get_attr, set_attr) \
389  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
390#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \
391  SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
392#define SWIG_NewPackedObj(ptr, sz, type) \
393  SWIG_Python_NewPackedObj(ptr, sz, type)
394#define SWIG_InstallConstants(d, constants) \
395  SWIG_Python_InstallConstants(d, constants)
396
397typedef double (*py_objasdbl_conv)(PyObject *obj);
398
399#ifdef SWIG_NOINCLUDE
400
401SWIGIMPORT(int)               SWIG_Python_ConvertPtr(PyObject *, void **, swig_type_info *, int);
402SWIGIMPORT(PyObject *)        SWIG_Python_NewPointerObj(void *, swig_type_info *,int own);
403SWIGIMPORT(void *)            SWIG_Python_MustGetPtr(PyObject *, swig_type_info *, int, int);
404SWIGIMPORT(PyObject *)        SWIG_Python_newvarlink(void);
405SWIGIMPORT(void)              SWIG_Python_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
406SWIGIMPORT(int)               SWIG_Python_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
407SWIGIMPORT(PyObject *)        SWIG_Python_NewPackedObj(void *, int sz, swig_type_info *);
408SWIGIMPORT(void)              SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]);
409
410
411#else
412
413
414/* -----------------------------------------------------------------------------
415 * global variable support code.
416 * ----------------------------------------------------------------------------- */
417
418typedef struct swig_globalvar {   
419  char       *name;                  /* Name of global variable */
420  PyObject *(*get_attr)(void);       /* Return the current value */
421  int       (*set_attr)(PyObject *); /* Set the value */
422  struct swig_globalvar *next;
423} swig_globalvar;
424
425typedef struct swig_varlinkobject {
426  PyObject_HEAD
427  swig_globalvar *vars;
428} swig_varlinkobject;
429
430static PyObject *
431swig_varlink_repr(swig_varlinkobject *v) {
432  v = v;
433  return PyString_FromString("<Global variables>");
434}
435
436static int
437swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
438  swig_globalvar  *var;
439  flags = flags;
440  fprintf(fp,"Global variables { ");
441  for (var = v->vars; var; var=var->next) {
442    fprintf(fp,"%s", var->name);
443    if (var->next) fprintf(fp,", ");
444  }
445  fprintf(fp," }\n");
446  return 0;
447}
448
449static PyObject *
450swig_varlink_getattr(swig_varlinkobject *v, char *n) {
451  swig_globalvar *var = v->vars;
452  while (var) {
453    if (strcmp(var->name,n) == 0) {
454      return (*var->get_attr)();
455    }
456    var = var->next;
457  }
458  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
459  return NULL;
460}
461
462static int
463swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
464  swig_globalvar *var = v->vars;
465  while (var) {
466    if (strcmp(var->name,n) == 0) {
467      return (*var->set_attr)(p);
468    }
469    var = var->next;
470  }
471  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
472  return 1;
473}
474
475statichere PyTypeObject varlinktype = {
476  PyObject_HEAD_INIT(0)             
477  0,                                  /* Number of items in variable part (ob_size) */
478  (char *)"swigvarlink",              /* Type name (tp_name) */
479  sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
480  0,                                  /* Itemsize (tp_itemsize) */
481  0,                                  /* Deallocator (tp_dealloc) */ 
482  (printfunc) swig_varlink_print,     /* Print (tp_print) */
483  (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
484  (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
485  0,                                  /* tp_compare */
486  (reprfunc) swig_varlink_repr,       /* tp_repr */
487  0,                                  /* tp_as_number */
488  0,                                  /* tp_as_sequence */
489  0,                                  /* tp_as_mapping */
490  0,                                  /* tp_hash */
491  0,                                  /* tp_call */
492  0,                                  /* tp_str */
493  0,                                  /* tp_getattro */
494  0,                                  /* tp_setattro */
495  0,                                  /* tp_as_buffer */
496  0,                                  /* tp_flags */
497  0,                                  /* tp_doc */
498  0,                                  /* tp_traverse */
499  0,                                  /* tp_clear */
500  0,                                  /* tp_richcompare */
501  0,                                  /* tp_weaklistoffset */
502#if PY_VERSION_HEX >= 0x02020000
503  0,                                  /* tp_iter */
504  0,                                  /* tp_iternext */
505  0,                                  /* tp_methods */
506  0,                                  /* tp_members */
507  0,                                  /* tp_getset */
508  0,                                  /* tp_base */
509  0,                                  /* tp_dict */
510  0,                                  /* tp_descr_get */
511  0,                                  /* tp_descr_set */
512  0,                                  /* tp_dictoffset */
513  0,                                  /* tp_init */
514  0,                                  /* tp_alloc */
515  0,                                  /* tp_new */
516  0,                                  /* tp_free */
517  0,                                  /* tp_is_gc */
518  0,                                  /* tp_bases */
519  0,                                  /* tp_mro */
520  0,                                  /* tp_cache */
521  0,                                  /* tp_subclasses */
522  0,                                  /* tp_weaklist */
523#endif
524#if PY_VERSION_HEX >= 0x02030200
525  0,                                  /* tp_del */
526#endif
527#ifdef COUNT_ALLOCS
528  /* these must be last */
529  0,                                  /* tp_alloc */
530  0,                                  /* tp_free */
531  0,                                  /* tp_maxalloc */
532  0,                                  /*  tp_next */
533#endif
534};
535
536/* Create a variable linking object for use later */
537SWIGRUNTIME(PyObject *)
538SWIG_Python_newvarlink(void) {
539  swig_varlinkobject *result = 0;
540  result = PyMem_NEW(swig_varlinkobject,1);
541  varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
542  result->ob_type = &varlinktype;
543  result->vars = 0;
544  result->ob_refcnt = 0;
545  Py_XINCREF((PyObject *) result);
546  return ((PyObject*) result);
547}
548
549SWIGRUNTIME(void)
550SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
551  swig_varlinkobject *v;
552  swig_globalvar *gv;
553  v= (swig_varlinkobject *) p;
554  gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
555  gv->name = (char *) malloc(strlen(name)+1);
556  strcpy(gv->name,name);
557  gv->get_attr = get_attr;
558  gv->set_attr = set_attr;
559  gv->next = v->vars;
560  v->vars = gv;
561}
562
563/* Convert a pointer value */
564SWIGRUNTIME(int)
565SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
566  swig_type_info *tc;
567  char  *c = 0;
568  static PyObject *SWIG_this = 0;
569  int    newref = 0;
570  PyObject  *pyobj = 0;
571
572  if (!obj) return 0;
573  if (obj == Py_None) {
574    *ptr = 0;
575    return 0;
576  }
577#ifdef SWIG_COBJECT_TYPES
578  if (!(PyCObject_Check(obj))) {
579    if (!SWIG_this)
580      SWIG_this = PyString_FromString("this");
581    pyobj = obj;
582    obj = PyObject_GetAttr(obj,SWIG_this);
583    newref = 1;
584    if (!obj) goto type_error;
585    if (!PyCObject_Check(obj)) {
586      Py_DECREF(obj);
587      goto type_error;
588    }
589  } 
590  *ptr = PyCObject_AsVoidPtr(obj);
591  c = (char *) PyCObject_GetDesc(obj);
592  if (newref) Py_DECREF(obj);
593  goto cobject;
594#else
595  if (!(PyString_Check(obj))) {
596    if (!SWIG_this)
597      SWIG_this = PyString_FromString("this");
598    pyobj = obj;
599    obj = PyObject_GetAttr(obj,SWIG_this);
600    newref = 1;
601    if (!obj) goto type_error;
602    if (!PyString_Check(obj)) {
603      Py_DECREF(obj);
604      goto type_error;
605    }
606  } 
607  c = PyString_AS_STRING(obj);
608  /* Pointer values must start with leading underscore */
609  if (*c != '_') {
610    *ptr = (void *) 0;
611    if (strcmp(c,"NULL") == 0) {
612      if (newref) { Py_DECREF(obj); }
613      return 0;
614    } else {
615      if (newref) { Py_DECREF(obj); }
616      goto type_error;
617    }
618  }
619  c++;
620  c = SWIG_UnpackData(c,ptr,sizeof(void *));
621  if (newref) { Py_DECREF(obj); }
622#endif
623
624#ifdef SWIG_COBJECT_TYPES
625cobject:
626#endif
627
628  if (ty) {
629    tc = SWIG_TypeCheck(c,ty);
630    if (!tc) goto type_error;
631    *ptr = SWIG_TypeCast(tc,(void*) *ptr);
632  }
633
634  if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
635    PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
636  }
637  return 0;
638
639type_error:
640  PyErr_Clear();
641  if (flags & SWIG_POINTER_EXCEPTION) {
642    if (ty && c) {
643      PyErr_Format(PyExc_TypeError, 
644                   "Type error. Got %s, expected %s",
645                   c, ty->name);
646    } else {
647      PyErr_SetString(PyExc_TypeError,"Expected a pointer");
648    }
649  }
650  return -1;
651}
652
653/* Convert a pointer value, signal an exception on a type mismatch */
654SWIGRUNTIME(void *)
655SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
656  void *result;
657  SWIG_Python_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION);
658  return result;
659}
660
661/* Convert a packed value value */
662SWIGRUNTIME(int)
663SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
664  swig_type_info *tc;
665  char  *c = 0;
666
667  if ((!obj) || (!PyString_Check(obj))) goto type_error;
668  c = PyString_AS_STRING(obj);
669  /* Pointer values must start with leading underscore */
670  if (*c != '_') goto type_error;
671  c++;
672  c = SWIG_UnpackData(c,ptr,sz);
673  if (ty) {
674    tc = SWIG_TypeCheck(c,ty);
675    if (!tc) goto type_error;
676  }
677  return 0;
678
679type_error:
680
681  if (flags) {
682    if (ty && c) {
683      PyErr_Format(PyExc_TypeError, 
684                   "Type error. Got %s, expected %s",
685                   c, ty->name);
686    } else {
687      PyErr_SetString(PyExc_TypeError,"Expected a pointer");
688    }
689  }
690  return -1;
691}
692
693/* Create a new pointer object */
694SWIGRUNTIME(PyObject *)
695SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
696  PyObject *robj;
697  if (!ptr) {
698    Py_INCREF(Py_None);
699    return Py_None;
700  }
701#ifdef SWIG_COBJECT_TYPES
702  robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
703#else
704  {
705    char result[1024];
706    char *r = result;
707    *(r++) = '_';
708    r = SWIG_PackData(r,&ptr,sizeof(void *));
709    strcpy(r,type->name);
710    robj = PyString_FromString(result);
711  }
712#endif
713  if (!robj || (robj == Py_None)) return robj;
714  if (type->clientdata) {
715    PyObject *inst;
716    PyObject *args = Py_BuildValue((char*)"(O)", robj);
717    Py_DECREF(robj);
718    inst = PyObject_CallObject((PyObject *) type->clientdata, args);
719    Py_DECREF(args);
720    if (inst) {
721      if (own) {
722        PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
723      }
724      robj = inst;
725    }
726  }
727  return robj;
728}
729
730SWIGRUNTIME(PyObject *)
731SWIG_Python_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
732  char result[1024];
733  char *r = result;
734  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
735  *(r++) = '_';
736  r = SWIG_PackData(r,ptr,sz);
737  strcpy(r,type->name);
738  return PyString_FromString(result);
739}
740
741/* Install Constants */
742SWIGRUNTIME(void)
743SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
744  int i;
745  PyObject *obj;
746  for (i = 0; constants[i].type; i++) {
747    switch(constants[i].type) {
748    case SWIG_PY_INT:
749      obj = PyInt_FromLong(constants[i].lvalue);
750      break;
751    case SWIG_PY_FLOAT:
752      obj = PyFloat_FromDouble(constants[i].dvalue);
753      break;
754    case SWIG_PY_STRING:
755      if (constants[i].pvalue) {
756        obj = PyString_FromString((char *) constants[i].pvalue);
757      } else {
758        Py_INCREF(Py_None);
759        obj = Py_None;
760      }
761      break;
762    case SWIG_PY_POINTER:
763      obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
764      break;
765    case SWIG_PY_BINARY:
766      obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
767      break;
768    default:
769      obj = 0;
770      break;
771    }
772    if (obj) {
773      PyDict_SetItemString(d,constants[i].name,obj);
774      Py_DECREF(obj);
775    }
776  }
777}
778
779#endif
780
781/* Contract support */
782
783#define SWIG_contract_assert(expr, msg) if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
784
785#ifdef __cplusplus
786}
787#endif
788
789
790/* -------- TYPES TABLE (BEGIN) -------- */
791
792#define  SWIGTYPE_p_batch_status swig_types[0]
793#define  SWIGTYPE_p_resource_t swig_types[1]
794#define  SWIGTYPE_p_char swig_types[2]
795#define  SWIGTYPE_p_attropl swig_types[3]
796#define  SWIGTYPE_p_p_char swig_types[4]
797#define  SWIGTYPE_p_attrl swig_types[5]
798#define  SWIGTYPE_p_long swig_types[6]
799#define  SWIGTYPE_p_int swig_types[7]
800static swig_type_info *swig_types[9];
801
802/* -------- TYPES TABLE (END) -------- */
803
804
805/*-----------------------------------------------
806              @(target):= _pbs.so
807  ------------------------------------------------*/
808#define SWIG_init    init_pbs
809
810#define SWIG_name    "_pbs"
811
812/* Auxiliar swig  macros that appear in the header */
813
814#define SWIG_OLDOBJ  1
815#define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
816#define SWIG_PYSTR   SWIG_NEWOBJ + 1
817
818#ifdef __cplusplus
819#define SWIGSTATICINLINE(a) static inline a
820#define SWIGSTATIC(a) static a
821#define swig_new_array(size,Type) (new Type[(size)])
822#define swig_delete(cptr) delete cptr
823#define swig_delete_array(cptr) delete[] cptr
824#define swig_const_cast(a,Type) const_cast<Type >(a)
825#define swig_static_cast(a,Type) static_cast<Type >(a)
826#define swig_reinterpret_cast(a,Type) reinterpret_cast<Type >(a)
827#define swig_new_copy(ptr,Type) (new Type(*ptr))
828#define swig_numeric_cast(a,Type) static_cast<Type >(a)
829
830#else /* C case */
831
832#define SWIGSTATICINLINE(a) static a
833#define SWIGSTATIC(a) static a
834#define swig_new_array(size,Type) ((Type*) malloc((size)*sizeof(Type)))
835#define swig_delete(cptr) free((char*)cptr)
836#define swig_delete_array(cptr) free((char*)cptr)
837#define swig_const_cast(a,Type) (Type)(a)
838#define swig_static_cast(a,Type) (Type)(a)
839#define swig_reinterpret_cast(a,Type) (Type)(a)
840#define swig_numeric_cast(a,Type) (Type)(a)
841#define swig_new_copy(ptr,Type)  ((Type*)memcpy(malloc(sizeof(Type)),ptr,sizeof(Type)))
842
843#endif /* __cplusplus */
844
845
846/*@/usr/share/swig1.3/python/pymacros.swg,63,SWIG_define@*/
847#define SWIG_From_signed_SS_char PyInt_FromLong
848/*@@*/
849/*@/usr/share/swig1.3/python/pymacros.swg,63,SWIG_define@*/
850#define SWIG_From_unsigned_SS_char PyInt_FromLong
851/*@@*/
852/*@/usr/share/swig1.3/python/pymacros.swg,63,SWIG_define@*/
853#define SWIG_From_short PyInt_FromLong
854/*@@*/
855/*@/usr/share/swig1.3/python/pymacros.swg,63,SWIG_define@*/
856#define SWIG_From_unsigned_SS_short PyInt_FromLong
857/*@@*/
858/*@/usr/share/swig1.3/python/pymacros.swg,63,SWIG_define@*/
859#define SWIG_From_int PyInt_FromLong
860/*@@*/
861/*@/usr/share/swig1.3/python/pymacros.swg,63,SWIG_define@*/
862#define SWIG_From_long PyInt_FromLong
863/*@@*/
864/*@/usr/share/swig1.3/python/pymacros.swg,63,SWIG_define@*/
865#define SWIG_From_float PyFloat_FromDouble
866/*@@*/
867/*@/usr/share/swig1.3/python/pymacros.swg,63,SWIG_define@*/
868#define SWIG_From_double PyFloat_FromDouble
869/*@@*/
870
871
872
873#include "pbs_ifl.h"
874#include "pbs_error.h"
875#include "rm.h"
876#include "log.h"
877
878#define SARA_DEBUG 0
879
880//extern int pbs_errno;
881
882
883
884int Get_List_Size(PyObject *src)
885{
886  if (PyList_Check(src))
887    return(PyList_Size(src));
888  else {
889
890    /* check if valid NULL pointer */
891    if ( PyString_Check(src) ) {
892      if ( ! strcmp(PyString_AsString(src), "NULL") )
893        return(0);
894    }
895    else
896      return(-1);
897
898  } // end else
899} // end Get_List_Size()
900
901
902
903
904// The default constructor for struct attrl
905//
906struct attrl *new_attrl(int number)
907{
908  struct attrl *ptr;
909  struct attrl *prev, *current;
910  int i;
911
912  /*
913    allocate memory as a one block is handy for Python scripts
914    and fill in the next fields so it also works for the C-library
915  */
916  ptr = (struct attrl *) malloc(number * sizeof(struct attrl));
917
918  prev = NULL;
919  current = ptr + (number - 1);
920  for (i=0; i < number; i++)
921  { 
922    // printf("constructor called\n");
923    current->name     = (char *) malloc(MAXNAMLEN * sizeof(char));
924    current->resource = (char *) malloc(MAXNAMLEN * sizeof(char));
925    current->value    = (char *) malloc(MAXNAMLEN * sizeof(char));
926
927    bzero( (void*) current->name, sizeof(current->name));
928    bzero( (void*) current->resource, sizeof(current->resource));
929    bzero( (void*) current->value, sizeof(current->value));
930
931    current->next     = prev;
932    prev = current;
933    current--;
934  }
935  return (struct attrl *)ptr;
936
937} // end new_attrl()
938
939
940// The default constructor for struct attropl
941//
942struct attropl *new_attropl(int number)
943{
944  struct attropl *ptr;
945  struct attropl *prev, *current;
946  int i;
947
948  /*
949    allocate memory as a one block is handy for Python scripts
950    and fill in the next fields so it also works for the C-library
951  */
952  ptr = (struct attropl *) malloc(number * sizeof(struct attropl));
953
954  prev = NULL;
955  current = ptr + (number - 1);
956  for (i=0; i < number; i++)
957  { 
958    // printf("constructor called\n");
959    current->name     = (char *) malloc(MAXNAMLEN * sizeof(char));
960    current->resource = (char *) malloc(MAXNAMLEN * sizeof(char));
961    current->value    = (char *) malloc(MAXNAMLEN * sizeof(char));
962
963    bzero( (void*) current->name, sizeof(current->name));
964    bzero( (void*) current->resource, sizeof(current->resource));
965    bzero( (void*) current->value, sizeof(current->value));
966    current->op = 0;
967
968    current->next     = prev;
969    prev = current;
970    current--;
971  }
972  return (struct attropl *)ptr;
973
974} // end new_attropl()
975
976/* Not used only returned */
977struct batch_status *new_batch_status()
978{
979   struct batch_status *ptr;
980
981   ptr = (struct batch_status *) malloc(sizeof(struct batch_status));
982   return (struct batch_status *)ptr;
983} // end new struct batch_status
984
985int get_error()
986{
987   char *errmsg;
988
989   errmsg = pbse_to_txt();
990   if (SARA_DEBUG)
991   {
992      printf("Bas = %d\n", pbs_errno);
993      printf("Bas = %d, text = %s\n", pbs_errno, errmsg);
994   }
995   return (pbs_errno);
996}
997
998
999
1000
1001#include <limits.h>
1002
1003
1004SWIGSTATICINLINE(int)
1005  SWIG_CheckLongInRange(long value, long min_value, long max_value,
1006                        const char *errmsg)
1007{
1008  if (value < min_value) {
1009    if (errmsg) {
1010      PyErr_Format(PyExc_OverflowError, 
1011                   "value %ld is less than '%s' minimum %ld", 
1012                   value, errmsg, min_value);
1013    }
1014    return 0;   
1015  } else if (value > max_value) {
1016    if (errmsg) {
1017      PyErr_Format(PyExc_OverflowError,
1018                   "value %ld is greater than '%s' maximum %ld", 
1019                   value, errmsg, max_value);
1020    }
1021    return 0;
1022  }
1023  return 1;
1024}
1025
1026
1027SWIGSTATICINLINE(int)
1028  SWIG_AsVal_long(PyObject * obj, long* val)
1029{
1030  if (PyInt_Check(obj)) {
1031    if (val) *val = PyInt_AS_LONG(obj);
1032    return 1;
1033  }
1034  if (PyLong_Check(obj)) {
1035    long v = PyLong_AsLong(obj);
1036    if (!PyErr_Occurred()) {
1037      if (val) *val = v;
1038      return 1;
1039    } else {
1040      if (!val) PyErr_Clear();
1041      return 0;
1042    }
1043  }
1044  if (val) {
1045    PyErr_SetString(PyExc_TypeError, "a long is expected");
1046  }
1047  return 0;
1048 }
1049
1050
1051#if INT_MAX != LONG_MAX
1052SWIGSTATICINLINE(int)
1053  SWIG_AsVal_int(PyObject *obj, int *val)
1054{ 
1055  const char* errmsg = val ? "int" : 0;
1056  long v;
1057  if (SWIG_AsVal_long(obj, &v)) {
1058    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1059      if (val) *val = swig_numeric_cast(v, int);
1060      return 1;
1061    } else {
1062      return 0;
1063    }
1064  } else {
1065    PyErr_Clear();
1066  }
1067  if (val) {
1068    PyErr_SetString(PyExc_TypeError, "an int is expected");
1069  }
1070  return 0;   
1071}
1072#else
1073SWIGSTATICINLINE(int)
1074  SWIG_AsVal_int(PyObject *obj, int *val)
1075{
1076  return SWIG_AsVal_long(obj,(long*)val);
1077}
1078#endif
1079
1080
1081SWIGSTATICINLINE(int)
1082SWIG_As_int(PyObject* obj)
1083{
1084  int v;
1085  if (!SWIG_AsVal_int(obj, &v)) {
1086    /*
1087      this is needed to make valgrind/purify happier.  the other
1088      solution is throw an exception, but since this code should work
1089      with plain C ....
1090     */
1091    memset((void*)&v, 0, sizeof(int));
1092  }
1093  return v;
1094}
1095
1096 
1097SWIGSTATICINLINE(int)
1098SWIG_Check_int(PyObject* obj)
1099{
1100  return SWIG_AsVal_int(obj, (int*)0);
1101}
1102
1103
1104SWIGSTATICINLINE(PyObject *)
1105SWIG_FromCharPtr(const char* cptr)
1106{ 
1107  if (cptr) {
1108    size_t size = strlen(cptr);
1109    if (size > INT_MAX) {
1110      return SWIG_NewPointerObj(swig_const_cast(cptr,char*), 
1111                                SWIG_TypeQuery("char *"), 0);
1112    } else {
1113      if (size != 0) {
1114        return PyString_FromStringAndSize(cptr, size);
1115      } else {
1116        return PyString_FromString(cptr);
1117      }
1118    }
1119  }
1120  Py_INCREF(Py_None);
1121  return Py_None;
1122}
1123
1124
1125/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1126SWIGSTATIC(int)
1127SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1128{
1129  static swig_type_info* pchar_info = 0;
1130  char* vptr = 0;
1131  if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1132  if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1133    if (cptr) *cptr = vptr;
1134    if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1135    return SWIG_OLDOBJ;
1136  } else {
1137    if (PyString_Check(obj)) {
1138      if (cptr) {
1139        *cptr = PyString_AS_STRING(obj);
1140        if (psize) {
1141          *psize = PyString_GET_SIZE(obj) + 1;
1142        }
1143      }
1144      return SWIG_PYSTR;
1145    }
1146  }
1147  if (cptr) {
1148    PyErr_SetString(PyExc_TypeError, "a string is expected");
1149  }
1150  return 0;
1151}
1152
1153
1154SWIGSTATICINLINE(int)
1155SWIG_AsCharPtr(PyObject *obj, char **val)
1156{
1157  char* cptr = 0;
1158  if (SWIG_AsCharPtrAndSize(obj, &cptr, (size_t*)(0))) {
1159    if (val) *val = cptr;
1160    return 1;
1161  }
1162  if (val) {
1163    PyErr_SetString(PyExc_TypeError, "a char* is expected");
1164  }
1165  return 0;
1166}
1167
1168char *attrl___str__(struct attrl *self){
1169    static char temp[4 * 255] ;
1170    snprintf(temp, sizeof(temp), "(%s,%s,%s)", 
1171      self->name, self->resource, self->value);
1172   
1173    return &temp[0];
1174  }
1175char *attropl___str__(struct attropl *self){
1176    static char temp[4 * 255] ;
1177    snprintf(temp, sizeof(temp), "(%s,%s,%s)", 
1178      self->name, self->resource, self->value);
1179   
1180    return &temp[0];
1181  }
1182extern int pbs_errno;
1183extern char *pbs_server;
1184
1185SWIGSTATIC(int)
1186SWIG_AsNewCharPtr(PyObject *obj, char **val)
1187{
1188  char* cptr = 0; size_t csize = 0;
1189  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize);
1190  if (res) {
1191    if (val) {
1192      if (csize) {
1193        *val = swig_new_array(csize, char);
1194        memcpy(*val, cptr, --csize);
1195        (*val)[csize] = 0;
1196      } else if (cptr) {
1197        *val = swig_new_array(1, char);
1198        (*val)[0] = 0;
1199      } else {
1200        *val = 0;
1201      }
1202    }
1203    return SWIG_NEWOBJ;
1204  } 
1205  if (val) {
1206    PyErr_SetString(PyExc_TypeError, "a char* is expected");
1207  }
1208  return 0;
1209}
1210
1211extern char avail(int,char *);
1212
1213SWIGSTATICINLINE(PyObject*)
1214  SWIG_From_char(char c) 
1215{ 
1216  return PyString_FromStringAndSize(&c,1);
1217}
1218
1219extern int pbs_asyrunjob(int,char *,char *,char *);
1220extern int pbs_alterjob(int,char *,struct attrl *,char *);
1221extern int pbs_connect(char *);
1222extern int pbs_query_max_connections();
1223extern char *pbs_default(void);
1224extern int pbs_deljob(int,char *,char *);
1225extern int pbs_disconnect(int);
1226extern char *pbs_geterrmsg(int);
1227extern int pbs_holdjob(int,char *,char *,char *);
1228extern char *pbs_locjob(int,char *,char *);
1229extern int pbs_manager(int,int,int,char *,struct attropl *,char *);
1230extern int pbs_movejob(int,char *,char *,char *);
1231extern int pbs_msgjob(int,char *,int,char *,char *);
1232extern int pbs_orderjob(int,char *,char *,char *);
1233extern int pbs_rescquery(int,char **,int,int *,int *,int *,int *);
1234extern int pbs_rescreserve(int,char **,int,resource_t *);
1235extern int pbs_rescrelease(int,resource_t);
1236extern int pbs_rerunjob(int,char *,char *);
1237extern int pbs_rlsjob(int,char *,char *,char *);
1238extern int pbs_runjob(int,char *,char *,char *);
1239extern char **pbs_selectjob(int,struct attropl *,char *);
1240extern int pbs_sigjob(int,char *,char *,char *);
1241extern void pbs_statfree(struct batch_status *);
1242extern struct batch_status *pbs_statjob(int,char *,struct attrl *,char *);
1243extern struct batch_status *pbs_selstat(int,struct attropl *,char *);
1244extern struct batch_status *pbs_statque(int,char *,struct attrl *,char *);
1245extern struct batch_status *pbs_statserver(int,struct attrl *,char *);
1246extern struct batch_status *pbs_statnode(int,char *,struct attrl *,char *);
1247extern char *pbs_submit(int,struct attropl *,char *,char *,char *);
1248extern int pbs_terminate(int,int,char *);
1249extern int totpool(int,int);
1250extern int usepool(int,int);
1251
1252SWIGSTATICINLINE(int)
1253  SWIG_CheckUnsignedLongInRange(unsigned long value,
1254                                unsigned long max_value,
1255                                const char *errmsg) 
1256{
1257  if (value > max_value) {
1258    if (errmsg) {
1259      PyErr_Format(PyExc_OverflowError,
1260                   "value %ld is greater than '%s' minimum %ld",
1261                   value, errmsg, max_value);
1262    }
1263    return 0;
1264  }
1265  return 1;
1266 }
1267
1268
1269SWIGSTATICINLINE(int)
1270  SWIG_AsVal_unsigned_SS_long(PyObject * obj, unsigned long *val) 
1271{
1272  if (PyInt_Check(obj)) {
1273    long v = PyInt_AS_LONG(obj);
1274    if (v >= 0) {
1275      if (val) *val = v;
1276      return 1;
1277    }   
1278  }
1279  if (PyLong_Check(obj)) {
1280    unsigned long v = PyLong_AsUnsignedLong(obj);
1281    if (!PyErr_Occurred()) {
1282      if (val) *val = v;
1283      return 1;
1284    } else {
1285      if (!val) PyErr_Clear();
1286      return 0;
1287    }
1288  } 
1289  if (val) {
1290    PyErr_SetString(PyExc_TypeError, "an unsigned long is expected");
1291  }
1292  return 0;
1293}
1294
1295
1296#if UINT_MAX != ULONG_MAX
1297SWIGSTATICINLINE(int)
1298  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1299{ 
1300  const char* errmsg = val ? "unsigned int" : 0;
1301  unsigned long v;
1302  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1303    if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1304      if (val) *val = swig_numeric_cast(v, unsigned int);
1305      return 1;
1306    }
1307  } else {
1308    PyErr_Clear();
1309  }
1310  if (val) {
1311    PyErr_SetString(PyExc_TypeError, "an unsigned int is expected");
1312  }
1313  return 0;   
1314}
1315#else
1316SWIGSTATICINLINE(unsigned int)
1317  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1318{
1319  return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1320}
1321#endif
1322
1323
1324SWIGSTATICINLINE(unsigned int)
1325SWIG_As_unsigned_SS_int(PyObject* obj)
1326{
1327  unsigned int v;
1328  if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1329    /*
1330      this is needed to make valgrind/purify happier.  the other
1331      solution is throw an exception, but since this code should work
1332      with plain C ....
1333     */
1334    memset((void*)&v, 0, sizeof(unsigned int));
1335  }
1336  return v;
1337}
1338
1339 
1340SWIGSTATICINLINE(int)
1341SWIG_Check_unsigned_SS_int(PyObject* obj)
1342{
1343  return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1344}
1345
1346extern long *log_event_mask;
1347extern void log_close(int);
1348extern void log_err(int,char *,char *);
1349extern void log_event(int,int,char *,char *);
1350extern int log_open(char *,char *);
1351extern void log_record(int,int,char *,char *);
1352extern char log_buffer[4096];
1353
1354SWIGSTATIC(int)
1355SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
1356{ 
1357  char* cptr; size_t csize; 
1358  if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
1359    /* in C you can do:       
1360
1361         char x[5] = "hello";
1362
1363        ie, assing the array using an extra '0' char.
1364    */
1365    if ((csize == size + 1) && !(cptr[csize-1])) --csize;
1366    if (csize <= size) {
1367      if (val) {
1368        if (csize) memcpy(val, cptr, csize);
1369        if (csize < size) memset(val + csize, 0, size - csize);
1370      }
1371      return 1;
1372    }
1373  }
1374  if (val) {
1375    PyErr_Format(PyExc_TypeError, 
1376                 "a char array of maximum size %ld is expected", 
1377                 size);
1378  }
1379  return 0;
1380}
1381
1382
1383SWIGSTATICINLINE(PyObject *)
1384SWIG_FromCharArray(const char* carray, size_t size)
1385{
1386  if (size > INT_MAX) {
1387    SWIG_NewPointerObj(swig_const_cast(carray,char*), SWIG_TypeQuery("char *"), 0);
1388    return Py_None;   
1389  } else {
1390    return PyString_FromStringAndSize(carray, swig_numeric_cast(size,int));
1391  }
1392}
1393
1394extern int setup_env(char *);
1395extern int chk_file_sec(char *,int,int,int,int);
1396#ifdef __cplusplus
1397extern "C" {
1398#endif
1399static PyObject *_wrap_new_attrl(PyObject *self, PyObject *args) {
1400    PyObject *resultobj;
1401    int arg1 ;
1402    struct attrl *result;
1403    PyObject * obj0 = 0 ;
1404   
1405    if(!PyArg_ParseTuple(args,(char *)"O:new_attrl",&obj0)) goto fail;
1406    arg1 = (int)SWIG_As_int(obj0); 
1407    if (PyErr_Occurred()) SWIG_fail;
1408    result = (struct attrl *)new_attrl(arg1);
1409   
1410    {
1411        PyObject        *obj_batch;
1412        struct attrl    *ptr;
1413        int             i=0, len=0;
1414       
1415        if (SARA_DEBUG) printf("Converteren c (struct attrl *) -> python:\n");
1416       
1417        ptr = result;
1418        while (ptr != NULL) {
1419            len++;
1420            ptr = ptr->next;
1421        }
1422        resultobj = PyList_New(len);
1423       
1424        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
1425       
1426        if (SARA_DEBUG) printf("\t<Contents>\n");
1427        ptr = result;
1428        for (i=0; i < len; i++) {
1429            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attrl,1); 
1430            PyList_SetItem(resultobj, i, obj_batch);   
1431            if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
1432            ptr = ptr->next;
1433        }
1434        if (SARA_DEBUG) printf("\t</Contents>\n");
1435    }
1436    return resultobj;
1437    fail:
1438    return NULL;
1439}
1440
1441
1442static PyObject *_wrap_new_attropl(PyObject *self, PyObject *args) {
1443    PyObject *resultobj;
1444    int arg1 ;
1445    struct attropl *result;
1446    PyObject * obj0 = 0 ;
1447   
1448    if(!PyArg_ParseTuple(args,(char *)"O:new_attropl",&obj0)) goto fail;
1449    arg1 = (int)SWIG_As_int(obj0); 
1450    if (PyErr_Occurred()) SWIG_fail;
1451    result = (struct attropl *)new_attropl(arg1);
1452   
1453    {
1454        PyObject                *obj_batch;
1455        struct attropl  *ptr;
1456        int                     i=0, len=0;
1457       
1458        if (SARA_DEBUG) printf("Converteren c (struct attropl *) -> python:\n");
1459       
1460        ptr = result;
1461        while (ptr != NULL) {
1462            len++;
1463            ptr = ptr->next;
1464        }
1465        resultobj = PyList_New(len);
1466        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
1467       
1468        if (SARA_DEBUG) printf("\t<Contents>\n");
1469        ptr = result;
1470        for (i=0; i < len; i++) {
1471            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attropl,1); 
1472            PyList_SetItem(resultobj, i, obj_batch);   
1473            ptr = ptr->next;
1474        }
1475        if (SARA_DEBUG) printf("\t</Contents>\n");
1476    }
1477    return resultobj;
1478    fail:
1479    return NULL;
1480}
1481
1482
1483static PyObject *_wrap_new_batch_status(PyObject *self, PyObject *args) {
1484    PyObject *resultobj;
1485    struct batch_status *result;
1486   
1487    if(!PyArg_ParseTuple(args,(char *)":new_batch_status")) goto fail;
1488    result = (struct batch_status *)new_batch_status();
1489   
1490    {
1491        PyObject *obj_batch;
1492        struct batch_status *ptr;
1493        int i=0, len=0;
1494       
1495        // printf("Ja we are in bussniss\n");
1496        if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
1497       
1498        // Deterime length of list
1499        //
1500        ptr = result;
1501        while (ptr != NULL) {
1502            len++;
1503            ptr = ptr->next;
1504        }
1505        resultobj = PyList_New(len);
1506       
1507        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
1508       
1509        // Make a list of batch_status pointers
1510        //
1511        if (SARA_DEBUG) printf("\t<Contents>\n");
1512        ptr = result;
1513        for (i=0; i < len; i++) {
1514            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0); 
1515            PyList_SetItem(resultobj, i, obj_batch);   
1516            if (SARA_DEBUG)  {
1517                printf("\t\t- %s\n", ptr->name);
1518            }
1519            ptr = ptr->next;
1520        }
1521        if (SARA_DEBUG) printf("\t</Contents>\n");
1522    }
1523    return resultobj;
1524    fail:
1525    return NULL;
1526}
1527
1528
1529static PyObject *_wrap_get_error(PyObject *self, PyObject *args) {
1530    PyObject *resultobj;
1531    int result;
1532   
1533    if(!PyArg_ParseTuple(args,(char *)":get_error")) goto fail;
1534    result = (int)get_error();
1535   
1536    resultobj = SWIG_From_int((int)result);
1537    return resultobj;
1538    fail:
1539    return NULL;
1540}
1541
1542
1543static PyObject *_wrap_attrl_name_set(PyObject *self, PyObject *args) {
1544    PyObject *resultobj;
1545    struct attrl *arg1 = (struct attrl *) 0 ;
1546    char *arg2 ;
1547    PyObject * obj0 = 0 ;
1548    PyObject * obj1 = 0 ;
1549   
1550    if(!PyArg_ParseTuple(args,(char *)"OO:attrl_name_set",&obj0,&obj1)) goto fail;
1551    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1552    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1553    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
1554    {
1555        if (arg1->name) free((char*)arg1->name);
1556        if (arg2) {
1557            arg1->name = (char *) malloc(strlen(arg2)+1);
1558            strcpy((char*)arg1->name,arg2);
1559        } else {
1560            arg1->name = 0;
1561        }
1562    }
1563    Py_INCREF(Py_None); resultobj = Py_None;
1564    return resultobj;
1565    fail:
1566    return NULL;
1567}
1568
1569
1570static PyObject *_wrap_attrl_name_get(PyObject *self, PyObject *args) {
1571    PyObject *resultobj;
1572    struct attrl *arg1 = (struct attrl *) 0 ;
1573    char *result;
1574    PyObject * obj0 = 0 ;
1575   
1576    if(!PyArg_ParseTuple(args,(char *)"O:attrl_name_get",&obj0)) goto fail;
1577    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1578    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1579    result = (char *) ((arg1)->name);
1580   
1581    resultobj = SWIG_FromCharPtr(result);
1582    return resultobj;
1583    fail:
1584    return NULL;
1585}
1586
1587
1588static PyObject *_wrap_attrl_resource_set(PyObject *self, PyObject *args) {
1589    PyObject *resultobj;
1590    struct attrl *arg1 = (struct attrl *) 0 ;
1591    char *arg2 ;
1592    PyObject * obj0 = 0 ;
1593    PyObject * obj1 = 0 ;
1594   
1595    if(!PyArg_ParseTuple(args,(char *)"OO:attrl_resource_set",&obj0,&obj1)) goto fail;
1596    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1597    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1598    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
1599    {
1600        if (arg1->resource) free((char*)arg1->resource);
1601        if (arg2) {
1602            arg1->resource = (char *) malloc(strlen(arg2)+1);
1603            strcpy((char*)arg1->resource,arg2);
1604        } else {
1605            arg1->resource = 0;
1606        }
1607    }
1608    Py_INCREF(Py_None); resultobj = Py_None;
1609    return resultobj;
1610    fail:
1611    return NULL;
1612}
1613
1614
1615static PyObject *_wrap_attrl_resource_get(PyObject *self, PyObject *args) {
1616    PyObject *resultobj;
1617    struct attrl *arg1 = (struct attrl *) 0 ;
1618    char *result;
1619    PyObject * obj0 = 0 ;
1620   
1621    if(!PyArg_ParseTuple(args,(char *)"O:attrl_resource_get",&obj0)) goto fail;
1622    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1623    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1624    result = (char *) ((arg1)->resource);
1625   
1626    resultobj = SWIG_FromCharPtr(result);
1627    return resultobj;
1628    fail:
1629    return NULL;
1630}
1631
1632
1633static PyObject *_wrap_attrl_value_set(PyObject *self, PyObject *args) {
1634    PyObject *resultobj;
1635    struct attrl *arg1 = (struct attrl *) 0 ;
1636    char *arg2 ;
1637    PyObject * obj0 = 0 ;
1638    PyObject * obj1 = 0 ;
1639   
1640    if(!PyArg_ParseTuple(args,(char *)"OO:attrl_value_set",&obj0,&obj1)) goto fail;
1641    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1642    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1643    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
1644    {
1645        if (arg1->value) free((char*)arg1->value);
1646        if (arg2) {
1647            arg1->value = (char *) malloc(strlen(arg2)+1);
1648            strcpy((char*)arg1->value,arg2);
1649        } else {
1650            arg1->value = 0;
1651        }
1652    }
1653    Py_INCREF(Py_None); resultobj = Py_None;
1654    return resultobj;
1655    fail:
1656    return NULL;
1657}
1658
1659
1660static PyObject *_wrap_attrl_value_get(PyObject *self, PyObject *args) {
1661    PyObject *resultobj;
1662    struct attrl *arg1 = (struct attrl *) 0 ;
1663    char *result;
1664    PyObject * obj0 = 0 ;
1665   
1666    if(!PyArg_ParseTuple(args,(char *)"O:attrl_value_get",&obj0)) goto fail;
1667    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1668    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1669    result = (char *) ((arg1)->value);
1670   
1671    resultobj = SWIG_FromCharPtr(result);
1672    return resultobj;
1673    fail:
1674    return NULL;
1675}
1676
1677
1678static PyObject *_wrap_attrl_op_set(PyObject *self, PyObject *args) {
1679    PyObject *resultobj;
1680    struct attrl *arg1 = (struct attrl *) 0 ;
1681    int arg2 ;
1682    PyObject * obj0 = 0 ;
1683    PyObject * obj1 = 0 ;
1684   
1685    if(!PyArg_ParseTuple(args,(char *)"OO:attrl_op_set",&obj0,&obj1)) goto fail;
1686    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1687    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1688    arg2 = (int)SWIG_As_int(obj1); 
1689    if (PyErr_Occurred()) SWIG_fail;
1690    if (arg1) (arg1)->op = (enum batch_op)arg2;
1691   
1692    Py_INCREF(Py_None); resultobj = Py_None;
1693    return resultobj;
1694    fail:
1695    return NULL;
1696}
1697
1698
1699static PyObject *_wrap_attrl_op_get(PyObject *self, PyObject *args) {
1700    PyObject *resultobj;
1701    struct attrl *arg1 = (struct attrl *) 0 ;
1702    int result;
1703    PyObject * obj0 = 0 ;
1704   
1705    if(!PyArg_ParseTuple(args,(char *)"O:attrl_op_get",&obj0)) goto fail;
1706    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1707    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1708    result = (int) ((arg1)->op);
1709   
1710    resultobj = SWIG_From_int((int)result);
1711    return resultobj;
1712    fail:
1713    return NULL;
1714}
1715
1716
1717static PyObject *_wrap_attrl___str__(PyObject *self, PyObject *args) {
1718    PyObject *resultobj;
1719    struct attrl *arg1 = (struct attrl *) 0 ;
1720    char *result;
1721    PyObject * obj0 = 0 ;
1722   
1723    if(!PyArg_ParseTuple(args,(char *)"O:attrl___str__",&obj0)) goto fail;
1724    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attrl,
1725    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1726    result = (char *)attrl___str__(arg1);
1727   
1728    resultobj = SWIG_FromCharPtr(result);
1729    return resultobj;
1730    fail:
1731    return NULL;
1732}
1733
1734
1735static PyObject * attrl_swigregister(PyObject *self, PyObject *args) {
1736    PyObject *obj;
1737    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
1738    SWIG_TypeClientData(SWIGTYPE_p_attrl, obj);
1739    Py_INCREF(obj);
1740    return Py_BuildValue((char *)"");
1741}
1742static PyObject *_wrap_attropl_name_set(PyObject *self, PyObject *args) {
1743    PyObject *resultobj;
1744    struct attropl *arg1 = (struct attropl *) 0 ;
1745    char *arg2 ;
1746    PyObject * obj0 = 0 ;
1747    PyObject * obj1 = 0 ;
1748   
1749    if(!PyArg_ParseTuple(args,(char *)"OO:attropl_name_set",&obj0,&obj1)) goto fail;
1750    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1751    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1752    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
1753    {
1754        if (arg1->name) free((char*)arg1->name);
1755        if (arg2) {
1756            arg1->name = (char *) malloc(strlen(arg2)+1);
1757            strcpy((char*)arg1->name,arg2);
1758        } else {
1759            arg1->name = 0;
1760        }
1761    }
1762    Py_INCREF(Py_None); resultobj = Py_None;
1763    return resultobj;
1764    fail:
1765    return NULL;
1766}
1767
1768
1769static PyObject *_wrap_attropl_name_get(PyObject *self, PyObject *args) {
1770    PyObject *resultobj;
1771    struct attropl *arg1 = (struct attropl *) 0 ;
1772    char *result;
1773    PyObject * obj0 = 0 ;
1774   
1775    if(!PyArg_ParseTuple(args,(char *)"O:attropl_name_get",&obj0)) goto fail;
1776    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1777    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1778    result = (char *) ((arg1)->name);
1779   
1780    resultobj = SWIG_FromCharPtr(result);
1781    return resultobj;
1782    fail:
1783    return NULL;
1784}
1785
1786
1787static PyObject *_wrap_attropl_resource_set(PyObject *self, PyObject *args) {
1788    PyObject *resultobj;
1789    struct attropl *arg1 = (struct attropl *) 0 ;
1790    char *arg2 ;
1791    PyObject * obj0 = 0 ;
1792    PyObject * obj1 = 0 ;
1793   
1794    if(!PyArg_ParseTuple(args,(char *)"OO:attropl_resource_set",&obj0,&obj1)) goto fail;
1795    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1796    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1797    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
1798    {
1799        if (arg1->resource) free((char*)arg1->resource);
1800        if (arg2) {
1801            arg1->resource = (char *) malloc(strlen(arg2)+1);
1802            strcpy((char*)arg1->resource,arg2);
1803        } else {
1804            arg1->resource = 0;
1805        }
1806    }
1807    Py_INCREF(Py_None); resultobj = Py_None;
1808    return resultobj;
1809    fail:
1810    return NULL;
1811}
1812
1813
1814static PyObject *_wrap_attropl_resource_get(PyObject *self, PyObject *args) {
1815    PyObject *resultobj;
1816    struct attropl *arg1 = (struct attropl *) 0 ;
1817    char *result;
1818    PyObject * obj0 = 0 ;
1819   
1820    if(!PyArg_ParseTuple(args,(char *)"O:attropl_resource_get",&obj0)) goto fail;
1821    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1822    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1823    result = (char *) ((arg1)->resource);
1824   
1825    resultobj = SWIG_FromCharPtr(result);
1826    return resultobj;
1827    fail:
1828    return NULL;
1829}
1830
1831
1832static PyObject *_wrap_attropl_value_set(PyObject *self, PyObject *args) {
1833    PyObject *resultobj;
1834    struct attropl *arg1 = (struct attropl *) 0 ;
1835    char *arg2 ;
1836    PyObject * obj0 = 0 ;
1837    PyObject * obj1 = 0 ;
1838   
1839    if(!PyArg_ParseTuple(args,(char *)"OO:attropl_value_set",&obj0,&obj1)) goto fail;
1840    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1841    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1842    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
1843    {
1844        if (arg1->value) free((char*)arg1->value);
1845        if (arg2) {
1846            arg1->value = (char *) malloc(strlen(arg2)+1);
1847            strcpy((char*)arg1->value,arg2);
1848        } else {
1849            arg1->value = 0;
1850        }
1851    }
1852    Py_INCREF(Py_None); resultobj = Py_None;
1853    return resultobj;
1854    fail:
1855    return NULL;
1856}
1857
1858
1859static PyObject *_wrap_attropl_value_get(PyObject *self, PyObject *args) {
1860    PyObject *resultobj;
1861    struct attropl *arg1 = (struct attropl *) 0 ;
1862    char *result;
1863    PyObject * obj0 = 0 ;
1864   
1865    if(!PyArg_ParseTuple(args,(char *)"O:attropl_value_get",&obj0)) goto fail;
1866    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1867    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1868    result = (char *) ((arg1)->value);
1869   
1870    resultobj = SWIG_FromCharPtr(result);
1871    return resultobj;
1872    fail:
1873    return NULL;
1874}
1875
1876
1877static PyObject *_wrap_attropl_op_set(PyObject *self, PyObject *args) {
1878    PyObject *resultobj;
1879    struct attropl *arg1 = (struct attropl *) 0 ;
1880    int arg2 ;
1881    PyObject * obj0 = 0 ;
1882    PyObject * obj1 = 0 ;
1883   
1884    if(!PyArg_ParseTuple(args,(char *)"OO:attropl_op_set",&obj0,&obj1)) goto fail;
1885    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1886    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1887    arg2 = (int)SWIG_As_int(obj1); 
1888    if (PyErr_Occurred()) SWIG_fail;
1889    if (arg1) (arg1)->op = (enum batch_op)arg2;
1890   
1891    Py_INCREF(Py_None); resultobj = Py_None;
1892    return resultobj;
1893    fail:
1894    return NULL;
1895}
1896
1897
1898static PyObject *_wrap_attropl_op_get(PyObject *self, PyObject *args) {
1899    PyObject *resultobj;
1900    struct attropl *arg1 = (struct attropl *) 0 ;
1901    int result;
1902    PyObject * obj0 = 0 ;
1903   
1904    if(!PyArg_ParseTuple(args,(char *)"O:attropl_op_get",&obj0)) goto fail;
1905    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1906    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1907    result = (int) ((arg1)->op);
1908   
1909    resultobj = SWIG_From_int((int)result);
1910    return resultobj;
1911    fail:
1912    return NULL;
1913}
1914
1915
1916static PyObject *_wrap_attropl___str__(PyObject *self, PyObject *args) {
1917    PyObject *resultobj;
1918    struct attropl *arg1 = (struct attropl *) 0 ;
1919    char *result;
1920    PyObject * obj0 = 0 ;
1921   
1922    if(!PyArg_ParseTuple(args,(char *)"O:attropl___str__",&obj0)) goto fail;
1923    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_attropl,
1924    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1925    result = (char *)attropl___str__(arg1);
1926   
1927    resultobj = SWIG_FromCharPtr(result);
1928    return resultobj;
1929    fail:
1930    return NULL;
1931}
1932
1933
1934static PyObject * attropl_swigregister(PyObject *self, PyObject *args) {
1935    PyObject *obj;
1936    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
1937    SWIG_TypeClientData(SWIGTYPE_p_attropl, obj);
1938    Py_INCREF(obj);
1939    return Py_BuildValue((char *)"");
1940}
1941static PyObject *_wrap_batch_status_name_set(PyObject *self, PyObject *args) {
1942    PyObject *resultobj;
1943    struct batch_status *arg1 = (struct batch_status *) 0 ;
1944    char *arg2 ;
1945    PyObject * obj0 = 0 ;
1946    PyObject * obj1 = 0 ;
1947   
1948    if(!PyArg_ParseTuple(args,(char *)"OO:batch_status_name_set",&obj0,&obj1)) goto fail;
1949    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_batch_status,
1950    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1951    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
1952    {
1953        if (arg1->name) free((char*)arg1->name);
1954        if (arg2) {
1955            arg1->name = (char *) malloc(strlen(arg2)+1);
1956            strcpy((char*)arg1->name,arg2);
1957        } else {
1958            arg1->name = 0;
1959        }
1960    }
1961    Py_INCREF(Py_None); resultobj = Py_None;
1962    return resultobj;
1963    fail:
1964    return NULL;
1965}
1966
1967
1968static PyObject *_wrap_batch_status_name_get(PyObject *self, PyObject *args) {
1969    PyObject *resultobj;
1970    struct batch_status *arg1 = (struct batch_status *) 0 ;
1971    char *result;
1972    PyObject * obj0 = 0 ;
1973   
1974    if(!PyArg_ParseTuple(args,(char *)"O:batch_status_name_get",&obj0)) goto fail;
1975    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_batch_status,
1976    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1977    result = (char *) ((arg1)->name);
1978   
1979    resultobj = SWIG_FromCharPtr(result);
1980    return resultobj;
1981    fail:
1982    return NULL;
1983}
1984
1985
1986static PyObject *_wrap_batch_status_attribs_set(PyObject *self, PyObject *args) {
1987    PyObject *resultobj;
1988    struct batch_status *arg1 = (struct batch_status *) 0 ;
1989    struct attrl *arg2 = (struct attrl *) 0 ;
1990    PyObject * obj0 = 0 ;
1991    PyObject * obj1 = 0 ;
1992   
1993    if(!PyArg_ParseTuple(args,(char *)"OO:batch_status_attribs_set",&obj0,&obj1)) goto fail;
1994    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_batch_status,
1995    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
1996    if ((SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_attrl,
1997    SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN)) == -1) SWIG_fail;
1998    if (arg1) (arg1)->attribs = arg2;
1999   
2000    Py_INCREF(Py_None); resultobj = Py_None;
2001    return resultobj;
2002    fail:
2003    return NULL;
2004}
2005
2006
2007static PyObject *_wrap_batch_status_attribs_get(PyObject *self, PyObject *args) {
2008    PyObject *resultobj;
2009    struct batch_status *arg1 = (struct batch_status *) 0 ;
2010    struct attrl *result;
2011    PyObject * obj0 = 0 ;
2012   
2013    if(!PyArg_ParseTuple(args,(char *)"O:batch_status_attribs_get",&obj0)) goto fail;
2014    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_batch_status,
2015    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
2016    result = (struct attrl *) ((arg1)->attribs);
2017   
2018    {
2019        PyObject        *obj_batch;
2020        struct attrl    *ptr;
2021        int             i=0, len=0;
2022       
2023        if (SARA_DEBUG) printf("Converteren c (struct attrl *) -> python:\n");
2024       
2025        ptr = result;
2026        while (ptr != NULL) {
2027            len++;
2028            ptr = ptr->next;
2029        }
2030        resultobj = PyList_New(len);
2031       
2032        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
2033       
2034        if (SARA_DEBUG) printf("\t<Contents>\n");
2035        ptr = result;
2036        for (i=0; i < len; i++) {
2037            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attrl,1); 
2038            PyList_SetItem(resultobj, i, obj_batch);   
2039            if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
2040            ptr = ptr->next;
2041        }
2042        if (SARA_DEBUG) printf("\t</Contents>\n");
2043    }
2044    return resultobj;
2045    fail:
2046    return NULL;
2047}
2048
2049
2050static PyObject *_wrap_batch_status_text_set(PyObject *self, PyObject *args) {
2051    PyObject *resultobj;
2052    struct batch_status *arg1 = (struct batch_status *) 0 ;
2053    char *arg2 ;
2054    PyObject * obj0 = 0 ;
2055    PyObject * obj1 = 0 ;
2056   
2057    if(!PyArg_ParseTuple(args,(char *)"OO:batch_status_text_set",&obj0,&obj1)) goto fail;
2058    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_batch_status,
2059    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
2060    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2061    {
2062        if (arg1->text) free((char*)arg1->text);
2063        if (arg2) {
2064            arg1->text = (char *) malloc(strlen(arg2)+1);
2065            strcpy((char*)arg1->text,arg2);
2066        } else {
2067            arg1->text = 0;
2068        }
2069    }
2070    Py_INCREF(Py_None); resultobj = Py_None;
2071    return resultobj;
2072    fail:
2073    return NULL;
2074}
2075
2076
2077static PyObject *_wrap_batch_status_text_get(PyObject *self, PyObject *args) {
2078    PyObject *resultobj;
2079    struct batch_status *arg1 = (struct batch_status *) 0 ;
2080    char *result;
2081    PyObject * obj0 = 0 ;
2082   
2083    if(!PyArg_ParseTuple(args,(char *)"O:batch_status_text_get",&obj0)) goto fail;
2084    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_batch_status,
2085    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
2086    result = (char *) ((arg1)->text);
2087   
2088    resultobj = SWIG_FromCharPtr(result);
2089    return resultobj;
2090    fail:
2091    return NULL;
2092}
2093
2094
2095static PyObject * batch_status_swigregister(PyObject *self, PyObject *args) {
2096    PyObject *obj;
2097    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2098    SWIG_TypeClientData(SWIGTYPE_p_batch_status, obj);
2099    Py_INCREF(obj);
2100    return Py_BuildValue((char *)"");
2101}
2102static int _wrap_pbs_errno_set(PyObject *_val) {
2103    {
2104        int temp = (int) SWIG_As_int(_val); 
2105        if (PyErr_Occurred()) {
2106            PyErr_SetString(PyExc_TypeError, "C/C++ variable 'pbs_errno (int)'");
2107            return 1;
2108        }
2109        pbs_errno = temp;
2110    }
2111    return 0;
2112}
2113
2114
2115static PyObject *_wrap_pbs_errno_get() {
2116    PyObject *pyobj;
2117   
2118    pyobj = SWIG_From_int((int)pbs_errno);
2119    return pyobj;
2120}
2121
2122
2123static int _wrap_pbs_server_set(PyObject *_val) {
2124    {
2125        char *cptr = 0;
2126        if (!SWIG_AsNewCharPtr(_val, &cptr)) {
2127            PyErr_Clear();
2128            PyErr_SetString(PyExc_TypeError, "C/C++ variable 'pbs_server (char *)'");
2129            return 1;
2130        }
2131        if (pbs_server) swig_delete_array(pbs_server);
2132        pbs_server = cptr;
2133    }
2134    return 0;
2135}
2136
2137
2138static PyObject *_wrap_pbs_server_get() {
2139    PyObject *pyobj;
2140   
2141    pyobj = SWIG_FromCharPtr(pbs_server);
2142    return pyobj;
2143}
2144
2145
2146static PyObject *_wrap_avail(PyObject *self, PyObject *args) {
2147    PyObject *resultobj;
2148    int arg1 ;
2149    char *arg2 ;
2150    char result;
2151    PyObject * obj0 = 0 ;
2152    PyObject * obj1 = 0 ;
2153   
2154    if(!PyArg_ParseTuple(args,(char *)"OO:avail",&obj0,&obj1)) goto fail;
2155    arg1 = (int)SWIG_As_int(obj0); 
2156    if (PyErr_Occurred()) SWIG_fail;
2157    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2158    result = (char)avail(arg1,arg2);
2159   
2160    resultobj = SWIG_From_char((char)result);
2161    return resultobj;
2162    fail:
2163    return NULL;
2164}
2165
2166
2167static PyObject *_wrap_pbs_asyrunjob(PyObject *self, PyObject *args) {
2168    PyObject *resultobj;
2169    int arg1 ;
2170    char *arg2 ;
2171    char *arg3 ;
2172    char *arg4 ;
2173    int result;
2174    PyObject * obj0 = 0 ;
2175    PyObject * obj1 = 0 ;
2176    PyObject * obj2 = 0 ;
2177    PyObject * obj3 = 0 ;
2178   
2179    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_asyrunjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2180    arg1 = (int)SWIG_As_int(obj0); 
2181    if (PyErr_Occurred()) SWIG_fail;
2182    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2183    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2184    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2185    result = (int)pbs_asyrunjob(arg1,arg2,arg3,arg4);
2186   
2187    resultobj = SWIG_From_int((int)result);
2188    return resultobj;
2189    fail:
2190    return NULL;
2191}
2192
2193
2194static PyObject *_wrap_pbs_alterjob(PyObject *self, PyObject *args) {
2195    PyObject *resultobj;
2196    int arg1 ;
2197    char *arg2 ;
2198    struct attrl *arg3 = (struct attrl *) 0 ;
2199    char *arg4 ;
2200    int result;
2201    PyObject * obj0 = 0 ;
2202    PyObject * obj1 = 0 ;
2203    PyObject * obj2 = 0 ;
2204    PyObject * obj3 = 0 ;
2205   
2206    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_alterjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2207    arg1 = (int)SWIG_As_int(obj0); 
2208    if (PyErr_Occurred()) SWIG_fail;
2209    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2210    {
2211        PyObject        *py_obj;
2212        struct attrl    *ptr, *prev;
2213        char            s[255];
2214        int             i=0, size=0;
2215       
2216        // printf("Python --> C\n");
2217       
2218        if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
2219       
2220        size = Get_List_Size(obj2);
2221        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
2222       
2223        if ( size == -1 ) {
2224            PyErr_SetString(PyExc_TypeError, "not a list");
2225            return NULL; 
2226        }
2227       
2228        if (SARA_DEBUG) printf("\t<Contents>\n");
2229       
2230        arg3 = prev = NULL;
2231        for ( i=0; i < size; i++ ) {
2232            py_obj = PyList_GetItem(obj2, i);
2233            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
2234                sprintf(s,"list item %d has wrong type", i);
2235                PyErr_SetString(PyExc_TypeError, s);
2236                return NULL;
2237               
2238                // This will skipp the wrong entry
2239                // continue;
2240            }
2241           
2242            /*
2243                 * Make first entry head of C linked list
2244                */ 
2245            if ( i == 0) {
2246                arg3 = ptr;
2247                ptr->next = prev;
2248            }
2249            else {
2250                prev->next = ptr;
2251                ptr->next = NULL;
2252            }
2253            if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
2254           
2255            prev = ptr;
2256           
2257        } // end for
2258        if (SARA_DEBUG) printf("\t</Contents>\n");
2259    }
2260    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2261    result = (int)pbs_alterjob(arg1,arg2,arg3,arg4);
2262   
2263    resultobj = SWIG_From_int((int)result);
2264    return resultobj;
2265    fail:
2266    return NULL;
2267}
2268
2269
2270static PyObject *_wrap_pbs_connect(PyObject *self, PyObject *args) {
2271    PyObject *resultobj;
2272    char *arg1 ;
2273    int result;
2274    PyObject * obj0 = 0 ;
2275   
2276    if(!PyArg_ParseTuple(args,(char *)"O:pbs_connect",&obj0)) goto fail;
2277    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) SWIG_fail;
2278    result = (int)pbs_connect(arg1);
2279   
2280    resultobj = SWIG_From_int((int)result);
2281    return resultobj;
2282    fail:
2283    return NULL;
2284}
2285
2286
2287static PyObject *_wrap_pbs_query_max_connections(PyObject *self, PyObject *args) {
2288    PyObject *resultobj;
2289    int result;
2290   
2291    if(!PyArg_ParseTuple(args,(char *)":pbs_query_max_connections")) goto fail;
2292    result = (int)pbs_query_max_connections();
2293   
2294    resultobj = SWIG_From_int((int)result);
2295    return resultobj;
2296    fail:
2297    return NULL;
2298}
2299
2300
2301static PyObject *_wrap_pbs_default(PyObject *self, PyObject *args) {
2302    PyObject *resultobj;
2303    char *result;
2304   
2305    if(!PyArg_ParseTuple(args,(char *)":pbs_default")) goto fail;
2306    result = (char *)pbs_default();
2307   
2308    resultobj = SWIG_FromCharPtr(result);
2309    return resultobj;
2310    fail:
2311    return NULL;
2312}
2313
2314
2315static PyObject *_wrap_pbs_deljob(PyObject *self, PyObject *args) {
2316    PyObject *resultobj;
2317    int arg1 ;
2318    char *arg2 ;
2319    char *arg3 ;
2320    int result;
2321    PyObject * obj0 = 0 ;
2322    PyObject * obj1 = 0 ;
2323    PyObject * obj2 = 0 ;
2324   
2325    if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_deljob",&obj0,&obj1,&obj2)) goto fail;
2326    arg1 = (int)SWIG_As_int(obj0); 
2327    if (PyErr_Occurred()) SWIG_fail;
2328    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2329    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2330    result = (int)pbs_deljob(arg1,arg2,arg3);
2331   
2332    resultobj = SWIG_From_int((int)result);
2333    return resultobj;
2334    fail:
2335    return NULL;
2336}
2337
2338
2339static PyObject *_wrap_pbs_disconnect(PyObject *self, PyObject *args) {
2340    PyObject *resultobj;
2341    int arg1 ;
2342    int result;
2343    PyObject * obj0 = 0 ;
2344   
2345    if(!PyArg_ParseTuple(args,(char *)"O:pbs_disconnect",&obj0)) goto fail;
2346    arg1 = (int)SWIG_As_int(obj0); 
2347    if (PyErr_Occurred()) SWIG_fail;
2348    result = (int)pbs_disconnect(arg1);
2349   
2350    resultobj = SWIG_From_int((int)result);
2351    return resultobj;
2352    fail:
2353    return NULL;
2354}
2355
2356
2357static PyObject *_wrap_pbs_geterrmsg(PyObject *self, PyObject *args) {
2358    PyObject *resultobj;
2359    int arg1 ;
2360    char *result;
2361    PyObject * obj0 = 0 ;
2362   
2363    if(!PyArg_ParseTuple(args,(char *)"O:pbs_geterrmsg",&obj0)) goto fail;
2364    arg1 = (int)SWIG_As_int(obj0); 
2365    if (PyErr_Occurred()) SWIG_fail;
2366    result = (char *)pbs_geterrmsg(arg1);
2367   
2368    resultobj = SWIG_FromCharPtr(result);
2369    return resultobj;
2370    fail:
2371    return NULL;
2372}
2373
2374
2375static PyObject *_wrap_pbs_holdjob(PyObject *self, PyObject *args) {
2376    PyObject *resultobj;
2377    int arg1 ;
2378    char *arg2 ;
2379    char *arg3 ;
2380    char *arg4 ;
2381    int result;
2382    PyObject * obj0 = 0 ;
2383    PyObject * obj1 = 0 ;
2384    PyObject * obj2 = 0 ;
2385    PyObject * obj3 = 0 ;
2386   
2387    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_holdjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2388    arg1 = (int)SWIG_As_int(obj0); 
2389    if (PyErr_Occurred()) SWIG_fail;
2390    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2391    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2392    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2393    result = (int)pbs_holdjob(arg1,arg2,arg3,arg4);
2394   
2395    resultobj = SWIG_From_int((int)result);
2396    return resultobj;
2397    fail:
2398    return NULL;
2399}
2400
2401
2402static PyObject *_wrap_pbs_locjob(PyObject *self, PyObject *args) {
2403    PyObject *resultobj;
2404    int arg1 ;
2405    char *arg2 ;
2406    char *arg3 ;
2407    char *result;
2408    PyObject * obj0 = 0 ;
2409    PyObject * obj1 = 0 ;
2410    PyObject * obj2 = 0 ;
2411   
2412    if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_locjob",&obj0,&obj1,&obj2)) goto fail;
2413    arg1 = (int)SWIG_As_int(obj0); 
2414    if (PyErr_Occurred()) SWIG_fail;
2415    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2416    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2417    result = (char *)pbs_locjob(arg1,arg2,arg3);
2418   
2419    resultobj = SWIG_FromCharPtr(result);
2420    return resultobj;
2421    fail:
2422    return NULL;
2423}
2424
2425
2426static PyObject *_wrap_pbs_manager(PyObject *self, PyObject *args) {
2427    PyObject *resultobj;
2428    int arg1 ;
2429    int arg2 ;
2430    int arg3 ;
2431    char *arg4 ;
2432    struct attropl *arg5 = (struct attropl *) 0 ;
2433    char *arg6 ;
2434    int result;
2435    PyObject * obj0 = 0 ;
2436    PyObject * obj1 = 0 ;
2437    PyObject * obj2 = 0 ;
2438    PyObject * obj3 = 0 ;
2439    PyObject * obj4 = 0 ;
2440    PyObject * obj5 = 0 ;
2441   
2442    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:pbs_manager",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2443    arg1 = (int)SWIG_As_int(obj0); 
2444    if (PyErr_Occurred()) SWIG_fail;
2445    arg2 = (int)SWIG_As_int(obj1); 
2446    if (PyErr_Occurred()) SWIG_fail;
2447    arg3 = (int)SWIG_As_int(obj2); 
2448    if (PyErr_Occurred()) SWIG_fail;
2449    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2450    {
2451        PyObject                *py_obj;
2452        struct attropl  *ptr, *prev;
2453        char                    s[255];
2454        int                     i=0, size=0;
2455       
2456        // printf("Python --> C\n");
2457       
2458        if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
2459       
2460        size = Get_List_Size(obj4);
2461       
2462        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
2463       
2464        if ( size == -1 ) {
2465            PyErr_SetString(PyExc_TypeError, "not a list");
2466            return NULL; 
2467        }
2468        //printf("Size = %d\n", size);
2469       
2470        if (SARA_DEBUG) printf("\t<Contents>\n");
2471       
2472        arg5 = prev = NULL;
2473        for ( i=0; i < size; i++ ) {
2474            py_obj = PyList_GetItem(obj4, i);
2475            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
2476                sprintf(s,"list item %d has wrong type", i);
2477                PyErr_SetString(PyExc_TypeError, s);
2478                return NULL;
2479               
2480                // This will skipp the wrong entry
2481                // continue;
2482            }
2483           
2484            /*
2485                 * Make first entry head of C linked list
2486                */ 
2487            if ( i == 0) {
2488                arg5 = ptr;
2489                ptr->next = prev;
2490            }
2491            else {
2492                prev->next = ptr;
2493                ptr->next = NULL;
2494            }
2495            prev = ptr;
2496           
2497        } // end for
2498        if (SARA_DEBUG) printf("\t</Contents>\n");
2499    }
2500    if (!SWIG_AsCharPtr(obj5, (char**)&arg6)) SWIG_fail;
2501    result = (int)pbs_manager(arg1,arg2,arg3,arg4,arg5,arg6);
2502   
2503    resultobj = SWIG_From_int((int)result);
2504    return resultobj;
2505    fail:
2506    return NULL;
2507}
2508
2509
2510static PyObject *_wrap_pbs_movejob(PyObject *self, PyObject *args) {
2511    PyObject *resultobj;
2512    int arg1 ;
2513    char *arg2 ;
2514    char *arg3 ;
2515    char *arg4 ;
2516    int result;
2517    PyObject * obj0 = 0 ;
2518    PyObject * obj1 = 0 ;
2519    PyObject * obj2 = 0 ;
2520    PyObject * obj3 = 0 ;
2521   
2522    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_movejob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2523    arg1 = (int)SWIG_As_int(obj0); 
2524    if (PyErr_Occurred()) SWIG_fail;
2525    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2526    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2527    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2528    result = (int)pbs_movejob(arg1,arg2,arg3,arg4);
2529   
2530    resultobj = SWIG_From_int((int)result);
2531    return resultobj;
2532    fail:
2533    return NULL;
2534}
2535
2536
2537static PyObject *_wrap_pbs_msgjob(PyObject *self, PyObject *args) {
2538    PyObject *resultobj;
2539    int arg1 ;
2540    char *arg2 ;
2541    int arg3 ;
2542    char *arg4 ;
2543    char *arg5 ;
2544    int result;
2545    PyObject * obj0 = 0 ;
2546    PyObject * obj1 = 0 ;
2547    PyObject * obj2 = 0 ;
2548    PyObject * obj3 = 0 ;
2549    PyObject * obj4 = 0 ;
2550   
2551    if(!PyArg_ParseTuple(args,(char *)"OOOOO:pbs_msgjob",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2552    arg1 = (int)SWIG_As_int(obj0); 
2553    if (PyErr_Occurred()) SWIG_fail;
2554    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2555    arg3 = (int)SWIG_As_int(obj2); 
2556    if (PyErr_Occurred()) SWIG_fail;
2557    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2558    if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) SWIG_fail;
2559    result = (int)pbs_msgjob(arg1,arg2,arg3,arg4,arg5);
2560   
2561    resultobj = SWIG_From_int((int)result);
2562    return resultobj;
2563    fail:
2564    return NULL;
2565}
2566
2567
2568static PyObject *_wrap_pbs_orderjob(PyObject *self, PyObject *args) {
2569    PyObject *resultobj;
2570    int arg1 ;
2571    char *arg2 ;
2572    char *arg3 ;
2573    char *arg4 ;
2574    int result;
2575    PyObject * obj0 = 0 ;
2576    PyObject * obj1 = 0 ;
2577    PyObject * obj2 = 0 ;
2578    PyObject * obj3 = 0 ;
2579   
2580    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_orderjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2581    arg1 = (int)SWIG_As_int(obj0); 
2582    if (PyErr_Occurred()) SWIG_fail;
2583    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2584    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2585    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2586    result = (int)pbs_orderjob(arg1,arg2,arg3,arg4);
2587   
2588    resultobj = SWIG_From_int((int)result);
2589    return resultobj;
2590    fail:
2591    return NULL;
2592}
2593
2594
2595static PyObject *_wrap_pbs_rescquery(PyObject *self, PyObject *args) {
2596    PyObject *resultobj;
2597    int arg1 ;
2598    char **arg2 = (char **) 0 ;
2599    int arg3 ;
2600    int *arg4 = (int *) 0 ;
2601    int *arg5 = (int *) 0 ;
2602    int *arg6 = (int *) 0 ;
2603    int *arg7 = (int *) 0 ;
2604    int result;
2605    PyObject * obj0 = 0 ;
2606    PyObject * obj1 = 0 ;
2607    PyObject * obj2 = 0 ;
2608    PyObject * obj3 = 0 ;
2609    PyObject * obj4 = 0 ;
2610    PyObject * obj5 = 0 ;
2611    PyObject * obj6 = 0 ;
2612   
2613    if(!PyArg_ParseTuple(args,(char *)"OOOOOOO:pbs_rescquery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2614    arg1 = (int)SWIG_As_int(obj0); 
2615    if (PyErr_Occurred()) SWIG_fail;
2616    {
2617        int             i=0, size=0;
2618        PyObject        *py_obj;
2619       
2620        if (SARA_DEBUG) printf("Convert python -> c (char **):\n");
2621       
2622        size = Get_List_Size(obj1);
2623       
2624        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
2625       
2626        if ( size == -1 ) {
2627            PyErr_SetString(PyExc_TypeError, "not a list");
2628            return NULL; 
2629        }
2630        // printf("Size = %d\n", size);
2631       
2632        if (SARA_DEBUG) printf("\t<Contents>\n");
2633       
2634        arg2 = (char **) malloc( (size+1) * sizeof(char *));
2635        for (i=0; i < size; i++) {
2636            py_obj = PyList_GetItem(obj1, i);
2637            if (PyString_Check(py_obj)) {
2638                arg2[i] = PyString_AsString(py_obj);
2639                if (SARA_DEBUG) printf("%s", arg2[i]);
2640            }
2641            else {
2642                PyErr_SetString(PyExc_TypeError, "not a list of strings");
2643                free(arg2);
2644                return NULL; 
2645            }
2646        } // end for
2647        arg2[i] = 0;
2648        if (SARA_DEBUG) printf("\t</Contents>\n");
2649    }
2650    arg3 = (int)SWIG_As_int(obj2); 
2651    if (PyErr_Occurred()) SWIG_fail;
2652    if ((SWIG_ConvertPtr(obj3,(void **)(&arg4),SWIGTYPE_p_int,
2653    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
2654    if ((SWIG_ConvertPtr(obj4,(void **)(&arg5),SWIGTYPE_p_int,
2655    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
2656    if ((SWIG_ConvertPtr(obj5,(void **)(&arg6),SWIGTYPE_p_int,
2657    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
2658    if ((SWIG_ConvertPtr(obj6,(void **)(&arg7),SWIGTYPE_p_int,
2659    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
2660    result = (int)pbs_rescquery(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
2661   
2662    resultobj = SWIG_From_int((int)result);
2663    {
2664        free( (char *) arg2);
2665    }
2666    return resultobj;
2667    fail:
2668    {
2669        free( (char *) arg2);
2670    }
2671    return NULL;
2672}
2673
2674
2675static PyObject *_wrap_pbs_rescreserve(PyObject *self, PyObject *args) {
2676    PyObject *resultobj;
2677    int arg1 ;
2678    char **arg2 = (char **) 0 ;
2679    int arg3 ;
2680    resource_t *arg4 = (resource_t *) 0 ;
2681    int result;
2682    PyObject * obj0 = 0 ;
2683    PyObject * obj1 = 0 ;
2684    PyObject * obj2 = 0 ;
2685    PyObject * obj3 = 0 ;
2686   
2687    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_rescreserve",&obj0,&obj1,&obj2,&obj3)) goto fail;
2688    arg1 = (int)SWIG_As_int(obj0); 
2689    if (PyErr_Occurred()) SWIG_fail;
2690    {
2691        int             i=0, size=0;
2692        PyObject        *py_obj;
2693       
2694        if (SARA_DEBUG) printf("Convert python -> c (char **):\n");
2695       
2696        size = Get_List_Size(obj1);
2697       
2698        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
2699       
2700        if ( size == -1 ) {
2701            PyErr_SetString(PyExc_TypeError, "not a list");
2702            return NULL; 
2703        }
2704        // printf("Size = %d\n", size);
2705       
2706        if (SARA_DEBUG) printf("\t<Contents>\n");
2707       
2708        arg2 = (char **) malloc( (size+1) * sizeof(char *));
2709        for (i=0; i < size; i++) {
2710            py_obj = PyList_GetItem(obj1, i);
2711            if (PyString_Check(py_obj)) {
2712                arg2[i] = PyString_AsString(py_obj);
2713                if (SARA_DEBUG) printf("%s", arg2[i]);
2714            }
2715            else {
2716                PyErr_SetString(PyExc_TypeError, "not a list of strings");
2717                free(arg2);
2718                return NULL; 
2719            }
2720        } // end for
2721        arg2[i] = 0;
2722        if (SARA_DEBUG) printf("\t</Contents>\n");
2723    }
2724    arg3 = (int)SWIG_As_int(obj2); 
2725    if (PyErr_Occurred()) SWIG_fail;
2726    if ((SWIG_ConvertPtr(obj3,(void **)(&arg4),SWIGTYPE_p_resource_t,
2727    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
2728    result = (int)pbs_rescreserve(arg1,arg2,arg3,arg4);
2729   
2730    resultobj = SWIG_From_int((int)result);
2731    {
2732        free( (char *) arg2);
2733    }
2734    return resultobj;
2735    fail:
2736    {
2737        free( (char *) arg2);
2738    }
2739    return NULL;
2740}
2741
2742
2743static PyObject *_wrap_pbs_rescrelease(PyObject *self, PyObject *args) {
2744    PyObject *resultobj;
2745    int arg1 ;
2746    resource_t arg2 ;
2747    int result;
2748    PyObject * obj0 = 0 ;
2749    PyObject * obj1 = 0 ;
2750   
2751    if(!PyArg_ParseTuple(args,(char *)"OO:pbs_rescrelease",&obj0,&obj1)) goto fail;
2752    arg1 = (int)SWIG_As_int(obj0); 
2753    if (PyErr_Occurred()) SWIG_fail;
2754    arg2 = (resource_t)SWIG_As_int(obj1); 
2755    if (PyErr_Occurred()) SWIG_fail;
2756    result = (int)pbs_rescrelease(arg1,arg2);
2757   
2758    resultobj = SWIG_From_int((int)result);
2759    return resultobj;
2760    fail:
2761    return NULL;
2762}
2763
2764
2765static PyObject *_wrap_pbs_rerunjob(PyObject *self, PyObject *args) {
2766    PyObject *resultobj;
2767    int arg1 ;
2768    char *arg2 ;
2769    char *arg3 ;
2770    int result;
2771    PyObject * obj0 = 0 ;
2772    PyObject * obj1 = 0 ;
2773    PyObject * obj2 = 0 ;
2774   
2775    if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_rerunjob",&obj0,&obj1,&obj2)) goto fail;
2776    arg1 = (int)SWIG_As_int(obj0); 
2777    if (PyErr_Occurred()) SWIG_fail;
2778    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2779    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2780    result = (int)pbs_rerunjob(arg1,arg2,arg3);
2781   
2782    resultobj = SWIG_From_int((int)result);
2783    return resultobj;
2784    fail:
2785    return NULL;
2786}
2787
2788
2789static PyObject *_wrap_pbs_rlsjob(PyObject *self, PyObject *args) {
2790    PyObject *resultobj;
2791    int arg1 ;
2792    char *arg2 ;
2793    char *arg3 ;
2794    char *arg4 ;
2795    int result;
2796    PyObject * obj0 = 0 ;
2797    PyObject * obj1 = 0 ;
2798    PyObject * obj2 = 0 ;
2799    PyObject * obj3 = 0 ;
2800   
2801    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_rlsjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2802    arg1 = (int)SWIG_As_int(obj0); 
2803    if (PyErr_Occurred()) SWIG_fail;
2804    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2805    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2806    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2807    result = (int)pbs_rlsjob(arg1,arg2,arg3,arg4);
2808   
2809    resultobj = SWIG_From_int((int)result);
2810    return resultobj;
2811    fail:
2812    return NULL;
2813}
2814
2815
2816static PyObject *_wrap_pbs_runjob(PyObject *self, PyObject *args) {
2817    PyObject *resultobj;
2818    int arg1 ;
2819    char *arg2 ;
2820    char *arg3 ;
2821    char *arg4 ;
2822    int result;
2823    PyObject * obj0 = 0 ;
2824    PyObject * obj1 = 0 ;
2825    PyObject * obj2 = 0 ;
2826    PyObject * obj3 = 0 ;
2827   
2828    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_runjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2829    arg1 = (int)SWIG_As_int(obj0); 
2830    if (PyErr_Occurred()) SWIG_fail;
2831    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2832    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2833    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2834    result = (int)pbs_runjob(arg1,arg2,arg3,arg4);
2835   
2836    resultobj = SWIG_From_int((int)result);
2837    return resultobj;
2838    fail:
2839    return NULL;
2840}
2841
2842
2843static PyObject *_wrap_pbs_selectjob(PyObject *self, PyObject *args) {
2844    PyObject *resultobj;
2845    int arg1 ;
2846    struct attropl *arg2 = (struct attropl *) 0 ;
2847    char *arg3 ;
2848    char **result;
2849    PyObject * obj0 = 0 ;
2850    PyObject * obj1 = 0 ;
2851    PyObject * obj2 = 0 ;
2852   
2853    if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_selectjob",&obj0,&obj1,&obj2)) goto fail;
2854    arg1 = (int)SWIG_As_int(obj0); 
2855    if (PyErr_Occurred()) SWIG_fail;
2856    {
2857        PyObject                *py_obj;
2858        struct attropl  *ptr, *prev;
2859        char                    s[255];
2860        int                     i=0, size=0;
2861       
2862        // printf("Python --> C\n");
2863       
2864        if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
2865       
2866        size = Get_List_Size(obj1);
2867       
2868        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
2869       
2870        if ( size == -1 ) {
2871            PyErr_SetString(PyExc_TypeError, "not a list");
2872            return NULL; 
2873        }
2874        //printf("Size = %d\n", size);
2875       
2876        if (SARA_DEBUG) printf("\t<Contents>\n");
2877       
2878        arg2 = prev = NULL;
2879        for ( i=0; i < size; i++ ) {
2880            py_obj = PyList_GetItem(obj1, i);
2881            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
2882                sprintf(s,"list item %d has wrong type", i);
2883                PyErr_SetString(PyExc_TypeError, s);
2884                return NULL;
2885               
2886                // This will skipp the wrong entry
2887                // continue;
2888            }
2889           
2890            /*
2891                 * Make first entry head of C linked list
2892                */ 
2893            if ( i == 0) {
2894                arg2 = ptr;
2895                ptr->next = prev;
2896            }
2897            else {
2898                prev->next = ptr;
2899                ptr->next = NULL;
2900            }
2901            prev = ptr;
2902           
2903        } // end for
2904        if (SARA_DEBUG) printf("\t</Contents>\n");
2905    }
2906    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2907    result = (char **)pbs_selectjob(arg1,arg2,arg3);
2908   
2909    {
2910        int len=0, i;
2911       
2912        if (result == NULL) 
2913        resultobj = PyList_New(0);
2914        else {
2915            while (result[len]) 
2916            len++;
2917           
2918            resultobj = PyList_New(len);
2919            for (i=0; i < len; i++ )
2920            PyList_SetItem(resultobj, i , PyString_FromString(result[i])); 
2921        }
2922    }
2923    return resultobj;
2924    fail:
2925    return NULL;
2926}
2927
2928
2929static PyObject *_wrap_pbs_sigjob(PyObject *self, PyObject *args) {
2930    PyObject *resultobj;
2931    int arg1 ;
2932    char *arg2 ;
2933    char *arg3 ;
2934    char *arg4 ;
2935    int result;
2936    PyObject * obj0 = 0 ;
2937    PyObject * obj1 = 0 ;
2938    PyObject * obj2 = 0 ;
2939    PyObject * obj3 = 0 ;
2940   
2941    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_sigjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2942    arg1 = (int)SWIG_As_int(obj0); 
2943    if (PyErr_Occurred()) SWIG_fail;
2944    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
2945    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
2946    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
2947    result = (int)pbs_sigjob(arg1,arg2,arg3,arg4);
2948   
2949    resultobj = SWIG_From_int((int)result);
2950    return resultobj;
2951    fail:
2952    return NULL;
2953}
2954
2955
2956static PyObject *_wrap_pbs_statfree(PyObject *self, PyObject *args) {
2957    PyObject *resultobj;
2958    struct batch_status *arg1 = (struct batch_status *) 0 ;
2959    PyObject * obj0 = 0 ;
2960   
2961    if(!PyArg_ParseTuple(args,(char *)"O:pbs_statfree",&obj0)) goto fail;
2962    {
2963        PyObject                *py_obj;
2964        struct batch_status     *ptr, *prev;
2965        char                    s[255];
2966        int                     i=0, size=0;
2967       
2968        // printf("Python --> C\n");
2969       
2970        if (SARA_DEBUG) printf("Converteren python -> c (struct batch_status *):\n");
2971       
2972        size = Get_List_Size(obj0);
2973        if (SARA_DEBUG) printf("\tSize of list: %d\n", size);
2974       
2975        if ( size == -1 ) {
2976            PyErr_SetString(PyExc_TypeError, "not a list");
2977            return NULL; 
2978        }
2979        // printf("Size = %d\n", size);
2980       
2981        if (SARA_DEBUG) printf("\t<Contents>\n");
2982       
2983        arg1 = prev = NULL;
2984        for ( i=0; i < size; i++ ) {
2985            py_obj = PyList_GetItem(obj0, i);
2986            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_batch_status, 1)) {
2987                sprintf(s,"list item %d has wrong type", i);
2988                PyErr_SetString(PyExc_TypeError, s);
2989                return NULL;
2990               
2991                // This will skipp the wrong entry
2992                // continue;
2993            }
2994           
2995            /*
2996                 * Make first entry head of C linked list
2997                */ 
2998            if ( i == 0) {
2999                arg1 = ptr;
3000                ptr->next = prev;
3001            }
3002            else {
3003                prev->next = ptr;
3004                ptr->next = NULL;
3005            }
3006           
3007            if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3008            prev = ptr;
3009           
3010        } // end for
3011       
3012        if (SARA_DEBUG) printf("\t</Contents>\n");
3013    }
3014    pbs_statfree(arg1);
3015   
3016    Py_INCREF(Py_None); resultobj = Py_None;
3017    return resultobj;
3018    fail:
3019    return NULL;
3020}
3021
3022
3023static PyObject *_wrap_pbs_statjob(PyObject *self, PyObject *args) {
3024    PyObject *resultobj;
3025    int arg1 ;
3026    char *arg2 ;
3027    struct attrl *arg3 = (struct attrl *) 0 ;
3028    char *arg4 ;
3029    struct batch_status *result;
3030    PyObject * obj0 = 0 ;
3031    PyObject * obj1 = 0 ;
3032    PyObject * obj2 = 0 ;
3033    PyObject * obj3 = 0 ;
3034   
3035    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_statjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
3036    arg1 = (int)SWIG_As_int(obj0); 
3037    if (PyErr_Occurred()) SWIG_fail;
3038    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
3039    {
3040        PyObject        *py_obj;
3041        struct attrl    *ptr, *prev;
3042        char            s[255];
3043        int             i=0, size=0;
3044       
3045        // printf("Python --> C\n");
3046       
3047        if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
3048       
3049        size = Get_List_Size(obj2);
3050        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3051       
3052        if ( size == -1 ) {
3053            PyErr_SetString(PyExc_TypeError, "not a list");
3054            return NULL; 
3055        }
3056       
3057        if (SARA_DEBUG) printf("\t<Contents>\n");
3058       
3059        arg3 = prev = NULL;
3060        for ( i=0; i < size; i++ ) {
3061            py_obj = PyList_GetItem(obj2, i);
3062            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
3063                sprintf(s,"list item %d has wrong type", i);
3064                PyErr_SetString(PyExc_TypeError, s);
3065                return NULL;
3066               
3067                // This will skipp the wrong entry
3068                // continue;
3069            }
3070           
3071            /*
3072                 * Make first entry head of C linked list
3073                */ 
3074            if ( i == 0) {
3075                arg3 = ptr;
3076                ptr->next = prev;
3077            }
3078            else {
3079                prev->next = ptr;
3080                ptr->next = NULL;
3081            }
3082            if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3083           
3084            prev = ptr;
3085           
3086        } // end for
3087        if (SARA_DEBUG) printf("\t</Contents>\n");
3088    }
3089    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
3090    result = (struct batch_status *)pbs_statjob(arg1,arg2,arg3,arg4);
3091   
3092    {
3093        PyObject *obj_batch;
3094        struct batch_status *ptr;
3095        int i=0, len=0;
3096       
3097        // printf("Ja we are in bussniss\n");
3098        if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
3099       
3100        // Deterime length of list
3101        //
3102        ptr = result;
3103        while (ptr != NULL) {
3104            len++;
3105            ptr = ptr->next;
3106        }
3107        resultobj = PyList_New(len);
3108       
3109        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3110       
3111        // Make a list of batch_status pointers
3112        //
3113        if (SARA_DEBUG) printf("\t<Contents>\n");
3114        ptr = result;
3115        for (i=0; i < len; i++) {
3116            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0); 
3117            PyList_SetItem(resultobj, i, obj_batch);   
3118            if (SARA_DEBUG)  {
3119                printf("\t\t- %s\n", ptr->name);
3120            }
3121            ptr = ptr->next;
3122        }
3123        if (SARA_DEBUG) printf("\t</Contents>\n");
3124    }
3125    return resultobj;
3126    fail:
3127    return NULL;
3128}
3129
3130
3131static PyObject *_wrap_pbs_selstat(PyObject *self, PyObject *args) {
3132    PyObject *resultobj;
3133    int arg1 ;
3134    struct attropl *arg2 = (struct attropl *) 0 ;
3135    char *arg3 ;
3136    struct batch_status *result;
3137    PyObject * obj0 = 0 ;
3138    PyObject * obj1 = 0 ;
3139    PyObject * obj2 = 0 ;
3140   
3141    if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_selstat",&obj0,&obj1,&obj2)) goto fail;
3142    arg1 = (int)SWIG_As_int(obj0); 
3143    if (PyErr_Occurred()) SWIG_fail;
3144    {
3145        PyObject                *py_obj;
3146        struct attropl  *ptr, *prev;
3147        char                    s[255];
3148        int                     i=0, size=0;
3149       
3150        // printf("Python --> C\n");
3151       
3152        if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
3153       
3154        size = Get_List_Size(obj1);
3155       
3156        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3157       
3158        if ( size == -1 ) {
3159            PyErr_SetString(PyExc_TypeError, "not a list");
3160            return NULL; 
3161        }
3162        //printf("Size = %d\n", size);
3163       
3164        if (SARA_DEBUG) printf("\t<Contents>\n");
3165       
3166        arg2 = prev = NULL;
3167        for ( i=0; i < size; i++ ) {
3168            py_obj = PyList_GetItem(obj1, i);
3169            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
3170                sprintf(s,"list item %d has wrong type", i);
3171                PyErr_SetString(PyExc_TypeError, s);
3172                return NULL;
3173               
3174                // This will skipp the wrong entry
3175                // continue;
3176            }
3177           
3178            /*
3179                 * Make first entry head of C linked list
3180                */ 
3181            if ( i == 0) {
3182                arg2 = ptr;
3183                ptr->next = prev;
3184            }
3185            else {
3186                prev->next = ptr;
3187                ptr->next = NULL;
3188            }
3189            prev = ptr;
3190           
3191        } // end for
3192        if (SARA_DEBUG) printf("\t</Contents>\n");
3193    }
3194    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
3195    result = (struct batch_status *)pbs_selstat(arg1,arg2,arg3);
3196   
3197    {
3198        PyObject *obj_batch;
3199        struct batch_status *ptr;
3200        int i=0, len=0;
3201       
3202        // printf("Ja we are in bussniss\n");
3203        if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
3204       
3205        // Deterime length of list
3206        //
3207        ptr = result;
3208        while (ptr != NULL) {
3209            len++;
3210            ptr = ptr->next;
3211        }
3212        resultobj = PyList_New(len);
3213       
3214        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3215       
3216        // Make a list of batch_status pointers
3217        //
3218        if (SARA_DEBUG) printf("\t<Contents>\n");
3219        ptr = result;
3220        for (i=0; i < len; i++) {
3221            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0); 
3222            PyList_SetItem(resultobj, i, obj_batch);   
3223            if (SARA_DEBUG)  {
3224                printf("\t\t- %s\n", ptr->name);
3225            }
3226            ptr = ptr->next;
3227        }
3228        if (SARA_DEBUG) printf("\t</Contents>\n");
3229    }
3230    return resultobj;
3231    fail:
3232    return NULL;
3233}
3234
3235
3236static PyObject *_wrap_pbs_statque(PyObject *self, PyObject *args) {
3237    PyObject *resultobj;
3238    int arg1 ;
3239    char *arg2 ;
3240    struct attrl *arg3 = (struct attrl *) 0 ;
3241    char *arg4 ;
3242    struct batch_status *result;
3243    PyObject * obj0 = 0 ;
3244    PyObject * obj1 = 0 ;
3245    PyObject * obj2 = 0 ;
3246    PyObject * obj3 = 0 ;
3247   
3248    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_statque",&obj0,&obj1,&obj2,&obj3)) goto fail;
3249    arg1 = (int)SWIG_As_int(obj0); 
3250    if (PyErr_Occurred()) SWIG_fail;
3251    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
3252    {
3253        PyObject        *py_obj;
3254        struct attrl    *ptr, *prev;
3255        char            s[255];
3256        int             i=0, size=0;
3257       
3258        // printf("Python --> C\n");
3259       
3260        if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
3261       
3262        size = Get_List_Size(obj2);
3263        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3264       
3265        if ( size == -1 ) {
3266            PyErr_SetString(PyExc_TypeError, "not a list");
3267            return NULL; 
3268        }
3269       
3270        if (SARA_DEBUG) printf("\t<Contents>\n");
3271       
3272        arg3 = prev = NULL;
3273        for ( i=0; i < size; i++ ) {
3274            py_obj = PyList_GetItem(obj2, i);
3275            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
3276                sprintf(s,"list item %d has wrong type", i);
3277                PyErr_SetString(PyExc_TypeError, s);
3278                return NULL;
3279               
3280                // This will skipp the wrong entry
3281                // continue;
3282            }
3283           
3284            /*
3285                 * Make first entry head of C linked list
3286                */ 
3287            if ( i == 0) {
3288                arg3 = ptr;
3289                ptr->next = prev;
3290            }
3291            else {
3292                prev->next = ptr;
3293                ptr->next = NULL;
3294            }
3295            if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3296           
3297            prev = ptr;
3298           
3299        } // end for
3300        if (SARA_DEBUG) printf("\t</Contents>\n");
3301    }
3302    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
3303    result = (struct batch_status *)pbs_statque(arg1,arg2,arg3,arg4);
3304   
3305    {
3306        PyObject *obj_batch;
3307        struct batch_status *ptr;
3308        int i=0, len=0;
3309       
3310        // printf("Ja we are in bussniss\n");
3311        if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
3312       
3313        // Deterime length of list
3314        //
3315        ptr = result;
3316        while (ptr != NULL) {
3317            len++;
3318            ptr = ptr->next;
3319        }
3320        resultobj = PyList_New(len);
3321       
3322        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3323       
3324        // Make a list of batch_status pointers
3325        //
3326        if (SARA_DEBUG) printf("\t<Contents>\n");
3327        ptr = result;
3328        for (i=0; i < len; i++) {
3329            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0); 
3330            PyList_SetItem(resultobj, i, obj_batch);   
3331            if (SARA_DEBUG)  {
3332                printf("\t\t- %s\n", ptr->name);
3333            }
3334            ptr = ptr->next;
3335        }
3336        if (SARA_DEBUG) printf("\t</Contents>\n");
3337    }
3338    return resultobj;
3339    fail:
3340    return NULL;
3341}
3342
3343
3344static PyObject *_wrap_pbs_statserver(PyObject *self, PyObject *args) {
3345    PyObject *resultobj;
3346    int arg1 ;
3347    struct attrl *arg2 = (struct attrl *) 0 ;
3348    char *arg3 ;
3349    struct batch_status *result;
3350    PyObject * obj0 = 0 ;
3351    PyObject * obj1 = 0 ;
3352    PyObject * obj2 = 0 ;
3353   
3354    if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_statserver",&obj0,&obj1,&obj2)) goto fail;
3355    arg1 = (int)SWIG_As_int(obj0); 
3356    if (PyErr_Occurred()) SWIG_fail;
3357    {
3358        PyObject        *py_obj;
3359        struct attrl    *ptr, *prev;
3360        char            s[255];
3361        int             i=0, size=0;
3362       
3363        // printf("Python --> C\n");
3364       
3365        if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
3366       
3367        size = Get_List_Size(obj1);
3368        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3369       
3370        if ( size == -1 ) {
3371            PyErr_SetString(PyExc_TypeError, "not a list");
3372            return NULL; 
3373        }
3374       
3375        if (SARA_DEBUG) printf("\t<Contents>\n");
3376       
3377        arg2 = prev = NULL;
3378        for ( i=0; i < size; i++ ) {
3379            py_obj = PyList_GetItem(obj1, i);
3380            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
3381                sprintf(s,"list item %d has wrong type", i);
3382                PyErr_SetString(PyExc_TypeError, s);
3383                return NULL;
3384               
3385                // This will skipp the wrong entry
3386                // continue;
3387            }
3388           
3389            /*
3390                 * Make first entry head of C linked list
3391                */ 
3392            if ( i == 0) {
3393                arg2 = ptr;
3394                ptr->next = prev;
3395            }
3396            else {
3397                prev->next = ptr;
3398                ptr->next = NULL;
3399            }
3400            if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3401           
3402            prev = ptr;
3403           
3404        } // end for
3405        if (SARA_DEBUG) printf("\t</Contents>\n");
3406    }
3407    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
3408    result = (struct batch_status *)pbs_statserver(arg1,arg2,arg3);
3409   
3410    {
3411        PyObject *obj_batch;
3412        struct batch_status *ptr;
3413        int i=0, len=0;
3414       
3415        // printf("Ja we are in bussniss\n");
3416        if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
3417       
3418        // Deterime length of list
3419        //
3420        ptr = result;
3421        while (ptr != NULL) {
3422            len++;
3423            ptr = ptr->next;
3424        }
3425        resultobj = PyList_New(len);
3426       
3427        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3428       
3429        // Make a list of batch_status pointers
3430        //
3431        if (SARA_DEBUG) printf("\t<Contents>\n");
3432        ptr = result;
3433        for (i=0; i < len; i++) {
3434            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0); 
3435            PyList_SetItem(resultobj, i, obj_batch);   
3436            if (SARA_DEBUG)  {
3437                printf("\t\t- %s\n", ptr->name);
3438            }
3439            ptr = ptr->next;
3440        }
3441        if (SARA_DEBUG) printf("\t</Contents>\n");
3442    }
3443    return resultobj;
3444    fail:
3445    return NULL;
3446}
3447
3448
3449static PyObject *_wrap_pbs_statnode(PyObject *self, PyObject *args) {
3450    PyObject *resultobj;
3451    int arg1 ;
3452    char *arg2 ;
3453    struct attrl *arg3 = (struct attrl *) 0 ;
3454    char *arg4 ;
3455    struct batch_status *result;
3456    PyObject * obj0 = 0 ;
3457    PyObject * obj1 = 0 ;
3458    PyObject * obj2 = 0 ;
3459    PyObject * obj3 = 0 ;
3460   
3461    if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_statnode",&obj0,&obj1,&obj2,&obj3)) goto fail;
3462    arg1 = (int)SWIG_As_int(obj0); 
3463    if (PyErr_Occurred()) SWIG_fail;
3464    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
3465    {
3466        PyObject        *py_obj;
3467        struct attrl    *ptr, *prev;
3468        char            s[255];
3469        int             i=0, size=0;
3470       
3471        // printf("Python --> C\n");
3472       
3473        if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
3474       
3475        size = Get_List_Size(obj2);
3476        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3477       
3478        if ( size == -1 ) {
3479            PyErr_SetString(PyExc_TypeError, "not a list");
3480            return NULL; 
3481        }
3482       
3483        if (SARA_DEBUG) printf("\t<Contents>\n");
3484       
3485        arg3 = prev = NULL;
3486        for ( i=0; i < size; i++ ) {
3487            py_obj = PyList_GetItem(obj2, i);
3488            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
3489                sprintf(s,"list item %d has wrong type", i);
3490                PyErr_SetString(PyExc_TypeError, s);
3491                return NULL;
3492               
3493                // This will skipp the wrong entry
3494                // continue;
3495            }
3496           
3497            /*
3498                 * Make first entry head of C linked list
3499                */ 
3500            if ( i == 0) {
3501                arg3 = ptr;
3502                ptr->next = prev;
3503            }
3504            else {
3505                prev->next = ptr;
3506                ptr->next = NULL;
3507            }
3508            if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3509           
3510            prev = ptr;
3511           
3512        } // end for
3513        if (SARA_DEBUG) printf("\t</Contents>\n");
3514    }
3515    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
3516    result = (struct batch_status *)pbs_statnode(arg1,arg2,arg3,arg4);
3517   
3518    {
3519        PyObject *obj_batch;
3520        struct batch_status *ptr;
3521        int i=0, len=0;
3522       
3523        // printf("Ja we are in bussniss\n");
3524        if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
3525       
3526        // Deterime length of list
3527        //
3528        ptr = result;
3529        while (ptr != NULL) {
3530            len++;
3531            ptr = ptr->next;
3532        }
3533        resultobj = PyList_New(len);
3534       
3535        if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3536       
3537        // Make a list of batch_status pointers
3538        //
3539        if (SARA_DEBUG) printf("\t<Contents>\n");
3540        ptr = result;
3541        for (i=0; i < len; i++) {
3542            obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0); 
3543            PyList_SetItem(resultobj, i, obj_batch);   
3544            if (SARA_DEBUG)  {
3545                printf("\t\t- %s\n", ptr->name);
3546            }
3547            ptr = ptr->next;
3548        }
3549        if (SARA_DEBUG) printf("\t</Contents>\n");
3550    }
3551    return resultobj;
3552    fail:
3553    return NULL;
3554}
3555
3556
3557static PyObject *_wrap_pbs_submit(PyObject *self, PyObject *args) {
3558    PyObject *resultobj;
3559    int arg1 ;
3560    struct attropl *arg2 = (struct attropl *) 0 ;
3561    char *arg3 ;
3562    char *arg4 ;
3563    char *arg5 ;
3564    char *result;
3565    PyObject * obj0 = 0 ;
3566    PyObject * obj1 = 0 ;
3567    PyObject * obj2 = 0 ;
3568    PyObject * obj3 = 0 ;
3569    PyObject * obj4 = 0 ;
3570   
3571    if(!PyArg_ParseTuple(args,(char *)"OOOOO:pbs_submit",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3572    arg1 = (int)SWIG_As_int(obj0); 
3573    if (PyErr_Occurred()) SWIG_fail;
3574    {
3575        PyObject                *py_obj;
3576        struct attropl  *ptr, *prev;
3577        char                    s[255];
3578        int                     i=0, size=0;
3579       
3580        // printf("Python --> C\n");
3581       
3582        if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
3583       
3584        size = Get_List_Size(obj1);
3585       
3586        if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3587       
3588        if ( size == -1 ) {
3589            PyErr_SetString(PyExc_TypeError, "not a list");
3590            return NULL; 
3591        }
3592        //printf("Size = %d\n", size);
3593       
3594        if (SARA_DEBUG) printf("\t<Contents>\n");
3595       
3596        arg2 = prev = NULL;
3597        for ( i=0; i < size; i++ ) {
3598            py_obj = PyList_GetItem(obj1, i);
3599            if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
3600                sprintf(s,"list item %d has wrong type", i);
3601                PyErr_SetString(PyExc_TypeError, s);
3602                return NULL;
3603               
3604                // This will skipp the wrong entry
3605                // continue;
3606            }
3607           
3608            /*
3609                 * Make first entry head of C linked list
3610                */ 
3611            if ( i == 0) {
3612                arg2 = ptr;
3613                ptr->next = prev;
3614            }
3615            else {
3616                prev->next = ptr;
3617                ptr->next = NULL;
3618            }
3619            prev = ptr;
3620           
3621        } // end for
3622        if (SARA_DEBUG) printf("\t</Contents>\n");
3623    }
3624    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
3625    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
3626    if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) SWIG_fail;
3627    result = (char *)pbs_submit(arg1,arg2,arg3,arg4,arg5);
3628   
3629    resultobj = SWIG_FromCharPtr(result);
3630    return resultobj;
3631    fail:
3632    return NULL;
3633}
3634
3635
3636static PyObject *_wrap_pbs_terminate(PyObject *self, PyObject *args) {
3637    PyObject *resultobj;
3638    int arg1 ;
3639    int arg2 ;
3640    char *arg3 ;
3641    int result;
3642    PyObject * obj0 = 0 ;
3643    PyObject * obj1 = 0 ;
3644    PyObject * obj2 = 0 ;
3645   
3646    if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_terminate",&obj0,&obj1,&obj2)) goto fail;
3647    arg1 = (int)SWIG_As_int(obj0); 
3648    if (PyErr_Occurred()) SWIG_fail;
3649    arg2 = (int)SWIG_As_int(obj1); 
3650    if (PyErr_Occurred()) SWIG_fail;
3651    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
3652    result = (int)pbs_terminate(arg1,arg2,arg3);
3653   
3654    resultobj = SWIG_From_int((int)result);
3655    return resultobj;
3656    fail:
3657    return NULL;
3658}
3659
3660
3661static PyObject *_wrap_totpool(PyObject *self, PyObject *args) {
3662    PyObject *resultobj;
3663    int arg1 ;
3664    int arg2 ;
3665    int result;
3666    PyObject * obj0 = 0 ;
3667    PyObject * obj1 = 0 ;
3668   
3669    if(!PyArg_ParseTuple(args,(char *)"OO:totpool",&obj0,&obj1)) goto fail;
3670    arg1 = (int)SWIG_As_int(obj0); 
3671    if (PyErr_Occurred()) SWIG_fail;
3672    arg2 = (int)SWIG_As_int(obj1); 
3673    if (PyErr_Occurred()) SWIG_fail;
3674    result = (int)totpool(arg1,arg2);
3675   
3676    resultobj = SWIG_From_int((int)result);
3677    return resultobj;
3678    fail:
3679    return NULL;
3680}
3681
3682
3683static PyObject *_wrap_usepool(PyObject *self, PyObject *args) {
3684    PyObject *resultobj;
3685    int arg1 ;
3686    int arg2 ;
3687    int result;
3688    PyObject * obj0 = 0 ;
3689    PyObject * obj1 = 0 ;
3690   
3691    if(!PyArg_ParseTuple(args,(char *)"OO:usepool",&obj0,&obj1)) goto fail;
3692    arg1 = (int)SWIG_As_int(obj0); 
3693    if (PyErr_Occurred()) SWIG_fail;
3694    arg2 = (int)SWIG_As_int(obj1); 
3695    if (PyErr_Occurred()) SWIG_fail;
3696    result = (int)usepool(arg1,arg2);
3697   
3698    resultobj = SWIG_From_int((int)result);
3699    return resultobj;
3700    fail:
3701    return NULL;
3702}
3703
3704
3705static PyObject *_wrap_openrm(PyObject *self, PyObject *args) {
3706    PyObject *resultobj;
3707    char *arg1 ;
3708    unsigned int arg2 ;
3709    int result;
3710    PyObject * obj0 = 0 ;
3711    PyObject * obj1 = 0 ;
3712   
3713    if(!PyArg_ParseTuple(args,(char *)"OO:openrm",&obj0,&obj1)) goto fail;
3714    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) SWIG_fail;
3715    arg2 = (unsigned int)SWIG_As_unsigned_SS_int(obj1); 
3716    if (PyErr_Occurred()) SWIG_fail;
3717    result = (int)openrm(arg1,arg2);
3718   
3719    resultobj = SWIG_From_int((int)result);
3720    return resultobj;
3721    fail:
3722    return NULL;
3723}
3724
3725
3726static PyObject *_wrap_closerm(PyObject *self, PyObject *args) {
3727    PyObject *resultobj;
3728    int arg1 ;
3729    int result;
3730    PyObject * obj0 = 0 ;
3731   
3732    if(!PyArg_ParseTuple(args,(char *)"O:closerm",&obj0)) goto fail;
3733    arg1 = (int)SWIG_As_int(obj0); 
3734    if (PyErr_Occurred()) SWIG_fail;
3735    result = (int)closerm(arg1);
3736   
3737    resultobj = SWIG_From_int((int)result);
3738    return resultobj;
3739    fail:
3740    return NULL;
3741}
3742
3743
3744static PyObject *_wrap_downrm(PyObject *self, PyObject *args) {
3745    PyObject *resultobj;
3746    int arg1 ;
3747    int result;
3748    PyObject * obj0 = 0 ;
3749   
3750    if(!PyArg_ParseTuple(args,(char *)"O:downrm",&obj0)) goto fail;
3751    arg1 = (int)SWIG_As_int(obj0); 
3752    if (PyErr_Occurred()) SWIG_fail;
3753    result = (int)downrm(arg1);
3754   
3755    resultobj = SWIG_From_int((int)result);
3756    return resultobj;
3757    fail:
3758    return NULL;
3759}
3760
3761
3762static PyObject *_wrap_configrm(PyObject *self, PyObject *args) {
3763    PyObject *resultobj;
3764    int arg1 ;
3765    char *arg2 ;
3766    int result;
3767    PyObject * obj0 = 0 ;
3768    PyObject * obj1 = 0 ;
3769   
3770    if(!PyArg_ParseTuple(args,(char *)"OO:configrm",&obj0,&obj1)) goto fail;
3771    arg1 = (int)SWIG_As_int(obj0); 
3772    if (PyErr_Occurred()) SWIG_fail;
3773    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
3774    result = (int)configrm(arg1,arg2);
3775   
3776    resultobj = SWIG_From_int((int)result);
3777    return resultobj;
3778    fail:
3779    return NULL;
3780}
3781
3782
3783static PyObject *_wrap_addreq(PyObject *self, PyObject *args) {
3784    PyObject *resultobj;
3785    int arg1 ;
3786    char *arg2 ;
3787    int result;
3788    PyObject * obj0 = 0 ;
3789    PyObject * obj1 = 0 ;
3790   
3791    if(!PyArg_ParseTuple(args,(char *)"OO:addreq",&obj0,&obj1)) goto fail;
3792    arg1 = (int)SWIG_As_int(obj0); 
3793    if (PyErr_Occurred()) SWIG_fail;
3794    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
3795    result = (int)addreq(arg1,arg2);
3796   
3797    resultobj = SWIG_From_int((int)result);
3798    return resultobj;
3799    fail:
3800    return NULL;
3801}
3802
3803
3804static PyObject *_wrap_allreq(PyObject *self, PyObject *args) {
3805    PyObject *resultobj;
3806    char *arg1 ;
3807    int result;
3808    PyObject * obj0 = 0 ;
3809   
3810    if(!PyArg_ParseTuple(args,(char *)"O:allreq",&obj0)) goto fail;
3811    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) SWIG_fail;
3812    result = (int)allreq(arg1);
3813   
3814    resultobj = SWIG_From_int((int)result);
3815    return resultobj;
3816    fail:
3817    return NULL;
3818}
3819
3820
3821static PyObject *_wrap_flushreq(PyObject *self, PyObject *args) {
3822    PyObject *resultobj;
3823    int result;
3824   
3825    if(!PyArg_ParseTuple(args,(char *)":flushreq")) goto fail;
3826    result = (int)flushreq();
3827   
3828    resultobj = SWIG_From_int((int)result);
3829    return resultobj;
3830    fail:
3831    return NULL;
3832}
3833
3834
3835static PyObject *_wrap_activereq(PyObject *self, PyObject *args) {
3836    PyObject *resultobj;
3837    int result;
3838   
3839    if(!PyArg_ParseTuple(args,(char *)":activereq")) goto fail;
3840    result = (int)activereq();
3841   
3842    resultobj = SWIG_From_int((int)result);
3843    return resultobj;
3844    fail:
3845    return NULL;
3846}
3847
3848
3849static PyObject *_wrap_fullresp(PyObject *self, PyObject *args) {
3850    PyObject *resultobj;
3851    int arg1 ;
3852    PyObject * obj0 = 0 ;
3853   
3854    if(!PyArg_ParseTuple(args,(char *)"O:fullresp",&obj0)) goto fail;
3855    arg1 = (int)SWIG_As_int(obj0); 
3856    if (PyErr_Occurred()) SWIG_fail;
3857    fullresp(arg1);
3858   
3859    Py_INCREF(Py_None); resultobj = Py_None;
3860    return resultobj;
3861    fail:
3862    return NULL;
3863}
3864
3865
3866static PyObject *_wrap_getreq(PyObject *self, PyObject *args) {
3867    PyObject *resultobj;
3868    int arg1 ;
3869    char *result;
3870    PyObject * obj0 = 0 ;
3871   
3872    if(!PyArg_ParseTuple(args,(char *)"O:getreq",&obj0)) goto fail;
3873    arg1 = (int)SWIG_As_int(obj0); 
3874    if (PyErr_Occurred()) SWIG_fail;
3875    result = (char *)getreq(arg1);
3876   
3877    resultobj = SWIG_FromCharPtr(result);
3878    return resultobj;
3879    fail:
3880    return NULL;
3881}
3882
3883
3884static int _wrap_log_event_mask_set(PyObject *_val) {
3885    {
3886        void *temp;
3887        if ((SWIG_ConvertPtr(_val, &temp, SWIGTYPE_p_long, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN)) == -1) {
3888            PyErr_SetString(PyExc_TypeError, "C/C++ variable 'log_event_mask (long *)'");
3889            return 1;
3890        }
3891        log_event_mask = (long *) temp;
3892    }
3893    return 0;
3894}
3895
3896
3897static PyObject *_wrap_log_event_mask_get() {
3898    PyObject *pyobj;
3899   
3900    pyobj = SWIG_NewPointerObj((void *)(log_event_mask), SWIGTYPE_p_long, 0);
3901    return pyobj;
3902}
3903
3904
3905static PyObject *_wrap_log_close(PyObject *self, PyObject *args) {
3906    PyObject *resultobj;
3907    int arg1 ;
3908    PyObject * obj0 = 0 ;
3909   
3910    if(!PyArg_ParseTuple(args,(char *)"O:log_close",&obj0)) goto fail;
3911    arg1 = (int)SWIG_As_int(obj0); 
3912    if (PyErr_Occurred()) SWIG_fail;
3913    log_close(arg1);
3914   
3915    Py_INCREF(Py_None); resultobj = Py_None;
3916    return resultobj;
3917    fail:
3918    return NULL;
3919}
3920
3921
3922static PyObject *_wrap_log_err(PyObject *self, PyObject *args) {
3923    PyObject *resultobj;
3924    int arg1 ;
3925    char *arg2 ;
3926    char *arg3 ;
3927    PyObject * obj0 = 0 ;
3928    PyObject * obj1 = 0 ;
3929    PyObject * obj2 = 0 ;
3930   
3931    if(!PyArg_ParseTuple(args,(char *)"OOO:log_err",&obj0,&obj1,&obj2)) goto fail;
3932    arg1 = (int)SWIG_As_int(obj0); 
3933    if (PyErr_Occurred()) SWIG_fail;
3934    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
3935    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
3936    log_err(arg1,arg2,arg3);
3937   
3938    Py_INCREF(Py_None); resultobj = Py_None;
3939    return resultobj;
3940    fail:
3941    return NULL;
3942}
3943
3944
3945static PyObject *_wrap_log_event(PyObject *self, PyObject *args) {
3946    PyObject *resultobj;
3947    int arg1 ;
3948    int arg2 ;
3949    char *arg3 ;
3950    char *arg4 ;
3951    PyObject * obj0 = 0 ;
3952    PyObject * obj1 = 0 ;
3953    PyObject * obj2 = 0 ;
3954    PyObject * obj3 = 0 ;
3955   
3956    if(!PyArg_ParseTuple(args,(char *)"OOOO:log_event",&obj0,&obj1,&obj2,&obj3)) goto fail;
3957    arg1 = (int)SWIG_As_int(obj0); 
3958    if (PyErr_Occurred()) SWIG_fail;
3959    arg2 = (int)SWIG_As_int(obj1); 
3960    if (PyErr_Occurred()) SWIG_fail;
3961    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
3962    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
3963    log_event(arg1,arg2,arg3,arg4);
3964   
3965    Py_INCREF(Py_None); resultobj = Py_None;
3966    return resultobj;
3967    fail:
3968    return NULL;
3969}
3970
3971
3972static PyObject *_wrap_log_open(PyObject *self, PyObject *args) {
3973    PyObject *resultobj;
3974    char *arg1 ;
3975    char *arg2 ;
3976    int result;
3977    PyObject * obj0 = 0 ;
3978    PyObject * obj1 = 0 ;
3979   
3980    if(!PyArg_ParseTuple(args,(char *)"OO:log_open",&obj0,&obj1)) goto fail;
3981    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) SWIG_fail;
3982    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
3983    result = (int)log_open(arg1,arg2);
3984   
3985    resultobj = SWIG_From_int((int)result);
3986    return resultobj;
3987    fail:
3988    return NULL;
3989}
3990
3991
3992static PyObject *_wrap_log_record(PyObject *self, PyObject *args) {
3993    PyObject *resultobj;
3994    int arg1 ;
3995    int arg2 ;
3996    char *arg3 ;
3997    char *arg4 ;
3998    PyObject * obj0 = 0 ;
3999    PyObject * obj1 = 0 ;
4000    PyObject * obj2 = 0 ;
4001    PyObject * obj3 = 0 ;
4002   
4003    if(!PyArg_ParseTuple(args,(char *)"OOOO:log_record",&obj0,&obj1,&obj2,&obj3)) goto fail;
4004    arg1 = (int)SWIG_As_int(obj0); 
4005    if (PyErr_Occurred()) SWIG_fail;
4006    arg2 = (int)SWIG_As_int(obj1); 
4007    if (PyErr_Occurred()) SWIG_fail;
4008    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) SWIG_fail;
4009    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) SWIG_fail;
4010    log_record(arg1,arg2,arg3,arg4);
4011   
4012    Py_INCREF(Py_None); resultobj = Py_None;
4013    return resultobj;
4014    fail:
4015    return NULL;
4016}
4017
4018
4019static int _wrap_log_buffer_set(PyObject *_val) {
4020    {
4021        if (!SWIG_AsCharArray(_val, log_buffer, 4096)) {
4022            PyErr_Clear();
4023            PyErr_SetString(PyExc_TypeError, "C/C++ variable 'log_buffer (char *)'");
4024            return 1;
4025        }
4026    }
4027    return 0;
4028}
4029
4030
4031static PyObject *_wrap_log_buffer_get() {
4032    PyObject *pyobj;
4033   
4034    {
4035        size_t size = 4096;
4036       
4037        while (size && (log_buffer[size - 1] == '\0')) --size;
4038       
4039        pyobj = SWIG_FromCharArray(log_buffer, size);
4040    }
4041    return pyobj;
4042}
4043
4044
4045static PyObject *_wrap_setup_env(PyObject *self, PyObject *args) {
4046    PyObject *resultobj;
4047    char *arg1 ;
4048    int result;
4049    PyObject * obj0 = 0 ;
4050   
4051    if(!PyArg_ParseTuple(args,(char *)"O:setup_env",&obj0)) goto fail;
4052    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) SWIG_fail;
4053    result = (int)setup_env(arg1);
4054   
4055    resultobj = SWIG_From_int((int)result);
4056    return resultobj;
4057    fail:
4058    return NULL;
4059}
4060
4061
4062static PyObject *_wrap_chk_file_sec(PyObject *self, PyObject *args) {
4063    PyObject *resultobj;
4064    char *arg1 ;
4065    int arg2 ;
4066    int arg3 ;
4067    int arg4 ;
4068    int arg5 ;
4069    int result;
4070    PyObject * obj0 = 0 ;
4071    PyObject * obj1 = 0 ;
4072    PyObject * obj2 = 0 ;
4073    PyObject * obj3 = 0 ;
4074    PyObject * obj4 = 0 ;
4075   
4076    if(!PyArg_ParseTuple(args,(char *)"OOOOO:chk_file_sec",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4077    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) SWIG_fail;
4078    arg2 = (int)SWIG_As_int(obj1); 
4079    if (PyErr_Occurred()) SWIG_fail;
4080    arg3 = (int)SWIG_As_int(obj2); 
4081    if (PyErr_Occurred()) SWIG_fail;
4082    arg4 = (int)SWIG_As_int(obj3); 
4083    if (PyErr_Occurred()) SWIG_fail;
4084    arg5 = (int)SWIG_As_int(obj4); 
4085    if (PyErr_Occurred()) SWIG_fail;
4086    result = (int)chk_file_sec(arg1,arg2,arg3,arg4,arg5);
4087   
4088    resultobj = SWIG_From_int((int)result);
4089    return resultobj;
4090    fail:
4091    return NULL;
4092}
4093
4094
4095static int _wrap_msg_daemonname_set(PyObject *_val) {
4096    {
4097        char *cptr = 0;
4098        if (!SWIG_AsNewCharPtr(_val, &cptr)) {
4099            PyErr_Clear();
4100            PyErr_SetString(PyExc_TypeError, "C/C++ variable 'msg_daemonname (char *)'");
4101            return 1;
4102        }
4103        if (msg_daemonname) swig_delete_array(msg_daemonname);
4104        msg_daemonname = cptr;
4105    }
4106    return 0;
4107}
4108
4109
4110static PyObject *_wrap_msg_daemonname_get() {
4111    PyObject *pyobj;
4112   
4113    pyobj = SWIG_FromCharPtr(msg_daemonname);
4114    return pyobj;
4115}
4116
4117
4118static PyMethodDef SwigMethods[] = {
4119         { (char *)"new_attrl", _wrap_new_attrl, METH_VARARGS, NULL },
4120         { (char *)"new_attropl", _wrap_new_attropl, METH_VARARGS, NULL },
4121         { (char *)"new_batch_status", _wrap_new_batch_status, METH_VARARGS, NULL },
4122         { (char *)"get_error", _wrap_get_error, METH_VARARGS, NULL },
4123         { (char *)"attrl_name_set", _wrap_attrl_name_set, METH_VARARGS, NULL },
4124         { (char *)"attrl_name_get", _wrap_attrl_name_get, METH_VARARGS, NULL },
4125         { (char *)"attrl_resource_set", _wrap_attrl_resource_set, METH_VARARGS, NULL },
4126         { (char *)"attrl_resource_get", _wrap_attrl_resource_get, METH_VARARGS, NULL },
4127         { (char *)"attrl_value_set", _wrap_attrl_value_set, METH_VARARGS, NULL },
4128         { (char *)"attrl_value_get", _wrap_attrl_value_get, METH_VARARGS, NULL },
4129         { (char *)"attrl_op_set", _wrap_attrl_op_set, METH_VARARGS, NULL },
4130         { (char *)"attrl_op_get", _wrap_attrl_op_get, METH_VARARGS, NULL },
4131         { (char *)"attrl___str__", _wrap_attrl___str__, METH_VARARGS, NULL },
4132         { (char *)"attrl_swigregister", attrl_swigregister, METH_VARARGS, NULL },
4133         { (char *)"attropl_name_set", _wrap_attropl_name_set, METH_VARARGS, NULL },
4134         { (char *)"attropl_name_get", _wrap_attropl_name_get, METH_VARARGS, NULL },
4135         { (char *)"attropl_resource_set", _wrap_attropl_resource_set, METH_VARARGS, NULL },
4136         { (char *)"attropl_resource_get", _wrap_attropl_resource_get, METH_VARARGS, NULL },
4137         { (char *)"attropl_value_set", _wrap_attropl_value_set, METH_VARARGS, NULL },
4138         { (char *)"attropl_value_get", _wrap_attropl_value_get, METH_VARARGS, NULL },
4139         { (char *)"attropl_op_set", _wrap_attropl_op_set, METH_VARARGS, NULL },
4140         { (char *)"attropl_op_get", _wrap_attropl_op_get, METH_VARARGS, NULL },
4141         { (char *)"attropl___str__", _wrap_attropl___str__, METH_VARARGS, NULL },
4142         { (char *)"attropl_swigregister", attropl_swigregister, METH_VARARGS, NULL },
4143         { (char *)"batch_status_name_set", _wrap_batch_status_name_set, METH_VARARGS, NULL },
4144         { (char *)"batch_status_name_get", _wrap_batch_status_name_get, METH_VARARGS, NULL },
4145         { (char *)"batch_status_attribs_set", _wrap_batch_status_attribs_set, METH_VARARGS, NULL },
4146         { (char *)"batch_status_attribs_get", _wrap_batch_status_attribs_get, METH_VARARGS, NULL },
4147         { (char *)"batch_status_text_set", _wrap_batch_status_text_set, METH_VARARGS, NULL },
4148         { (char *)"batch_status_text_get", _wrap_batch_status_text_get, METH_VARARGS, NULL },
4149         { (char *)"batch_status_swigregister", batch_status_swigregister, METH_VARARGS, NULL },
4150         { (char *)"avail", _wrap_avail, METH_VARARGS, NULL },
4151         { (char *)"pbs_asyrunjob", _wrap_pbs_asyrunjob, METH_VARARGS, NULL },
4152         { (char *)"pbs_alterjob", _wrap_pbs_alterjob, METH_VARARGS, NULL },
4153         { (char *)"pbs_connect", _wrap_pbs_connect, METH_VARARGS, NULL },
4154         { (char *)"pbs_query_max_connections", _wrap_pbs_query_max_connections, METH_VARARGS, NULL },
4155         { (char *)"pbs_default", _wrap_pbs_default, METH_VARARGS, NULL },
4156         { (char *)"pbs_deljob", _wrap_pbs_deljob, METH_VARARGS, NULL },
4157         { (char *)"pbs_disconnect", _wrap_pbs_disconnect, METH_VARARGS, NULL },
4158         { (char *)"pbs_geterrmsg", _wrap_pbs_geterrmsg, METH_VARARGS, NULL },
4159         { (char *)"pbs_holdjob", _wrap_pbs_holdjob, METH_VARARGS, NULL },
4160         { (char *)"pbs_locjob", _wrap_pbs_locjob, METH_VARARGS, NULL },
4161         { (char *)"pbs_manager", _wrap_pbs_manager, METH_VARARGS, NULL },
4162         { (char *)"pbs_movejob", _wrap_pbs_movejob, METH_VARARGS, NULL },
4163         { (char *)"pbs_msgjob", _wrap_pbs_msgjob, METH_VARARGS, NULL },
4164         { (char *)"pbs_orderjob", _wrap_pbs_orderjob, METH_VARARGS, NULL },
4165         { (char *)"pbs_rescquery", _wrap_pbs_rescquery, METH_VARARGS, NULL },
4166         { (char *)"pbs_rescreserve", _wrap_pbs_rescreserve, METH_VARARGS, NULL },
4167         { (char *)"pbs_rescrelease", _wrap_pbs_rescrelease, METH_VARARGS, NULL },
4168         { (char *)"pbs_rerunjob", _wrap_pbs_rerunjob, METH_VARARGS, NULL },
4169         { (char *)"pbs_rlsjob", _wrap_pbs_rlsjob, METH_VARARGS, NULL },
4170         { (char *)"pbs_runjob", _wrap_pbs_runjob, METH_VARARGS, NULL },
4171         { (char *)"pbs_selectjob", _wrap_pbs_selectjob, METH_VARARGS, NULL },
4172         { (char *)"pbs_sigjob", _wrap_pbs_sigjob, METH_VARARGS, NULL },
4173         { (char *)"pbs_statfree", _wrap_pbs_statfree, METH_VARARGS, NULL },
4174         { (char *)"pbs_statjob", _wrap_pbs_statjob, METH_VARARGS, NULL },
4175         { (char *)"pbs_selstat", _wrap_pbs_selstat, METH_VARARGS, NULL },
4176         { (char *)"pbs_statque", _wrap_pbs_statque, METH_VARARGS, NULL },
4177         { (char *)"pbs_statserver", _wrap_pbs_statserver, METH_VARARGS, NULL },
4178         { (char *)"pbs_statnode", _wrap_pbs_statnode, METH_VARARGS, NULL },
4179         { (char *)"pbs_submit", _wrap_pbs_submit, METH_VARARGS, NULL },
4180         { (char *)"pbs_terminate", _wrap_pbs_terminate, METH_VARARGS, NULL },
4181         { (char *)"totpool", _wrap_totpool, METH_VARARGS, NULL },
4182         { (char *)"usepool", _wrap_usepool, METH_VARARGS, NULL },
4183         { (char *)"openrm", _wrap_openrm, METH_VARARGS, NULL },
4184         { (char *)"closerm", _wrap_closerm, METH_VARARGS, NULL },
4185         { (char *)"downrm", _wrap_downrm, METH_VARARGS, NULL },
4186         { (char *)"configrm", _wrap_configrm, METH_VARARGS, NULL },
4187         { (char *)"addreq", _wrap_addreq, METH_VARARGS, NULL },
4188         { (char *)"allreq", _wrap_allreq, METH_VARARGS, NULL },
4189         { (char *)"flushreq", _wrap_flushreq, METH_VARARGS, NULL },
4190         { (char *)"activereq", _wrap_activereq, METH_VARARGS, NULL },
4191         { (char *)"fullresp", _wrap_fullresp, METH_VARARGS, NULL },
4192         { (char *)"getreq", _wrap_getreq, METH_VARARGS, NULL },
4193         { (char *)"log_close", _wrap_log_close, METH_VARARGS, NULL },
4194         { (char *)"log_err", _wrap_log_err, METH_VARARGS, NULL },
4195         { (char *)"log_event", _wrap_log_event, METH_VARARGS, NULL },
4196         { (char *)"log_open", _wrap_log_open, METH_VARARGS, NULL },
4197         { (char *)"log_record", _wrap_log_record, METH_VARARGS, NULL },
4198         { (char *)"setup_env", _wrap_setup_env, METH_VARARGS, NULL },
4199         { (char *)"chk_file_sec", _wrap_chk_file_sec, METH_VARARGS, NULL },
4200         { NULL, NULL, 0, NULL }
4201};
4202
4203
4204/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4205
4206static swig_type_info _swigt__p_batch_status[] = {{"_p_batch_status", 0, "struct batch_status *", 0, 0, 0, 0},{"_p_batch_status", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
4207static swig_type_info _swigt__p_resource_t[] = {{"_p_resource_t", 0, "int *|resource_t *", 0, 0, 0, 0},{"_p_resource_t", 0, 0, 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
4208static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
4209static swig_type_info _swigt__p_attropl[] = {{"_p_attropl", 0, "struct attropl *", 0, 0, 0, 0},{"_p_attropl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
4210static swig_type_info _swigt__p_p_char[] = {{"_p_p_char", 0, "char **", 0, 0, 0, 0},{"_p_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
4211static swig_type_info _swigt__p_attrl[] = {{"_p_attrl", 0, "struct attrl *", 0, 0, 0, 0},{"_p_attrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
4212static swig_type_info _swigt__p_long[] = {{"_p_long", 0, "long *", 0, 0, 0, 0},{"_p_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
4213static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_resource_t", 0, 0, 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
4214
4215static swig_type_info *swig_types_initial[] = {
4216_swigt__p_batch_status, 
4217_swigt__p_resource_t, 
4218_swigt__p_char, 
4219_swigt__p_attropl, 
4220_swigt__p_p_char, 
4221_swigt__p_attrl, 
4222_swigt__p_long, 
4223_swigt__p_int, 
42240
4225};
4226
4227
4228/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4229
4230static swig_const_info swig_const_table[] = {
4231{ SWIG_PY_POINTER, (char*)"ATTR_a", 0, 0, (void *)"Execution_Time", &SWIGTYPE_p_char},
4232{ SWIG_PY_POINTER, (char*)"ATTR_c", 0, 0, (void *)"Checkpoint", &SWIGTYPE_p_char},
4233{ SWIG_PY_POINTER, (char*)"ATTR_e", 0, 0, (void *)"Error_Path", &SWIGTYPE_p_char},
4234{ SWIG_PY_POINTER, (char*)"ATTR_g", 0, 0, (void *)"group_list", &SWIGTYPE_p_char},
4235{ SWIG_PY_POINTER, (char*)"ATTR_h", 0, 0, (void *)"Hold_Types", &SWIGTYPE_p_char},
4236{ SWIG_PY_POINTER, (char*)"ATTR_j", 0, 0, (void *)"Join_Path", &SWIGTYPE_p_char},
4237{ SWIG_PY_POINTER, (char*)"ATTR_k", 0, 0, (void *)"Keep_Files", &SWIGTYPE_p_char},
4238{ SWIG_PY_POINTER, (char*)"ATTR_l", 0, 0, (void *)"Resource_List", &SWIGTYPE_p_char},
4239{ SWIG_PY_POINTER, (char*)"ATTR_m", 0, 0, (void *)"Mail_Points", &SWIGTYPE_p_char},
4240{ SWIG_PY_POINTER, (char*)"ATTR_o", 0, 0, (void *)"Output_Path", &SWIGTYPE_p_char},
4241{ SWIG_PY_POINTER, (char*)"ATTR_p", 0, 0, (void *)"Priority", &SWIGTYPE_p_char},
4242{ SWIG_PY_POINTER, (char*)"ATTR_q", 0, 0, (void *)"destination", &SWIGTYPE_p_char},
4243{ SWIG_PY_POINTER, (char*)"ATTR_r", 0, 0, (void *)"Rerunable", &SWIGTYPE_p_char},
4244{ SWIG_PY_POINTER, (char*)"ATTR_u", 0, 0, (void *)"User_List", &SWIGTYPE_p_char},
4245{ SWIG_PY_POINTER, (char*)"ATTR_v", 0, 0, (void *)"Variable_List", &SWIGTYPE_p_char},
4246{ SWIG_PY_POINTER, (char*)"ATTR_A", 0, 0, (void *)"Account_Name", &SWIGTYPE_p_char},
4247{ SWIG_PY_POINTER, (char*)"ATTR_M", 0, 0, (void *)"Mail_Users", &SWIGTYPE_p_char},
4248{ SWIG_PY_POINTER, (char*)"ATTR_N", 0, 0, (void *)"Job_Name", &SWIGTYPE_p_char},
4249{ SWIG_PY_POINTER, (char*)"ATTR_S", 0, 0, (void *)"Shell_Path_List", &SWIGTYPE_p_char},
4250{ SWIG_PY_POINTER, (char*)"ATTR_depend", 0, 0, (void *)"depend", &SWIGTYPE_p_char},
4251{ SWIG_PY_POINTER, (char*)"ATTR_inter", 0, 0, (void *)"interactive", &SWIGTYPE_p_char},
4252{ SWIG_PY_POINTER, (char*)"ATTR_stagein", 0, 0, (void *)"stagein", &SWIGTYPE_p_char},
4253{ SWIG_PY_POINTER, (char*)"ATTR_stageout", 0, 0, (void *)"stageout", &SWIGTYPE_p_char},
4254{ SWIG_PY_POINTER, (char*)"ATTR_ctime", 0, 0, (void *)"ctime", &SWIGTYPE_p_char},
4255{ SWIG_PY_POINTER, (char*)"ATTR_exechost", 0, 0, (void *)"exec_host", &SWIGTYPE_p_char},
4256{ SWIG_PY_POINTER, (char*)"ATTR_mtime", 0, 0, (void *)"mtime", &SWIGTYPE_p_char},
4257{ SWIG_PY_POINTER, (char*)"ATTR_qtime", 0, 0, (void *)"qtime", &SWIGTYPE_p_char},
4258{ SWIG_PY_POINTER, (char*)"ATTR_session", 0, 0, (void *)"session_id", &SWIGTYPE_p_char},
4259{ SWIG_PY_POINTER, (char*)"ATTR_euser", 0, 0, (void *)"euser", &SWIGTYPE_p_char},
4260{ SWIG_PY_POINTER, (char*)"ATTR_egroup", 0, 0, (void *)"egroup", &SWIGTYPE_p_char},
4261{ SWIG_PY_POINTER, (char*)"ATTR_hashname", 0, 0, (void *)"hashname", &SWIGTYPE_p_char},
4262{ SWIG_PY_POINTER, (char*)"ATTR_hopcount", 0, 0, (void *)"hop_count", &SWIGTYPE_p_char},
4263{ SWIG_PY_POINTER, (char*)"ATTR_security", 0, 0, (void *)"security", &SWIGTYPE_p_char},
4264{ SWIG_PY_POINTER, (char*)"ATTR_sched_hint", 0, 0, (void *)"sched_hint", &SWIGTYPE_p_char},
4265{ SWIG_PY_POINTER, (char*)"ATTR_substate", 0, 0, (void *)"substate", &SWIGTYPE_p_char},
4266{ SWIG_PY_POINTER, (char*)"ATTR_name", 0, 0, (void *)"Job_Name", &SWIGTYPE_p_char},
4267{ SWIG_PY_POINTER, (char*)"ATTR_owner", 0, 0, (void *)"Job_Owner", &SWIGTYPE_p_char},
4268{ SWIG_PY_POINTER, (char*)"ATTR_used", 0, 0, (void *)"resources_used", &SWIGTYPE_p_char},
4269{ SWIG_PY_POINTER, (char*)"ATTR_state", 0, 0, (void *)"job_state", &SWIGTYPE_p_char},
4270{ SWIG_PY_POINTER, (char*)"ATTR_queue", 0, 0, (void *)"queue", &SWIGTYPE_p_char},
4271{ SWIG_PY_POINTER, (char*)"ATTR_server", 0, 0, (void *)"server", &SWIGTYPE_p_char},
4272{ SWIG_PY_POINTER, (char*)"ATTR_maxrun", 0, 0, (void *)"max_running", &SWIGTYPE_p_char},
4273{ SWIG_PY_POINTER, (char*)"ATTR_total", 0, 0, (void *)"total_jobs", &SWIGTYPE_p_char},
4274{ SWIG_PY_POINTER, (char*)"ATTR_comment", 0, 0, (void *)"comment", &SWIGTYPE_p_char},
4275{ SWIG_PY_POINTER, (char*)"ATTR_cookie", 0, 0, (void *)"cookie", &SWIGTYPE_p_char},
4276{ SWIG_PY_POINTER, (char*)"ATTR_qrank", 0, 0, (void *)"queue_rank", &SWIGTYPE_p_char},
4277{ SWIG_PY_POINTER, (char*)"ATTR_altid", 0, 0, (void *)"alt_id", &SWIGTYPE_p_char},
4278{ SWIG_PY_POINTER, (char*)"ATTR_etime", 0, 0, (void *)"etime", &SWIGTYPE_p_char},
4279{ SWIG_PY_POINTER, (char*)"ATTR_aclgren", 0, 0, (void *)"acl_group_enable", &SWIGTYPE_p_char},
4280{ SWIG_PY_POINTER, (char*)"ATTR_aclgroup", 0, 0, (void *)"acl_groups", &SWIGTYPE_p_char},
4281{ SWIG_PY_POINTER, (char*)"ATTR_aclhten", 0, 0, (void *)"acl_host_enable", &SWIGTYPE_p_char},
4282{ SWIG_PY_POINTER, (char*)"ATTR_aclhost", 0, 0, (void *)"acl_hosts", &SWIGTYPE_p_char},
4283{ SWIG_PY_POINTER, (char*)"ATTR_acluren", 0, 0, (void *)"acl_user_enable", &SWIGTYPE_p_char},
4284{ SWIG_PY_POINTER, (char*)"ATTR_acluser", 0, 0, (void *)"acl_users", &SWIGTYPE_p_char},
4285{ SWIG_PY_POINTER, (char*)"ATTR_altrouter", 0, 0, (void *)"alt_router", &SWIGTYPE_p_char},
4286{ SWIG_PY_POINTER, (char*)"ATTR_chkptmin", 0, 0, (void *)"checkpoint_min", &SWIGTYPE_p_char},
4287{ SWIG_PY_POINTER, (char*)"ATTR_enable", 0, 0, (void *)"enabled", &SWIGTYPE_p_char},
4288{ SWIG_PY_POINTER, (char*)"ATTR_fromroute", 0, 0, (void *)"from_route_only", &SWIGTYPE_p_char},
4289{ SWIG_PY_POINTER, (char*)"ATTR_killdelay", 0, 0, (void *)"kill_delay", &SWIGTYPE_p_char},
4290{ SWIG_PY_POINTER, (char*)"ATTR_maxgrprun", 0, 0, (void *)"max_group_run", &SWIGTYPE_p_char},
4291{ SWIG_PY_POINTER, (char*)"ATTR_maxque", 0, 0, (void *)"max_queuable", &SWIGTYPE_p_char},
4292{ SWIG_PY_POINTER, (char*)"ATTR_maxuserrun", 0, 0, (void *)"max_user_run", &SWIGTYPE_p_char},
4293{ SWIG_PY_POINTER, (char*)"ATTR_qtype", 0, 0, (void *)"queue_type", &SWIGTYPE_p_char},
4294{ SWIG_PY_POINTER, (char*)"ATTR_rescassn", 0, 0, (void *)"resources_assigned", &SWIGTYPE_p_char},
4295{ SWIG_PY_POINTER, (char*)"ATTR_rescdflt", 0, 0, (void *)"resources_default", &SWIGTYPE_p_char},
4296{ SWIG_PY_POINTER, (char*)"ATTR_rescmax", 0, 0, (void *)"resources_max", &SWIGTYPE_p_char},
4297{ SWIG_PY_POINTER, (char*)"ATTR_rescmin", 0, 0, (void *)"resources_min", &SWIGTYPE_p_char},
4298{ SWIG_PY_POINTER, (char*)"ATTR_rndzretry", 0, 0, (void *)"rendezvous_retry", &SWIGTYPE_p_char},
4299{ SWIG_PY_POINTER, (char*)"ATTR_routedest", 0, 0, (void *)"route_destinations", &SWIGTYPE_p_char},
4300{ SWIG_PY_POINTER, (char*)"ATTR_routeheld", 0, 0, (void *)"route_held_jobs", &SWIGTYPE_p_char},
4301{ SWIG_PY_POINTER, (char*)"ATTR_routewait", 0, 0, (void *)"route_waiting_jobs", &SWIGTYPE_p_char},
4302{ SWIG_PY_POINTER, (char*)"ATTR_routeretry", 0, 0, (void *)"route_retry_time", &SWIGTYPE_p_char},
4303{ SWIG_PY_POINTER, (char*)"ATTR_routelife", 0, 0, (void *)"route_lifetime", &SWIGTYPE_p_char},
4304{ SWIG_PY_POINTER, (char*)"ATTR_rsvexpdt", 0, 0, (void *)"reserved_expedite", &SWIGTYPE_p_char},
4305{ SWIG_PY_POINTER, (char*)"ATTR_rsvsync", 0, 0, (void *)"reserved_sync", &SWIGTYPE_p_char},
4306{ SWIG_PY_POINTER, (char*)"ATTR_start", 0, 0, (void *)"started", &SWIGTYPE_p_char},
4307{ SWIG_PY_POINTER, (char*)"ATTR_count", 0, 0, (void *)"state_count", &SWIGTYPE_p_char},
4308{ SWIG_PY_POINTER, (char*)"ATTR_number", 0, 0, (void *)"number_jobs", &SWIGTYPE_p_char},
4309{ SWIG_PY_POINTER, (char*)"ATTR_reqprop", 0, 0, (void *)"required_property", &SWIGTYPE_p_char},
4310{ SWIG_PY_POINTER, (char*)"ATTR_aclroot", 0, 0, (void *)"acl_roots", &SWIGTYPE_p_char},
4311{ SWIG_PY_POINTER, (char*)"ATTR_managers", 0, 0, (void *)"managers", &SWIGTYPE_p_char},
4312{ SWIG_PY_POINTER, (char*)"ATTR_dfltque", 0, 0, (void *)"default_queue", &SWIGTYPE_p_char},
4313{ SWIG_PY_POINTER, (char*)"ATTR_defnode", 0, 0, (void *)"default_node", &SWIGTYPE_p_char},
4314{ SWIG_PY_POINTER, (char*)"ATTR_locsvrs", 0, 0, (void *)"location_servers", &SWIGTYPE_p_char},
4315{ SWIG_PY_POINTER, (char*)"ATTR_logevents", 0, 0, (void *)"log_events", &SWIGTYPE_p_char},
4316{ SWIG_PY_POINTER, (char*)"ATTR_logfile", 0, 0, (void *)"log_file", &SWIGTYPE_p_char},
4317{ SWIG_PY_POINTER, (char*)"ATTR_mailfrom", 0, 0, (void *)"mail_from", &SWIGTYPE_p_char},
4318{ SWIG_PY_POINTER, (char*)"ATTR_nodepack", 0, 0, (void *)"node_pack", &SWIGTYPE_p_char},
4319{ SWIG_PY_POINTER, (char*)"ATTR_operators", 0, 0, (void *)"operators", &SWIGTYPE_p_char},
4320{ SWIG_PY_POINTER, (char*)"ATTR_queryother", 0, 0, (void *)"query_other_jobs", &SWIGTYPE_p_char},
4321{ SWIG_PY_POINTER, (char*)"ATTR_resccost", 0, 0, (void *)"resources_cost", &SWIGTYPE_p_char},
4322{ SWIG_PY_POINTER, (char*)"ATTR_rescavail", 0, 0, (void *)"resources_available", &SWIGTYPE_p_char},
4323{ SWIG_PY_POINTER, (char*)"ATTR_schedit", 0, 0, (void *)"scheduler_iteration", &SWIGTYPE_p_char},
4324{ SWIG_PY_POINTER, (char*)"ATTR_scheduling", 0, 0, (void *)"scheduling", &SWIGTYPE_p_char},
4325{ SWIG_PY_POINTER, (char*)"ATTR_status", 0, 0, (void *)"server_state", &SWIGTYPE_p_char},
4326{ SWIG_PY_POINTER, (char*)"ATTR_syscost", 0, 0, (void *)"system_cost", &SWIGTYPE_p_char},
4327{ SWIG_PY_POINTER, (char*)"ATTR_pingrate", 0, 0, (void *)"node_ping_rate", &SWIGTYPE_p_char},
4328{ SWIG_PY_POINTER, (char*)"ATTR_ndchkrate", 0, 0, (void *)"node_check_rate", &SWIGTYPE_p_char},
4329{ SWIG_PY_POINTER, (char*)"ATTR_procpack", 0, 0, (void *)"proc_pack", &SWIGTYPE_p_char},
4330{ SWIG_PY_POINTER, (char*)"ATTR_NODE_state", 0, 0, (void *)"state", &SWIGTYPE_p_char},
4331{ SWIG_PY_POINTER, (char*)"ATTR_NODE_np", 0, 0, (void *)"np", &SWIGTYPE_p_char},
4332{ SWIG_PY_POINTER, (char*)"ATTR_NODE_properties", 0, 0, (void *)"properties", &SWIGTYPE_p_char},
4333{ SWIG_PY_POINTER, (char*)"ATTR_NODE_ntype", 0, 0, (void *)"ntype", &SWIGTYPE_p_char},
4334{ SWIG_PY_POINTER, (char*)"ATTR_NODE_jobs", 0, 0, (void *)"jobs", &SWIGTYPE_p_char},
4335{ SWIG_PY_POINTER, (char*)"CHECKPOINT_UNSPECIFIED", 0, 0, (void *)"u", &SWIGTYPE_p_char},
4336{ SWIG_PY_POINTER, (char*)"NO_HOLD", 0, 0, (void *)"n", &SWIGTYPE_p_char},
4337{ SWIG_PY_POINTER, (char*)"NO_JOIN", 0, 0, (void *)"n", &SWIGTYPE_p_char},
4338{ SWIG_PY_POINTER, (char*)"NO_KEEP", 0, 0, (void *)"n", &SWIGTYPE_p_char},
4339{ SWIG_PY_POINTER, (char*)"MAIL_AT_ABORT", 0, 0, (void *)"a", &SWIGTYPE_p_char},
4340{ SWIG_PY_POINTER, (char*)"DELDELAY", 0, 0, (void *)"deldelay=", &SWIGTYPE_p_char},
4341{ SWIG_PY_POINTER, (char*)"USER_HOLD", 0, 0, (void *)"u", &SWIGTYPE_p_char},
4342{ SWIG_PY_POINTER, (char*)"OTHER_HOLD", 0, 0, (void *)"o", &SWIGTYPE_p_char},
4343{ SWIG_PY_POINTER, (char*)"SYSTEM_HOLD", 0, 0, (void *)"s", &SWIGTYPE_p_char},
4344{ SWIG_PY_POINTER, (char*)"ND_free", 0, 0, (void *)"free", &SWIGTYPE_p_char},
4345{ SWIG_PY_POINTER, (char*)"ND_offline", 0, 0, (void *)"offline", &SWIGTYPE_p_char},
4346{ SWIG_PY_POINTER, (char*)"ND_down", 0, 0, (void *)"down", &SWIGTYPE_p_char},
4347{ SWIG_PY_POINTER, (char*)"ND_reserve", 0, 0, (void *)"reserve", &SWIGTYPE_p_char},
4348{ SWIG_PY_POINTER, (char*)"ND_job_exclusive", 0, 0, (void *)"job-exclusive", &SWIGTYPE_p_char},
4349{ SWIG_PY_POINTER, (char*)"ND_job_sharing", 0, 0, (void *)"job-sharing", &SWIGTYPE_p_char},
4350{ SWIG_PY_POINTER, (char*)"ND_busy", 0, 0, (void *)"busy", &SWIGTYPE_p_char},
4351{ SWIG_PY_POINTER, (char*)"ND_state_unknown", 0, 0, (void *)"state-unknown", &SWIGTYPE_p_char},
4352{ SWIG_PY_POINTER, (char*)"ND_timeshared", 0, 0, (void *)"time-shared", &SWIGTYPE_p_char},
4353{ SWIG_PY_POINTER, (char*)"ND_cluster", 0, 0, (void *)"cluster", &SWIGTYPE_p_char},
4354{ SWIG_PY_POINTER, (char*)"SIG_RESUME", 0, 0, (void *)"resume", &SWIGTYPE_p_char},
4355{ SWIG_PY_POINTER, (char*)"SIG_SUSPEND", 0, 0, (void *)"suspend", &SWIGTYPE_p_char},
4356{ SWIG_PY_POINTER, (char*)"PBS_BATCH_SERVICE_NAME", 0, 0, (void *)"pbs", &SWIGTYPE_p_char},
4357{ SWIG_PY_POINTER, (char*)"PBS_BATCH_SERVICE_NAME_DIS", 0, 0, (void *)"pbs_dis", &SWIGTYPE_p_char},
4358{ SWIG_PY_POINTER, (char*)"PBS_MOM_SERVICE_NAME", 0, 0, (void *)"pbs_mom", &SWIGTYPE_p_char},
4359{ SWIG_PY_POINTER, (char*)"PBS_MANAGER_SERVICE_NAME", 0, 0, (void *)"pbs_resmon", &SWIGTYPE_p_char},
4360{ SWIG_PY_POINTER, (char*)"PBS_SCHEDULER_SERVICE_NAME", 0, 0, (void *)"pbs_sched", &SWIGTYPE_p_char},
4361{0, 0, 0, 0.0, 0, 0}};
4362
4363#ifdef __cplusplus
4364}
4365#endif
4366
4367#ifdef __cplusplus
4368extern "C"
4369#endif
4370SWIGEXPORT(void) SWIG_init(void) {
4371    static PyObject *SWIG_globals = 0; 
4372    static int       typeinit = 0;
4373    PyObject *m, *d;
4374    int       i;
4375    if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
4376    m = Py_InitModule((char *) SWIG_name, SwigMethods);
4377    d = PyModule_GetDict(m);
4378   
4379    if (!typeinit) {
4380        for (i = 0; swig_types_initial[i]; i++) {
4381            swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
4382        }
4383        typeinit = 1;
4384    }
4385    SWIG_InstallConstants(d,swig_const_table);
4386   
4387    PyDict_SetItemString(d,"ATTR_a", SWIG_FromCharPtr("Execution_Time"));
4388    PyDict_SetItemString(d,"ATTR_c", SWIG_FromCharPtr("Checkpoint"));
4389    PyDict_SetItemString(d,"ATTR_e", SWIG_FromCharPtr("Error_Path"));
4390    PyDict_SetItemString(d,"ATTR_g", SWIG_FromCharPtr("group_list"));
4391    PyDict_SetItemString(d,"ATTR_h", SWIG_FromCharPtr("Hold_Types"));
4392    PyDict_SetItemString(d,"ATTR_j", SWIG_FromCharPtr("Join_Path"));
4393    PyDict_SetItemString(d,"ATTR_k", SWIG_FromCharPtr("Keep_Files"));
4394    PyDict_SetItemString(d,"ATTR_l", SWIG_FromCharPtr("Resource_List"));
4395    PyDict_SetItemString(d,"ATTR_m", SWIG_FromCharPtr("Mail_Points"));
4396    PyDict_SetItemString(d,"ATTR_o", SWIG_FromCharPtr("Output_Path"));
4397    PyDict_SetItemString(d,"ATTR_p", SWIG_FromCharPtr("Priority"));
4398    PyDict_SetItemString(d,"ATTR_q", SWIG_FromCharPtr("destination"));
4399    PyDict_SetItemString(d,"ATTR_r", SWIG_FromCharPtr("Rerunable"));
4400    PyDict_SetItemString(d,"ATTR_u", SWIG_FromCharPtr("User_List"));
4401    PyDict_SetItemString(d,"ATTR_v", SWIG_FromCharPtr("Variable_List"));
4402    PyDict_SetItemString(d,"ATTR_A", SWIG_FromCharPtr("Account_Name"));
4403    PyDict_SetItemString(d,"ATTR_M", SWIG_FromCharPtr("Mail_Users"));
4404    PyDict_SetItemString(d,"ATTR_N", SWIG_FromCharPtr("Job_Name"));
4405    PyDict_SetItemString(d,"ATTR_S", SWIG_FromCharPtr("Shell_Path_List"));
4406    PyDict_SetItemString(d,"ATTR_depend", SWIG_FromCharPtr("depend"));
4407    PyDict_SetItemString(d,"ATTR_inter", SWIG_FromCharPtr("interactive"));
4408    PyDict_SetItemString(d,"ATTR_stagein", SWIG_FromCharPtr("stagein"));
4409    PyDict_SetItemString(d,"ATTR_stageout", SWIG_FromCharPtr("stageout"));
4410    PyDict_SetItemString(d,"ATTR_ctime", SWIG_FromCharPtr("ctime"));
4411    PyDict_SetItemString(d,"ATTR_exechost", SWIG_FromCharPtr("exec_host"));
4412    PyDict_SetItemString(d,"ATTR_mtime", SWIG_FromCharPtr("mtime"));
4413    PyDict_SetItemString(d,"ATTR_qtime", SWIG_FromCharPtr("qtime"));
4414    PyDict_SetItemString(d,"ATTR_session", SWIG_FromCharPtr("session_id"));
4415    PyDict_SetItemString(d,"ATTR_euser", SWIG_FromCharPtr("euser"));
4416    PyDict_SetItemString(d,"ATTR_egroup", SWIG_FromCharPtr("egroup"));
4417    PyDict_SetItemString(d,"ATTR_hashname", SWIG_FromCharPtr("hashname"));
4418    PyDict_SetItemString(d,"ATTR_hopcount", SWIG_FromCharPtr("hop_count"));
4419    PyDict_SetItemString(d,"ATTR_security", SWIG_FromCharPtr("security"));
4420    PyDict_SetItemString(d,"ATTR_sched_hint", SWIG_FromCharPtr("sched_hint"));
4421    PyDict_SetItemString(d,"ATTR_substate", SWIG_FromCharPtr("substate"));
4422    PyDict_SetItemString(d,"ATTR_name", SWIG_FromCharPtr("Job_Name"));
4423    PyDict_SetItemString(d,"ATTR_owner", SWIG_FromCharPtr("Job_Owner"));
4424    PyDict_SetItemString(d,"ATTR_used", SWIG_FromCharPtr("resources_used"));
4425    PyDict_SetItemString(d,"ATTR_state", SWIG_FromCharPtr("job_state"));
4426    PyDict_SetItemString(d,"ATTR_queue", SWIG_FromCharPtr("queue"));
4427    PyDict_SetItemString(d,"ATTR_server", SWIG_FromCharPtr("server"));
4428    PyDict_SetItemString(d,"ATTR_maxrun", SWIG_FromCharPtr("max_running"));
4429    PyDict_SetItemString(d,"ATTR_total", SWIG_FromCharPtr("total_jobs"));
4430    PyDict_SetItemString(d,"ATTR_comment", SWIG_FromCharPtr("comment"));
4431    PyDict_SetItemString(d,"ATTR_cookie", SWIG_FromCharPtr("cookie"));
4432    PyDict_SetItemString(d,"ATTR_qrank", SWIG_FromCharPtr("queue_rank"));
4433    PyDict_SetItemString(d,"ATTR_altid", SWIG_FromCharPtr("alt_id"));
4434    PyDict_SetItemString(d,"ATTR_etime", SWIG_FromCharPtr("etime"));
4435    PyDict_SetItemString(d,"ATTR_aclgren", SWIG_FromCharPtr("acl_group_enable"));
4436    PyDict_SetItemString(d,"ATTR_aclgroup", SWIG_FromCharPtr("acl_groups"));
4437    PyDict_SetItemString(d,"ATTR_aclhten", SWIG_FromCharPtr("acl_host_enable"));
4438    PyDict_SetItemString(d,"ATTR_aclhost", SWIG_FromCharPtr("acl_hosts"));
4439    PyDict_SetItemString(d,"ATTR_acluren", SWIG_FromCharPtr("acl_user_enable"));
4440    PyDict_SetItemString(d,"ATTR_acluser", SWIG_FromCharPtr("acl_users"));
4441    PyDict_SetItemString(d,"ATTR_altrouter", SWIG_FromCharPtr("alt_router"));
4442    PyDict_SetItemString(d,"ATTR_chkptmin", SWIG_FromCharPtr("checkpoint_min"));
4443    PyDict_SetItemString(d,"ATTR_enable", SWIG_FromCharPtr("enabled"));
4444    PyDict_SetItemString(d,"ATTR_fromroute", SWIG_FromCharPtr("from_route_only"));
4445    PyDict_SetItemString(d,"ATTR_killdelay", SWIG_FromCharPtr("kill_delay"));
4446    PyDict_SetItemString(d,"ATTR_maxgrprun", SWIG_FromCharPtr("max_group_run"));
4447    PyDict_SetItemString(d,"ATTR_maxque", SWIG_FromCharPtr("max_queuable"));
4448    PyDict_SetItemString(d,"ATTR_maxuserrun", SWIG_FromCharPtr("max_user_run"));
4449    PyDict_SetItemString(d,"ATTR_qtype", SWIG_FromCharPtr("queue_type"));
4450    PyDict_SetItemString(d,"ATTR_rescassn", SWIG_FromCharPtr("resources_assigned"));
4451    PyDict_SetItemString(d,"ATTR_rescdflt", SWIG_FromCharPtr("resources_default"));
4452    PyDict_SetItemString(d,"ATTR_rescmax", SWIG_FromCharPtr("resources_max"));
4453    PyDict_SetItemString(d,"ATTR_rescmin", SWIG_FromCharPtr("resources_min"));
4454    PyDict_SetItemString(d,"ATTR_rndzretry", SWIG_FromCharPtr("rendezvous_retry"));
4455    PyDict_SetItemString(d,"ATTR_routedest", SWIG_FromCharPtr("route_destinations"));
4456    PyDict_SetItemString(d,"ATTR_routeheld", SWIG_FromCharPtr("route_held_jobs"));
4457    PyDict_SetItemString(d,"ATTR_routewait", SWIG_FromCharPtr("route_waiting_jobs"));
4458    PyDict_SetItemString(d,"ATTR_routeretry", SWIG_FromCharPtr("route_retry_time"));
4459    PyDict_SetItemString(d,"ATTR_routelife", SWIG_FromCharPtr("route_lifetime"));
4460    PyDict_SetItemString(d,"ATTR_rsvexpdt", SWIG_FromCharPtr("reserved_expedite"));
4461    PyDict_SetItemString(d,"ATTR_rsvsync", SWIG_FromCharPtr("reserved_sync"));
4462    PyDict_SetItemString(d,"ATTR_start", SWIG_FromCharPtr("started"));
4463    PyDict_SetItemString(d,"ATTR_count", SWIG_FromCharPtr("state_count"));
4464    PyDict_SetItemString(d,"ATTR_number", SWIG_FromCharPtr("number_jobs"));
4465    PyDict_SetItemString(d,"ATTR_reqprop", SWIG_FromCharPtr("required_property"));
4466    PyDict_SetItemString(d,"ATTR_aclroot", SWIG_FromCharPtr("acl_roots"));
4467    PyDict_SetItemString(d,"ATTR_managers", SWIG_FromCharPtr("managers"));
4468    PyDict_SetItemString(d,"ATTR_dfltque", SWIG_FromCharPtr("default_queue"));
4469    PyDict_SetItemString(d,"ATTR_defnode", SWIG_FromCharPtr("default_node"));
4470    PyDict_SetItemString(d,"ATTR_locsvrs", SWIG_FromCharPtr("location_servers"));
4471    PyDict_SetItemString(d,"ATTR_logevents", SWIG_FromCharPtr("log_events"));
4472    PyDict_SetItemString(d,"ATTR_logfile", SWIG_FromCharPtr("log_file"));
4473    PyDict_SetItemString(d,"ATTR_mailfrom", SWIG_FromCharPtr("mail_from"));
4474    PyDict_SetItemString(d,"ATTR_nodepack", SWIG_FromCharPtr("node_pack"));
4475    PyDict_SetItemString(d,"ATTR_operators", SWIG_FromCharPtr("operators"));
4476    PyDict_SetItemString(d,"ATTR_queryother", SWIG_FromCharPtr("query_other_jobs"));
4477    PyDict_SetItemString(d,"ATTR_resccost", SWIG_FromCharPtr("resources_cost"));
4478    PyDict_SetItemString(d,"ATTR_rescavail", SWIG_FromCharPtr("resources_available"));
4479    PyDict_SetItemString(d,"ATTR_schedit", SWIG_FromCharPtr("scheduler_iteration"));
4480    PyDict_SetItemString(d,"ATTR_scheduling", SWIG_FromCharPtr("scheduling"));
4481    PyDict_SetItemString(d,"ATTR_status", SWIG_FromCharPtr("server_state"));
4482    PyDict_SetItemString(d,"ATTR_syscost", SWIG_FromCharPtr("system_cost"));
4483    PyDict_SetItemString(d,"ATTR_pingrate", SWIG_FromCharPtr("node_ping_rate"));
4484    PyDict_SetItemString(d,"ATTR_ndchkrate", SWIG_FromCharPtr("node_check_rate"));
4485    PyDict_SetItemString(d,"ATTR_procpack", SWIG_FromCharPtr("proc_pack"));
4486    PyDict_SetItemString(d,"ATTR_NODE_state", SWIG_FromCharPtr("state"));
4487    PyDict_SetItemString(d,"ATTR_NODE_np", SWIG_FromCharPtr("np"));
4488    PyDict_SetItemString(d,"ATTR_NODE_properties", SWIG_FromCharPtr("properties"));
4489    PyDict_SetItemString(d,"ATTR_NODE_ntype", SWIG_FromCharPtr("ntype"));
4490    PyDict_SetItemString(d,"ATTR_NODE_jobs", SWIG_FromCharPtr("jobs"));
4491    PyDict_SetItemString(d,"CHECKPOINT_UNSPECIFIED", SWIG_FromCharPtr("u"));
4492    PyDict_SetItemString(d,"NO_HOLD", SWIG_FromCharPtr("n"));
4493    PyDict_SetItemString(d,"NO_JOIN", SWIG_FromCharPtr("n"));
4494    PyDict_SetItemString(d,"NO_KEEP", SWIG_FromCharPtr("n"));
4495    PyDict_SetItemString(d,"MAIL_AT_ABORT", SWIG_FromCharPtr("a"));
4496    PyDict_SetItemString(d,"DELDELAY", SWIG_FromCharPtr("deldelay="));
4497    PyDict_SetItemString(d,"USER_HOLD", SWIG_FromCharPtr("u"));
4498    PyDict_SetItemString(d,"OTHER_HOLD", SWIG_FromCharPtr("o"));
4499    PyDict_SetItemString(d,"SYSTEM_HOLD", SWIG_FromCharPtr("s"));
4500    PyDict_SetItemString(d,"ND_free", SWIG_FromCharPtr("free"));
4501    PyDict_SetItemString(d,"ND_offline", SWIG_FromCharPtr("offline"));
4502    PyDict_SetItemString(d,"ND_down", SWIG_FromCharPtr("down"));
4503    PyDict_SetItemString(d,"ND_reserve", SWIG_FromCharPtr("reserve"));
4504    PyDict_SetItemString(d,"ND_job_exclusive", SWIG_FromCharPtr("job-exclusive"));
4505    PyDict_SetItemString(d,"ND_job_sharing", SWIG_FromCharPtr("job-sharing"));
4506    PyDict_SetItemString(d,"ND_busy", SWIG_FromCharPtr("busy"));
4507    PyDict_SetItemString(d,"ND_state_unknown", SWIG_FromCharPtr("state-unknown"));
4508    PyDict_SetItemString(d,"ND_timeshared", SWIG_FromCharPtr("time-shared"));
4509    PyDict_SetItemString(d,"ND_cluster", SWIG_FromCharPtr("cluster"));
4510    PyDict_SetItemString(d,"MAX_ENCODE_BFR", SWIG_From_int((int)100));
4511    PyDict_SetItemString(d,"MGR_CMD_CREATE", SWIG_From_int((int)0));
4512    PyDict_SetItemString(d,"MGR_CMD_DELETE", SWIG_From_int((int)1));
4513    PyDict_SetItemString(d,"MGR_CMD_SET", SWIG_From_int((int)2));
4514    PyDict_SetItemString(d,"MGR_CMD_UNSET", SWIG_From_int((int)3));
4515    PyDict_SetItemString(d,"MGR_CMD_LIST", SWIG_From_int((int)4));
4516    PyDict_SetItemString(d,"MGR_CMD_PRINT", SWIG_From_int((int)5));
4517    PyDict_SetItemString(d,"MGR_CMD_ACTIVE", SWIG_From_int((int)6));
4518    PyDict_SetItemString(d,"MGR_OBJ_NONE", SWIG_From_int((int)-1));
4519    PyDict_SetItemString(d,"MGR_OBJ_SERVER", SWIG_From_int((int)0));
4520    PyDict_SetItemString(d,"MGR_OBJ_QUEUE", SWIG_From_int((int)1));
4521    PyDict_SetItemString(d,"MGR_OBJ_JOB", SWIG_From_int((int)2));
4522    PyDict_SetItemString(d,"MGR_OBJ_NODE", SWIG_From_int((int)3));
4523    PyDict_SetItemString(d,"MSG_OUT", SWIG_From_int((int)1));
4524    PyDict_SetItemString(d,"MSG_ERR", SWIG_From_int((int)2));
4525    PyDict_SetItemString(d,"SHUT_SIG", SWIG_From_int((int)-1));
4526    PyDict_SetItemString(d,"SHUT_IMMEDIATE", SWIG_From_int((int)0));
4527    PyDict_SetItemString(d,"SHUT_DELAY", SWIG_From_int((int)1));
4528    PyDict_SetItemString(d,"SHUT_QUICK", SWIG_From_int((int)2));
4529    PyDict_SetItemString(d,"SIG_RESUME", SWIG_FromCharPtr("resume"));
4530    PyDict_SetItemString(d,"SIG_SUSPEND", SWIG_FromCharPtr("suspend"));
4531    PyDict_SetItemString(d,"PBS_MAXHOSTNAME", SWIG_From_int((int)64));
4532    PyDict_SetItemString(d,"MAXPATHLEN", SWIG_From_int((int)1024));
4533    PyDict_SetItemString(d,"MAXNAMLEN", SWIG_From_int((int)255));
4534    PyDict_SetItemString(d,"PBS_MAXUSER", SWIG_From_int((int)16));
4535    PyDict_SetItemString(d,"PBS_MAXGRPN", SWIG_From_int((int)16));
4536    PyDict_SetItemString(d,"PBS_MAXQUEUENAME", SWIG_From_int((int)15));
4537    PyDict_SetItemString(d,"PBS_MAXSERVERNAME", SWIG_From_int((int)64));
4538    PyDict_SetItemString(d,"PBS_MAXSEQNUM", SWIG_From_int((int)6));
4539    PyDict_SetItemString(d,"PBS_MAXPORTNUM", SWIG_From_int((int)5));
4540    PyDict_SetItemString(d,"PBS_MAXSVRJOBID", SWIG_From_int((int)(6+64+5+2)));
4541    PyDict_SetItemString(d,"PBS_MAXCLTJOBID", SWIG_From_int((int)((6+64+5+2) +64+5+2)));
4542    PyDict_SetItemString(d,"PBS_MAXDEST", SWIG_From_int((int)1024));
4543    PyDict_SetItemString(d,"PBS_MAXROUTEDEST", SWIG_From_int((int)(15+64+5+2)));
4544    PyDict_SetItemString(d,"PBS_USE_IFF", SWIG_From_int((int)1));
4545    PyDict_SetItemString(d,"PBS_INTERACTIVE", SWIG_From_int((int)1));
4546    PyDict_SetItemString(d,"PBS_TERM_BUF_SZ", SWIG_From_int((int)80));
4547    PyDict_SetItemString(d,"PBS_TERM_CCA", SWIG_From_int((int)6));
4548    PyDict_SetItemString(d,"PBS_BATCH_SERVICE_NAME", SWIG_FromCharPtr("pbs"));
4549    PyDict_SetItemString(d,"PBS_BATCH_SERVICE_PORT", SWIG_From_int((int)15001));
4550    PyDict_SetItemString(d,"PBS_BATCH_SERVICE_NAME_DIS", SWIG_FromCharPtr("pbs_dis"));
4551    PyDict_SetItemString(d,"PBS_BATCH_SERVICE_PORT_DIS", SWIG_From_int((int)15001));
4552    PyDict_SetItemString(d,"PBS_MOM_SERVICE_NAME", SWIG_FromCharPtr("pbs_mom"));
4553    PyDict_SetItemString(d,"PBS_MOM_SERVICE_PORT", SWIG_From_int((int)15002));
4554    PyDict_SetItemString(d,"PBS_MANAGER_SERVICE_NAME", SWIG_FromCharPtr("pbs_resmon"));
4555    PyDict_SetItemString(d,"PBS_MANAGER_SERVICE_PORT", SWIG_From_int((int)15003));
4556    PyDict_SetItemString(d,"PBS_SCHEDULER_SERVICE_NAME", SWIG_FromCharPtr("pbs_sched"));
4557    PyDict_SetItemString(d,"PBS_SCHEDULER_SERVICE_PORT", SWIG_From_int((int)15004));
4558    PyDict_SetItemString(d,"SET", SWIG_From_int((int)SET));
4559    PyDict_SetItemString(d,"UNSET", SWIG_From_int((int)UNSET));
4560    PyDict_SetItemString(d,"INCR", SWIG_From_int((int)INCR));
4561    PyDict_SetItemString(d,"DECR", SWIG_From_int((int)DECR));
4562    PyDict_SetItemString(d,"EQ", SWIG_From_int((int)EQ));
4563    PyDict_SetItemString(d,"NE", SWIG_From_int((int)NE));
4564    PyDict_SetItemString(d,"GE", SWIG_From_int((int)GE));
4565    PyDict_SetItemString(d,"GT", SWIG_From_int((int)GT));
4566    PyDict_SetItemString(d,"LE", SWIG_From_int((int)LE));
4567    PyDict_SetItemString(d,"LT", SWIG_From_int((int)LT));
4568    PyDict_SetItemString(d,"DFLT", SWIG_From_int((int)DFLT));
4569    PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
4570    SWIG_addvarlink(SWIG_globals,(char*)"pbs_errno",_wrap_pbs_errno_get, _wrap_pbs_errno_set);
4571    SWIG_addvarlink(SWIG_globals,(char*)"pbs_server",_wrap_pbs_server_get, _wrap_pbs_server_set);
4572    PyDict_SetItemString(d,"LOG_BUF_SIZE", SWIG_From_int((int)4096));
4573    SWIG_addvarlink(SWIG_globals,(char*)"log_event_mask",_wrap_log_event_mask_get, _wrap_log_event_mask_set);
4574    SWIG_addvarlink(SWIG_globals,(char*)"log_buffer",_wrap_log_buffer_get, _wrap_log_buffer_set);
4575    PyDict_SetItemString(d,"PBSEVENT_ERROR", SWIG_From_int((int)0x0001));
4576    PyDict_SetItemString(d,"PBSEVENT_SYSTEM", SWIG_From_int((int)0x0002));
4577    PyDict_SetItemString(d,"PBSEVENT_ADMIN", SWIG_From_int((int)0x0004));
4578    PyDict_SetItemString(d,"PBSEVENT_JOB", SWIG_From_int((int)0x0008));
4579    PyDict_SetItemString(d,"PBSEVENT_JOB_USAGE", SWIG_From_int((int)0x0010));
4580    PyDict_SetItemString(d,"PBSEVENT_SECURITY", SWIG_From_int((int)0x0020));
4581    PyDict_SetItemString(d,"PBSEVENT_SCHED", SWIG_From_int((int)0x0040));
4582    PyDict_SetItemString(d,"PBSEVENT_DEBUG", SWIG_From_int((int)0x0080));
4583    PyDict_SetItemString(d,"PBSEVENT_DEBUG2", SWIG_From_int((int)0x0100));
4584    PyDict_SetItemString(d,"PBSEVENT_FORCE", SWIG_From_int((int)0x8000));
4585    PyDict_SetItemString(d,"PBS_EVENTCLASS_SERVER", SWIG_From_int((int)1));
4586    PyDict_SetItemString(d,"PBS_EVENTCLASS_QUEUE", SWIG_From_int((int)2));
4587    PyDict_SetItemString(d,"PBS_EVENTCLASS_JOB", SWIG_From_int((int)3));
4588    PyDict_SetItemString(d,"PBS_EVENTCLASS_REQUEST", SWIG_From_int((int)4));
4589    PyDict_SetItemString(d,"PBS_EVENTCLASS_FILE", SWIG_From_int((int)5));
4590    PyDict_SetItemString(d,"PBS_EVENTCLASS_ACCT", SWIG_From_int((int)6));
4591    PyDict_SetItemString(d,"PBS_EVENTCLASS_NODE", SWIG_From_int((int)7));
4592    PyDict_SetItemString(d,"PBSEVENT_MASK", SWIG_From_int((int)0x01ff));
4593    SWIG_addvarlink(SWIG_globals,(char*)"msg_daemonname",_wrap_msg_daemonname_get, _wrap_msg_daemonname_set);
4594}
4595
Note: See TracBrowser for help on using the repository browser.