Context Navigation

source: trunk/src/pbs_wrap.c @ 144

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

src/pbs_wrap.c:

Turned off debugging

Property svn:keywords set to Id

File size: 175.8 KB

Line
1	/* ----------------------------------------------------------------------------
2	* This file was automatically generated by SWIG (http://www.swig.org).
3	* Version 1.3.24
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	#ifndef SWIG_TEMPLATE_DISAMBIGUATOR
14	# if defined(__SUNPRO_CC)
15	# define SWIG_TEMPLATE_DISAMBIGUATOR template
16	# else
17	# define SWIG_TEMPLATE_DISAMBIGUATOR
18	# endif
19	#endif
20
21
22	#include <Python.h>
23
24	/***********************************************************************
25	* swigrun.swg
26	*
27	* This file contains generic CAPI SWIG runtime support for pointer
28	* type checking.
29	*
30	************************************************************************/
31
32	/* This should only be incremented when either the layout of swig_type_info changes,
33	or for whatever reason, the runtime changes incompatibly */
34	#define SWIG_RUNTIME_VERSION "1"
35
36	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
37	#ifdef SWIG_TYPE_TABLE
38	#define SWIG_QUOTE_STRING(x) #x
39	#define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
40	#define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
41	#else
42	#define SWIG_TYPE_TABLE_NAME
43	#endif
44
45	#include <string.h>
46
47	#ifndef SWIGINLINE
48	#if defined(__cplusplus) \|\| (defined(__GNUC__) && !defined(__STRICT_ANSI__))
49	# define SWIGINLINE inline
50	#else
51	# define SWIGINLINE
52	#endif
53	#endif
54
55	/*
56	You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
57	creating a static or dynamic library from the swig runtime code.
58	In 99.9% of the cases, swig just needs to declare them as 'static'.
59
60	But only do this if is strictly necessary, ie, if you have problems
61	with your compiler or so.
62	*/
63	#ifndef SWIGRUNTIME
64	#define SWIGRUNTIME static
65	#endif
66	#ifndef SWIGRUNTIMEINLINE
67	#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
68	#endif
69
70	#ifdef __cplusplus
71	extern "C" {
72	#endif
73
74	typedef void (swig_converter_func)(void *);
75	typedef struct swig_type_info (swig_dycast_func)(void **);
76
77	typedef struct swig_type_info {
78	const char *name;
79	swig_converter_func converter;
80	const char *str;
81	void *clientdata;
82	swig_dycast_func dcast;
83	struct swig_type_info *next;
84	struct swig_type_info *prev;
85	} swig_type_info;
86
87	/*
88	Compare two type names skipping the space characters, therefore
89	"char" == "char " and "Class<int>" == "Class<int >", etc.
90
91	Return 0 when the two name types are equivalent, as in
92	strncmp, but skipping ' '.
93	*/
94	SWIGRUNTIME int
95	SWIG_TypeNameComp(const char f1, const char l1,
96	const char f2, const char l2) {
97	for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
98	while ((*f1 == ' ') && (f1 != l1)) ++f1;
99	while ((*f2 == ' ') && (f2 != l2)) ++f2;
100	if (f1 != f2) return f1 - f2;
101	}
102	return (l1 - f1) - (l2 - f2);
103	}
104
105	/*
106	Check type equivalence in a name list like <name1>\|<name2>\|...
107	*/
108	SWIGRUNTIME int
109	SWIG_TypeEquiv(const char nb, const char tb) {
110	int equiv = 0;
111	const char* te = tb + strlen(tb);
112	const char* ne = nb;
113	while (!equiv && *ne) {
114	for (nb = ne; *ne; ++ne) {
115	if (*ne == '\|') break;
116	}
117	equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
118	if (*ne) ++ne;
119	}
120	return equiv;
121	}
122
123	/*
124	Register a type mapping with the type-checking
125	*/
126	SWIGRUNTIME swig_type_info *
127	SWIG_TypeRegisterTL(swig_type_info *tl, swig_type_info ti) {
128	swig_type_info tc, head, ret, next;
129	/* Check to see if this type has already been registered */
130	tc = *tl;
131	while (tc) {
132	/* check simple type equivalence */
133	int typeequiv = (strcmp(tc->name, ti->name) == 0);
134	/* check full type equivalence, resolving typedefs */
135	if (!typeequiv) {
136	/* only if tc is not a typedef (no '\|' on it) */
137	if (tc->str && ti->str && !strstr(tc->str,"\|")) {
138	typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
139	}
140	}
141	if (typeequiv) {
142	/* Already exists in the table. Just add additional types to the list */
143	if (ti->clientdata) tc->clientdata = ti->clientdata;
144	head = tc;
145	next = tc->next;
146	goto l1;
147	}
148	tc = tc->prev;
149	}
150	head = ti;
151	next = 0;
152
153	/* Place in list */
154	ti->prev = *tl;
155	*tl = ti;
156
157	/* Build linked lists */
158	l1:
159	ret = head;
160	tc = ti + 1;
161	/* Patch up the rest of the links */
162	while (tc->name) {
163	head->next = tc;
164	tc->prev = head;
165	head = tc;
166	tc++;
167	}
168	if (next) next->prev = head;
169	head->next = next;
170
171	return ret;
172	}
173
174	/*
175	Check the typename
176	*/
177	SWIGRUNTIME swig_type_info *
178	SWIG_TypeCheck(const char c, swig_type_info ty) {
179	swig_type_info *s;
180	if (!ty) return 0; /* Void pointer */
181	s = ty->next; /* First element always just a name */
182	do {
183	if (strcmp(s->name,c) == 0) {
184	if (s == ty->next) return s;
185	/* Move s to the top of the linked list */
186	s->prev->next = s->next;
187	if (s->next) {
188	s->next->prev = s->prev;
189	}
190	/* Insert s as second element in the list */
191	s->next = ty->next;
192	if (ty->next) ty->next->prev = s;
193	ty->next = s;
194	s->prev = ty;
195	return s;
196	}
197	s = s->next;
198	} while (s && (s != ty->next));
199	return 0;
200	}
201
202	/*
203	Cast a pointer up an inheritance hierarchy
204	*/
205	SWIGRUNTIMEINLINE void *
206	SWIG_TypeCast(swig_type_info ty, void ptr) {
207	return ((!ty) \|\| (!ty->converter)) ? ptr : (*ty->converter)(ptr);
208	}
209
210	/*
211	Dynamic pointer casting. Down an inheritance hierarchy
212	*/
213	SWIGRUNTIME swig_type_info *
214	SWIG_TypeDynamicCast(swig_type_info ty, void *ptr) {
215	swig_type_info *lastty = ty;
216	if (!ty \|\| !ty->dcast) return ty;
217	while (ty && (ty->dcast)) {
218	ty = (*ty->dcast)(ptr);
219	if (ty) lastty = ty;
220	}
221	return lastty;
222	}
223
224	/*
225	Return the name associated with this type
226	*/
227	SWIGRUNTIMEINLINE const char *
228	SWIG_TypeName(const swig_type_info *ty) {
229	return ty->name;
230	}
231
232	/*
233	Return the pretty name associated with this type,
234	that is an unmangled type name in a form presentable to the user.
235	*/
236	SWIGRUNTIME const char *
237	SWIG_TypePrettyName(const swig_type_info *type) {
238	/* The "str" field contains the equivalent pretty names of the
239	type, separated by vertical-bar characters. We choose
240	to print the last name, as it is often (?) the most
241	specific. */
242	if (type->str != NULL) {
243	const char *last_name = type->str;
244	const char *s;
245	for (s = type->str; *s; s++)
246	if (*s == '\|') last_name = s+1;
247	return last_name;
248	}
249	else
250	return type->name;
251	}
252
253	/*
254	Search for a swig_type_info structure
255	*/
256	SWIGRUNTIME swig_type_info *
257	SWIG_TypeQueryTL(swig_type_info tl, const char name) {
258	swig_type_info *ty = tl;
259	while (ty) {
260	if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
261	if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
262	ty = ty->prev;
263	}
264	return 0;
265	}
266
267	/*
268	Set the clientdata field for a type
269	*/
270	SWIGRUNTIME void
271	SWIG_TypeClientDataTL(swig_type_info tl, swig_type_info ti, void *clientdata) {
272	swig_type_info tc, equiv;
273	if (ti->clientdata) return;
274	/* if (ti->clientdata == clientdata) return; */
275	ti->clientdata = clientdata;
276	equiv = ti->next;
277	while (equiv) {
278	if (!equiv->converter) {
279	tc = tl;
280	while (tc) {
281	if ((strcmp(tc->name, equiv->name) == 0))
282	SWIG_TypeClientDataTL(tl,tc,clientdata);
283	tc = tc->prev;
284	}
285	}
286	equiv = equiv->next;
287	}
288	}
289
290	/*
291	Pack binary data into a string
292	*/
293	SWIGRUNTIME char *
294	SWIG_PackData(char c, void ptr, size_t sz) {
295	static char hex[17] = "0123456789abcdef";
296	unsigned char u = (unsigned char ) ptr;
297	const unsigned char *eu = u + sz;
298	register unsigned char uu;
299	for (; u != eu; ++u) {
300	uu = *u;
301	*(c++) = hex[(uu & 0xf0) >> 4];
302	*(c++) = hex[uu & 0xf];
303	}
304	return c;
305	}
306
307	/*
308	Unpack binary data from a string
309	*/
310	SWIGRUNTIME const char *
311	SWIG_UnpackData(const char c, void ptr, size_t sz) {
312	register unsigned char u = (unsigned char ) ptr;
313	register const unsigned char *eu = u + sz;
314	for (; u != eu; ++u) {
315	register int d = *(c++);
316	register unsigned char uu = 0;
317	if ((d >= '0') && (d <= '9'))
318	uu = ((d - '0') << 4);
319	else if ((d >= 'a') && (d <= 'f'))
320	uu = ((d - ('a'-10)) << 4);
321	else
322	return (char *) 0;
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	else
329	return (char *) 0;
330	*u = uu;
331	}
332	return c;
333	}
334
335	/*
336	This function will propagate the clientdata field of type to any new
337	swig_type_info structures that have been added into the list of
338	equivalent types. It is like calling SWIG_TypeClientData(type,
339	clientdata) a second time.
340	*/
341	SWIGRUNTIME void
342	SWIG_PropagateClientDataTL(swig_type_info tl, swig_type_info type) {
343	swig_type_info *equiv = type->next;
344	swig_type_info *tc;
345	if (!type->clientdata) return;
346	while (equiv) {
347	if (!equiv->converter) {
348	tc = tl;
349	while (tc) {
350	if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
351	SWIG_TypeClientDataTL(tl,tc, type->clientdata);
352	tc = tc->prev;
353	}
354	}
355	equiv = equiv->next;
356	}
357	}
358
359	/*
360	Pack 'void *' into a string buffer.
361	*/
362	SWIGRUNTIME char *
363	SWIG_PackVoidPtr(char buff, void ptr, const char *name, size_t bsz) {
364	char *r = buff;
365	if ((2sizeof(void ) + 2) > bsz) return 0;
366	*(r++) = '_';
367	r = SWIG_PackData(r,&ptr,sizeof(void *));
368	if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
369	strcpy(r,name);
370	return buff;
371	}
372
373	SWIGRUNTIME const char *
374	SWIG_UnpackVoidPtr(const char c, void ptr, const char name) {
375	if (*c != '_') {
376	if (strcmp(c,"NULL") == 0) {
377	ptr = (void ) 0;
378	return name;
379	} else {
380	return 0;
381	}
382	}
383	return SWIG_UnpackData(++c,ptr,sizeof(void *));
384	}
385
386	SWIGRUNTIME char *
387	SWIG_PackDataName(char buff, void ptr, size_t sz, const char *name, size_t bsz) {
388	char *r = buff;
389	size_t lname = (name ? strlen(name) : 0);
390	if ((2*sz + 2 + lname) > bsz) return 0;
391	*(r++) = '_';
392	r = SWIG_PackData(r,ptr,sz);
393	if (lname) {
394	strncpy(r,name,lname+1);
395	} else {
396	*r = 0;
397	}
398	return buff;
399	}
400
401	SWIGRUNTIME const char *
402	SWIG_UnpackDataName(const char c, void ptr, size_t sz, const char *name) {
403	if (*c != '_') {
404	if (strcmp(c,"NULL") == 0) {
405	memset(ptr,0,sz);
406	return name;
407	} else {
408	return 0;
409	}
410	}
411	return SWIG_UnpackData(++c,ptr,sz);
412	}
413
414	#ifdef __cplusplus
415	}
416	#endif
417
418	/***********************************************************************
419	* common.swg
420	*
421	* This file contains generic SWIG runtime support for pointer
422	* type checking as well as a few commonly used macros to control
423	* external linkage.
424	*
425	* Author : David Beazley (beazley@cs.uchicago.edu)
426	*
427	* Copyright (c) 1999-2000, The University of Chicago
428	*
429	* This file may be freely redistributed without license or fee provided
430	* this copyright message remains intact.
431	************************************************************************/
432
433
434	#if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
435	# if !defined(STATIC_LINKED)
436	# define SWIGEXPORT(a) __declspec(dllexport) a
437	# else
438	# define SWIGEXPORT(a) a
439	# endif
440	#else
441	# define SWIGEXPORT(a) a
442	#endif
443
444	#ifdef __cplusplus
445	extern "C" {
446	#endif
447
448
449	/*************************************************************************/
450
451
452	/* The static type info list */
453
454	static swig_type_info *swig_type_list = 0;
455	static swig_type_info **swig_type_list_handle = &swig_type_list;
456
457
458	/* Register a type mapping with the type-checking */
459	static swig_type_info *
460	SWIG_TypeRegister(swig_type_info *ti) {
461	return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
462	}
463
464	/* Search for a swig_type_info structure */
465	static swig_type_info *
466	SWIG_TypeQuery(const char *name) {
467	return SWIG_TypeQueryTL(*swig_type_list_handle, name);
468	}
469
470	/* Set the clientdata field for a type */
471	static void
472	SWIG_TypeClientData(swig_type_info ti, void clientdata) {
473	SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
474	}
475
476	/* This function will propagate the clientdata field of type to
477	* any new swig_type_info structures that have been added into the list
478	* of equivalent types. It is like calling
479	* SWIG_TypeClientData(type, clientdata) a second time.
480	*/
481	static void
482	SWIG_PropagateClientData(swig_type_info *type) {
483	SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
484	}
485
486	#ifdef __cplusplus
487	}
488	#endif
489
490	/* -----------------------------------------------------------------------------
491	* SWIG API. Portion that goes into the runtime
492	* ----------------------------------------------------------------------------- */
493
494	#ifdef __cplusplus
495	extern "C" {
496	#endif
497
498	/* -----------------------------------------------------------------------------
499	* for internal method declarations
500	* ----------------------------------------------------------------------------- */
501
502	#ifndef SWIGINTERN
503	#define SWIGINTERN static
504	#endif
505
506	#ifndef SWIGINTERNSHORT
507	#ifdef __cplusplus
508	#define SWIGINTERNSHORT static inline
509	#else /* C case */
510	#define SWIGINTERNSHORT static
511	#endif /* __cplusplus */
512	#endif
513
514
515	/*
516	Exception handling in wrappers
517	*/
518	#define SWIG_fail goto fail
519	#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
520	#define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
521	#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
522	#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
523	#define SWIG_null_ref(type) SWIG_Python_NullRef(type)
524
525	/*
526	Contract support
527	*/
528	#define SWIG_contract_assert(expr, msg) \
529	if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
530
531	/* -----------------------------------------------------------------------------
532	* Constant declarations
533	* ----------------------------------------------------------------------------- */
534
535	/* Constant Types */
536	#define SWIG_PY_INT 1
537	#define SWIG_PY_FLOAT 2
538	#define SWIG_PY_STRING 3
539	#define SWIG_PY_POINTER 4
540	#define SWIG_PY_BINARY 5
541
542	/* Constant information structure */
543	typedef struct swig_const_info {
544	int type;
545	char *name;
546	long lvalue;
547	double dvalue;
548	void *pvalue;
549	swig_type_info **ptype;
550	} swig_const_info;
551
552
553	/* -----------------------------------------------------------------------------
554	* Alloc. memory flags
555	* ----------------------------------------------------------------------------- */
556	#define SWIG_OLDOBJ 1
557	#define SWIG_NEWOBJ SWIG_OLDOBJ + 1
558	#define SWIG_PYSTR SWIG_NEWOBJ + 1
559
560	#ifdef __cplusplus
561	}
562	#endif
563
564
565	/***********************************************************************
566	* pyrun.swg
567	*
568	* This file contains the runtime support for Python modules
569	* and includes code for managing global variables and pointer
570	* type checking.
571	*
572	* Author : David Beazley (beazley@cs.uchicago.edu)
573	************************************************************************/
574
575	/* Common SWIG API */
576	#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
577	#define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
578	#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
579
580
581	/* Python-specific SWIG API */
582	#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
583	#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
584
585
586	/* -----------------------------------------------------------------------------
587	* Pointer declarations
588	* ----------------------------------------------------------------------------- */
589	/*
590	Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
591	C/C++ pointers in the python side. Very useful for debugging, but
592	not always safe.
593	*/
594	#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
595	# define SWIG_COBJECT_TYPES
596	#endif
597
598	/* Flags for pointer conversion */
599	#define SWIG_POINTER_EXCEPTION 0x1
600	#define SWIG_POINTER_DISOWN 0x2
601
602
603	#ifdef __cplusplus
604	extern "C" {
605	#endif
606
607	/* -----------------------------------------------------------------------------
608	* Create a new pointer string
609	* ----------------------------------------------------------------------------- */
610
611	#ifndef SWIG_BUFFER_SIZE
612	#define SWIG_BUFFER_SIZE 1024
613	#endif
614
615	#if defined(SWIG_COBJECT_TYPES)
616	#if !defined(SWIG_COBJECT_PYTHON)
617	/* -----------------------------------------------------------------------------
618	* Implements a simple Swig Object type, and use it instead of PyCObject
619	* ----------------------------------------------------------------------------- */
620
621	typedef struct {
622	PyObject_HEAD
623	void *ptr;
624	const char *desc;
625	} PySwigObject;
626
627	/* Declarations for objects of type PySwigObject */
628
629	SWIGRUNTIME int
630	PySwigObject_print(PySwigObject v, FILE fp, int flags)
631	{
632	char result[SWIG_BUFFER_SIZE];
633	if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
634	fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
635	return 0;
636	} else {
637	return 1;
638	}
639	}
640
641	SWIGRUNTIME PyObject *
642	PySwigObject_repr(PySwigObject *v)
643	{
644	char result[SWIG_BUFFER_SIZE];
645	return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
646	PyString_FromFormat("<Swig Object at %s>", result) : 0;
647	}
648
649	SWIGRUNTIME PyObject *
650	PySwigObject_str(PySwigObject *v)
651	{
652	char result[SWIG_BUFFER_SIZE];
653	return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
654	PyString_FromString(result) : 0;
655	}
656
657	SWIGRUNTIME PyObject *
658	PySwigObject_long(PySwigObject *v)
659	{
660	return PyLong_FromUnsignedLong((unsigned long) v->ptr);
661	}
662
663	SWIGRUNTIME PyObject *
664	PySwigObject_oct(PySwigObject *v)
665	{
666	char buf[100];
667	unsigned long x = (unsigned long)v->ptr;
668	if (x == 0)
669	strcpy(buf, "0");
670	else
671	PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
672	return PyString_FromString(buf);
673	}
674
675	SWIGRUNTIME PyObject *
676	PySwigObject_hex(PySwigObject *v)
677	{
678	char buf[100];
679	PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
680	return PyString_FromString(buf);
681	}
682
683	SWIGRUNTIME int
684	PySwigObject_compare(PySwigObject v, PySwigObject w)
685	{
686	int c = strcmp(v->desc, w->desc);
687	if (c) {
688	return c;
689	} else {
690	void *i = v->ptr;
691	void *j = w->ptr;
692	return (i < j) ? -1 : (i > j) ? 1 : 0;
693	}
694	}
695
696	SWIGRUNTIME void
697	PySwigObject_dealloc(PySwigObject *self)
698	{
699	PyObject_DEL(self);
700	}
701
702	SWIGRUNTIME PyTypeObject*
703	PySwigObject_GetType() {
704	static char PySwigObject_Type__doc__[] =
705	"Swig object carries a C/C++ instance pointer";
706
707	static PyNumberMethods PySwigObject_as_number = {
708	(binaryfunc)0, /nb_add/
709	(binaryfunc)0, /nb_subtract/
710	(binaryfunc)0, /nb_multiply/
711	(binaryfunc)0, /nb_divide/
712	(binaryfunc)0, /nb_remainder/
713	(binaryfunc)0, /nb_divmod/
714	(ternaryfunc)0,/nb_power/
715	(unaryfunc)0, /nb_negative/
716	(unaryfunc)0, /nb_positive/
717	(unaryfunc)0, /nb_absolute/
718	(inquiry)0, /nb_nonzero/
719	0, /nb_invert/
720	0, /nb_lshift/
721	0, /nb_rshift/
722	0, /nb_and/
723	0, /nb_xor/
724	0, /nb_or/
725	(coercion)0, /nb_coerce/
726	(unaryfunc)PySwigObject_long, /nb_int/
727	(unaryfunc)PySwigObject_long, /nb_long/
728	(unaryfunc)0, /nb_float/
729	(unaryfunc)PySwigObject_oct, /nb_oct/
730	(unaryfunc)PySwigObject_hex, /nb_hex/
731	#if PY_VERSION_HEX >= 0x02000000
732	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
733	#endif
734	};
735
736	static int type_init = 0;
737	static PyTypeObject PySwigObject_Type;
738
739	if (!type_init) {
740	PyTypeObject tmp = {
741	PyObject_HEAD_INIT(&PyType_Type)
742	0, /ob_size/
743	"PySwigObject", /tp_name/
744	sizeof(PySwigObject), /tp_basicsize/
745	0, /tp_itemsize/
746	/* methods */
747	(destructor)PySwigObject_dealloc, /tp_dealloc/
748	(printfunc)PySwigObject_print, /tp_print/
749	(getattrfunc)0, /tp_getattr/
750	(setattrfunc)0, /tp_setattr/
751	(cmpfunc)PySwigObject_compare, /tp_compare/
752	(reprfunc)PySwigObject_repr, /tp_repr/
753	&PySwigObject_as_number, /tp_as_number/
754	0, /tp_as_sequence/
755	0, /tp_as_mapping/
756	(hashfunc)0, /tp_hash/
757	(ternaryfunc)0, /tp_call/
758	(reprfunc)PySwigObject_str, /tp_str/
759	/* Space for future expansion */
760	0L,0L,0L,0L,
761	PySwigObject_Type__doc__, /* Documentation string */
762	#if PY_VERSION_HEX >= 0x02000000
763	0, /* tp_traverse */
764	0, /* tp_clear */
765	#endif
766	#if PY_VERSION_HEX >= 0x02010000
767	0, /* tp_richcompare */
768	0, /* tp_weaklistoffset */
769	#endif
770	#if PY_VERSION_HEX >= 0x02020000
771	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
772	#endif
773	#if PY_VERSION_HEX >= 0x02030000
774	0, /* tp_del */
775	#endif
776	#ifdef COUNT_ALLOCS
777	0,0,0,0 /* tp_alloc -> tp_next */
778	#endif
779	};
780
781	PySwigObject_Type = tmp;
782	type_init = 1;
783	}
784
785	return &PySwigObject_Type;
786	}
787
788	SWIGRUNTIME PyObject *
789	PySwigObject_FromVoidPtrAndDesc(void ptr, const char desc)
790	{
791	PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
792	if (self == NULL) return NULL;
793	self->ptr = ptr;
794	self->desc = desc;
795	return (PyObject *)self;
796	}
797
798	SWIGRUNTIMEINLINE void *
799	PySwigObject_AsVoidPtr(PyObject *self)
800	{
801	return ((PySwigObject *)self)->ptr;
802	}
803
804	SWIGRUNTIMEINLINE const char *
805	PySwigObject_GetDesc(PyObject *self)
806	{
807	return ((PySwigObject *)self)->desc;
808	}
809
810	SWIGRUNTIMEINLINE int
811	PySwigObject_Check(PyObject *op) {
812	return ((op)->ob_type == PySwigObject_GetType())
813	\|\| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
814	}
815
816	/* -----------------------------------------------------------------------------
817	* Implements a simple Swig Packed type, and use it instead of string
818	* ----------------------------------------------------------------------------- */
819
820	typedef struct {
821	PyObject_HEAD
822	void *pack;
823	const char *desc;
824	size_t size;
825	} PySwigPacked;
826
827	SWIGRUNTIME int
828	PySwigPacked_print(PySwigPacked v, FILE fp, int flags)
829	{
830	char result[SWIG_BUFFER_SIZE];
831	fputs("<Swig Packed ", fp);
832	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
833	fputs("at ", fp);
834	fputs(result, fp);
835	}
836	fputs(v->desc,fp);
837	fputs(">", fp);
838	return 0;
839	}
840
841	SWIGRUNTIME PyObject *
842	PySwigPacked_repr(PySwigPacked *v)
843	{
844	char result[SWIG_BUFFER_SIZE];
845	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
846	return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
847	} else {
848	return PyString_FromFormat("<Swig Packed %s>", v->desc);
849	}
850	}
851
852	SWIGRUNTIME PyObject *
853	PySwigPacked_str(PySwigPacked *v)
854	{
855	char result[SWIG_BUFFER_SIZE];
856	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
857	return PyString_FromFormat("%s%s", result, v->desc);
858	} else {
859	return PyString_FromFormat("%s", v->desc);
860	}
861	}
862
863	SWIGRUNTIME int
864	PySwigPacked_compare(PySwigPacked v, PySwigPacked w)
865	{
866	int c = strcmp(v->desc, w->desc);
867	if (c) {
868	return c;
869	} else {
870	size_t i = v->size;
871	size_t j = w->size;
872	int s = (i < j) ? -1 : (i > j) ? 1 : 0;
873	return s ? s : strncmp((char )v->pack, (char )w->pack, 2*v->size);
874	}
875	}
876
877	SWIGRUNTIME void
878	PySwigPacked_dealloc(PySwigPacked *self)
879	{
880	free(self->pack);
881	PyObject_DEL(self);
882	}
883
884	SWIGRUNTIME PyTypeObject*
885	PySwigPacked_GetType() {
886	static char PySwigPacked_Type__doc__[] =
887	"Swig object carries a C/C++ instance pointer";
888	static int type_init = 0;
889
890	static PyTypeObject PySwigPacked_Type;
891	if (!type_init) {
892	PyTypeObject tmp = {
893	PyObject_HEAD_INIT(&PyType_Type)
894	0, /ob_size/
895	"PySwigPacked", /tp_name/
896	sizeof(PySwigPacked), /tp_basicsize/
897	0, /tp_itemsize/
898	/* methods */
899	(destructor)PySwigPacked_dealloc, /tp_dealloc/
900	(printfunc)PySwigPacked_print, /tp_print/
901	(getattrfunc)0, /tp_getattr/
902	(setattrfunc)0, /tp_setattr/
903	(cmpfunc)PySwigPacked_compare, /tp_compare/
904	(reprfunc)PySwigPacked_repr, /tp_repr/
905	0, /tp_as_number/
906	0, /tp_as_sequence/
907	0, /tp_as_mapping/
908	(hashfunc)0, /tp_hash/
909	(ternaryfunc)0, /tp_call/
910	(reprfunc)PySwigPacked_str, /tp_str/
911	/* Space for future expansion */
912	0L,0L,0L,0L,
913	PySwigPacked_Type__doc__, /* Documentation string */
914	#if PY_VERSION_HEX >= 0x02000000
915	0, /* tp_traverse */
916	0, /* tp_clear */
917	#endif
918	#if PY_VERSION_HEX >= 0x02010000
919	0, /* tp_richcompare */
920	0, /* tp_weaklistoffset */
921	#endif
922	#if PY_VERSION_HEX >= 0x02020000
923	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
924	#endif
925	#if PY_VERSION_HEX >= 0x02030000
926	0, /* tp_del */
927	#endif
928	#ifdef COUNT_ALLOCS
929	0,0,0,0 /* tp_alloc -> tp_next */
930	#endif
931	};
932
933	PySwigPacked_Type = tmp;
934	type_init = 1;
935	}
936
937
938
939	return &PySwigPacked_Type;
940	}
941
942	SWIGRUNTIME PyObject *
943	PySwigPacked_FromDataAndDesc(void ptr, size_t size, const char desc)
944	{
945	PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
946	if (self == NULL) {
947	return NULL;
948	} else {
949	void *pack = malloc(size);
950	memcpy(pack, ptr, size);
951	self->pack = pack;
952	self->desc = desc;
953	self->size = size;
954	return (PyObject *) self;
955	}
956	}
957
958	SWIGRUNTIMEINLINE const char *
959	PySwigPacked_UnpackData(PyObject obj, void ptr, size_t size)
960	{
961	PySwigPacked self = (PySwigPacked )obj;
962	if (self->size != size) return 0;
963	memcpy(ptr, self->pack, size);
964	return self->desc;
965	}
966
967	SWIGRUNTIMEINLINE const char *
968	PySwigPacked_GetDesc(PyObject *self)
969	{
970	return ((PySwigPacked *)self)->desc;
971	}
972
973	SWIGRUNTIMEINLINE int
974	PySwigPacked_Check(PyObject *op) {
975	return ((op)->ob_type == PySwigPacked_GetType())
976	\|\| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
977	}
978
979	#else
980	/* -----------------------------------------------------------------------------
981	* Use the old Python PyCObject instead of PySwigObject
982	* ----------------------------------------------------------------------------- */
983
984	#define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
985	#define PySwigObject_Check(obj) PyCObject_Check(obj)
986	#define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
987	#define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
988
989	#endif
990
991	#endif
992
993	/* -----------------------------------------------------------------------------
994	* errors manipulation
995	* ----------------------------------------------------------------------------- */
996
997	SWIGRUNTIME void
998	SWIG_Python_TypeError(const char type, PyObject obj)
999	{
1000	if (type) {
1001	#if defined(SWIG_COBJECT_TYPES)
1002	if (PySwigObject_Check(obj)) {
1003	const char otype = (const char ) PySwigObject_GetDesc(obj);
1004	if (otype) {
1005	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1006	type, otype);
1007	return;
1008	}
1009	} else
1010	#endif
1011	{
1012	const char *otype = (obj ? obj->ob_type->tp_name : 0);
1013	if (otype) {
1014	PyObject *str = PyObject_Str(obj);
1015	const char *cstr = str ? PyString_AsString(str) : 0;
1016	if (cstr) {
1017	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1018	type, otype, cstr);
1019	} else {
1020	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1021	type, otype);
1022	}
1023	Py_DECREF(str);
1024	return;
1025	}
1026	}
1027	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1028	} else {
1029	PyErr_Format(PyExc_TypeError, "unexpected type is received");
1030	}
1031	}
1032
1033	SWIGRUNTIMEINLINE void
1034	SWIG_Python_NullRef(const char *type)
1035	{
1036	if (type) {
1037	PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1038	} else {
1039	PyErr_Format(PyExc_TypeError, "null reference was received");
1040	}
1041	}
1042
1043	SWIGRUNTIME int
1044	SWIG_Python_AddErrMesg(const char* mesg, int infront)
1045	{
1046	if (PyErr_Occurred()) {
1047	PyObject *type = 0;
1048	PyObject *value = 0;
1049	PyObject *traceback = 0;
1050	PyErr_Fetch(&type, &value, &traceback);
1051	if (value) {
1052	PyObject *old_str = PyObject_Str(value);
1053	Py_XINCREF(type);
1054	PyErr_Clear();
1055	if (infront) {
1056	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1057	} else {
1058	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1059	}
1060	Py_DECREF(old_str);
1061	}
1062	return 1;
1063	} else {
1064	return 0;
1065	}
1066	}
1067
1068	SWIGRUNTIME int
1069	SWIG_Python_ArgFail(int argnum)
1070	{
1071	if (PyErr_Occurred()) {
1072	/* add information about failing argument */
1073	char mesg[256];
1074	sprintf(mesg, "argument number %d:", argnum);
1075	return SWIG_Python_AddErrMesg(mesg, 1);
1076	} else {
1077	return 0;
1078	}
1079	}
1080
1081
1082	/* -----------------------------------------------------------------------------
1083	* pointers/data manipulation
1084	* ----------------------------------------------------------------------------- */
1085
1086	/* Convert a pointer value */
1087	SWIGRUNTIME int
1088	SWIG_Python_ConvertPtr(PyObject obj, void ptr, swig_type_info ty, int flags) {
1089	swig_type_info *tc;
1090	const char *c = 0;
1091	static PyObject *SWIG_this = 0;
1092	int newref = 0;
1093	PyObject *pyobj = 0;
1094	void *vptr;
1095
1096	if (!obj) return 0;
1097	if (obj == Py_None) {
1098	*ptr = 0;
1099	return 0;
1100	}
1101
1102	#ifdef SWIG_COBJECT_TYPES
1103	if (!(PySwigObject_Check(obj))) {
1104	if (!SWIG_this)
1105	SWIG_this = PyString_FromString("this");
1106	pyobj = obj;
1107	obj = PyObject_GetAttr(obj,SWIG_this);
1108	newref = 1;
1109	if (!obj) goto type_error;
1110	if (!PySwigObject_Check(obj)) {
1111	Py_DECREF(obj);
1112	goto type_error;
1113	}
1114	}
1115	vptr = PySwigObject_AsVoidPtr(obj);
1116	c = (const char *) PySwigObject_GetDesc(obj);
1117	if (newref) { Py_DECREF(obj); }
1118	goto type_check;
1119	#else
1120	if (!(PyString_Check(obj))) {
1121	if (!SWIG_this)
1122	SWIG_this = PyString_FromString("this");
1123	pyobj = obj;
1124	obj = PyObject_GetAttr(obj,SWIG_this);
1125	newref = 1;
1126	if (!obj) goto type_error;
1127	if (!PyString_Check(obj)) {
1128	Py_DECREF(obj);
1129	goto type_error;
1130	}
1131	}
1132	c = PyString_AS_STRING(obj);
1133	/* Pointer values must start with leading underscore */
1134	c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1135	if (newref) { Py_DECREF(obj); }
1136	if (!c) goto type_error;
1137	#endif
1138
1139	type_check:
1140
1141	if (ty) {
1142	tc = SWIG_TypeCheck(c,ty);
1143	if (!tc) goto type_error;
1144	*ptr = SWIG_TypeCast(tc,vptr);
1145	} else {
1146	*ptr = vptr;
1147	}
1148
1149	if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1150	PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1151	}
1152	return 0;
1153
1154	type_error:
1155	PyErr_Clear();
1156	if (pyobj && !obj) {
1157	obj = pyobj;
1158	if (PyCFunction_Check(obj)) {
1159	/* here we get the method pointer for callbacks */
1160	char doc = (((PyCFunctionObject )obj) -> m_ml -> ml_doc);
1161	c = doc ? strstr(doc, "swig_ptr: ") : 0;
1162	if (c) {
1163	c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1164	if (!c) goto type_error;
1165	goto type_check;
1166	}
1167	}
1168	}
1169	if (flags & SWIG_POINTER_EXCEPTION) {
1170	if (ty) {
1171	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1172	} else {
1173	SWIG_Python_TypeError("C/C++ pointer", obj);
1174	}
1175	}
1176	return -1;
1177	}
1178
1179	/* Convert a pointer value, signal an exception on a type mismatch */
1180	SWIGRUNTIME void *
1181	SWIG_Python_MustGetPtr(PyObject obj, swig_type_info ty, int argnum, int flags) {
1182	void *result;
1183	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1184	PyErr_Clear();
1185	if (flags & SWIG_POINTER_EXCEPTION) {
1186	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1187	SWIG_Python_ArgFail(argnum);
1188	}
1189	}
1190	return result;
1191	}
1192
1193	/* Convert a packed value value */
1194	SWIGRUNTIME int
1195	SWIG_Python_ConvertPacked(PyObject obj, void ptr, size_t sz, swig_type_info *ty, int flags) {
1196	swig_type_info *tc;
1197	const char *c = 0;
1198
1199	#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1200	c = PySwigPacked_UnpackData(obj, ptr, sz);
1201	#else
1202	if ((!obj) \|\| (!PyString_Check(obj))) goto type_error;
1203	c = PyString_AS_STRING(obj);
1204	/* Pointer values must start with leading underscore */
1205	c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1206	#endif
1207	if (!c) goto type_error;
1208	if (ty) {
1209	tc = SWIG_TypeCheck(c,ty);
1210	if (!tc) goto type_error;
1211	}
1212	return 0;
1213
1214	type_error:
1215	PyErr_Clear();
1216	if (flags & SWIG_POINTER_EXCEPTION) {
1217	if (ty) {
1218	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1219	} else {
1220	SWIG_Python_TypeError("C/C++ packed data", obj);
1221	}
1222	}
1223	return -1;
1224	}
1225
1226	/* Create a new array object */
1227	SWIGRUNTIME PyObject *
1228	SWIG_Python_NewPointerObj(void ptr, swig_type_info type, int own) {
1229	PyObject *robj = 0;
1230	if (!ptr) {
1231	Py_INCREF(Py_None);
1232	return Py_None;
1233	}
1234	#ifdef SWIG_COBJECT_TYPES
1235	robj = PySwigObject_FromVoidPtrAndDesc((void ) ptr, (char )type->name);
1236	#else
1237	{
1238	char result[SWIG_BUFFER_SIZE];
1239	robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1240	PyString_FromString(result) : 0;
1241	}
1242	#endif
1243	if (!robj \|\| (robj == Py_None)) return robj;
1244	if (type->clientdata) {
1245	PyObject *inst;
1246	PyObject args = Py_BuildValue((char)"(O)", robj);
1247	Py_DECREF(robj);
1248	inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1249	Py_DECREF(args);
1250	if (inst) {
1251	if (own) {
1252	PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1253	}
1254	robj = inst;
1255	}
1256	}
1257	return robj;
1258	}
1259
1260	SWIGRUNTIME PyObject *
1261	SWIG_Python_NewPackedObj(void ptr, size_t sz, swig_type_info type) {
1262	PyObject *robj = 0;
1263	if (!ptr) {
1264	Py_INCREF(Py_None);
1265	return Py_None;
1266	}
1267	#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1268	robj = PySwigPacked_FromDataAndDesc((void ) ptr, sz, (char )type->name);
1269	#else
1270	{
1271	char result[SWIG_BUFFER_SIZE];
1272	robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1273	PyString_FromString(result) : 0;
1274	}
1275	#endif
1276	return robj;
1277	}
1278
1279	/* -----------------------------------------------------------------------------*
1280	* Get type list
1281	* -----------------------------------------------------------------------------*/
1282
1283	#ifdef SWIG_LINK_RUNTIME
1284	void SWIG_ReturnGlobalTypeList(void );
1285	#endif
1286
1287	SWIGRUNTIME swig_type_info **
1288	SWIG_Python_GetTypeListHandle() {
1289	static void type_pointer = (void )0;
1290	/* first check if module already created */
1291	if (!type_pointer) {
1292	#ifdef SWIG_LINK_RUNTIME
1293	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1294	#else
1295	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1296	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1297	if (PyErr_Occurred()) {
1298	PyErr_Clear();
1299	type_pointer = (void *)0;
1300	}
1301	}
1302	#endif
1303	return (swig_type_info **) type_pointer;
1304	}
1305
1306	/*
1307	Search for a swig_type_info structure
1308	*/
1309	SWIGRUNTIMEINLINE swig_type_info *
1310	SWIG_Python_GetTypeList() {
1311	swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1312	return tlh ? tlh : (swig_type_info)0;
1313	}
1314
1315	#define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1316
1317	#ifdef __cplusplus
1318	}
1319	#endif
1320
1321
1322	/* -------- TYPES TABLE (BEGIN) -------- */
1323
1324	#define SWIGTYPE_p_batch_status swig_types[0]
1325	#define SWIGTYPE_p_char swig_types[1]
1326	#define SWIGTYPE_p_attropl swig_types[2]
1327	#define SWIGTYPE_p_p_char swig_types[3]
1328	#define SWIGTYPE_size_t swig_types[4]
1329	#define SWIGTYPE_p_attrl swig_types[5]
1330	#define SWIGTYPE_p_long swig_types[6]
1331	#define SWIGTYPE_ptrdiff_t swig_types[7]
1332	#define SWIGTYPE_p_int swig_types[8]
1333	static swig_type_info *swig_types[10];
1334
1335	/* -------- TYPES TABLE (END) -------- */
1336
1337
1338	/*-----------------------------------------------
1339	@(target):= _pbs.so
1340	------------------------------------------------*/
1341	#define SWIG_init init_pbs
1342
1343	#define SWIG_name "_pbs"
1344
1345
1346	#include "pbs_ifl.h"
1347	#include "pbs_error.h"
1348	#include "rm.h"
1349	#include "log.h"
1350
1351	#define SARA_DEBUG 0
1352
1353	//extern int pbs_errno;
1354
1355
1356
1357	int Get_List_Size(PyObject *src)
1358	{
1359	if (PyList_Check(src))
1360	return(PyList_Size(src));
1361
1362	/* check if valid NULL pointer */
1363	if ( PyString_Check(src) ) {
1364	if ( ! strcmp(PyString_AsString(src), "NULL") )
1365	return(0);
1366	}
1367	return(-1);
1368
1369	} // end Get_List_Size()
1370
1371
1372
1373
1374	// The default constructor for struct attrl
1375	//
1376	struct attrl *new_attrl(int number)
1377	{
1378	struct attrl *ptr;
1379	struct attrl prev, current;
1380	int i;
1381
1382	/*
1383	allocate memory as a one block is handy for Python scripts
1384	and fill in the next fields so it also works for the C-library
1385	*/
1386	ptr = (struct attrl ) malloc(number sizeof(struct attrl));
1387
1388	prev = NULL;
1389	current = ptr + (number - 1);
1390	for (i=0; i < number; i++)
1391	{
1392	// printf("constructor called\n");
1393	current->name = (char ) malloc(MAXNAMLEN sizeof(char));
1394	current->resource = (char ) malloc(MAXNAMLEN sizeof(char));
1395	current->value = (char ) malloc(MAXNAMLEN sizeof(char));
1396
1397	bzero( (void*) current->name, sizeof(current->name));
1398	bzero( (void*) current->resource, sizeof(current->resource));
1399	bzero( (void*) current->value, sizeof(current->value));
1400
1401	current->next = prev;
1402	prev = current;
1403	current--;
1404	}
1405	return (struct attrl *)ptr;
1406
1407	} // end new_attrl()
1408
1409
1410	// The default constructor for struct attropl
1411	//
1412	struct attropl *new_attropl(int number)
1413	{
1414	struct attropl *ptr;
1415	struct attropl prev, current;
1416	int i;
1417
1418	/*
1419	allocate memory as a one block is handy for Python scripts
1420	and fill in the next fields so it also works for the C-library
1421	*/
1422	ptr = (struct attropl ) malloc(number sizeof(struct attropl));
1423
1424	prev = NULL;
1425	current = ptr + (number - 1);
1426	for (i=0; i < number; i++)
1427	{
1428	// printf("constructor called\n");
1429	current->name = (char ) malloc(MAXNAMLEN sizeof(char));
1430	current->resource = (char ) malloc(MAXNAMLEN sizeof(char));
1431	current->value = (char ) malloc(MAXNAMLEN sizeof(char));
1432
1433	bzero( (void*) current->name, sizeof(current->name));
1434	bzero( (void*) current->resource, sizeof(current->resource));
1435	bzero( (void*) current->value, sizeof(current->value));
1436	current->op = 0;
1437
1438	current->next = prev;
1439	prev = current;
1440	current--;
1441	}
1442	return (struct attropl *)ptr;
1443
1444	} // end new_attropl()
1445
1446	/* Not used only returned */
1447	struct batch_status *new_batch_status()
1448	{
1449	struct batch_status *ptr;
1450
1451	ptr = (struct batch_status *) malloc(sizeof(struct batch_status));
1452	return (struct batch_status *)ptr;
1453	} // end new struct batch_status
1454
1455	int get_error()
1456	{
1457	char *errmsg;
1458
1459	errmsg = pbse_to_txt(pbs_errno);
1460	if (SARA_DEBUG)
1461	{
1462	printf("Bas = %d\n", pbs_errno);
1463	printf("Bas = %d, text = %s\n", pbs_errno, errmsg);
1464	}
1465	return (pbs_errno);
1466	}
1467
1468
1469
1470
1471	#include <limits.h>
1472
1473
1474	SWIGINTERN int
1475	SWIG_CheckLongInRange(long value, long min_value, long max_value,
1476	const char *errmsg)
1477	{
1478	if (value < min_value) {
1479	if (errmsg) {
1480	PyErr_Format(PyExc_OverflowError,
1481	"value %ld is less than '%s' minimum %ld",
1482	value, errmsg, min_value);
1483	}
1484	return 0;
1485	} else if (value > max_value) {
1486	if (errmsg) {
1487	PyErr_Format(PyExc_OverflowError,
1488	"value %ld is greater than '%s' maximum %ld",
1489	value, errmsg, max_value);
1490	}
1491	return 0;
1492	}
1493	return 1;
1494	}
1495
1496
1497	SWIGINTERN int
1498	SWIG_AsVal_long(PyObject * obj, long* val)
1499	{
1500	if (PyInt_Check(obj)) {
1501	if (val) *val = PyInt_AS_LONG(obj);
1502	return 1;
1503	}
1504	if (PyLong_Check(obj)) {
1505	long v = PyLong_AsLong(obj);
1506	if (!PyErr_Occurred()) {
1507	if (val) *val = v;
1508	return 1;
1509	} else {
1510	if (!val) PyErr_Clear();
1511	return 0;
1512	}
1513	}
1514	if (val) {
1515	SWIG_type_error("long", obj);
1516	}
1517	return 0;
1518	}
1519
1520
1521	#if INT_MAX != LONG_MAX
1522	SWIGINTERN int
1523	SWIG_AsVal_int(PyObject obj, int val)
1524	{
1525	const char* errmsg = val ? "int" : (char*)0;
1526	long v;
1527	if (SWIG_AsVal_long(obj, &v)) {
1528	if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1529	if (val) *val = (int)(v);
1530	return 1;
1531	} else {
1532	return 0;
1533	}
1534	} else {
1535	PyErr_Clear();
1536	}
1537	if (val) {
1538	SWIG_type_error(errmsg, obj);
1539	}
1540	return 0;
1541	}
1542	#else
1543	SWIGINTERNSHORT int
1544	SWIG_AsVal_int(PyObject obj, int val)
1545	{
1546	return SWIG_AsVal_long(obj,(long*)val);
1547	}
1548	#endif
1549
1550
1551	SWIGINTERNSHORT int
1552	SWIG_As_int(PyObject* obj)
1553	{
1554	int v;
1555	if (!SWIG_AsVal_int(obj, &v)) {
1556	/*
1557	this is needed to make valgrind/purify happier.
1558	*/
1559	memset((void*)&v, 0, sizeof(int));
1560	}
1561	return v;
1562	}
1563
1564
1565	SWIGINTERNSHORT int
1566	SWIG_Check_int(PyObject* obj)
1567	{
1568	return SWIG_AsVal_int(obj, (int*)0);
1569	}
1570
1571
1572	/@/usr/share/swig1.3/python/pymacros.swg,66,SWIG_define@/
1573	#define SWIG_From_int PyInt_FromLong
1574	/@@/
1575
1576
1577	SWIGINTERN PyObject *
1578	SWIG_FromCharPtr(const char* cptr)
1579	{
1580	if (cptr) {
1581	size_t size = strlen(cptr);
1582	if (size > INT_MAX) {
1583	return SWIG_NewPointerObj((char*)(cptr),
1584	SWIG_TypeQuery("char *"), 0);
1585	} else {
1586	if (size != 0) {
1587	return PyString_FromStringAndSize(cptr, size);
1588	} else {
1589	return PyString_FromString(cptr);
1590	}
1591	}
1592	}
1593	Py_INCREF(Py_None);
1594	return Py_None;
1595	}
1596
1597
1598	/* returns SWIG_OLDOBJ if the input is a raw char, SWIG_PYSTR if is a PyString /
1599	SWIGINTERN int
1600	SWIG_AsCharPtrAndSize(PyObject obj, char* cptr, size_t* psize)
1601	{
1602	static swig_type_info* pchar_info = 0;
1603	char* vptr = 0;
1604	if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1605	if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1606	if (cptr) *cptr = vptr;
1607	if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1608	return SWIG_OLDOBJ;
1609	} else {
1610	PyErr_Clear();
1611	if (PyString_Check(obj)) {
1612	if (cptr) {
1613	*cptr = PyString_AS_STRING(obj);
1614	if (psize) {
1615	*psize = PyString_GET_SIZE(obj) + 1;
1616	}
1617	}
1618	return SWIG_PYSTR;
1619	}
1620	}
1621	if (cptr) {
1622	SWIG_type_error("char *", obj);
1623	}
1624	return 0;
1625	}
1626
1627
1628	SWIGINTERNSHORT int
1629	SWIG_AsCharPtr(PyObject obj, char *val)
1630	{
1631	if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
1632	return 1;
1633	}
1634	if (val) {
1635	PyErr_Clear();
1636	SWIG_type_error("char *", obj);
1637	}
1638	return 0;
1639	}
1640
1641	static char attrl___str__(struct attrl self){
1642	static char temp[4 * 255] ;
1643	snprintf(temp, sizeof(temp), "(%s,%s,%s)",
1644	self->name, self->resource, self->value);
1645
1646	return &temp[0];
1647	}
1648	static char attropl___str__(struct attropl self){
1649	static char temp[4 * 255] ;
1650	snprintf(temp, sizeof(temp), "(%s,%s,%s)",
1651	self->name, self->resource, self->value);
1652
1653	return &temp[0];
1654	}
1655	extern int pbs_errno;
1656	extern char *pbs_server;
1657
1658	SWIGINTERN int
1659	SWIG_AsNewCharPtr(PyObject obj, char *val)
1660	{
1661	char* cptr = 0; size_t csize = 0;
1662	int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize);
1663	if (res) {
1664	if (val) {
1665	if (csize) {
1666	val = ((char) malloc((csize)*sizeof(char)));
1667	memcpy(*val, cptr, --csize);
1668	(*val)[csize] = 0;
1669	} else if (cptr) {
1670	val = ((char) malloc((1)*sizeof(char)));
1671	(*val)[0] = 0;
1672	} else {
1673	*val = 0;
1674	}
1675	}
1676	return SWIG_NEWOBJ;
1677	}
1678	if (val) {
1679	SWIG_type_error("char *", obj);
1680	}
1681	return 0;
1682	}
1683
1684	char avail(int,char );
1685	int pbs_asyrunjob(int,char ,char ,char *);
1686	int pbs_alterjob(int,char ,struct attrl ,char *);
1687	int pbs_connect(char *);
1688	int pbs_query_max_connections();
1689	char *pbs_default(void);
1690	int pbs_deljob(int,char ,char );
1691	int pbs_disconnect(int);
1692	int pbs_holdjob(int,char ,char ,char *);
1693	char pbs_locjob(int,char ,char *);
1694	int pbs_manager(int,int,int,char ,struct attropl ,char *);
1695	int pbs_movejob(int,char ,char ,char *);
1696	int pbs_msgjob(int,char ,int,char ,char *);
1697	int pbs_orderjob(int,char ,char ,char *);
1698	int pbs_rescquery(int,char *,int,int ,int ,int ,int *);
1699
1700	SWIGINTERN PyObject*
1701	t_output_helper(PyObject* target, PyObject* o) {
1702	if (!target) {
1703	target = o;
1704	} else if (target == Py_None) {
1705	Py_DECREF(target);
1706	target = o;
1707	} else {
1708	if (!PyList_Check(target)) {
1709	PyObject *o2 = target;
1710	target = PyList_New(1);
1711	PyList_SetItem(target, 0, o2);
1712	}
1713	PyList_Append(target,o);
1714	}
1715	return target;
1716	}
1717
1718
1719	int pbs_rescreserve(int,char *,int,int );
1720	int pbs_rescrelease(int,int);
1721	int pbs_rerunjob(int,char ,char );
1722	int pbs_rlsjob(int,char ,char ,char *);
1723	int pbs_runjob(int,char ,char ,char *);
1724	char *pbs_selectjob(int,struct attropl ,char *);
1725	int pbs_sigjob(int,char ,char ,char *);
1726	void pbs_statfree(struct batch_status *);
1727	struct batch_status pbs_statjob(int,char ,struct attrl ,char );
1728	struct batch_status pbs_selstat(int,struct attropl ,char *);
1729	struct batch_status pbs_statque(int,char ,struct attrl ,char );
1730	struct batch_status pbs_statserver(int,struct attrl ,char *);
1731	struct batch_status pbs_statnode(int,char ,struct attrl ,char );
1732	char pbs_submit(int,struct attropl ,char ,char ,char *);
1733	int pbs_terminate(int,int,char *);
1734	int totpool(int,int);
1735	int usepool(int,int);
1736
1737	SWIGINTERNSHORT int
1738	SWIG_CheckUnsignedLongInRange(unsigned long value,
1739	unsigned long max_value,
1740	const char *errmsg)
1741	{
1742	if (value > max_value) {
1743	if (errmsg) {
1744	PyErr_Format(PyExc_OverflowError,
1745	"value %lu is greater than '%s' minimum %lu",
1746	value, errmsg, max_value);
1747	}
1748	return 0;
1749	}
1750	return 1;
1751	}
1752
1753
1754	SWIGINTERN int
1755	SWIG_AsVal_unsigned_SS_long(PyObject obj, unsigned long val)
1756	{
1757	if (PyInt_Check(obj)) {
1758	long v = PyInt_AS_LONG(obj);
1759	if (v >= 0) {
1760	if (val) *val = v;
1761	return 1;
1762	}
1763	}
1764	if (PyLong_Check(obj)) {
1765	unsigned long v = PyLong_AsUnsignedLong(obj);
1766	if (!PyErr_Occurred()) {
1767	if (val) *val = v;
1768	return 1;
1769	} else {
1770	if (!val) PyErr_Clear();
1771	return 0;
1772	}
1773	}
1774	if (val) {
1775	SWIG_type_error("unsigned long", obj);
1776	}
1777	return 0;
1778	}
1779
1780
1781	#if UINT_MAX != ULONG_MAX
1782	SWIGINTERN int
1783	SWIG_AsVal_unsigned_SS_int(PyObject obj, unsigned int val)
1784	{
1785	const char* errmsg = val ? "unsigned int" : (char*)0;
1786	unsigned long v;
1787	if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1788	if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1789	if (val) *val = (unsigned int)(v);
1790	return 1;
1791	}
1792	} else {
1793	PyErr_Clear();
1794	}
1795	if (val) {
1796	SWIG_type_error(errmsg, obj);
1797	}
1798	return 0;
1799	}
1800	#else
1801	SWIGINTERNSHORT unsigned int
1802	SWIG_AsVal_unsigned_SS_int(PyObject obj, unsigned int val)
1803	{
1804	return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1805	}
1806	#endif
1807
1808
1809	SWIGINTERNSHORT unsigned int
1810	SWIG_As_unsigned_SS_int(PyObject* obj)
1811	{
1812	unsigned int v;
1813	if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1814	/*
1815	this is needed to make valgrind/purify happier.
1816	*/
1817	memset((void*)&v, 0, sizeof(unsigned int));
1818	}
1819	return v;
1820	}
1821
1822
1823	SWIGINTERNSHORT int
1824	SWIG_Check_unsigned_SS_int(PyObject* obj)
1825	{
1826	return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1827	}
1828
1829	extern long *log_event_mask;
1830	void log_close(int);
1831	void log_err(int,char ,char );
1832	void log_event(int,int,char ,char );
1833	int log_open(char ,char );
1834	void log_record(int,int,char ,char );
1835	extern char log_buffer[4096];
1836
1837	SWIGINTERN int
1838	SWIG_AsCharArray(PyObject obj, char val, size_t size)
1839	{
1840	char* cptr; size_t csize;
1841	if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
1842	/* in C you can do:
1843
1844	char x[5] = "hello";
1845
1846	ie, assing the array using an extra '0' char.
1847	*/
1848	if ((csize == size + 1) && !(cptr[csize-1])) --csize;
1849	if (csize <= size) {
1850	if (val) {
1851	if (csize) memcpy(val, cptr, csize);
1852	if (csize < size) memset(val + csize, 0, size - csize);
1853	}
1854	return 1;
1855	}
1856	}
1857	if (val) {
1858	PyErr_Format(PyExc_TypeError,
1859	"a char array of maximum size %lu is expected",
1860	(unsigned long) size);
1861	}
1862	return 0;
1863	}
1864
1865
1866	SWIGINTERNSHORT PyObject *
1867	SWIG_FromCharArray(const char* carray, size_t size)
1868	{
1869	if (size > INT_MAX) {
1870	return Py_None;
1871	} else {
1872	return PyString_FromStringAndSize(carray, (int)(size));
1873	}
1874	}
1875
1876	int setup_env(char *);
1877	int chk_file_sec(char *,int,int,int,int);
1878	#ifdef __cplusplus
1879	extern "C" {
1880	#endif
1881	static PyObject _wrap_new_attrl(PyObject self, PyObject *args) {
1882	PyObject *resultobj;
1883	int arg1 ;
1884	struct attrl *result;
1885	PyObject * obj0 = 0 ;
1886
1887	if(!PyArg_ParseTuple(args,(char *)"O:new_attrl",&obj0)) goto fail;
1888	{
1889	arg1 = (int)(SWIG_As_int(obj0));
1890	if (SWIG_arg_fail(1)) SWIG_fail;
1891	}
1892	result = (struct attrl *)new_attrl(arg1);
1893
1894	{
1895	PyObject *obj_batch;
1896	struct attrl *ptr;
1897	int i=0, len=0;
1898
1899	if (SARA_DEBUG) printf("Converteren c (struct attrl *) -> python:\n");
1900
1901	ptr = result;
1902	while (ptr != NULL) {
1903	len++;
1904	ptr = ptr->next;
1905	}
1906	resultobj = PyList_New(len);
1907
1908	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
1909
1910	if (SARA_DEBUG) printf("\t<Contents>\n");
1911	ptr = result;
1912	for (i=0; i < len; i++) {
1913	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attrl,1);
1914	PyList_SetItem(resultobj, i, obj_batch);
1915	if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
1916	ptr = ptr->next;
1917	}
1918	if (SARA_DEBUG) printf("\t</Contents>\n");
1919	}
1920	return resultobj;
1921	fail:
1922	return NULL;
1923	}
1924
1925
1926	static PyObject _wrap_new_attropl(PyObject self, PyObject *args) {
1927	PyObject *resultobj;
1928	int arg1 ;
1929	struct attropl *result;
1930	PyObject * obj0 = 0 ;
1931
1932	if(!PyArg_ParseTuple(args,(char *)"O:new_attropl",&obj0)) goto fail;
1933	{
1934	arg1 = (int)(SWIG_As_int(obj0));
1935	if (SWIG_arg_fail(1)) SWIG_fail;
1936	}
1937	result = (struct attropl *)new_attropl(arg1);
1938
1939	{
1940	PyObject *obj_batch;
1941	struct attropl *ptr;
1942	int i=0, len=0;
1943
1944	if (SARA_DEBUG) printf("Converteren c (struct attropl *) -> python:\n");
1945
1946	ptr = result;
1947	while (ptr != NULL) {
1948	len++;
1949	ptr = ptr->next;
1950	}
1951	resultobj = PyList_New(len);
1952	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
1953
1954	if (SARA_DEBUG) printf("\t<Contents>\n");
1955	ptr = result;
1956	for (i=0; i < len; i++) {
1957	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attropl,1);
1958	PyList_SetItem(resultobj, i, obj_batch);
1959	ptr = ptr->next;
1960	}
1961	if (SARA_DEBUG) printf("\t</Contents>\n");
1962	}
1963	return resultobj;
1964	fail:
1965	return NULL;
1966	}
1967
1968
1969	static PyObject _wrap_new_batch_status(PyObject self, PyObject *args) {
1970	PyObject *resultobj;
1971	struct batch_status *result;
1972
1973	if(!PyArg_ParseTuple(args,(char *)":new_batch_status")) goto fail;
1974	result = (struct batch_status *)new_batch_status();
1975
1976	{
1977	PyObject *obj_batch;
1978	struct batch_status *ptr;
1979	int i=0, len=0;
1980
1981	// printf("Ja we are in bussniss\n");
1982	if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
1983
1984	// Deterime length of list
1985	//
1986	ptr = result;
1987	while (ptr != NULL) {
1988	len++;
1989	ptr = ptr->next;
1990	}
1991	resultobj = PyList_New(len);
1992
1993	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
1994
1995	// Make a list of batch_status pointers
1996	//
1997	if (SARA_DEBUG) printf("\t<Contents>\n");
1998	ptr = result;
1999	for (i=0; i < len; i++) {
2000	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0);
2001	PyList_SetItem(resultobj, i, obj_batch);
2002	if (SARA_DEBUG) {
2003	printf("\t\t- %s\n", ptr->name);
2004	}
2005	ptr = ptr->next;
2006	}
2007	if (SARA_DEBUG) printf("\t</Contents>\n");
2008	}
2009	return resultobj;
2010	fail:
2011	return NULL;
2012	}
2013
2014
2015	static PyObject _wrap_get_error(PyObject self, PyObject *args) {
2016	PyObject *resultobj;
2017	int result;
2018
2019	if(!PyArg_ParseTuple(args,(char *)":get_error")) goto fail;
2020	result = (int)get_error();
2021
2022	{
2023	resultobj = SWIG_From_int((int)(result));
2024	}
2025	return resultobj;
2026	fail:
2027	return NULL;
2028	}
2029
2030
2031	static PyObject _wrap_attrl_name_set(PyObject self, PyObject *args) {
2032	PyObject *resultobj;
2033	struct attrl arg1 = (struct attrl ) 0 ;
2034	char arg2 = (char ) 0 ;
2035	PyObject * obj0 = 0 ;
2036	PyObject * obj1 = 0 ;
2037
2038	if(!PyArg_ParseTuple(args,(char *)"OO:attrl_name_set",&obj0,&obj1)) goto fail;
2039	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2040	if (SWIG_arg_fail(1)) SWIG_fail;
2041	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2042	SWIG_arg_fail(2);SWIG_fail;
2043	}
2044	{
2045	if (arg1->name) free((char*)arg1->name);
2046	if (arg2) {
2047	arg1->name = (char *) malloc(strlen(arg2)+1);
2048	strcpy((char*)arg1->name,arg2);
2049	} else {
2050	arg1->name = 0;
2051	}
2052	}
2053	Py_INCREF(Py_None); resultobj = Py_None;
2054	return resultobj;
2055	fail:
2056	return NULL;
2057	}
2058
2059
2060	static PyObject _wrap_attrl_name_get(PyObject self, PyObject *args) {
2061	PyObject *resultobj;
2062	struct attrl arg1 = (struct attrl ) 0 ;
2063	char *result;
2064	PyObject * obj0 = 0 ;
2065
2066	if(!PyArg_ParseTuple(args,(char *)"O:attrl_name_get",&obj0)) goto fail;
2067	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2068	if (SWIG_arg_fail(1)) SWIG_fail;
2069	result = (char *) ((arg1)->name);
2070
2071	resultobj = SWIG_FromCharPtr(result);
2072	return resultobj;
2073	fail:
2074	return NULL;
2075	}
2076
2077
2078	static PyObject _wrap_attrl_resource_set(PyObject self, PyObject *args) {
2079	PyObject *resultobj;
2080	struct attrl arg1 = (struct attrl ) 0 ;
2081	char arg2 = (char ) 0 ;
2082	PyObject * obj0 = 0 ;
2083	PyObject * obj1 = 0 ;
2084
2085	if(!PyArg_ParseTuple(args,(char *)"OO:attrl_resource_set",&obj0,&obj1)) goto fail;
2086	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2087	if (SWIG_arg_fail(1)) SWIG_fail;
2088	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2089	SWIG_arg_fail(2);SWIG_fail;
2090	}
2091	{
2092	if (arg1->resource) free((char*)arg1->resource);
2093	if (arg2) {
2094	arg1->resource = (char *) malloc(strlen(arg2)+1);
2095	strcpy((char*)arg1->resource,arg2);
2096	} else {
2097	arg1->resource = 0;
2098	}
2099	}
2100	Py_INCREF(Py_None); resultobj = Py_None;
2101	return resultobj;
2102	fail:
2103	return NULL;
2104	}
2105
2106
2107	static PyObject _wrap_attrl_resource_get(PyObject self, PyObject *args) {
2108	PyObject *resultobj;
2109	struct attrl arg1 = (struct attrl ) 0 ;
2110	char *result;
2111	PyObject * obj0 = 0 ;
2112
2113	if(!PyArg_ParseTuple(args,(char *)"O:attrl_resource_get",&obj0)) goto fail;
2114	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2115	if (SWIG_arg_fail(1)) SWIG_fail;
2116	result = (char *) ((arg1)->resource);
2117
2118	resultobj = SWIG_FromCharPtr(result);
2119	return resultobj;
2120	fail:
2121	return NULL;
2122	}
2123
2124
2125	static PyObject _wrap_attrl_value_set(PyObject self, PyObject *args) {
2126	PyObject *resultobj;
2127	struct attrl arg1 = (struct attrl ) 0 ;
2128	char arg2 = (char ) 0 ;
2129	PyObject * obj0 = 0 ;
2130	PyObject * obj1 = 0 ;
2131
2132	if(!PyArg_ParseTuple(args,(char *)"OO:attrl_value_set",&obj0,&obj1)) goto fail;
2133	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2134	if (SWIG_arg_fail(1)) SWIG_fail;
2135	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2136	SWIG_arg_fail(2);SWIG_fail;
2137	}
2138	{
2139	if (arg1->value) free((char*)arg1->value);
2140	if (arg2) {
2141	arg1->value = (char *) malloc(strlen(arg2)+1);
2142	strcpy((char*)arg1->value,arg2);
2143	} else {
2144	arg1->value = 0;
2145	}
2146	}
2147	Py_INCREF(Py_None); resultobj = Py_None;
2148	return resultobj;
2149	fail:
2150	return NULL;
2151	}
2152
2153
2154	static PyObject _wrap_attrl_value_get(PyObject self, PyObject *args) {
2155	PyObject *resultobj;
2156	struct attrl arg1 = (struct attrl ) 0 ;
2157	char *result;
2158	PyObject * obj0 = 0 ;
2159
2160	if(!PyArg_ParseTuple(args,(char *)"O:attrl_value_get",&obj0)) goto fail;
2161	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2162	if (SWIG_arg_fail(1)) SWIG_fail;
2163	result = (char *) ((arg1)->value);
2164
2165	resultobj = SWIG_FromCharPtr(result);
2166	return resultobj;
2167	fail:
2168	return NULL;
2169	}
2170
2171
2172	static PyObject _wrap_attrl_op_set(PyObject self, PyObject *args) {
2173	PyObject *resultobj;
2174	struct attrl arg1 = (struct attrl ) 0 ;
2175	enum batch_op arg2 ;
2176	PyObject * obj0 = 0 ;
2177	PyObject * obj1 = 0 ;
2178
2179	if(!PyArg_ParseTuple(args,(char *)"OO:attrl_op_set",&obj0,&obj1)) goto fail;
2180	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2181	if (SWIG_arg_fail(1)) SWIG_fail;
2182	{
2183	arg2 = (enum batch_op)(SWIG_As_int(obj1));
2184	if (SWIG_arg_fail(2)) SWIG_fail;
2185	}
2186	if (arg1) (arg1)->op = (enum batch_op )arg2;
2187
2188	Py_INCREF(Py_None); resultobj = Py_None;
2189	return resultobj;
2190	fail:
2191	return NULL;
2192	}
2193
2194
2195	static PyObject _wrap_attrl_op_get(PyObject self, PyObject *args) {
2196	PyObject *resultobj;
2197	struct attrl arg1 = (struct attrl ) 0 ;
2198	enum batch_op result;
2199	PyObject * obj0 = 0 ;
2200
2201	if(!PyArg_ParseTuple(args,(char *)"O:attrl_op_get",&obj0)) goto fail;
2202	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2203	if (SWIG_arg_fail(1)) SWIG_fail;
2204	result = (enum batch_op) ((arg1)->op);
2205
2206	resultobj = SWIG_From_int((result));
2207	return resultobj;
2208	fail:
2209	return NULL;
2210	}
2211
2212
2213	static PyObject _wrap_attrl___str__(PyObject self, PyObject *args) {
2214	PyObject *resultobj;
2215	struct attrl arg1 = (struct attrl ) 0 ;
2216	char *result;
2217	PyObject * obj0 = 0 ;
2218
2219	if(!PyArg_ParseTuple(args,(char *)"O:attrl___str__",&obj0)) goto fail;
2220	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| 0);
2221	if (SWIG_arg_fail(1)) SWIG_fail;
2222	result = (char *)attrl___str__(arg1);
2223
2224	resultobj = SWIG_FromCharPtr(result);
2225	return resultobj;
2226	fail:
2227	return NULL;
2228	}
2229
2230
2231	static PyObject * attrl_swigregister(PyObject self, PyObject args) {
2232	PyObject *obj;
2233	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2234	SWIG_TypeClientData(SWIGTYPE_p_attrl, obj);
2235	Py_INCREF(obj);
2236	return Py_BuildValue((char *)"");
2237	}
2238	static PyObject _wrap_attropl_name_set(PyObject self, PyObject *args) {
2239	PyObject *resultobj;
2240	struct attropl arg1 = (struct attropl ) 0 ;
2241	char arg2 = (char ) 0 ;
2242	PyObject * obj0 = 0 ;
2243	PyObject * obj1 = 0 ;
2244
2245	if(!PyArg_ParseTuple(args,(char *)"OO:attropl_name_set",&obj0,&obj1)) goto fail;
2246	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2247	if (SWIG_arg_fail(1)) SWIG_fail;
2248	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2249	SWIG_arg_fail(2);SWIG_fail;
2250	}
2251	{
2252	if (arg1->name) free((char*)arg1->name);
2253	if (arg2) {
2254	arg1->name = (char *) malloc(strlen(arg2)+1);
2255	strcpy((char*)arg1->name,arg2);
2256	} else {
2257	arg1->name = 0;
2258	}
2259	}
2260	Py_INCREF(Py_None); resultobj = Py_None;
2261	return resultobj;
2262	fail:
2263	return NULL;
2264	}
2265
2266
2267	static PyObject _wrap_attropl_name_get(PyObject self, PyObject *args) {
2268	PyObject *resultobj;
2269	struct attropl arg1 = (struct attropl ) 0 ;
2270	char *result;
2271	PyObject * obj0 = 0 ;
2272
2273	if(!PyArg_ParseTuple(args,(char *)"O:attropl_name_get",&obj0)) goto fail;
2274	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2275	if (SWIG_arg_fail(1)) SWIG_fail;
2276	result = (char *) ((arg1)->name);
2277
2278	resultobj = SWIG_FromCharPtr(result);
2279	return resultobj;
2280	fail:
2281	return NULL;
2282	}
2283
2284
2285	static PyObject _wrap_attropl_resource_set(PyObject self, PyObject *args) {
2286	PyObject *resultobj;
2287	struct attropl arg1 = (struct attropl ) 0 ;
2288	char arg2 = (char ) 0 ;
2289	PyObject * obj0 = 0 ;
2290	PyObject * obj1 = 0 ;
2291
2292	if(!PyArg_ParseTuple(args,(char *)"OO:attropl_resource_set",&obj0,&obj1)) goto fail;
2293	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2294	if (SWIG_arg_fail(1)) SWIG_fail;
2295	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2296	SWIG_arg_fail(2);SWIG_fail;
2297	}
2298	{
2299	if (arg1->resource) free((char*)arg1->resource);
2300	if (arg2) {
2301	arg1->resource = (char *) malloc(strlen(arg2)+1);
2302	strcpy((char*)arg1->resource,arg2);
2303	} else {
2304	arg1->resource = 0;
2305	}
2306	}
2307	Py_INCREF(Py_None); resultobj = Py_None;
2308	return resultobj;
2309	fail:
2310	return NULL;
2311	}
2312
2313
2314	static PyObject _wrap_attropl_resource_get(PyObject self, PyObject *args) {
2315	PyObject *resultobj;
2316	struct attropl arg1 = (struct attropl ) 0 ;
2317	char *result;
2318	PyObject * obj0 = 0 ;
2319
2320	if(!PyArg_ParseTuple(args,(char *)"O:attropl_resource_get",&obj0)) goto fail;
2321	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2322	if (SWIG_arg_fail(1)) SWIG_fail;
2323	result = (char *) ((arg1)->resource);
2324
2325	resultobj = SWIG_FromCharPtr(result);
2326	return resultobj;
2327	fail:
2328	return NULL;
2329	}
2330
2331
2332	static PyObject _wrap_attropl_value_set(PyObject self, PyObject *args) {
2333	PyObject *resultobj;
2334	struct attropl arg1 = (struct attropl ) 0 ;
2335	char arg2 = (char ) 0 ;
2336	PyObject * obj0 = 0 ;
2337	PyObject * obj1 = 0 ;
2338
2339	if(!PyArg_ParseTuple(args,(char *)"OO:attropl_value_set",&obj0,&obj1)) goto fail;
2340	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2341	if (SWIG_arg_fail(1)) SWIG_fail;
2342	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2343	SWIG_arg_fail(2);SWIG_fail;
2344	}
2345	{
2346	if (arg1->value) free((char*)arg1->value);
2347	if (arg2) {
2348	arg1->value = (char *) malloc(strlen(arg2)+1);
2349	strcpy((char*)arg1->value,arg2);
2350	} else {
2351	arg1->value = 0;
2352	}
2353	}
2354	Py_INCREF(Py_None); resultobj = Py_None;
2355	return resultobj;
2356	fail:
2357	return NULL;
2358	}
2359
2360
2361	static PyObject _wrap_attropl_value_get(PyObject self, PyObject *args) {
2362	PyObject *resultobj;
2363	struct attropl arg1 = (struct attropl ) 0 ;
2364	char *result;
2365	PyObject * obj0 = 0 ;
2366
2367	if(!PyArg_ParseTuple(args,(char *)"O:attropl_value_get",&obj0)) goto fail;
2368	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2369	if (SWIG_arg_fail(1)) SWIG_fail;
2370	result = (char *) ((arg1)->value);
2371
2372	resultobj = SWIG_FromCharPtr(result);
2373	return resultobj;
2374	fail:
2375	return NULL;
2376	}
2377
2378
2379	static PyObject _wrap_attropl_op_set(PyObject self, PyObject *args) {
2380	PyObject *resultobj;
2381	struct attropl arg1 = (struct attropl ) 0 ;
2382	enum batch_op arg2 ;
2383	PyObject * obj0 = 0 ;
2384	PyObject * obj1 = 0 ;
2385
2386	if(!PyArg_ParseTuple(args,(char *)"OO:attropl_op_set",&obj0,&obj1)) goto fail;
2387	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2388	if (SWIG_arg_fail(1)) SWIG_fail;
2389	{
2390	arg2 = (enum batch_op)(SWIG_As_int(obj1));
2391	if (SWIG_arg_fail(2)) SWIG_fail;
2392	}
2393	if (arg1) (arg1)->op = (enum batch_op )arg2;
2394
2395	Py_INCREF(Py_None); resultobj = Py_None;
2396	return resultobj;
2397	fail:
2398	return NULL;
2399	}
2400
2401
2402	static PyObject _wrap_attropl_op_get(PyObject self, PyObject *args) {
2403	PyObject *resultobj;
2404	struct attropl arg1 = (struct attropl ) 0 ;
2405	enum batch_op result;
2406	PyObject * obj0 = 0 ;
2407
2408	if(!PyArg_ParseTuple(args,(char *)"O:attropl_op_get",&obj0)) goto fail;
2409	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2410	if (SWIG_arg_fail(1)) SWIG_fail;
2411	result = (enum batch_op) ((arg1)->op);
2412
2413	resultobj = SWIG_From_int((result));
2414	return resultobj;
2415	fail:
2416	return NULL;
2417	}
2418
2419
2420	static PyObject _wrap_attropl___str__(PyObject self, PyObject *args) {
2421	PyObject *resultobj;
2422	struct attropl arg1 = (struct attropl ) 0 ;
2423	char *result;
2424	PyObject * obj0 = 0 ;
2425
2426	if(!PyArg_ParseTuple(args,(char *)"O:attropl___str__",&obj0)) goto fail;
2427	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_attropl, SWIG_POINTER_EXCEPTION \| 0);
2428	if (SWIG_arg_fail(1)) SWIG_fail;
2429	result = (char *)attropl___str__(arg1);
2430
2431	resultobj = SWIG_FromCharPtr(result);
2432	return resultobj;
2433	fail:
2434	return NULL;
2435	}
2436
2437
2438	static PyObject * attropl_swigregister(PyObject self, PyObject args) {
2439	PyObject *obj;
2440	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2441	SWIG_TypeClientData(SWIGTYPE_p_attropl, obj);
2442	Py_INCREF(obj);
2443	return Py_BuildValue((char *)"");
2444	}
2445	static PyObject _wrap_batch_status_name_set(PyObject self, PyObject *args) {
2446	PyObject *resultobj;
2447	struct batch_status arg1 = (struct batch_status ) 0 ;
2448	char arg2 = (char ) 0 ;
2449	PyObject * obj0 = 0 ;
2450	PyObject * obj1 = 0 ;
2451
2452	if(!PyArg_ParseTuple(args,(char *)"OO:batch_status_name_set",&obj0,&obj1)) goto fail;
2453	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_batch_status, SWIG_POINTER_EXCEPTION \| 0);
2454	if (SWIG_arg_fail(1)) SWIG_fail;
2455	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2456	SWIG_arg_fail(2);SWIG_fail;
2457	}
2458	{
2459	if (arg1->name) free((char*)arg1->name);
2460	if (arg2) {
2461	arg1->name = (char *) malloc(strlen(arg2)+1);
2462	strcpy((char*)arg1->name,arg2);
2463	} else {
2464	arg1->name = 0;
2465	}
2466	}
2467	Py_INCREF(Py_None); resultobj = Py_None;
2468	return resultobj;
2469	fail:
2470	return NULL;
2471	}
2472
2473
2474	static PyObject _wrap_batch_status_name_get(PyObject self, PyObject *args) {
2475	PyObject *resultobj;
2476	struct batch_status arg1 = (struct batch_status ) 0 ;
2477	char *result;
2478	PyObject * obj0 = 0 ;
2479
2480	if(!PyArg_ParseTuple(args,(char *)"O:batch_status_name_get",&obj0)) goto fail;
2481	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_batch_status, SWIG_POINTER_EXCEPTION \| 0);
2482	if (SWIG_arg_fail(1)) SWIG_fail;
2483	result = (char *) ((arg1)->name);
2484
2485	resultobj = SWIG_FromCharPtr(result);
2486	return resultobj;
2487	fail:
2488	return NULL;
2489	}
2490
2491
2492	static PyObject _wrap_batch_status_attribs_set(PyObject self, PyObject *args) {
2493	PyObject *resultobj;
2494	struct batch_status arg1 = (struct batch_status ) 0 ;
2495	struct attrl arg2 = (struct attrl ) 0 ;
2496	PyObject * obj0 = 0 ;
2497	PyObject * obj1 = 0 ;
2498
2499	if(!PyArg_ParseTuple(args,(char *)"OO:batch_status_attribs_set",&obj0,&obj1)) goto fail;
2500	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_batch_status, SWIG_POINTER_EXCEPTION \| 0);
2501	if (SWIG_arg_fail(1)) SWIG_fail;
2502	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_attrl, SWIG_POINTER_EXCEPTION \| SWIG_POINTER_DISOWN);
2503	if (SWIG_arg_fail(2)) SWIG_fail;
2504	if (arg1) (arg1)->attribs = arg2;
2505
2506	Py_INCREF(Py_None); resultobj = Py_None;
2507	return resultobj;
2508	fail:
2509	return NULL;
2510	}
2511
2512
2513	static PyObject _wrap_batch_status_attribs_get(PyObject self, PyObject *args) {
2514	PyObject *resultobj;
2515	struct batch_status arg1 = (struct batch_status ) 0 ;
2516	struct attrl *result;
2517	PyObject * obj0 = 0 ;
2518
2519	if(!PyArg_ParseTuple(args,(char *)"O:batch_status_attribs_get",&obj0)) goto fail;
2520	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_batch_status, SWIG_POINTER_EXCEPTION \| 0);
2521	if (SWIG_arg_fail(1)) SWIG_fail;
2522	result = (struct attrl *) ((arg1)->attribs);
2523
2524	{
2525	PyObject *obj_batch;
2526	struct attrl *ptr;
2527	int i=0, len=0;
2528
2529	if (SARA_DEBUG) printf("Converteren c (struct attrl *) -> python:\n");
2530
2531	ptr = result;
2532	while (ptr != NULL) {
2533	len++;
2534	ptr = ptr->next;
2535	}
2536	resultobj = PyList_New(len);
2537
2538	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
2539
2540	if (SARA_DEBUG) printf("\t<Contents>\n");
2541	ptr = result;
2542	for (i=0; i < len; i++) {
2543	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_attrl,1);
2544	PyList_SetItem(resultobj, i, obj_batch);
2545	if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
2546	ptr = ptr->next;
2547	}
2548	if (SARA_DEBUG) printf("\t</Contents>\n");
2549	}
2550	return resultobj;
2551	fail:
2552	return NULL;
2553	}
2554
2555
2556	static PyObject _wrap_batch_status_text_set(PyObject self, PyObject *args) {
2557	PyObject *resultobj;
2558	struct batch_status arg1 = (struct batch_status ) 0 ;
2559	char arg2 = (char ) 0 ;
2560	PyObject * obj0 = 0 ;
2561	PyObject * obj1 = 0 ;
2562
2563	if(!PyArg_ParseTuple(args,(char *)"OO:batch_status_text_set",&obj0,&obj1)) goto fail;
2564	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_batch_status, SWIG_POINTER_EXCEPTION \| 0);
2565	if (SWIG_arg_fail(1)) SWIG_fail;
2566	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2567	SWIG_arg_fail(2);SWIG_fail;
2568	}
2569	{
2570	if (arg1->text) free((char*)arg1->text);
2571	if (arg2) {
2572	arg1->text = (char *) malloc(strlen(arg2)+1);
2573	strcpy((char*)arg1->text,arg2);
2574	} else {
2575	arg1->text = 0;
2576	}
2577	}
2578	Py_INCREF(Py_None); resultobj = Py_None;
2579	return resultobj;
2580	fail:
2581	return NULL;
2582	}
2583
2584
2585	static PyObject _wrap_batch_status_text_get(PyObject self, PyObject *args) {
2586	PyObject *resultobj;
2587	struct batch_status arg1 = (struct batch_status ) 0 ;
2588	char *result;
2589	PyObject * obj0 = 0 ;
2590
2591	if(!PyArg_ParseTuple(args,(char *)"O:batch_status_text_get",&obj0)) goto fail;
2592	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_batch_status, SWIG_POINTER_EXCEPTION \| 0);
2593	if (SWIG_arg_fail(1)) SWIG_fail;
2594	result = (char *) ((arg1)->text);
2595
2596	resultobj = SWIG_FromCharPtr(result);
2597	return resultobj;
2598	fail:
2599	return NULL;
2600	}
2601
2602
2603	static PyObject * batch_status_swigregister(PyObject self, PyObject args) {
2604	PyObject *obj;
2605	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2606	SWIG_TypeClientData(SWIGTYPE_p_batch_status, obj);
2607	Py_INCREF(obj);
2608	return Py_BuildValue((char *)"");
2609	}
2610	static int _wrap_pbs_errno_set(PyObject *_val) {
2611	{
2612	int temp = (int)(SWIG_As_int(_val));
2613	if (PyErr_Occurred()) {
2614	SWIG_append_errmsg("C/C++ variable 'pbs_errno (int)'");
2615	return 1;
2616	}
2617	pbs_errno = temp;
2618	}
2619	return 0;
2620	}
2621
2622
2623	static PyObject *_wrap_pbs_errno_get(void) {
2624	PyObject *pyobj;
2625
2626	{
2627	pyobj = SWIG_From_int((int)(pbs_errno));
2628	}
2629	return pyobj;
2630	}
2631
2632
2633	static int _wrap_pbs_server_set(PyObject *_val) {
2634	{
2635	char *cptr = 0;
2636	if (!SWIG_AsNewCharPtr(_val, &cptr)) {
2637	SWIG_append_errmsg("C/C++ variable 'pbs_server'");
2638	return 1;
2639	}
2640	if (pbs_server) free((char*)pbs_server);
2641	pbs_server = cptr;
2642	}
2643	return 0;
2644	}
2645
2646
2647	static PyObject *_wrap_pbs_server_get(void) {
2648	PyObject *pyobj;
2649
2650	pyobj = SWIG_FromCharPtr(pbs_server);
2651	return pyobj;
2652	}
2653
2654
2655	static PyObject _wrap_avail(PyObject self, PyObject *args) {
2656	PyObject *resultobj;
2657	int arg1 ;
2658	char arg2 = (char ) 0 ;
2659	char *result;
2660	PyObject * obj0 = 0 ;
2661	PyObject * obj1 = 0 ;
2662
2663	if(!PyArg_ParseTuple(args,(char *)"OO:avail",&obj0,&obj1)) goto fail;
2664	{
2665	arg1 = (int)(SWIG_As_int(obj0));
2666	if (SWIG_arg_fail(1)) SWIG_fail;
2667	}
2668	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2669	SWIG_arg_fail(2);SWIG_fail;
2670	}
2671	result = (char *)avail(arg1,arg2);
2672
2673	resultobj = SWIG_FromCharPtr(result);
2674	return resultobj;
2675	fail:
2676	return NULL;
2677	}
2678
2679
2680	static PyObject _wrap_pbs_asyrunjob(PyObject self, PyObject *args) {
2681	PyObject *resultobj;
2682	int arg1 ;
2683	char arg2 = (char ) 0 ;
2684	char arg3 = (char ) 0 ;
2685	char arg4 = (char ) 0 ;
2686	int result;
2687	PyObject * obj0 = 0 ;
2688	PyObject * obj1 = 0 ;
2689	PyObject * obj2 = 0 ;
2690	PyObject * obj3 = 0 ;
2691
2692	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_asyrunjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2693	{
2694	arg1 = (int)(SWIG_As_int(obj0));
2695	if (SWIG_arg_fail(1)) SWIG_fail;
2696	}
2697	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2698	SWIG_arg_fail(2);SWIG_fail;
2699	}
2700	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
2701	SWIG_arg_fail(3);SWIG_fail;
2702	}
2703	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
2704	SWIG_arg_fail(4);SWIG_fail;
2705	}
2706	result = (int)pbs_asyrunjob(arg1,arg2,arg3,arg4);
2707
2708	{
2709	resultobj = SWIG_From_int((int)(result));
2710	}
2711	return resultobj;
2712	fail:
2713	return NULL;
2714	}
2715
2716
2717	static PyObject _wrap_pbs_alterjob(PyObject self, PyObject *args) {
2718	PyObject *resultobj;
2719	int arg1 ;
2720	char arg2 = (char ) 0 ;
2721	struct attrl arg3 = (struct attrl ) 0 ;
2722	char arg4 = (char ) 0 ;
2723	int result;
2724	PyObject * obj0 = 0 ;
2725	PyObject * obj1 = 0 ;
2726	PyObject * obj2 = 0 ;
2727	PyObject * obj3 = 0 ;
2728
2729	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_alterjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2730	{
2731	arg1 = (int)(SWIG_As_int(obj0));
2732	if (SWIG_arg_fail(1)) SWIG_fail;
2733	}
2734	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2735	SWIG_arg_fail(2);SWIG_fail;
2736	}
2737	{
2738	PyObject *py_obj;
2739	struct attrl ptr, prev;
2740	char s[255];
2741	int i=0, size=0;
2742
2743	// printf("Python --> C\n");
2744
2745	if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
2746
2747	size = Get_List_Size(obj2);
2748	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
2749
2750	if ( size == -1 ) {
2751	PyErr_SetString(PyExc_TypeError, "not a list");
2752	return NULL;
2753	}
2754
2755	if (SARA_DEBUG) printf("\t<Contents>\n");
2756
2757	arg3 = prev = NULL;
2758	for ( i=0; i < size; i++ ) {
2759	py_obj = PyList_GetItem(obj2, i);
2760	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
2761	sprintf(s,"list item %d has wrong type", i);
2762	PyErr_SetString(PyExc_TypeError, s);
2763	return NULL;
2764
2765	// This will skipp the wrong entry
2766	// continue;
2767	}
2768
2769	/*
2770	* Make first entry head of C linked list
2771	*/
2772	if ( i == 0) {
2773	arg3 = ptr;
2774	ptr->next = prev;
2775	}
2776	else {
2777	prev->next = ptr;
2778	ptr->next = NULL;
2779	}
2780	if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
2781
2782	prev = ptr;
2783
2784	} // end for
2785	if (SARA_DEBUG) printf("\t</Contents>\n");
2786	}
2787	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
2788	SWIG_arg_fail(4);SWIG_fail;
2789	}
2790	result = (int)pbs_alterjob(arg1,arg2,arg3,arg4);
2791
2792	{
2793	resultobj = SWIG_From_int((int)(result));
2794	}
2795	return resultobj;
2796	fail:
2797	return NULL;
2798	}
2799
2800
2801	static PyObject _wrap_pbs_connect(PyObject self, PyObject *args) {
2802	PyObject *resultobj;
2803	char arg1 = (char ) 0 ;
2804	int result;
2805	PyObject * obj0 = 0 ;
2806
2807	if(!PyArg_ParseTuple(args,(char *)"O:pbs_connect",&obj0)) goto fail;
2808	if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
2809	SWIG_arg_fail(1);SWIG_fail;
2810	}
2811	result = (int)pbs_connect(arg1);
2812
2813	{
2814	resultobj = SWIG_From_int((int)(result));
2815	}
2816	return resultobj;
2817	fail:
2818	return NULL;
2819	}
2820
2821
2822	static PyObject _wrap_pbs_query_max_connections(PyObject self, PyObject *args) {
2823	PyObject *resultobj;
2824	int result;
2825
2826	if(!PyArg_ParseTuple(args,(char *)":pbs_query_max_connections")) goto fail;
2827	result = (int)pbs_query_max_connections();
2828
2829	{
2830	resultobj = SWIG_From_int((int)(result));
2831	}
2832	return resultobj;
2833	fail:
2834	return NULL;
2835	}
2836
2837
2838	static PyObject _wrap_pbs_default(PyObject self, PyObject *args) {
2839	PyObject *resultobj;
2840	char *result;
2841
2842	if(!PyArg_ParseTuple(args,(char *)":pbs_default")) goto fail;
2843	result = (char *)pbs_default();
2844
2845	resultobj = SWIG_FromCharPtr(result);
2846	return resultobj;
2847	fail:
2848	return NULL;
2849	}
2850
2851
2852	static PyObject _wrap_pbs_deljob(PyObject self, PyObject *args) {
2853	PyObject *resultobj;
2854	int arg1 ;
2855	char arg2 = (char ) 0 ;
2856	char arg3 = (char ) 0 ;
2857	int result;
2858	PyObject * obj0 = 0 ;
2859	PyObject * obj1 = 0 ;
2860	PyObject * obj2 = 0 ;
2861
2862	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_deljob",&obj0,&obj1,&obj2)) goto fail;
2863	{
2864	arg1 = (int)(SWIG_As_int(obj0));
2865	if (SWIG_arg_fail(1)) SWIG_fail;
2866	}
2867	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2868	SWIG_arg_fail(2);SWIG_fail;
2869	}
2870	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
2871	SWIG_arg_fail(3);SWIG_fail;
2872	}
2873	result = (int)pbs_deljob(arg1,arg2,arg3);
2874
2875	{
2876	resultobj = SWIG_From_int((int)(result));
2877	}
2878	return resultobj;
2879	fail:
2880	return NULL;
2881	}
2882
2883
2884	static PyObject _wrap_pbs_disconnect(PyObject self, PyObject *args) {
2885	PyObject *resultobj;
2886	int arg1 ;
2887	int result;
2888	PyObject * obj0 = 0 ;
2889
2890	if(!PyArg_ParseTuple(args,(char *)"O:pbs_disconnect",&obj0)) goto fail;
2891	{
2892	arg1 = (int)(SWIG_As_int(obj0));
2893	if (SWIG_arg_fail(1)) SWIG_fail;
2894	}
2895	result = (int)pbs_disconnect(arg1);
2896
2897	{
2898	resultobj = SWIG_From_int((int)(result));
2899	}
2900	return resultobj;
2901	fail:
2902	return NULL;
2903	}
2904
2905
2906	static PyObject _wrap_pbs_holdjob(PyObject self, PyObject *args) {
2907	PyObject *resultobj;
2908	int arg1 ;
2909	char arg2 = (char ) 0 ;
2910	char arg3 = (char ) 0 ;
2911	char arg4 = (char ) 0 ;
2912	int result;
2913	PyObject * obj0 = 0 ;
2914	PyObject * obj1 = 0 ;
2915	PyObject * obj2 = 0 ;
2916	PyObject * obj3 = 0 ;
2917
2918	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_holdjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
2919	{
2920	arg1 = (int)(SWIG_As_int(obj0));
2921	if (SWIG_arg_fail(1)) SWIG_fail;
2922	}
2923	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2924	SWIG_arg_fail(2);SWIG_fail;
2925	}
2926	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
2927	SWIG_arg_fail(3);SWIG_fail;
2928	}
2929	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
2930	SWIG_arg_fail(4);SWIG_fail;
2931	}
2932	result = (int)pbs_holdjob(arg1,arg2,arg3,arg4);
2933
2934	{
2935	resultobj = SWIG_From_int((int)(result));
2936	}
2937	return resultobj;
2938	fail:
2939	return NULL;
2940	}
2941
2942
2943	static PyObject _wrap_pbs_locjob(PyObject self, PyObject *args) {
2944	PyObject *resultobj;
2945	int arg1 ;
2946	char arg2 = (char ) 0 ;
2947	char arg3 = (char ) 0 ;
2948	char *result;
2949	PyObject * obj0 = 0 ;
2950	PyObject * obj1 = 0 ;
2951	PyObject * obj2 = 0 ;
2952
2953	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_locjob",&obj0,&obj1,&obj2)) goto fail;
2954	{
2955	arg1 = (int)(SWIG_As_int(obj0));
2956	if (SWIG_arg_fail(1)) SWIG_fail;
2957	}
2958	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
2959	SWIG_arg_fail(2);SWIG_fail;
2960	}
2961	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
2962	SWIG_arg_fail(3);SWIG_fail;
2963	}
2964	result = (char *)pbs_locjob(arg1,arg2,arg3);
2965
2966	resultobj = SWIG_FromCharPtr(result);
2967	return resultobj;
2968	fail:
2969	return NULL;
2970	}
2971
2972
2973	static PyObject _wrap_pbs_manager(PyObject self, PyObject *args) {
2974	PyObject *resultobj;
2975	int arg1 ;
2976	int arg2 ;
2977	int arg3 ;
2978	char arg4 = (char ) 0 ;
2979	struct attropl arg5 = (struct attropl ) 0 ;
2980	char arg6 = (char ) 0 ;
2981	int result;
2982	PyObject * obj0 = 0 ;
2983	PyObject * obj1 = 0 ;
2984	PyObject * obj2 = 0 ;
2985	PyObject * obj3 = 0 ;
2986	PyObject * obj4 = 0 ;
2987	PyObject * obj5 = 0 ;
2988
2989	if(!PyArg_ParseTuple(args,(char *)"OOOOOO:pbs_manager",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2990	{
2991	arg1 = (int)(SWIG_As_int(obj0));
2992	if (SWIG_arg_fail(1)) SWIG_fail;
2993	}
2994	{
2995	arg2 = (int)(SWIG_As_int(obj1));
2996	if (SWIG_arg_fail(2)) SWIG_fail;
2997	}
2998	{
2999	arg3 = (int)(SWIG_As_int(obj2));
3000	if (SWIG_arg_fail(3)) SWIG_fail;
3001	}
3002	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3003	SWIG_arg_fail(4);SWIG_fail;
3004	}
3005	{
3006	PyObject *py_obj;
3007	struct attropl ptr, prev;
3008	char s[255];
3009	int i=0, size=0;
3010
3011	// printf("Python --> C\n");
3012
3013	if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
3014
3015	size = Get_List_Size(obj4);
3016
3017	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3018
3019	if ( size == -1 ) {
3020	PyErr_SetString(PyExc_TypeError, "not a list");
3021	return NULL;
3022	}
3023	//printf("Size = %d\n", size);
3024
3025	if (SARA_DEBUG) printf("\t<Contents>\n");
3026
3027	arg5 = prev = NULL;
3028	for ( i=0; i < size; i++ ) {
3029	py_obj = PyList_GetItem(obj4, i);
3030	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
3031	sprintf(s,"list item %d has wrong type", i);
3032	PyErr_SetString(PyExc_TypeError, s);
3033	return NULL;
3034
3035	// This will skipp the wrong entry
3036	// continue;
3037	}
3038
3039	/*
3040	* Make first entry head of C linked list
3041	*/
3042	if ( i == 0) {
3043	arg5 = ptr;
3044	ptr->next = prev;
3045	}
3046	else {
3047	prev->next = ptr;
3048	ptr->next = NULL;
3049	}
3050	prev = ptr;
3051
3052	} // end for
3053	if (SARA_DEBUG) printf("\t</Contents>\n");
3054	}
3055	if (!SWIG_AsCharPtr(obj5, (char**)&arg6)) {
3056	SWIG_arg_fail(6);SWIG_fail;
3057	}
3058	result = (int)pbs_manager(arg1,arg2,arg3,arg4,arg5,arg6);
3059
3060	{
3061	resultobj = SWIG_From_int((int)(result));
3062	}
3063	return resultobj;
3064	fail:
3065	return NULL;
3066	}
3067
3068
3069	static PyObject _wrap_pbs_movejob(PyObject self, PyObject *args) {
3070	PyObject *resultobj;
3071	int arg1 ;
3072	char arg2 = (char ) 0 ;
3073	char arg3 = (char ) 0 ;
3074	char arg4 = (char ) 0 ;
3075	int result;
3076	PyObject * obj0 = 0 ;
3077	PyObject * obj1 = 0 ;
3078	PyObject * obj2 = 0 ;
3079	PyObject * obj3 = 0 ;
3080
3081	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_movejob",&obj0,&obj1,&obj2,&obj3)) goto fail;
3082	{
3083	arg1 = (int)(SWIG_As_int(obj0));
3084	if (SWIG_arg_fail(1)) SWIG_fail;
3085	}
3086	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3087	SWIG_arg_fail(2);SWIG_fail;
3088	}
3089	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
3090	SWIG_arg_fail(3);SWIG_fail;
3091	}
3092	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3093	SWIG_arg_fail(4);SWIG_fail;
3094	}
3095	result = (int)pbs_movejob(arg1,arg2,arg3,arg4);
3096
3097	{
3098	resultobj = SWIG_From_int((int)(result));
3099	}
3100	return resultobj;
3101	fail:
3102	return NULL;
3103	}
3104
3105
3106	static PyObject _wrap_pbs_msgjob(PyObject self, PyObject *args) {
3107	PyObject *resultobj;
3108	int arg1 ;
3109	char arg2 = (char ) 0 ;
3110	int arg3 ;
3111	char arg4 = (char ) 0 ;
3112	char arg5 = (char ) 0 ;
3113	int result;
3114	PyObject * obj0 = 0 ;
3115	PyObject * obj1 = 0 ;
3116	PyObject * obj2 = 0 ;
3117	PyObject * obj3 = 0 ;
3118	PyObject * obj4 = 0 ;
3119
3120	if(!PyArg_ParseTuple(args,(char *)"OOOOO:pbs_msgjob",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3121	{
3122	arg1 = (int)(SWIG_As_int(obj0));
3123	if (SWIG_arg_fail(1)) SWIG_fail;
3124	}
3125	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3126	SWIG_arg_fail(2);SWIG_fail;
3127	}
3128	{
3129	arg3 = (int)(SWIG_As_int(obj2));
3130	if (SWIG_arg_fail(3)) SWIG_fail;
3131	}
3132	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3133	SWIG_arg_fail(4);SWIG_fail;
3134	}
3135	if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) {
3136	SWIG_arg_fail(5);SWIG_fail;
3137	}
3138	result = (int)pbs_msgjob(arg1,arg2,arg3,arg4,arg5);
3139
3140	{
3141	resultobj = SWIG_From_int((int)(result));
3142	}
3143	return resultobj;
3144	fail:
3145	return NULL;
3146	}
3147
3148
3149	static PyObject _wrap_pbs_orderjob(PyObject self, PyObject *args) {
3150	PyObject *resultobj;
3151	int arg1 ;
3152	char arg2 = (char ) 0 ;
3153	char arg3 = (char ) 0 ;
3154	char arg4 = (char ) 0 ;
3155	int result;
3156	PyObject * obj0 = 0 ;
3157	PyObject * obj1 = 0 ;
3158	PyObject * obj2 = 0 ;
3159	PyObject * obj3 = 0 ;
3160
3161	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_orderjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
3162	{
3163	arg1 = (int)(SWIG_As_int(obj0));
3164	if (SWIG_arg_fail(1)) SWIG_fail;
3165	}
3166	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3167	SWIG_arg_fail(2);SWIG_fail;
3168	}
3169	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
3170	SWIG_arg_fail(3);SWIG_fail;
3171	}
3172	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3173	SWIG_arg_fail(4);SWIG_fail;
3174	}
3175	result = (int)pbs_orderjob(arg1,arg2,arg3,arg4);
3176
3177	{
3178	resultobj = SWIG_From_int((int)(result));
3179	}
3180	return resultobj;
3181	fail:
3182	return NULL;
3183	}
3184
3185
3186	static PyObject _wrap_pbs_rescquery(PyObject self, PyObject *args) {
3187	PyObject *resultobj;
3188	int arg1 ;
3189	char arg2 = (char ) 0 ;
3190	int arg3 ;
3191	int arg4 = (int ) 0 ;
3192	int arg5 = (int ) 0 ;
3193	int arg6 = (int ) 0 ;
3194	int arg7 = (int ) 0 ;
3195	int result;
3196	int temp4 ;
3197	int res4 = 0 ;
3198	int temp5 ;
3199	int res5 = 0 ;
3200	int temp6 ;
3201	int res6 = 0 ;
3202	int temp7 ;
3203	int res7 = 0 ;
3204	PyObject * obj0 = 0 ;
3205	PyObject * obj1 = 0 ;
3206	PyObject * obj2 = 0 ;
3207
3208	arg4 = &temp4; res4 = SWIG_NEWOBJ;
3209	arg5 = &temp5; res5 = SWIG_NEWOBJ;
3210	arg6 = &temp6; res6 = SWIG_NEWOBJ;
3211	arg7 = &temp7; res7 = SWIG_NEWOBJ;
3212	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_rescquery",&obj0,&obj1,&obj2)) goto fail;
3213	{
3214	arg1 = (int)(SWIG_As_int(obj0));
3215	if (SWIG_arg_fail(1)) SWIG_fail;
3216	}
3217	{
3218	int i=0, size=0;
3219	PyObject *py_obj;
3220
3221	if (SARA_DEBUG) printf("Convert python -> c (char **):\n");
3222
3223	size = Get_List_Size(obj1);
3224
3225	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3226
3227	if ( size == -1 ) {
3228	PyErr_SetString(PyExc_TypeError, "not a list");
3229	return NULL;
3230	}
3231	// printf("Size = %d\n", size);
3232
3233	if (SARA_DEBUG) printf("\t<Contents>\n");
3234
3235	arg2 = (char *) malloc( (size+1) sizeof(char *));
3236	for (i=0; i < size; i++) {
3237	py_obj = PyList_GetItem(obj1, i);
3238	if (PyString_Check(py_obj)) {
3239	arg2[i] = PyString_AsString(py_obj);
3240	if (SARA_DEBUG) printf("%s", arg2[i]);
3241	}
3242	else {
3243	PyErr_SetString(PyExc_TypeError, "not a list of strings");
3244	free(arg2);
3245	return NULL;
3246	}
3247	} // end for
3248	arg2[i] = 0;
3249	if (SARA_DEBUG) printf("\t</Contents>\n");
3250	}
3251	{
3252	arg3 = (int)(SWIG_As_int(obj2));
3253	if (SWIG_arg_fail(3)) SWIG_fail;
3254	}
3255	result = (int)pbs_rescquery(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
3256
3257	{
3258	resultobj = SWIG_From_int((int)(result));
3259	}
3260	resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3261	SWIG_From_int((arg4)) : SWIG_NewPointerObj((void)(arg4), SWIGTYPE_p_int, 0)));
3262	resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3263	SWIG_From_int((arg5)) : SWIG_NewPointerObj((void)(arg5), SWIGTYPE_p_int, 0)));
3264	resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
3265	SWIG_From_int((arg6)) : SWIG_NewPointerObj((void)(arg6), SWIGTYPE_p_int, 0)));
3266	resultobj = t_output_helper(resultobj, ((res7 == SWIG_NEWOBJ) ?
3267	SWIG_From_int((arg7)) : SWIG_NewPointerObj((void)(arg7), SWIGTYPE_p_int, 0)));
3268	{
3269	free( (char *) arg2);
3270	}
3271	return resultobj;
3272	fail:
3273	{
3274	free( (char *) arg2);
3275	}
3276	return NULL;
3277	}
3278
3279
3280	static PyObject _wrap_pbs_rescreserve(PyObject self, PyObject *args) {
3281	PyObject *resultobj;
3282	int arg1 ;
3283	char arg2 = (char ) 0 ;
3284	int arg3 ;
3285	int arg4 = (int ) 0 ;
3286	int result;
3287	int temp4 ;
3288	int res4 = 0 ;
3289	PyObject * obj0 = 0 ;
3290	PyObject * obj1 = 0 ;
3291	PyObject * obj2 = 0 ;
3292
3293	arg4 = &temp4; res4 = SWIG_NEWOBJ;
3294	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_rescreserve",&obj0,&obj1,&obj2)) goto fail;
3295	{
3296	arg1 = (int)(SWIG_As_int(obj0));
3297	if (SWIG_arg_fail(1)) SWIG_fail;
3298	}
3299	{
3300	int i=0, size=0;
3301	PyObject *py_obj;
3302
3303	if (SARA_DEBUG) printf("Convert python -> c (char **):\n");
3304
3305	size = Get_List_Size(obj1);
3306
3307	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3308
3309	if ( size == -1 ) {
3310	PyErr_SetString(PyExc_TypeError, "not a list");
3311	return NULL;
3312	}
3313	// printf("Size = %d\n", size);
3314
3315	if (SARA_DEBUG) printf("\t<Contents>\n");
3316
3317	arg2 = (char *) malloc( (size+1) sizeof(char *));
3318	for (i=0; i < size; i++) {
3319	py_obj = PyList_GetItem(obj1, i);
3320	if (PyString_Check(py_obj)) {
3321	arg2[i] = PyString_AsString(py_obj);
3322	if (SARA_DEBUG) printf("%s", arg2[i]);
3323	}
3324	else {
3325	PyErr_SetString(PyExc_TypeError, "not a list of strings");
3326	free(arg2);
3327	return NULL;
3328	}
3329	} // end for
3330	arg2[i] = 0;
3331	if (SARA_DEBUG) printf("\t</Contents>\n");
3332	}
3333	{
3334	arg3 = (int)(SWIG_As_int(obj2));
3335	if (SWIG_arg_fail(3)) SWIG_fail;
3336	}
3337	result = (int)pbs_rescreserve(arg1,arg2,arg3,arg4);
3338
3339	{
3340	resultobj = SWIG_From_int((int)(result));
3341	}
3342	resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3343	SWIG_From_int((arg4)) : SWIG_NewPointerObj((void)(arg4), SWIGTYPE_p_int, 0)));
3344	{
3345	free( (char *) arg2);
3346	}
3347	return resultobj;
3348	fail:
3349	{
3350	free( (char *) arg2);
3351	}
3352	return NULL;
3353	}
3354
3355
3356	static PyObject _wrap_pbs_rescrelease(PyObject self, PyObject *args) {
3357	PyObject *resultobj;
3358	int arg1 ;
3359	int arg2 ;
3360	int result;
3361	PyObject * obj0 = 0 ;
3362	PyObject * obj1 = 0 ;
3363
3364	if(!PyArg_ParseTuple(args,(char *)"OO:pbs_rescrelease",&obj0,&obj1)) goto fail;
3365	{
3366	arg1 = (int)(SWIG_As_int(obj0));
3367	if (SWIG_arg_fail(1)) SWIG_fail;
3368	}
3369	{
3370	arg2 = (int)(SWIG_As_int(obj1));
3371	if (SWIG_arg_fail(2)) SWIG_fail;
3372	}
3373	result = (int)pbs_rescrelease(arg1,arg2);
3374
3375	{
3376	resultobj = SWIG_From_int((int)(result));
3377	}
3378	return resultobj;
3379	fail:
3380	return NULL;
3381	}
3382
3383
3384	static PyObject _wrap_pbs_rerunjob(PyObject self, PyObject *args) {
3385	PyObject *resultobj;
3386	int arg1 ;
3387	char arg2 = (char ) 0 ;
3388	char arg3 = (char ) 0 ;
3389	int result;
3390	PyObject * obj0 = 0 ;
3391	PyObject * obj1 = 0 ;
3392	PyObject * obj2 = 0 ;
3393
3394	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_rerunjob",&obj0,&obj1,&obj2)) goto fail;
3395	{
3396	arg1 = (int)(SWIG_As_int(obj0));
3397	if (SWIG_arg_fail(1)) SWIG_fail;
3398	}
3399	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3400	SWIG_arg_fail(2);SWIG_fail;
3401	}
3402	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
3403	SWIG_arg_fail(3);SWIG_fail;
3404	}
3405	result = (int)pbs_rerunjob(arg1,arg2,arg3);
3406
3407	{
3408	resultobj = SWIG_From_int((int)(result));
3409	}
3410	return resultobj;
3411	fail:
3412	return NULL;
3413	}
3414
3415
3416	static PyObject _wrap_pbs_rlsjob(PyObject self, PyObject *args) {
3417	PyObject *resultobj;
3418	int arg1 ;
3419	char arg2 = (char ) 0 ;
3420	char arg3 = (char ) 0 ;
3421	char arg4 = (char ) 0 ;
3422	int result;
3423	PyObject * obj0 = 0 ;
3424	PyObject * obj1 = 0 ;
3425	PyObject * obj2 = 0 ;
3426	PyObject * obj3 = 0 ;
3427
3428	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_rlsjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
3429	{
3430	arg1 = (int)(SWIG_As_int(obj0));
3431	if (SWIG_arg_fail(1)) SWIG_fail;
3432	}
3433	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3434	SWIG_arg_fail(2);SWIG_fail;
3435	}
3436	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
3437	SWIG_arg_fail(3);SWIG_fail;
3438	}
3439	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3440	SWIG_arg_fail(4);SWIG_fail;
3441	}
3442	result = (int)pbs_rlsjob(arg1,arg2,arg3,arg4);
3443
3444	{
3445	resultobj = SWIG_From_int((int)(result));
3446	}
3447	return resultobj;
3448	fail:
3449	return NULL;
3450	}
3451
3452
3453	static PyObject _wrap_pbs_runjob(PyObject self, PyObject *args) {
3454	PyObject *resultobj;
3455	int arg1 ;
3456	char arg2 = (char ) 0 ;
3457	char arg3 = (char ) 0 ;
3458	char arg4 = (char ) 0 ;
3459	int result;
3460	PyObject * obj0 = 0 ;
3461	PyObject * obj1 = 0 ;
3462	PyObject * obj2 = 0 ;
3463	PyObject * obj3 = 0 ;
3464
3465	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_runjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
3466	{
3467	arg1 = (int)(SWIG_As_int(obj0));
3468	if (SWIG_arg_fail(1)) SWIG_fail;
3469	}
3470	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3471	SWIG_arg_fail(2);SWIG_fail;
3472	}
3473	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
3474	SWIG_arg_fail(3);SWIG_fail;
3475	}
3476	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3477	SWIG_arg_fail(4);SWIG_fail;
3478	}
3479	result = (int)pbs_runjob(arg1,arg2,arg3,arg4);
3480
3481	{
3482	resultobj = SWIG_From_int((int)(result));
3483	}
3484	return resultobj;
3485	fail:
3486	return NULL;
3487	}
3488
3489
3490	static PyObject _wrap_pbs_selectjob(PyObject self, PyObject *args) {
3491	PyObject *resultobj;
3492	int arg1 ;
3493	struct attropl arg2 = (struct attropl ) 0 ;
3494	char arg3 = (char ) 0 ;
3495	char **result;
3496	PyObject * obj0 = 0 ;
3497	PyObject * obj1 = 0 ;
3498	PyObject * obj2 = 0 ;
3499
3500	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_selectjob",&obj0,&obj1,&obj2)) goto fail;
3501	{
3502	arg1 = (int)(SWIG_As_int(obj0));
3503	if (SWIG_arg_fail(1)) SWIG_fail;
3504	}
3505	{
3506	PyObject *py_obj;
3507	struct attropl ptr, prev;
3508	char s[255];
3509	int i=0, size=0;
3510
3511	// printf("Python --> C\n");
3512
3513	if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
3514
3515	size = Get_List_Size(obj1);
3516
3517	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3518
3519	if ( size == -1 ) {
3520	PyErr_SetString(PyExc_TypeError, "not a list");
3521	return NULL;
3522	}
3523	//printf("Size = %d\n", size);
3524
3525	if (SARA_DEBUG) printf("\t<Contents>\n");
3526
3527	arg2 = prev = NULL;
3528	for ( i=0; i < size; i++ ) {
3529	py_obj = PyList_GetItem(obj1, i);
3530	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
3531	sprintf(s,"list item %d has wrong type", i);
3532	PyErr_SetString(PyExc_TypeError, s);
3533	return NULL;
3534
3535	// This will skipp the wrong entry
3536	// continue;
3537	}
3538
3539	/*
3540	* Make first entry head of C linked list
3541	*/
3542	if ( i == 0) {
3543	arg2 = ptr;
3544	ptr->next = prev;
3545	}
3546	else {
3547	prev->next = ptr;
3548	ptr->next = NULL;
3549	}
3550	prev = ptr;
3551
3552	} // end for
3553	if (SARA_DEBUG) printf("\t</Contents>\n");
3554	}
3555	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
3556	SWIG_arg_fail(3);SWIG_fail;
3557	}
3558	result = (char **)pbs_selectjob(arg1,arg2,arg3);
3559
3560	{
3561	int len=0, i;
3562
3563	if (SARA_DEBUG)
3564	printf("Converteren char ** -> python list\n");
3565
3566
3567	if (result == NULL)
3568	resultobj = PyList_New(0);
3569	else {
3570	while (result[len])
3571	len++;
3572	}
3573
3574	if (SARA_DEBUG)
3575	printf("\tSize of List: %d\n", len);
3576
3577	resultobj = PyList_New(len);
3578	if (SARA_DEBUG)
3579	printf("\t<Contents>\n");
3580	for (i=0; i < len; i++ ) {
3581	PyList_SetItem(resultobj, i , PyString_FromString(result[i]));
3582	if (SARA_DEBUG)
3583	printf("\t\t- %s\n", result[i]);
3584	}
3585	if (SARA_DEBUG)
3586	printf("\t</Contents>\n");
3587	}
3588	return resultobj;
3589	fail:
3590	return NULL;
3591	}
3592
3593
3594	static PyObject _wrap_pbs_sigjob(PyObject self, PyObject *args) {
3595	PyObject *resultobj;
3596	int arg1 ;
3597	char arg2 = (char ) 0 ;
3598	char arg3 = (char ) 0 ;
3599	char arg4 = (char ) 0 ;
3600	int result;
3601	PyObject * obj0 = 0 ;
3602	PyObject * obj1 = 0 ;
3603	PyObject * obj2 = 0 ;
3604	PyObject * obj3 = 0 ;
3605
3606	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_sigjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
3607	{
3608	arg1 = (int)(SWIG_As_int(obj0));
3609	if (SWIG_arg_fail(1)) SWIG_fail;
3610	}
3611	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3612	SWIG_arg_fail(2);SWIG_fail;
3613	}
3614	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
3615	SWIG_arg_fail(3);SWIG_fail;
3616	}
3617	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3618	SWIG_arg_fail(4);SWIG_fail;
3619	}
3620	result = (int)pbs_sigjob(arg1,arg2,arg3,arg4);
3621
3622	{
3623	resultobj = SWIG_From_int((int)(result));
3624	}
3625	return resultobj;
3626	fail:
3627	return NULL;
3628	}
3629
3630
3631	static PyObject _wrap_pbs_statfree(PyObject self, PyObject *args) {
3632	PyObject *resultobj;
3633	struct batch_status arg1 = (struct batch_status ) 0 ;
3634	PyObject * obj0 = 0 ;
3635
3636	if(!PyArg_ParseTuple(args,(char *)"O:pbs_statfree",&obj0)) goto fail;
3637	{
3638	PyObject *py_obj;
3639	struct batch_status ptr, prev;
3640	char s[255];
3641	int i=0, size=0;
3642
3643	// printf("Python --> C\n");
3644
3645	if (SARA_DEBUG) printf("Converteren python -> c (struct batch_status *):\n");
3646
3647	size = Get_List_Size(obj0);
3648	if (SARA_DEBUG) printf("\tSize of list: %d\n", size);
3649
3650	if ( size == -1 ) {
3651	PyErr_SetString(PyExc_TypeError, "not a list");
3652	return NULL;
3653	}
3654	// printf("Size = %d\n", size);
3655
3656	if (SARA_DEBUG) printf("\t<Contents>\n");
3657
3658	arg1 = prev = NULL;
3659	for ( i=0; i < size; i++ ) {
3660	py_obj = PyList_GetItem(obj0, i);
3661	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_batch_status, 1)) {
3662	sprintf(s,"list item %d has wrong type", i);
3663	PyErr_SetString(PyExc_TypeError, s);
3664	return NULL;
3665
3666	// This will skipp the wrong entry
3667	// continue;
3668	}
3669
3670	/*
3671	* Make first entry head of C linked list
3672	*/
3673	if ( i == 0) {
3674	arg1 = ptr;
3675	ptr->next = prev;
3676	}
3677	else {
3678	prev->next = ptr;
3679	ptr->next = NULL;
3680	}
3681
3682	if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3683	prev = ptr;
3684
3685	} // end for
3686
3687	if (SARA_DEBUG) printf("\t</Contents>\n");
3688	}
3689	pbs_statfree(arg1);
3690
3691	Py_INCREF(Py_None); resultobj = Py_None;
3692	return resultobj;
3693	fail:
3694	return NULL;
3695	}
3696
3697
3698	static PyObject _wrap_pbs_statjob(PyObject self, PyObject *args) {
3699	PyObject *resultobj;
3700	int arg1 ;
3701	char arg2 = (char ) 0 ;
3702	struct attrl arg3 = (struct attrl ) 0 ;
3703	char arg4 = (char ) 0 ;
3704	struct batch_status *result;
3705	PyObject * obj0 = 0 ;
3706	PyObject * obj1 = 0 ;
3707	PyObject * obj2 = 0 ;
3708	PyObject * obj3 = 0 ;
3709
3710	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_statjob",&obj0,&obj1,&obj2,&obj3)) goto fail;
3711	{
3712	arg1 = (int)(SWIG_As_int(obj0));
3713	if (SWIG_arg_fail(1)) SWIG_fail;
3714	}
3715	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3716	SWIG_arg_fail(2);SWIG_fail;
3717	}
3718	{
3719	PyObject *py_obj;
3720	struct attrl ptr, prev;
3721	char s[255];
3722	int i=0, size=0;
3723
3724	// printf("Python --> C\n");
3725
3726	if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
3727
3728	size = Get_List_Size(obj2);
3729	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3730
3731	if ( size == -1 ) {
3732	PyErr_SetString(PyExc_TypeError, "not a list");
3733	return NULL;
3734	}
3735
3736	if (SARA_DEBUG) printf("\t<Contents>\n");
3737
3738	arg3 = prev = NULL;
3739	for ( i=0; i < size; i++ ) {
3740	py_obj = PyList_GetItem(obj2, i);
3741	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
3742	sprintf(s,"list item %d has wrong type", i);
3743	PyErr_SetString(PyExc_TypeError, s);
3744	return NULL;
3745
3746	// This will skipp the wrong entry
3747	// continue;
3748	}
3749
3750	/*
3751	* Make first entry head of C linked list
3752	*/
3753	if ( i == 0) {
3754	arg3 = ptr;
3755	ptr->next = prev;
3756	}
3757	else {
3758	prev->next = ptr;
3759	ptr->next = NULL;
3760	}
3761	if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3762
3763	prev = ptr;
3764
3765	} // end for
3766	if (SARA_DEBUG) printf("\t</Contents>\n");
3767	}
3768	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3769	SWIG_arg_fail(4);SWIG_fail;
3770	}
3771	result = (struct batch_status *)pbs_statjob(arg1,arg2,arg3,arg4);
3772
3773	{
3774	PyObject *obj_batch;
3775	struct batch_status *ptr;
3776	int i=0, len=0;
3777
3778	// printf("Ja we are in bussniss\n");
3779	if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
3780
3781	// Deterime length of list
3782	//
3783	ptr = result;
3784	while (ptr != NULL) {
3785	len++;
3786	ptr = ptr->next;
3787	}
3788	resultobj = PyList_New(len);
3789
3790	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3791
3792	// Make a list of batch_status pointers
3793	//
3794	if (SARA_DEBUG) printf("\t<Contents>\n");
3795	ptr = result;
3796	for (i=0; i < len; i++) {
3797	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0);
3798	PyList_SetItem(resultobj, i, obj_batch);
3799	if (SARA_DEBUG) {
3800	printf("\t\t- %s\n", ptr->name);
3801	}
3802	ptr = ptr->next;
3803	}
3804	if (SARA_DEBUG) printf("\t</Contents>\n");
3805	}
3806	return resultobj;
3807	fail:
3808	return NULL;
3809	}
3810
3811
3812	static PyObject _wrap_pbs_selstat(PyObject self, PyObject *args) {
3813	PyObject *resultobj;
3814	int arg1 ;
3815	struct attropl arg2 = (struct attropl ) 0 ;
3816	char arg3 = (char ) 0 ;
3817	struct batch_status *result;
3818	PyObject * obj0 = 0 ;
3819	PyObject * obj1 = 0 ;
3820	PyObject * obj2 = 0 ;
3821
3822	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_selstat",&obj0,&obj1,&obj2)) goto fail;
3823	{
3824	arg1 = (int)(SWIG_As_int(obj0));
3825	if (SWIG_arg_fail(1)) SWIG_fail;
3826	}
3827	{
3828	PyObject *py_obj;
3829	struct attropl ptr, prev;
3830	char s[255];
3831	int i=0, size=0;
3832
3833	// printf("Python --> C\n");
3834
3835	if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
3836
3837	size = Get_List_Size(obj1);
3838
3839	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3840
3841	if ( size == -1 ) {
3842	PyErr_SetString(PyExc_TypeError, "not a list");
3843	return NULL;
3844	}
3845	//printf("Size = %d\n", size);
3846
3847	if (SARA_DEBUG) printf("\t<Contents>\n");
3848
3849	arg2 = prev = NULL;
3850	for ( i=0; i < size; i++ ) {
3851	py_obj = PyList_GetItem(obj1, i);
3852	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
3853	sprintf(s,"list item %d has wrong type", i);
3854	PyErr_SetString(PyExc_TypeError, s);
3855	return NULL;
3856
3857	// This will skipp the wrong entry
3858	// continue;
3859	}
3860
3861	/*
3862	* Make first entry head of C linked list
3863	*/
3864	if ( i == 0) {
3865	arg2 = ptr;
3866	ptr->next = prev;
3867	}
3868	else {
3869	prev->next = ptr;
3870	ptr->next = NULL;
3871	}
3872	prev = ptr;
3873
3874	} // end for
3875	if (SARA_DEBUG) printf("\t</Contents>\n");
3876	}
3877	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
3878	SWIG_arg_fail(3);SWIG_fail;
3879	}
3880	result = (struct batch_status *)pbs_selstat(arg1,arg2,arg3);
3881
3882	{
3883	PyObject *obj_batch;
3884	struct batch_status *ptr;
3885	int i=0, len=0;
3886
3887	// printf("Ja we are in bussniss\n");
3888	if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
3889
3890	// Deterime length of list
3891	//
3892	ptr = result;
3893	while (ptr != NULL) {
3894	len++;
3895	ptr = ptr->next;
3896	}
3897	resultobj = PyList_New(len);
3898
3899	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
3900
3901	// Make a list of batch_status pointers
3902	//
3903	if (SARA_DEBUG) printf("\t<Contents>\n");
3904	ptr = result;
3905	for (i=0; i < len; i++) {
3906	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0);
3907	PyList_SetItem(resultobj, i, obj_batch);
3908	if (SARA_DEBUG) {
3909	printf("\t\t- %s\n", ptr->name);
3910	}
3911	ptr = ptr->next;
3912	}
3913	if (SARA_DEBUG) printf("\t</Contents>\n");
3914	}
3915	return resultobj;
3916	fail:
3917	return NULL;
3918	}
3919
3920
3921	static PyObject _wrap_pbs_statque(PyObject self, PyObject *args) {
3922	PyObject *resultobj;
3923	int arg1 ;
3924	char arg2 = (char ) 0 ;
3925	struct attrl arg3 = (struct attrl ) 0 ;
3926	char arg4 = (char ) 0 ;
3927	struct batch_status *result;
3928	PyObject * obj0 = 0 ;
3929	PyObject * obj1 = 0 ;
3930	PyObject * obj2 = 0 ;
3931	PyObject * obj3 = 0 ;
3932
3933	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_statque",&obj0,&obj1,&obj2,&obj3)) goto fail;
3934	{
3935	arg1 = (int)(SWIG_As_int(obj0));
3936	if (SWIG_arg_fail(1)) SWIG_fail;
3937	}
3938	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
3939	SWIG_arg_fail(2);SWIG_fail;
3940	}
3941	{
3942	PyObject *py_obj;
3943	struct attrl ptr, prev;
3944	char s[255];
3945	int i=0, size=0;
3946
3947	// printf("Python --> C\n");
3948
3949	if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
3950
3951	size = Get_List_Size(obj2);
3952	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
3953
3954	if ( size == -1 ) {
3955	PyErr_SetString(PyExc_TypeError, "not a list");
3956	return NULL;
3957	}
3958
3959	if (SARA_DEBUG) printf("\t<Contents>\n");
3960
3961	arg3 = prev = NULL;
3962	for ( i=0; i < size; i++ ) {
3963	py_obj = PyList_GetItem(obj2, i);
3964	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
3965	sprintf(s,"list item %d has wrong type", i);
3966	PyErr_SetString(PyExc_TypeError, s);
3967	return NULL;
3968
3969	// This will skipp the wrong entry
3970	// continue;
3971	}
3972
3973	/*
3974	* Make first entry head of C linked list
3975	*/
3976	if ( i == 0) {
3977	arg3 = ptr;
3978	ptr->next = prev;
3979	}
3980	else {
3981	prev->next = ptr;
3982	ptr->next = NULL;
3983	}
3984	if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
3985
3986	prev = ptr;
3987
3988	} // end for
3989	if (SARA_DEBUG) printf("\t</Contents>\n");
3990	}
3991	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
3992	SWIG_arg_fail(4);SWIG_fail;
3993	}
3994	result = (struct batch_status *)pbs_statque(arg1,arg2,arg3,arg4);
3995
3996	{
3997	PyObject *obj_batch;
3998	struct batch_status *ptr;
3999	int i=0, len=0;
4000
4001	// printf("Ja we are in bussniss\n");
4002	if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
4003
4004	// Deterime length of list
4005	//
4006	ptr = result;
4007	while (ptr != NULL) {
4008	len++;
4009	ptr = ptr->next;
4010	}
4011	resultobj = PyList_New(len);
4012
4013	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
4014
4015	// Make a list of batch_status pointers
4016	//
4017	if (SARA_DEBUG) printf("\t<Contents>\n");
4018	ptr = result;
4019	for (i=0; i < len; i++) {
4020	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0);
4021	PyList_SetItem(resultobj, i, obj_batch);
4022	if (SARA_DEBUG) {
4023	printf("\t\t- %s\n", ptr->name);
4024	}
4025	ptr = ptr->next;
4026	}
4027	if (SARA_DEBUG) printf("\t</Contents>\n");
4028	}
4029	return resultobj;
4030	fail:
4031	return NULL;
4032	}
4033
4034
4035	static PyObject _wrap_pbs_statserver(PyObject self, PyObject *args) {
4036	PyObject *resultobj;
4037	int arg1 ;
4038	struct attrl arg2 = (struct attrl ) 0 ;
4039	char arg3 = (char ) 0 ;
4040	struct batch_status *result;
4041	PyObject * obj0 = 0 ;
4042	PyObject * obj1 = 0 ;
4043	PyObject * obj2 = 0 ;
4044
4045	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_statserver",&obj0,&obj1,&obj2)) goto fail;
4046	{
4047	arg1 = (int)(SWIG_As_int(obj0));
4048	if (SWIG_arg_fail(1)) SWIG_fail;
4049	}
4050	{
4051	PyObject *py_obj;
4052	struct attrl ptr, prev;
4053	char s[255];
4054	int i=0, size=0;
4055
4056	// printf("Python --> C\n");
4057
4058	if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
4059
4060	size = Get_List_Size(obj1);
4061	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
4062
4063	if ( size == -1 ) {
4064	PyErr_SetString(PyExc_TypeError, "not a list");
4065	return NULL;
4066	}
4067
4068	if (SARA_DEBUG) printf("\t<Contents>\n");
4069
4070	arg2 = prev = NULL;
4071	for ( i=0; i < size; i++ ) {
4072	py_obj = PyList_GetItem(obj1, i);
4073	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
4074	sprintf(s,"list item %d has wrong type", i);
4075	PyErr_SetString(PyExc_TypeError, s);
4076	return NULL;
4077
4078	// This will skipp the wrong entry
4079	// continue;
4080	}
4081
4082	/*
4083	* Make first entry head of C linked list
4084	*/
4085	if ( i == 0) {
4086	arg2 = ptr;
4087	ptr->next = prev;
4088	}
4089	else {
4090	prev->next = ptr;
4091	ptr->next = NULL;
4092	}
4093	if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
4094
4095	prev = ptr;
4096
4097	} // end for
4098	if (SARA_DEBUG) printf("\t</Contents>\n");
4099	}
4100	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
4101	SWIG_arg_fail(3);SWIG_fail;
4102	}
4103	result = (struct batch_status *)pbs_statserver(arg1,arg2,arg3);
4104
4105	{
4106	PyObject *obj_batch;
4107	struct batch_status *ptr;
4108	int i=0, len=0;
4109
4110	// printf("Ja we are in bussniss\n");
4111	if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
4112
4113	// Deterime length of list
4114	//
4115	ptr = result;
4116	while (ptr != NULL) {
4117	len++;
4118	ptr = ptr->next;
4119	}
4120	resultobj = PyList_New(len);
4121
4122	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
4123
4124	// Make a list of batch_status pointers
4125	//
4126	if (SARA_DEBUG) printf("\t<Contents>\n");
4127	ptr = result;
4128	for (i=0; i < len; i++) {
4129	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0);
4130	PyList_SetItem(resultobj, i, obj_batch);
4131	if (SARA_DEBUG) {
4132	printf("\t\t- %s\n", ptr->name);
4133	}
4134	ptr = ptr->next;
4135	}
4136	if (SARA_DEBUG) printf("\t</Contents>\n");
4137	}
4138	return resultobj;
4139	fail:
4140	return NULL;
4141	}
4142
4143
4144	static PyObject _wrap_pbs_statnode(PyObject self, PyObject *args) {
4145	PyObject *resultobj;
4146	int arg1 ;
4147	char arg2 = (char ) 0 ;
4148	struct attrl arg3 = (struct attrl ) 0 ;
4149	char arg4 = (char ) 0 ;
4150	struct batch_status *result;
4151	PyObject * obj0 = 0 ;
4152	PyObject * obj1 = 0 ;
4153	PyObject * obj2 = 0 ;
4154	PyObject * obj3 = 0 ;
4155
4156	if(!PyArg_ParseTuple(args,(char *)"OOOO:pbs_statnode",&obj0,&obj1,&obj2,&obj3)) goto fail;
4157	{
4158	arg1 = (int)(SWIG_As_int(obj0));
4159	if (SWIG_arg_fail(1)) SWIG_fail;
4160	}
4161	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
4162	SWIG_arg_fail(2);SWIG_fail;
4163	}
4164	{
4165	PyObject *py_obj;
4166	struct attrl ptr, prev;
4167	char s[255];
4168	int i=0, size=0;
4169
4170	// printf("Python --> C\n");
4171
4172	if (SARA_DEBUG) printf("Converteren python -> c (struct attrl *):\n");
4173
4174	size = Get_List_Size(obj2);
4175	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
4176
4177	if ( size == -1 ) {
4178	PyErr_SetString(PyExc_TypeError, "not a list");
4179	return NULL;
4180	}
4181
4182	if (SARA_DEBUG) printf("\t<Contents>\n");
4183
4184	arg3 = prev = NULL;
4185	for ( i=0; i < size; i++ ) {
4186	py_obj = PyList_GetItem(obj2, i);
4187	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attrl, 1)) {
4188	sprintf(s,"list item %d has wrong type", i);
4189	PyErr_SetString(PyExc_TypeError, s);
4190	return NULL;
4191
4192	// This will skipp the wrong entry
4193	// continue;
4194	}
4195
4196	/*
4197	* Make first entry head of C linked list
4198	*/
4199	if ( i == 0) {
4200	arg3 = ptr;
4201	ptr->next = prev;
4202	}
4203	else {
4204	prev->next = ptr;
4205	ptr->next = NULL;
4206	}
4207	if (SARA_DEBUG) printf("\t\t- %s\n", ptr->name);
4208
4209	prev = ptr;
4210
4211	} // end for
4212	if (SARA_DEBUG) printf("\t</Contents>\n");
4213	}
4214	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
4215	SWIG_arg_fail(4);SWIG_fail;
4216	}
4217	result = (struct batch_status *)pbs_statnode(arg1,arg2,arg3,arg4);
4218
4219	{
4220	PyObject *obj_batch;
4221	struct batch_status *ptr;
4222	int i=0, len=0;
4223
4224	// printf("Ja we are in bussniss\n");
4225	if (SARA_DEBUG) printf("Converteren c (struct batch_status *) -> python:\n");
4226
4227	// Deterime length of list
4228	//
4229	ptr = result;
4230	while (ptr != NULL) {
4231	len++;
4232	ptr = ptr->next;
4233	}
4234	resultobj = PyList_New(len);
4235
4236	if (SARA_DEBUG) printf("\tSize of List: %d\n", len);
4237
4238	// Make a list of batch_status pointers
4239	//
4240	if (SARA_DEBUG) printf("\t<Contents>\n");
4241	ptr = result;
4242	for (i=0; i < len; i++) {
4243	obj_batch = SWIG_NewPointerObj((void *)ptr, SWIGTYPE_p_batch_status,0);
4244	PyList_SetItem(resultobj, i, obj_batch);
4245	if (SARA_DEBUG) {
4246	printf("\t\t- %s\n", ptr->name);
4247	}
4248	ptr = ptr->next;
4249	}
4250	if (SARA_DEBUG) printf("\t</Contents>\n");
4251	}
4252	return resultobj;
4253	fail:
4254	return NULL;
4255	}
4256
4257
4258	static PyObject _wrap_pbs_submit(PyObject self, PyObject *args) {
4259	PyObject *resultobj;
4260	int arg1 ;
4261	struct attropl arg2 = (struct attropl ) 0 ;
4262	char arg3 = (char ) 0 ;
4263	char arg4 = (char ) 0 ;
4264	char arg5 = (char ) 0 ;
4265	char *result;
4266	PyObject * obj0 = 0 ;
4267	PyObject * obj1 = 0 ;
4268	PyObject * obj2 = 0 ;
4269	PyObject * obj3 = 0 ;
4270	PyObject * obj4 = 0 ;
4271
4272	if(!PyArg_ParseTuple(args,(char *)"OOOOO:pbs_submit",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4273	{
4274	arg1 = (int)(SWIG_As_int(obj0));
4275	if (SWIG_arg_fail(1)) SWIG_fail;
4276	}
4277	{
4278	PyObject *py_obj;
4279	struct attropl ptr, prev;
4280	char s[255];
4281	int i=0, size=0;
4282
4283	// printf("Python --> C\n");
4284
4285	if (SARA_DEBUG) printf("Converteren python -> c (struct attropl *):\n");
4286
4287	size = Get_List_Size(obj1);
4288
4289	if (SARA_DEBUG) printf("\tSize of List: %d\n", size);
4290
4291	if ( size == -1 ) {
4292	PyErr_SetString(PyExc_TypeError, "not a list");
4293	return NULL;
4294	}
4295	//printf("Size = %d\n", size);
4296
4297	if (SARA_DEBUG) printf("\t<Contents>\n");
4298
4299	arg2 = prev = NULL;
4300	for ( i=0; i < size; i++ ) {
4301	py_obj = PyList_GetItem(obj1, i);
4302	if (SWIG_ConvertPtr(py_obj, (void **) &ptr, SWIGTYPE_p_attropl, 1)) {
4303	sprintf(s,"list item %d has wrong type", i);
4304	PyErr_SetString(PyExc_TypeError, s);
4305	return NULL;
4306
4307	// This will skipp the wrong entry
4308	// continue;
4309	}
4310
4311	/*
4312	* Make first entry head of C linked list
4313	*/
4314	if ( i == 0) {
4315	arg2 = ptr;
4316	ptr->next = prev;
4317	}
4318	else {
4319	prev->next = ptr;
4320	ptr->next = NULL;
4321	}
4322	prev = ptr;
4323
4324	} // end for
4325	if (SARA_DEBUG) printf("\t</Contents>\n");
4326	}
4327	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
4328	SWIG_arg_fail(3);SWIG_fail;
4329	}
4330	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
4331	SWIG_arg_fail(4);SWIG_fail;
4332	}
4333	if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) {
4334	SWIG_arg_fail(5);SWIG_fail;
4335	}
4336	result = (char *)pbs_submit(arg1,arg2,arg3,arg4,arg5);
4337
4338	resultobj = SWIG_FromCharPtr(result);
4339	return resultobj;
4340	fail:
4341	return NULL;
4342	}
4343
4344
4345	static PyObject _wrap_pbs_terminate(PyObject self, PyObject *args) {
4346	PyObject *resultobj;
4347	int arg1 ;
4348	int arg2 ;
4349	char arg3 = (char ) 0 ;
4350	int result;
4351	PyObject * obj0 = 0 ;
4352	PyObject * obj1 = 0 ;
4353	PyObject * obj2 = 0 ;
4354
4355	if(!PyArg_ParseTuple(args,(char *)"OOO:pbs_terminate",&obj0,&obj1,&obj2)) goto fail;
4356	{
4357	arg1 = (int)(SWIG_As_int(obj0));
4358	if (SWIG_arg_fail(1)) SWIG_fail;
4359	}
4360	{
4361	arg2 = (int)(SWIG_As_int(obj1));
4362	if (SWIG_arg_fail(2)) SWIG_fail;
4363	}
4364	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
4365	SWIG_arg_fail(3);SWIG_fail;
4366	}
4367	result = (int)pbs_terminate(arg1,arg2,arg3);
4368
4369	{
4370	resultobj = SWIG_From_int((int)(result));
4371	}
4372	return resultobj;
4373	fail:
4374	return NULL;
4375	}
4376
4377
4378	static PyObject _wrap_totpool(PyObject self, PyObject *args) {
4379	PyObject *resultobj;
4380	int arg1 ;
4381	int arg2 ;
4382	int result;
4383	PyObject * obj0 = 0 ;
4384	PyObject * obj1 = 0 ;
4385
4386	if(!PyArg_ParseTuple(args,(char *)"OO:totpool",&obj0,&obj1)) goto fail;
4387	{
4388	arg1 = (int)(SWIG_As_int(obj0));
4389	if (SWIG_arg_fail(1)) SWIG_fail;
4390	}
4391	{
4392	arg2 = (int)(SWIG_As_int(obj1));
4393	if (SWIG_arg_fail(2)) SWIG_fail;
4394	}
4395	result = (int)totpool(arg1,arg2);
4396
4397	{
4398	resultobj = SWIG_From_int((int)(result));
4399	}
4400	return resultobj;
4401	fail:
4402	return NULL;
4403	}
4404
4405
4406	static PyObject _wrap_usepool(PyObject self, PyObject *args) {
4407	PyObject *resultobj;
4408	int arg1 ;
4409	int arg2 ;
4410	int result;
4411	PyObject * obj0 = 0 ;
4412	PyObject * obj1 = 0 ;
4413
4414	if(!PyArg_ParseTuple(args,(char *)"OO:usepool",&obj0,&obj1)) goto fail;
4415	{
4416	arg1 = (int)(SWIG_As_int(obj0));
4417	if (SWIG_arg_fail(1)) SWIG_fail;
4418	}
4419	{
4420	arg2 = (int)(SWIG_As_int(obj1));
4421	if (SWIG_arg_fail(2)) SWIG_fail;
4422	}
4423	result = (int)usepool(arg1,arg2);
4424
4425	{
4426	resultobj = SWIG_From_int((int)(result));
4427	}
4428	return resultobj;
4429	fail:
4430	return NULL;
4431	}
4432
4433
4434	static PyObject _wrap_openrm(PyObject self, PyObject *args) {
4435	PyObject *resultobj;
4436	char arg1 = (char ) 0 ;
4437	unsigned int arg2 ;
4438	int result;
4439	PyObject * obj0 = 0 ;
4440	PyObject * obj1 = 0 ;
4441
4442	if(!PyArg_ParseTuple(args,(char *)"OO:openrm",&obj0,&obj1)) goto fail;
4443	if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
4444	SWIG_arg_fail(1);SWIG_fail;
4445	}
4446	{
4447	arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
4448	if (SWIG_arg_fail(2)) SWIG_fail;
4449	}
4450	result = (int)openrm(arg1,arg2);
4451
4452	{
4453	resultobj = SWIG_From_int((int)(result));
4454	}
4455	return resultobj;
4456	fail:
4457	return NULL;
4458	}
4459
4460
4461	static PyObject _wrap_closerm(PyObject self, PyObject *args) {
4462	PyObject *resultobj;
4463	int arg1 ;
4464	int result;
4465	PyObject * obj0 = 0 ;
4466
4467	if(!PyArg_ParseTuple(args,(char *)"O:closerm",&obj0)) goto fail;
4468	{
4469	arg1 = (int)(SWIG_As_int(obj0));
4470	if (SWIG_arg_fail(1)) SWIG_fail;
4471	}
4472	result = (int)closerm(arg1);
4473
4474	{
4475	resultobj = SWIG_From_int((int)(result));
4476	}
4477	return resultobj;
4478	fail:
4479	return NULL;
4480	}
4481
4482
4483	static PyObject _wrap_downrm(PyObject self, PyObject *args) {
4484	PyObject *resultobj;
4485	int arg1 ;
4486	int result;
4487	PyObject * obj0 = 0 ;
4488
4489	if(!PyArg_ParseTuple(args,(char *)"O:downrm",&obj0)) goto fail;
4490	{
4491	arg1 = (int)(SWIG_As_int(obj0));
4492	if (SWIG_arg_fail(1)) SWIG_fail;
4493	}
4494	result = (int)downrm(arg1);
4495
4496	{
4497	resultobj = SWIG_From_int((int)(result));
4498	}
4499	return resultobj;
4500	fail:
4501	return NULL;
4502	}
4503
4504
4505	static PyObject _wrap_configrm(PyObject self, PyObject *args) {
4506	PyObject *resultobj;
4507	int arg1 ;
4508	char arg2 = (char ) 0 ;
4509	int result;
4510	PyObject * obj0 = 0 ;
4511	PyObject * obj1 = 0 ;
4512
4513	if(!PyArg_ParseTuple(args,(char *)"OO:configrm",&obj0,&obj1)) goto fail;
4514	{
4515	arg1 = (int)(SWIG_As_int(obj0));
4516	if (SWIG_arg_fail(1)) SWIG_fail;
4517	}
4518	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
4519	SWIG_arg_fail(2);SWIG_fail;
4520	}
4521	result = (int)configrm(arg1,arg2);
4522
4523	{
4524	resultobj = SWIG_From_int((int)(result));
4525	}
4526	return resultobj;
4527	fail:
4528	return NULL;
4529	}
4530
4531
4532	static PyObject _wrap_addreq(PyObject self, PyObject *args) {
4533	PyObject *resultobj;
4534	int arg1 ;
4535	char arg2 = (char ) 0 ;
4536	int result;
4537	PyObject * obj0 = 0 ;
4538	PyObject * obj1 = 0 ;
4539
4540	if(!PyArg_ParseTuple(args,(char *)"OO:addreq",&obj0,&obj1)) goto fail;
4541	{
4542	arg1 = (int)(SWIG_As_int(obj0));
4543	if (SWIG_arg_fail(1)) SWIG_fail;
4544	}
4545	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
4546	SWIG_arg_fail(2);SWIG_fail;
4547	}
4548	result = (int)addreq(arg1,arg2);
4549
4550	{
4551	resultobj = SWIG_From_int((int)(result));
4552	}
4553	return resultobj;
4554	fail:
4555	return NULL;
4556	}
4557
4558
4559	static PyObject _wrap_allreq(PyObject self, PyObject *args) {
4560	PyObject *resultobj;
4561	char arg1 = (char ) 0 ;
4562	int result;
4563	PyObject * obj0 = 0 ;
4564
4565	if(!PyArg_ParseTuple(args,(char *)"O:allreq",&obj0)) goto fail;
4566	if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
4567	SWIG_arg_fail(1);SWIG_fail;
4568	}
4569	result = (int)allreq(arg1);
4570
4571	{
4572	resultobj = SWIG_From_int((int)(result));
4573	}
4574	return resultobj;
4575	fail:
4576	return NULL;
4577	}
4578
4579
4580	static PyObject _wrap_flushreq(PyObject self, PyObject *args) {
4581	PyObject *resultobj;
4582	int result;
4583
4584	if(!PyArg_ParseTuple(args,(char *)":flushreq")) goto fail;
4585	result = (int)flushreq();
4586
4587	{
4588	resultobj = SWIG_From_int((int)(result));
4589	}
4590	return resultobj;
4591	fail:
4592	return NULL;
4593	}
4594
4595
4596	static PyObject _wrap_activereq(PyObject self, PyObject *args) {
4597	PyObject *resultobj;
4598	int result;
4599
4600	if(!PyArg_ParseTuple(args,(char *)":activereq")) goto fail;
4601	result = (int)activereq();
4602
4603	{
4604	resultobj = SWIG_From_int((int)(result));
4605	}
4606	return resultobj;
4607	fail:
4608	return NULL;
4609	}
4610
4611
4612	static PyObject _wrap_fullresp(PyObject self, PyObject *args) {
4613	PyObject *resultobj;
4614	int arg1 ;
4615	PyObject * obj0 = 0 ;
4616
4617	if(!PyArg_ParseTuple(args,(char *)"O:fullresp",&obj0)) goto fail;
4618	{
4619	arg1 = (int)(SWIG_As_int(obj0));
4620	if (SWIG_arg_fail(1)) SWIG_fail;
4621	}
4622	fullresp(arg1);
4623
4624	Py_INCREF(Py_None); resultobj = Py_None;
4625	return resultobj;
4626	fail:
4627	return NULL;
4628	}
4629
4630
4631	static PyObject _wrap_getreq(PyObject self, PyObject *args) {
4632	PyObject *resultobj;
4633	int arg1 ;
4634	char *result;
4635	PyObject * obj0 = 0 ;
4636
4637	if(!PyArg_ParseTuple(args,(char *)"O:getreq",&obj0)) goto fail;
4638	{
4639	arg1 = (int)(SWIG_As_int(obj0));
4640	if (SWIG_arg_fail(1)) SWIG_fail;
4641	}
4642	result = (char *)getreq(arg1);
4643
4644	resultobj = SWIG_FromCharPtr(result);
4645	return resultobj;
4646	fail:
4647	return NULL;
4648	}
4649
4650
4651	static int _wrap_log_event_mask_set(PyObject *_val) {
4652	{
4653	void *temp;
4654	if ((SWIG_ConvertPtr(_val, &temp, SWIGTYPE_p_long, SWIG_POINTER_EXCEPTION \| SWIG_POINTER_DISOWN)) == -1) {
4655	SWIG_append_errmsg("C/C++ variable 'log_event_mask'");
4656	return 1;
4657	}
4658	log_event_mask = (long *) temp;
4659	}
4660	return 0;
4661	}
4662
4663
4664	static PyObject *_wrap_log_event_mask_get(void) {
4665	PyObject *pyobj;
4666
4667	pyobj = SWIG_NewPointerObj((void *)(log_event_mask), SWIGTYPE_p_long, 0);
4668	return pyobj;
4669	}
4670
4671
4672	static PyObject _wrap_log_close(PyObject self, PyObject *args) {
4673	PyObject *resultobj;
4674	int arg1 ;
4675	PyObject * obj0 = 0 ;
4676
4677	if(!PyArg_ParseTuple(args,(char *)"O:log_close",&obj0)) goto fail;
4678	{
4679	arg1 = (int)(SWIG_As_int(obj0));
4680	if (SWIG_arg_fail(1)) SWIG_fail;
4681	}
4682	log_close(arg1);
4683
4684	Py_INCREF(Py_None); resultobj = Py_None;
4685	return resultobj;
4686	fail:
4687	return NULL;
4688	}
4689
4690
4691	static PyObject _wrap_log_err(PyObject self, PyObject *args) {
4692	PyObject *resultobj;
4693	int arg1 ;
4694	char arg2 = (char ) 0 ;
4695	char arg3 = (char ) 0 ;
4696	PyObject * obj0 = 0 ;
4697	PyObject * obj1 = 0 ;
4698	PyObject * obj2 = 0 ;
4699
4700	if(!PyArg_ParseTuple(args,(char *)"OOO:log_err",&obj0,&obj1,&obj2)) goto fail;
4701	{
4702	arg1 = (int)(SWIG_As_int(obj0));
4703	if (SWIG_arg_fail(1)) SWIG_fail;
4704	}
4705	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
4706	SWIG_arg_fail(2);SWIG_fail;
4707	}
4708	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
4709	SWIG_arg_fail(3);SWIG_fail;
4710	}
4711	log_err(arg1,arg2,arg3);
4712
4713	Py_INCREF(Py_None); resultobj = Py_None;
4714	return resultobj;
4715	fail:
4716	return NULL;
4717	}
4718
4719
4720	static PyObject _wrap_log_event(PyObject self, PyObject *args) {
4721	PyObject *resultobj;
4722	int arg1 ;
4723	int arg2 ;
4724	char arg3 = (char ) 0 ;
4725	char arg4 = (char ) 0 ;
4726	PyObject * obj0 = 0 ;
4727	PyObject * obj1 = 0 ;
4728	PyObject * obj2 = 0 ;
4729	PyObject * obj3 = 0 ;
4730
4731	if(!PyArg_ParseTuple(args,(char *)"OOOO:log_event",&obj0,&obj1,&obj2,&obj3)) goto fail;
4732	{
4733	arg1 = (int)(SWIG_As_int(obj0));
4734	if (SWIG_arg_fail(1)) SWIG_fail;
4735	}
4736	{
4737	arg2 = (int)(SWIG_As_int(obj1));
4738	if (SWIG_arg_fail(2)) SWIG_fail;
4739	}
4740	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
4741	SWIG_arg_fail(3);SWIG_fail;
4742	}
4743	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
4744	SWIG_arg_fail(4);SWIG_fail;
4745	}
4746	log_event(arg1,arg2,arg3,arg4);
4747
4748	Py_INCREF(Py_None); resultobj = Py_None;
4749	return resultobj;
4750	fail:
4751	return NULL;
4752	}
4753
4754
4755	static PyObject _wrap_log_open(PyObject self, PyObject *args) {
4756	PyObject *resultobj;
4757	char arg1 = (char ) 0 ;
4758	char arg2 = (char ) 0 ;
4759	int result;
4760	PyObject * obj0 = 0 ;
4761	PyObject * obj1 = 0 ;
4762
4763	if(!PyArg_ParseTuple(args,(char *)"OO:log_open",&obj0,&obj1)) goto fail;
4764	if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
4765	SWIG_arg_fail(1);SWIG_fail;
4766	}
4767	if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
4768	SWIG_arg_fail(2);SWIG_fail;
4769	}
4770	result = (int)log_open(arg1,arg2);
4771
4772	{
4773	resultobj = SWIG_From_int((int)(result));
4774	}
4775	return resultobj;
4776	fail:
4777	return NULL;
4778	}
4779
4780
4781	static PyObject _wrap_log_record(PyObject self, PyObject *args) {
4782	PyObject *resultobj;
4783	int arg1 ;
4784	int arg2 ;
4785	char arg3 = (char ) 0 ;
4786	char arg4 = (char ) 0 ;
4787	PyObject * obj0 = 0 ;
4788	PyObject * obj1 = 0 ;
4789	PyObject * obj2 = 0 ;
4790	PyObject * obj3 = 0 ;
4791
4792	if(!PyArg_ParseTuple(args,(char *)"OOOO:log_record",&obj0,&obj1,&obj2,&obj3)) goto fail;
4793	{
4794	arg1 = (int)(SWIG_As_int(obj0));
4795	if (SWIG_arg_fail(1)) SWIG_fail;
4796	}
4797	{
4798	arg2 = (int)(SWIG_As_int(obj1));
4799	if (SWIG_arg_fail(2)) SWIG_fail;
4800	}
4801	if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
4802	SWIG_arg_fail(3);SWIG_fail;
4803	}
4804	if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
4805	SWIG_arg_fail(4);SWIG_fail;
4806	}
4807	log_record(arg1,arg2,arg3,arg4);
4808
4809	Py_INCREF(Py_None); resultobj = Py_None;
4810	return resultobj;
4811	fail:
4812	return NULL;
4813	}
4814
4815
4816	static int _wrap_log_buffer_set(PyObject *_val) {
4817	{
4818	if (!SWIG_AsCharArray(_val, log_buffer, 4096)) {
4819	SWIG_append_errmsg("C/C++ variable 'log_buffer'");
4820	return 1;
4821	}
4822	}
4823	return 0;
4824	}
4825
4826
4827	static PyObject *_wrap_log_buffer_get(void) {
4828	PyObject *pyobj;
4829
4830	{
4831	size_t size = 4096;
4832	#ifndef SWIG_PRESERVE_CARRAY_SIZE
4833	while (size && (log_buffer[size - 1] == '\0')) --size;
4834	#endif
4835	pyobj = SWIG_FromCharArray(log_buffer, size);
4836	}
4837	return pyobj;
4838	}
4839
4840
4841	static PyObject _wrap_setup_env(PyObject self, PyObject *args) {
4842	PyObject *resultobj;
4843	char arg1 = (char ) 0 ;
4844	int result;
4845	PyObject * obj0 = 0 ;
4846
4847	if(!PyArg_ParseTuple(args,(char *)"O:setup_env",&obj0)) goto fail;
4848	if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
4849	SWIG_arg_fail(1);SWIG_fail;
4850	}
4851	result = (int)setup_env(arg1);
4852
4853	{
4854	resultobj = SWIG_From_int((int)(result));
4855	}
4856	return resultobj;
4857	fail:
4858	return NULL;
4859	}
4860
4861
4862	static PyObject _wrap_chk_file_sec(PyObject self, PyObject *args) {
4863	PyObject *resultobj;
4864	char arg1 = (char ) 0 ;
4865	int arg2 ;
4866	int arg3 ;
4867	int arg4 ;
4868	int arg5 ;
4869	int result;
4870	PyObject * obj0 = 0 ;
4871	PyObject * obj1 = 0 ;
4872	PyObject * obj2 = 0 ;
4873	PyObject * obj3 = 0 ;
4874	PyObject * obj4 = 0 ;
4875
4876	if(!PyArg_ParseTuple(args,(char *)"OOOOO:chk_file_sec",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4877	if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
4878	SWIG_arg_fail(1);SWIG_fail;
4879	}
4880	{
4881	arg2 = (int)(SWIG_As_int(obj1));
4882	if (SWIG_arg_fail(2)) SWIG_fail;
4883	}
4884	{
4885	arg3 = (int)(SWIG_As_int(obj2));
4886	if (SWIG_arg_fail(3)) SWIG_fail;
4887	}
4888	{
4889	arg4 = (int)(SWIG_As_int(obj3));
4890	if (SWIG_arg_fail(4)) SWIG_fail;
4891	}
4892	{
4893	arg5 = (int)(SWIG_As_int(obj4));
4894	if (SWIG_arg_fail(5)) SWIG_fail;
4895	}
4896	result = (int)chk_file_sec(arg1,arg2,arg3,arg4,arg5);
4897
4898	{
4899	resultobj = SWIG_From_int((int)(result));
4900	}
4901	return resultobj;
4902	fail:
4903	return NULL;
4904	}
4905
4906
4907	static int _wrap_msg_daemonname_set(PyObject *_val) {
4908	{
4909	char *cptr = 0;
4910	if (!SWIG_AsNewCharPtr(_val, &cptr)) {
4911	SWIG_append_errmsg("C/C++ variable 'msg_daemonname'");
4912	return 1;
4913	}
4914	if (msg_daemonname) free((char*)msg_daemonname);
4915	msg_daemonname = cptr;
4916	}
4917	return 0;
4918	}
4919
4920
4921	static PyObject *_wrap_msg_daemonname_get(void) {
4922	PyObject *pyobj;
4923
4924	pyobj = SWIG_FromCharPtr(msg_daemonname);
4925	return pyobj;
4926	}
4927
4928
4929	static PyMethodDef SwigMethods[] = {
4930	{ (char *)"new_attrl", _wrap_new_attrl, METH_VARARGS, NULL},
4931	{ (char *)"new_attropl", _wrap_new_attropl, METH_VARARGS, NULL},
4932	{ (char *)"new_batch_status", _wrap_new_batch_status, METH_VARARGS, NULL},
4933	{ (char *)"get_error", _wrap_get_error, METH_VARARGS, NULL},
4934	{ (char *)"attrl_name_set", _wrap_attrl_name_set, METH_VARARGS, NULL},
4935	{ (char *)"attrl_name_get", _wrap_attrl_name_get, METH_VARARGS, NULL},
4936	{ (char *)"attrl_resource_set", _wrap_attrl_resource_set, METH_VARARGS, NULL},
4937	{ (char *)"attrl_resource_get", _wrap_attrl_resource_get, METH_VARARGS, NULL},
4938	{ (char *)"attrl_value_set", _wrap_attrl_value_set, METH_VARARGS, NULL},
4939	{ (char *)"attrl_value_get", _wrap_attrl_value_get, METH_VARARGS, NULL},
4940	{ (char *)"attrl_op_set", _wrap_attrl_op_set, METH_VARARGS, NULL},
4941	{ (char *)"attrl_op_get", _wrap_attrl_op_get, METH_VARARGS, NULL},
4942	{ (char *)"attrl___str__", _wrap_attrl___str__, METH_VARARGS, NULL},
4943	{ (char *)"attrl_swigregister", attrl_swigregister, METH_VARARGS, NULL},
4944	{ (char *)"attropl_name_set", _wrap_attropl_name_set, METH_VARARGS, NULL},
4945	{ (char *)"attropl_name_get", _wrap_attropl_name_get, METH_VARARGS, NULL},
4946	{ (char *)"attropl_resource_set", _wrap_attropl_resource_set, METH_VARARGS, NULL},
4947	{ (char *)"attropl_resource_get", _wrap_attropl_resource_get, METH_VARARGS, NULL},
4948	{ (char *)"attropl_value_set", _wrap_attropl_value_set, METH_VARARGS, NULL},
4949	{ (char *)"attropl_value_get", _wrap_attropl_value_get, METH_VARARGS, NULL},
4950	{ (char *)"attropl_op_set", _wrap_attropl_op_set, METH_VARARGS, NULL},
4951	{ (char *)"attropl_op_get", _wrap_attropl_op_get, METH_VARARGS, NULL},
4952	{ (char *)"attropl___str__", _wrap_attropl___str__, METH_VARARGS, NULL},
4953	{ (char *)"attropl_swigregister", attropl_swigregister, METH_VARARGS, NULL},
4954	{ (char *)"batch_status_name_set", _wrap_batch_status_name_set, METH_VARARGS, NULL},
4955	{ (char *)"batch_status_name_get", _wrap_batch_status_name_get, METH_VARARGS, NULL},
4956	{ (char *)"batch_status_attribs_set", _wrap_batch_status_attribs_set, METH_VARARGS, NULL},
4957	{ (char *)"batch_status_attribs_get", _wrap_batch_status_attribs_get, METH_VARARGS, NULL},
4958	{ (char *)"batch_status_text_set", _wrap_batch_status_text_set, METH_VARARGS, NULL},
4959	{ (char *)"batch_status_text_get", _wrap_batch_status_text_get, METH_VARARGS, NULL},
4960	{ (char *)"batch_status_swigregister", batch_status_swigregister, METH_VARARGS, NULL},
4961	{ (char *)"avail", _wrap_avail, METH_VARARGS, NULL},
4962	{ (char *)"pbs_asyrunjob", _wrap_pbs_asyrunjob, METH_VARARGS, NULL},
4963	{ (char *)"pbs_alterjob", _wrap_pbs_alterjob, METH_VARARGS, NULL},
4964	{ (char *)"pbs_connect", _wrap_pbs_connect, METH_VARARGS, NULL},
4965	{ (char *)"pbs_query_max_connections", _wrap_pbs_query_max_connections, METH_VARARGS, NULL},
4966	{ (char *)"pbs_default", _wrap_pbs_default, METH_VARARGS, NULL},
4967	{ (char *)"pbs_deljob", _wrap_pbs_deljob, METH_VARARGS, NULL},
4968	{ (char *)"pbs_disconnect", _wrap_pbs_disconnect, METH_VARARGS, NULL},
4969	{ (char *)"pbs_holdjob", _wrap_pbs_holdjob, METH_VARARGS, NULL},
4970	{ (char *)"pbs_locjob", _wrap_pbs_locjob, METH_VARARGS, NULL},
4971	{ (char *)"pbs_manager", _wrap_pbs_manager, METH_VARARGS, NULL},
4972	{ (char *)"pbs_movejob", _wrap_pbs_movejob, METH_VARARGS, NULL},
4973	{ (char *)"pbs_msgjob", _wrap_pbs_msgjob, METH_VARARGS, NULL},
4974	{ (char *)"pbs_orderjob", _wrap_pbs_orderjob, METH_VARARGS, NULL},
4975	{ (char *)"pbs_rescquery", _wrap_pbs_rescquery, METH_VARARGS, NULL},
4976	{ (char *)"pbs_rescreserve", _wrap_pbs_rescreserve, METH_VARARGS, NULL},
4977	{ (char *)"pbs_rescrelease", _wrap_pbs_rescrelease, METH_VARARGS, NULL},
4978	{ (char *)"pbs_rerunjob", _wrap_pbs_rerunjob, METH_VARARGS, NULL},
4979	{ (char *)"pbs_rlsjob", _wrap_pbs_rlsjob, METH_VARARGS, NULL},
4980	{ (char *)"pbs_runjob", _wrap_pbs_runjob, METH_VARARGS, NULL},
4981	{ (char *)"pbs_selectjob", _wrap_pbs_selectjob, METH_VARARGS, NULL},
4982	{ (char *)"pbs_sigjob", _wrap_pbs_sigjob, METH_VARARGS, NULL},
4983	{ (char *)"pbs_statfree", _wrap_pbs_statfree, METH_VARARGS, NULL},
4984	{ (char *)"pbs_statjob", _wrap_pbs_statjob, METH_VARARGS, NULL},
4985	{ (char *)"pbs_selstat", _wrap_pbs_selstat, METH_VARARGS, NULL},
4986	{ (char *)"pbs_statque", _wrap_pbs_statque, METH_VARARGS, NULL},
4987	{ (char *)"pbs_statserver", _wrap_pbs_statserver, METH_VARARGS, NULL},
4988	{ (char *)"pbs_statnode", _wrap_pbs_statnode, METH_VARARGS, NULL},
4989	{ (char *)"pbs_submit", _wrap_pbs_submit, METH_VARARGS, NULL},
4990	{ (char *)"pbs_terminate", _wrap_pbs_terminate, METH_VARARGS, NULL},
4991	{ (char *)"totpool", _wrap_totpool, METH_VARARGS, NULL},
4992	{ (char *)"usepool", _wrap_usepool, METH_VARARGS, NULL},
4993	{ (char *)"openrm", _wrap_openrm, METH_VARARGS, NULL},
4994	{ (char *)"closerm", _wrap_closerm, METH_VARARGS, NULL},
4995	{ (char *)"downrm", _wrap_downrm, METH_VARARGS, NULL},
4996	{ (char *)"configrm", _wrap_configrm, METH_VARARGS, NULL},
4997	{ (char *)"addreq", _wrap_addreq, METH_VARARGS, NULL},
4998	{ (char *)"allreq", _wrap_allreq, METH_VARARGS, NULL},
4999	{ (char *)"flushreq", _wrap_flushreq, METH_VARARGS, NULL},
5000	{ (char *)"activereq", _wrap_activereq, METH_VARARGS, NULL},
5001	{ (char *)"fullresp", _wrap_fullresp, METH_VARARGS, NULL},
5002	{ (char *)"getreq", _wrap_getreq, METH_VARARGS, NULL},
5003	{ (char *)"log_close", _wrap_log_close, METH_VARARGS, NULL},
5004	{ (char *)"log_err", _wrap_log_err, METH_VARARGS, NULL},
5005	{ (char *)"log_event", _wrap_log_event, METH_VARARGS, NULL},
5006	{ (char *)"log_open", _wrap_log_open, METH_VARARGS, NULL},
5007	{ (char *)"log_record", _wrap_log_record, METH_VARARGS, NULL},
5008	{ (char *)"setup_env", _wrap_setup_env, METH_VARARGS, NULL},
5009	{ (char *)"chk_file_sec", _wrap_chk_file_sec, METH_VARARGS, NULL},
5010	{ NULL, NULL, 0, NULL }
5011	};
5012
5013
5014	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5015
5016	static 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}};
5017	static 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}};
5018	static 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}};
5019	static 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}};
5020	static swig_type_info _swigt__size_t[] = {{"_size_t", 0, "size_t", 0, 0, 0, 0},{"_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
5021	static 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}};
5022	static 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}};
5023	static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
5024	static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
5025
5026	static swig_type_info *swig_types_initial[] = {
5027	_swigt__p_batch_status,
5028	_swigt__p_char,
5029	_swigt__p_attropl,
5030	_swigt__p_p_char,
5031	_swigt__size_t,
5032	_swigt__p_attrl,
5033	_swigt__p_long,
5034	_swigt__ptrdiff_t,
5035	_swigt__p_int,
5036	0
5037	};
5038
5039
5040	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
5041
5042	static swig_const_info swig_const_table[] = {
5043	{ SWIG_PY_POINTER, (char)"ATTR_a", 0, 0, (void )"Execution_Time", &SWIGTYPE_p_char},
5044	{ SWIG_PY_POINTER, (char)"ATTR_c", 0, 0, (void )"Checkpoint", &SWIGTYPE_p_char},
5045	{ SWIG_PY_POINTER, (char)"ATTR_e", 0, 0, (void )"Error_Path", &SWIGTYPE_p_char},
5046	{ SWIG_PY_POINTER, (char)"ATTR_g", 0, 0, (void )"group_list", &SWIGTYPE_p_char},
5047	{ SWIG_PY_POINTER, (char)"ATTR_h", 0, 0, (void )"Hold_Types", &SWIGTYPE_p_char},
5048	{ SWIG_PY_POINTER, (char)"ATTR_j", 0, 0, (void )"Join_Path", &SWIGTYPE_p_char},
5049	{ SWIG_PY_POINTER, (char)"ATTR_k", 0, 0, (void )"Keep_Files", &SWIGTYPE_p_char},
5050	{ SWIG_PY_POINTER, (char)"ATTR_l", 0, 0, (void )"Resource_List", &SWIGTYPE_p_char},
5051	{ SWIG_PY_POINTER, (char)"ATTR_m", 0, 0, (void )"Mail_Points", &SWIGTYPE_p_char},
5052	{ SWIG_PY_POINTER, (char)"ATTR_o", 0, 0, (void )"Output_Path", &SWIGTYPE_p_char},
5053	{ SWIG_PY_POINTER, (char)"ATTR_p", 0, 0, (void )"Priority", &SWIGTYPE_p_char},
5054	{ SWIG_PY_POINTER, (char)"ATTR_q", 0, 0, (void )"destination", &SWIGTYPE_p_char},
5055	{ SWIG_PY_POINTER, (char)"ATTR_r", 0, 0, (void )"Rerunable", &SWIGTYPE_p_char},
5056	{ SWIG_PY_POINTER, (char)"ATTR_u", 0, 0, (void )"User_List", &SWIGTYPE_p_char},
5057	{ SWIG_PY_POINTER, (char)"ATTR_v", 0, 0, (void )"Variable_List", &SWIGTYPE_p_char},
5058	{ SWIG_PY_POINTER, (char)"ATTR_A", 0, 0, (void )"Account_Name", &SWIGTYPE_p_char},
5059	{ SWIG_PY_POINTER, (char)"ATTR_M", 0, 0, (void )"Mail_Users", &SWIGTYPE_p_char},
5060	{ SWIG_PY_POINTER, (char)"ATTR_N", 0, 0, (void )"Job_Name", &SWIGTYPE_p_char},
5061	{ SWIG_PY_POINTER, (char)"ATTR_S", 0, 0, (void )"Shell_Path_List", &SWIGTYPE_p_char},
5062	{ SWIG_PY_POINTER, (char)"ATTR_depend", 0, 0, (void )"depend", &SWIGTYPE_p_char},
5063	{ SWIG_PY_POINTER, (char)"ATTR_inter", 0, 0, (void )"interactive", &SWIGTYPE_p_char},
5064	{ SWIG_PY_POINTER, (char)"ATTR_stagein", 0, 0, (void )"stagein", &SWIGTYPE_p_char},
5065	{ SWIG_PY_POINTER, (char)"ATTR_stageout", 0, 0, (void )"stageout", &SWIGTYPE_p_char},
5066	{ SWIG_PY_POINTER, (char)"ATTR_ctime", 0, 0, (void )"ctime", &SWIGTYPE_p_char},
5067	{ SWIG_PY_POINTER, (char)"ATTR_exechost", 0, 0, (void )"exec_host", &SWIGTYPE_p_char},
5068	{ SWIG_PY_POINTER, (char)"ATTR_mtime", 0, 0, (void )"mtime", &SWIGTYPE_p_char},
5069	{ SWIG_PY_POINTER, (char)"ATTR_qtime", 0, 0, (void )"qtime", &SWIGTYPE_p_char},
5070	{ SWIG_PY_POINTER, (char)"ATTR_session", 0, 0, (void )"session_id", &SWIGTYPE_p_char},
5071	{ SWIG_PY_POINTER, (char)"ATTR_euser", 0, 0, (void )"euser", &SWIGTYPE_p_char},
5072	{ SWIG_PY_POINTER, (char)"ATTR_egroup", 0, 0, (void )"egroup", &SWIGTYPE_p_char},
5073	{ SWIG_PY_POINTER, (char)"ATTR_hashname", 0, 0, (void )"hashname", &SWIGTYPE_p_char},
5074	{ SWIG_PY_POINTER, (char)"ATTR_hopcount", 0, 0, (void )"hop_count", &SWIGTYPE_p_char},
5075	{ SWIG_PY_POINTER, (char)"ATTR_security", 0, 0, (void )"security", &SWIGTYPE_p_char},
5076	{ SWIG_PY_POINTER, (char)"ATTR_sched_hint", 0, 0, (void )"sched_hint", &SWIGTYPE_p_char},
5077	{ SWIG_PY_POINTER, (char)"ATTR_substate", 0, 0, (void )"substate", &SWIGTYPE_p_char},
5078	{ SWIG_PY_POINTER, (char)"ATTR_name", 0, 0, (void )"Job_Name", &SWIGTYPE_p_char},
5079	{ SWIG_PY_POINTER, (char)"ATTR_owner", 0, 0, (void )"Job_Owner", &SWIGTYPE_p_char},
5080	{ SWIG_PY_POINTER, (char)"ATTR_used", 0, 0, (void )"resources_used", &SWIGTYPE_p_char},
5081	{ SWIG_PY_POINTER, (char)"ATTR_state", 0, 0, (void )"job_state", &SWIGTYPE_p_char},
5082	{ SWIG_PY_POINTER, (char)"ATTR_queue", 0, 0, (void )"queue", &SWIGTYPE_p_char},
5083	{ SWIG_PY_POINTER, (char)"ATTR_server", 0, 0, (void )"server", &SWIGTYPE_p_char},
5084	{ SWIG_PY_POINTER, (char)"ATTR_maxrun", 0, 0, (void )"max_running", &SWIGTYPE_p_char},
5085	{ SWIG_PY_POINTER, (char)"ATTR_total", 0, 0, (void )"total_jobs", &SWIGTYPE_p_char},
5086	{ SWIG_PY_POINTER, (char)"ATTR_comment", 0, 0, (void )"comment", &SWIGTYPE_p_char},
5087	{ SWIG_PY_POINTER, (char)"ATTR_cookie", 0, 0, (void )"cookie", &SWIGTYPE_p_char},
5088	{ SWIG_PY_POINTER, (char)"ATTR_qrank", 0, 0, (void )"queue_rank", &SWIGTYPE_p_char},
5089	{ SWIG_PY_POINTER, (char)"ATTR_altid", 0, 0, (void )"alt_id", &SWIGTYPE_p_char},
5090	{ SWIG_PY_POINTER, (char)"ATTR_etime", 0, 0, (void )"etime", &SWIGTYPE_p_char},
5091	{ SWIG_PY_POINTER, (char)"ATTR_aclgren", 0, 0, (void )"acl_group_enable", &SWIGTYPE_p_char},
5092	{ SWIG_PY_POINTER, (char)"ATTR_aclgroup", 0, 0, (void )"acl_groups", &SWIGTYPE_p_char},
5093	{ SWIG_PY_POINTER, (char)"ATTR_aclhten", 0, 0, (void )"acl_host_enable", &SWIGTYPE_p_char},
5094	{ SWIG_PY_POINTER, (char)"ATTR_aclhost", 0, 0, (void )"acl_hosts", &SWIGTYPE_p_char},
5095	{ SWIG_PY_POINTER, (char)"ATTR_acluren", 0, 0, (void )"acl_user_enable", &SWIGTYPE_p_char},
5096	{ SWIG_PY_POINTER, (char)"ATTR_acluser", 0, 0, (void )"acl_users", &SWIGTYPE_p_char},
5097	{ SWIG_PY_POINTER, (char)"ATTR_altrouter", 0, 0, (void )"alt_router", &SWIGTYPE_p_char},
5098	{ SWIG_PY_POINTER, (char)"ATTR_chkptmin", 0, 0, (void )"checkpoint_min", &SWIGTYPE_p_char},
5099	{ SWIG_PY_POINTER, (char)"ATTR_enable", 0, 0, (void )"enabled", &SWIGTYPE_p_char},
5100	{ SWIG_PY_POINTER, (char)"ATTR_fromroute", 0, 0, (void )"from_route_only", &SWIGTYPE_p_char},
5101	{ SWIG_PY_POINTER, (char)"ATTR_killdelay", 0, 0, (void )"kill_delay", &SWIGTYPE_p_char},
5102	{ SWIG_PY_POINTER, (char)"ATTR_maxgrprun", 0, 0, (void )"max_group_run", &SWIGTYPE_p_char},
5103	{ SWIG_PY_POINTER, (char)"ATTR_maxque", 0, 0, (void )"max_queuable", &SWIGTYPE_p_char},
5104	{ SWIG_PY_POINTER, (char)"ATTR_maxuserrun", 0, 0, (void )"max_user_run", &SWIGTYPE_p_char},
5105	{ SWIG_PY_POINTER, (char)"ATTR_qtype", 0, 0, (void )"queue_type", &SWIGTYPE_p_char},
5106	{ SWIG_PY_POINTER, (char)"ATTR_rescassn", 0, 0, (void )"resources_assigned", &SWIGTYPE_p_char},
5107	{ SWIG_PY_POINTER, (char)"ATTR_rescdflt", 0, 0, (void )"resources_default", &SWIGTYPE_p_char},
5108	{ SWIG_PY_POINTER, (char)"ATTR_rescmax", 0, 0, (void )"resources_max", &SWIGTYPE_p_char},
5109	{ SWIG_PY_POINTER, (char)"ATTR_rescmin", 0, 0, (void )"resources_min", &SWIGTYPE_p_char},
5110	{ SWIG_PY_POINTER, (char)"ATTR_rndzretry", 0, 0, (void )"rendezvous_retry", &SWIGTYPE_p_char},
5111	{ SWIG_PY_POINTER, (char)"ATTR_routedest", 0, 0, (void )"route_destinations", &SWIGTYPE_p_char},
5112	{ SWIG_PY_POINTER, (char)"ATTR_routeheld", 0, 0, (void )"route_held_jobs", &SWIGTYPE_p_char},
5113	{ SWIG_PY_POINTER, (char)"ATTR_routewait", 0, 0, (void )"route_waiting_jobs", &SWIGTYPE_p_char},
5114	{ SWIG_PY_POINTER, (char)"ATTR_routeretry", 0, 0, (void )"route_retry_time", &SWIGTYPE_p_char},
5115	{ SWIG_PY_POINTER, (char)"ATTR_routelife", 0, 0, (void )"route_lifetime", &SWIGTYPE_p_char},
5116	{ SWIG_PY_POINTER, (char)"ATTR_rsvexpdt", 0, 0, (void )"reserved_expedite", &SWIGTYPE_p_char},
5117	{ SWIG_PY_POINTER, (char)"ATTR_rsvsync", 0, 0, (void )"reserved_sync", &SWIGTYPE_p_char},
5118	{ SWIG_PY_POINTER, (char)"ATTR_start", 0, 0, (void )"started", &SWIGTYPE_p_char},
5119	{ SWIG_PY_POINTER, (char)"ATTR_count", 0, 0, (void )"state_count", &SWIGTYPE_p_char},
5120	{ SWIG_PY_POINTER, (char)"ATTR_number", 0, 0, (void )"number_jobs", &SWIGTYPE_p_char},
5121	{ SWIG_PY_POINTER, (char)"ATTR_reqprop", 0, 0, (void )"required_property", &SWIGTYPE_p_char},
5122	{ SWIG_PY_POINTER, (char)"ATTR_aclroot", 0, 0, (void )"acl_roots", &SWIGTYPE_p_char},
5123	{ SWIG_PY_POINTER, (char)"ATTR_managers", 0, 0, (void )"managers", &SWIGTYPE_p_char},
5124	{ SWIG_PY_POINTER, (char)"ATTR_dfltque", 0, 0, (void )"default_queue", &SWIGTYPE_p_char},
5125	{ SWIG_PY_POINTER, (char)"ATTR_defnode", 0, 0, (void )"default_node", &SWIGTYPE_p_char},
5126	{ SWIG_PY_POINTER, (char)"ATTR_locsvrs", 0, 0, (void )"location_servers", &SWIGTYPE_p_char},
5127	{ SWIG_PY_POINTER, (char)"ATTR_logevents", 0, 0, (void )"log_events", &SWIGTYPE_p_char},
5128	{ SWIG_PY_POINTER, (char)"ATTR_logfile", 0, 0, (void )"log_file", &SWIGTYPE_p_char},
5129	{ SWIG_PY_POINTER, (char)"ATTR_mailfrom", 0, 0, (void )"mail_from", &SWIGTYPE_p_char},
5130	{ SWIG_PY_POINTER, (char)"ATTR_nodepack", 0, 0, (void )"node_pack", &SWIGTYPE_p_char},
5131	{ SWIG_PY_POINTER, (char)"ATTR_operators", 0, 0, (void )"operators", &SWIGTYPE_p_char},
5132	{ SWIG_PY_POINTER, (char)"ATTR_queryother", 0, 0, (void )"query_other_jobs", &SWIGTYPE_p_char},
5133	{ SWIG_PY_POINTER, (char)"ATTR_resccost", 0, 0, (void )"resources_cost", &SWIGTYPE_p_char},
5134	{ SWIG_PY_POINTER, (char)"ATTR_rescavail", 0, 0, (void )"resources_available", &SWIGTYPE_p_char},
5135	{ SWIG_PY_POINTER, (char)"ATTR_schedit", 0, 0, (void )"scheduler_iteration", &SWIGTYPE_p_char},
5136	{ SWIG_PY_POINTER, (char)"ATTR_scheduling", 0, 0, (void )"scheduling", &SWIGTYPE_p_char},
5137	{ SWIG_PY_POINTER, (char)"ATTR_status", 0, 0, (void )"server_state", &SWIGTYPE_p_char},
5138	{ SWIG_PY_POINTER, (char)"ATTR_syscost", 0, 0, (void )"system_cost", &SWIGTYPE_p_char},
5139	{ SWIG_PY_POINTER, (char)"ATTR_pingrate", 0, 0, (void )"node_ping_rate", &SWIGTYPE_p_char},
5140	{ SWIG_PY_POINTER, (char)"ATTR_ndchkrate", 0, 0, (void )"node_check_rate", &SWIGTYPE_p_char},
5141	{ SWIG_PY_POINTER, (char)"ATTR_procpack", 0, 0, (void )"proc_pack", &SWIGTYPE_p_char},
5142	{ SWIG_PY_POINTER, (char)"ATTR_NODE_state", 0, 0, (void )"state", &SWIGTYPE_p_char},
5143	{ SWIG_PY_POINTER, (char)"ATTR_NODE_np", 0, 0, (void )"np", &SWIGTYPE_p_char},
5144	{ SWIG_PY_POINTER, (char)"ATTR_NODE_properties", 0, 0, (void )"properties", &SWIGTYPE_p_char},
5145	{ SWIG_PY_POINTER, (char)"ATTR_NODE_ntype", 0, 0, (void )"ntype", &SWIGTYPE_p_char},
5146	{ SWIG_PY_POINTER, (char)"ATTR_NODE_jobs", 0, 0, (void )"jobs", &SWIGTYPE_p_char},
5147	{ SWIG_PY_POINTER, (char)"CHECKPOINT_UNSPECIFIED", 0, 0, (void )"u", &SWIGTYPE_p_char},
5148	{ SWIG_PY_POINTER, (char)"NO_HOLD", 0, 0, (void )"n", &SWIGTYPE_p_char},
5149	{ SWIG_PY_POINTER, (char)"NO_JOIN", 0, 0, (void )"n", &SWIGTYPE_p_char},
5150	{ SWIG_PY_POINTER, (char)"NO_KEEP", 0, 0, (void )"n", &SWIGTYPE_p_char},
5151	{ SWIG_PY_POINTER, (char)"MAIL_AT_ABORT", 0, 0, (void )"a", &SWIGTYPE_p_char},
5152	{ SWIG_PY_POINTER, (char)"DELDELAY", 0, 0, (void )"deldelay=", &SWIGTYPE_p_char},
5153	{ SWIG_PY_POINTER, (char)"USER_HOLD", 0, 0, (void )"u", &SWIGTYPE_p_char},
5154	{ SWIG_PY_POINTER, (char)"OTHER_HOLD", 0, 0, (void )"o", &SWIGTYPE_p_char},
5155	{ SWIG_PY_POINTER, (char)"SYSTEM_HOLD", 0, 0, (void )"s", &SWIGTYPE_p_char},
5156	{ SWIG_PY_POINTER, (char)"ND_free", 0, 0, (void )"free", &SWIGTYPE_p_char},
5157	{ SWIG_PY_POINTER, (char)"ND_offline", 0, 0, (void )"offline", &SWIGTYPE_p_char},
5158	{ SWIG_PY_POINTER, (char)"ND_down", 0, 0, (void )"down", &SWIGTYPE_p_char},
5159	{ SWIG_PY_POINTER, (char)"ND_reserve", 0, 0, (void )"reserve", &SWIGTYPE_p_char},
5160	{ SWIG_PY_POINTER, (char)"ND_job_exclusive", 0, 0, (void )"job-exclusive", &SWIGTYPE_p_char},
5161	{ SWIG_PY_POINTER, (char)"ND_job_sharing", 0, 0, (void )"job-sharing", &SWIGTYPE_p_char},
5162	{ SWIG_PY_POINTER, (char)"ND_busy", 0, 0, (void )"busy", &SWIGTYPE_p_char},
5163	{ SWIG_PY_POINTER, (char)"ND_state_unknown", 0, 0, (void )"state-unknown", &SWIGTYPE_p_char},
5164	{ SWIG_PY_POINTER, (char)"ND_timeshared", 0, 0, (void )"time-shared", &SWIGTYPE_p_char},
5165	{ SWIG_PY_POINTER, (char)"ND_cluster", 0, 0, (void )"cluster", &SWIGTYPE_p_char},
5166	{ SWIG_PY_POINTER, (char)"SIG_RESUME", 0, 0, (void )"resume", &SWIGTYPE_p_char},
5167	{ SWIG_PY_POINTER, (char)"SIG_SUSPEND", 0, 0, (void )"suspend", &SWIGTYPE_p_char},
5168	{ SWIG_PY_POINTER, (char)"PBS_BATCH_SERVICE_NAME", 0, 0, (void )"pbs", &SWIGTYPE_p_char},
5169	{ SWIG_PY_POINTER, (char)"PBS_BATCH_SERVICE_NAME_DIS", 0, 0, (void )"pbs_dis", &SWIGTYPE_p_char},
5170	{ SWIG_PY_POINTER, (char)"PBS_MOM_SERVICE_NAME", 0, 0, (void )"pbs_mom", &SWIGTYPE_p_char},
5171	{ SWIG_PY_POINTER, (char)"PBS_MANAGER_SERVICE_NAME", 0, 0, (void )"pbs_resmon", &SWIGTYPE_p_char},
5172	{ SWIG_PY_POINTER, (char)"PBS_SCHEDULER_SERVICE_NAME", 0, 0, (void )"pbs_sched", &SWIGTYPE_p_char},
5173	{0, 0, 0, 0.0, 0, 0}};
5174
5175	#ifdef __cplusplus
5176	}
5177	#endif
5178
5179
5180	#ifdef __cplusplus
5181	extern "C" {
5182	#endif
5183
5184	/* Python-specific SWIG API */
5185	#define SWIG_newvarlink() SWIG_Python_newvarlink()
5186	#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
5187	#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
5188
5189	/* -----------------------------------------------------------------------------
5190	* global variable support code.
5191	* ----------------------------------------------------------------------------- */
5192
5193	typedef struct swig_globalvar {
5194	char name; / Name of global variable */
5195	PyObject (get_attr)(); /* Return the current value */
5196	int (set_attr)(PyObject ); /* Set the value */
5197	struct swig_globalvar *next;
5198	} swig_globalvar;
5199
5200	typedef struct swig_varlinkobject {
5201	PyObject_HEAD
5202	swig_globalvar *vars;
5203	} swig_varlinkobject;
5204
5205	static PyObject *
5206	swig_varlink_repr(swig_varlinkobject *v) {
5207	v = v;
5208	return PyString_FromString("<Swig global variables>");
5209	}
5210
5211	static int
5212	swig_varlink_print(swig_varlinkobject v, FILE fp, int flags) {
5213	swig_globalvar *var;
5214	flags = flags;
5215	fprintf(fp,"Swig global variables { ");
5216	for (var = v->vars; var; var=var->next) {
5217	fprintf(fp,"%s", var->name);
5218	if (var->next) fprintf(fp,", ");
5219	}
5220	fprintf(fp," }\n");
5221	return 0;
5222	}
5223
5224	static PyObject *
5225	swig_varlink_getattr(swig_varlinkobject v, char n) {
5226	swig_globalvar *var = v->vars;
5227	while (var) {
5228	if (strcmp(var->name,n) == 0) {
5229	return (*var->get_attr)();
5230	}
5231	var = var->next;
5232	}
5233	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
5234	return NULL;
5235	}
5236
5237	static int
5238	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {
5239	swig_globalvar *var = v->vars;
5240	while (var) {
5241	if (strcmp(var->name,n) == 0) {
5242	return (*var->set_attr)(p);
5243	}
5244	var = var->next;
5245	}
5246	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
5247	return 1;
5248	}
5249
5250	static PyTypeObject varlinktype = {
5251	PyObject_HEAD_INIT(0)
5252	0, /* Number of items in variable part (ob_size) */
5253	(char )"swigvarlink", / Type name (tp_name) */
5254	sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
5255	0, /* Itemsize (tp_itemsize) */
5256	0, /* Deallocator (tp_dealloc) */
5257	(printfunc) swig_varlink_print, /* Print (tp_print) */
5258	(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
5259	(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
5260	0, /* tp_compare */
5261	(reprfunc) swig_varlink_repr, /* tp_repr */
5262	0, /* tp_as_number */
5263	0, /* tp_as_sequence */
5264	0, /* tp_as_mapping */
5265	0, /* tp_hash */
5266	0, /* tp_call */
5267	0, /* tp_str */
5268	0, /* tp_getattro */
5269	0, /* tp_setattro */
5270	0, /* tp_as_buffer */
5271	0, /* tp_flags */
5272	0, /* tp_doc */
5273	#if PY_VERSION_HEX >= 0x02000000
5274	0, /* tp_traverse */
5275	0, /* tp_clear */
5276	#endif
5277	#if PY_VERSION_HEX >= 0x02010000
5278	0, /* tp_richcompare */
5279	0, /* tp_weaklistoffset */
5280	#endif
5281	#if PY_VERSION_HEX >= 0x02020000
5282	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
5283	#endif
5284	#if PY_VERSION_HEX >= 0x02030000
5285	0, /* tp_del */
5286	#endif
5287	#ifdef COUNT_ALLOCS
5288	0,0,0,0 /* tp_alloc -> tp_next */
5289	#endif
5290	};
5291
5292	/* Create a variable linking object for use later */
5293	static PyObject *
5294	SWIG_Python_newvarlink(void) {
5295	swig_varlinkobject *result = 0;
5296	result = PyMem_NEW(swig_varlinkobject,1);
5297	varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
5298	result->ob_type = &varlinktype;
5299	result->vars = 0;
5300	result->ob_refcnt = 0;
5301	Py_XINCREF((PyObject *) result);
5302	return ((PyObject*) result);
5303	}
5304
5305	static void
5306	SWIG_Python_addvarlink(PyObject p, char name, PyObject (get_attr)(void), int (set_attr)(PyObject p)) {
5307	swig_varlinkobject *v;
5308	swig_globalvar *gv;
5309	v= (swig_varlinkobject *) p;
5310	gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
5311	gv->name = (char *) malloc(strlen(name)+1);
5312	strcpy(gv->name,name);
5313	gv->get_attr = get_attr;
5314	gv->set_attr = set_attr;
5315	gv->next = v->vars;
5316	v->vars = gv;
5317	}
5318
5319	/* -----------------------------------------------------------------------------
5320	* constants/methods manipulation
5321	* ----------------------------------------------------------------------------- */
5322
5323	/* Install Constants */
5324	static void
5325	SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
5326	PyObject *obj = 0;
5327	size_t i;
5328	for (i = 0; constants[i].type; i++) {
5329	switch(constants[i].type) {
5330	case SWIG_PY_INT:
5331	obj = PyInt_FromLong(constants[i].lvalue);
5332	break;
5333	case SWIG_PY_FLOAT:
5334	obj = PyFloat_FromDouble(constants[i].dvalue);
5335	break;
5336	case SWIG_PY_STRING:
5337	if (constants[i].pvalue) {
5338	obj = PyString_FromString((char *) constants[i].pvalue);
5339	} else {
5340	Py_INCREF(Py_None);
5341	obj = Py_None;
5342	}
5343	break;
5344	case SWIG_PY_POINTER:
5345	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
5346	break;
5347	case SWIG_PY_BINARY:
5348	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
5349	break;
5350	default:
5351	obj = 0;
5352	break;
5353	}
5354	if (obj) {
5355	PyDict_SetItemString(d,constants[i].name,obj);
5356	Py_DECREF(obj);
5357	}
5358	}
5359	}
5360
5361	/* -----------------------------------------------------------------------------*/
5362	/* Fix SwigMethods to carry the callback ptrs when needed */
5363	/* -----------------------------------------------------------------------------*/
5364
5365	static void
5366	SWIG_Python_FixMethods(PyMethodDef *methods,
5367	swig_const_info *const_table,
5368	swig_type_info **types,
5369	swig_type_info **types_initial) {
5370	size_t i;
5371	for (i = 0; methods[i].ml_name; ++i) {
5372	char *c = methods[i].ml_doc;
5373	if (c && (c = strstr(c, "swig_ptr: "))) {
5374	int j;
5375	swig_const_info *ci = 0;
5376	char *name = c + 10;
5377	for (j = 0; const_table[j].type; j++) {
5378	if (strncmp(const_table[j].name, name,
5379	strlen(const_table[j].name)) == 0) {
5380	ci = &(const_table[j]);
5381	break;
5382	}
5383	}
5384	if (ci) {
5385	size_t shift = (ci->ptype) - types;
5386	swig_type_info *ty = types_initial[shift];
5387	size_t ldoc = (c - methods[i].ml_doc);
5388	size_t lptr = strlen(ty->name)+2sizeof(void)+2;
5389	char ndoc = (char)malloc(ldoc + lptr + 10);
5390	char *buff = ndoc;
5391	void ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void )(ci->lvalue);
5392	strncpy(buff, methods[i].ml_doc, ldoc);
5393	buff += ldoc;
5394	strncpy(buff, "swig_ptr: ", 10);
5395	buff += 10;
5396	SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
5397	methods[i].ml_doc = ndoc;
5398	}
5399	}
5400	}
5401	}
5402
5403	/* -----------------------------------------------------------------------------*
5404	* Initialize type list
5405	* -----------------------------------------------------------------------------*/
5406
5407	#if PY_MAJOR_VERSION < 2
5408	/* PyModule_AddObject function was introduced in Python 2.0. The following function
5409	is copied out of Python/modsupport.c in python version 2.3.4 */
5410	static int
5411	PyModule_AddObject(PyObject m, char name, PyObject *o)
5412	{
5413	PyObject *dict;
5414	if (!PyModule_Check(m)) {
5415	PyErr_SetString(PyExc_TypeError,
5416	"PyModule_AddObject() needs module as first arg");
5417	return -1;
5418	}
5419	if (!o) {
5420	PyErr_SetString(PyExc_TypeError,
5421	"PyModule_AddObject() needs non-NULL value");
5422	return -1;
5423	}
5424
5425	dict = PyModule_GetDict(m);
5426	if (dict == NULL) {
5427	/* Internal error -- modules must have a dict! */
5428	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
5429	PyModule_GetName(m));
5430	return -1;
5431	}
5432	if (PyDict_SetItemString(dict, name, o))
5433	return -1;
5434	Py_DECREF(o);
5435	return 0;
5436	}
5437	#endif
5438
5439	static swig_type_info **
5440	SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
5441	static PyMethodDef swig_empty_runtime_method_table[] = {
5442	{
5443	NULL, NULL, 0, NULL
5444	}
5445	};/* Sentinel */
5446
5447	PyObject module = Py_InitModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION,
5448	swig_empty_runtime_method_table);
5449	PyObject pointer = PyCObject_FromVoidPtr((void ) type_list_handle, NULL);
5450	if (pointer && module) {
5451	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
5452	}
5453	return type_list_handle;
5454	}
5455
5456	static swig_type_info **
5457	SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
5458	swig_type_info **type_pointer;
5459
5460	/* first check if module already created */
5461	type_pointer = SWIG_Python_GetTypeListHandle();
5462	if (type_pointer) {
5463	return type_pointer;
5464	} else {
5465	/* create a new module and variable */
5466	return SWIG_Python_SetTypeListHandle(type_list_handle);
5467	}
5468	}
5469
5470	#ifdef __cplusplus
5471	}
5472	#endif
5473
5474	/* -----------------------------------------------------------------------------*
5475	* Partial Init method
5476	* -----------------------------------------------------------------------------*/
5477
5478	#ifdef SWIG_LINK_RUNTIME
5479	#ifdef __cplusplus
5480	extern "C"
5481	#endif
5482	SWIGEXPORT(void ) SWIG_ReturnGlobalTypeList(void );
5483	#endif
5484
5485	#ifdef __cplusplus
5486	extern "C"
5487	#endif
5488	SWIGEXPORT(void) SWIG_init(void) {
5489	static PyObject *SWIG_globals = 0;
5490	static int typeinit = 0;
5491	PyObject m, d;
5492	int i;
5493	if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
5494
5495	/* Fix SwigMethods to carry the callback ptrs when needed */
5496	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
5497
5498	m = Py_InitModule((char *) SWIG_name, SwigMethods);
5499	d = PyModule_GetDict(m);
5500
5501	if (!typeinit) {
5502	#ifdef SWIG_LINK_RUNTIME
5503	swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
5504	#else
5505	# ifndef SWIG_STATIC_RUNTIME
5506	swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
5507	# endif
5508	#endif
5509	for (i = 0; swig_types_initial[i]; i++) {
5510	swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
5511	}
5512	typeinit = 1;
5513	}
5514	SWIG_InstallConstants(d,swig_const_table);
5515
5516	PyDict_SetItemString(d,"ATTR_a", SWIG_FromCharPtr("Execution_Time"));
5517	PyDict_SetItemString(d,"ATTR_c", SWIG_FromCharPtr("Checkpoint"));
5518	PyDict_SetItemString(d,"ATTR_e", SWIG_FromCharPtr("Error_Path"));
5519	PyDict_SetItemString(d,"ATTR_g", SWIG_FromCharPtr("group_list"));
5520	PyDict_SetItemString(d,"ATTR_h", SWIG_FromCharPtr("Hold_Types"));
5521	PyDict_SetItemString(d,"ATTR_j", SWIG_FromCharPtr("Join_Path"));
5522	PyDict_SetItemString(d,"ATTR_k", SWIG_FromCharPtr("Keep_Files"));
5523	PyDict_SetItemString(d,"ATTR_l", SWIG_FromCharPtr("Resource_List"));
5524	PyDict_SetItemString(d,"ATTR_m", SWIG_FromCharPtr("Mail_Points"));
5525	PyDict_SetItemString(d,"ATTR_o", SWIG_FromCharPtr("Output_Path"));
5526	PyDict_SetItemString(d,"ATTR_p", SWIG_FromCharPtr("Priority"));
5527	PyDict_SetItemString(d,"ATTR_q", SWIG_FromCharPtr("destination"));
5528	PyDict_SetItemString(d,"ATTR_r", SWIG_FromCharPtr("Rerunable"));
5529	PyDict_SetItemString(d,"ATTR_u", SWIG_FromCharPtr("User_List"));
5530	PyDict_SetItemString(d,"ATTR_v", SWIG_FromCharPtr("Variable_List"));
5531	PyDict_SetItemString(d,"ATTR_A", SWIG_FromCharPtr("Account_Name"));
5532	PyDict_SetItemString(d,"ATTR_M", SWIG_FromCharPtr("Mail_Users"));
5533	PyDict_SetItemString(d,"ATTR_N", SWIG_FromCharPtr("Job_Name"));
5534	PyDict_SetItemString(d,"ATTR_S", SWIG_FromCharPtr("Shell_Path_List"));
5535	PyDict_SetItemString(d,"ATTR_depend", SWIG_FromCharPtr("depend"));
5536	PyDict_SetItemString(d,"ATTR_inter", SWIG_FromCharPtr("interactive"));
5537	PyDict_SetItemString(d,"ATTR_stagein", SWIG_FromCharPtr("stagein"));
5538	PyDict_SetItemString(d,"ATTR_stageout", SWIG_FromCharPtr("stageout"));
5539	PyDict_SetItemString(d,"ATTR_ctime", SWIG_FromCharPtr("ctime"));
5540	PyDict_SetItemString(d,"ATTR_exechost", SWIG_FromCharPtr("exec_host"));
5541	PyDict_SetItemString(d,"ATTR_mtime", SWIG_FromCharPtr("mtime"));
5542	PyDict_SetItemString(d,"ATTR_qtime", SWIG_FromCharPtr("qtime"));
5543	PyDict_SetItemString(d,"ATTR_session", SWIG_FromCharPtr("session_id"));
5544	PyDict_SetItemString(d,"ATTR_euser", SWIG_FromCharPtr("euser"));
5545	PyDict_SetItemString(d,"ATTR_egroup", SWIG_FromCharPtr("egroup"));
5546	PyDict_SetItemString(d,"ATTR_hashname", SWIG_FromCharPtr("hashname"));
5547	PyDict_SetItemString(d,"ATTR_hopcount", SWIG_FromCharPtr("hop_count"));
5548	PyDict_SetItemString(d,"ATTR_security", SWIG_FromCharPtr("security"));
5549	PyDict_SetItemString(d,"ATTR_sched_hint", SWIG_FromCharPtr("sched_hint"));
5550	PyDict_SetItemString(d,"ATTR_substate", SWIG_FromCharPtr("substate"));
5551	PyDict_SetItemString(d,"ATTR_name", SWIG_FromCharPtr("Job_Name"));
5552	PyDict_SetItemString(d,"ATTR_owner", SWIG_FromCharPtr("Job_Owner"));
5553	PyDict_SetItemString(d,"ATTR_used", SWIG_FromCharPtr("resources_used"));
5554	PyDict_SetItemString(d,"ATTR_state", SWIG_FromCharPtr("job_state"));
5555	PyDict_SetItemString(d,"ATTR_queue", SWIG_FromCharPtr("queue"));
5556	PyDict_SetItemString(d,"ATTR_server", SWIG_FromCharPtr("server"));
5557	PyDict_SetItemString(d,"ATTR_maxrun", SWIG_FromCharPtr("max_running"));
5558	PyDict_SetItemString(d,"ATTR_total", SWIG_FromCharPtr("total_jobs"));
5559	PyDict_SetItemString(d,"ATTR_comment", SWIG_FromCharPtr("comment"));
5560	PyDict_SetItemString(d,"ATTR_cookie", SWIG_FromCharPtr("cookie"));
5561	PyDict_SetItemString(d,"ATTR_qrank", SWIG_FromCharPtr("queue_rank"));
5562	PyDict_SetItemString(d,"ATTR_altid", SWIG_FromCharPtr("alt_id"));
5563	PyDict_SetItemString(d,"ATTR_etime", SWIG_FromCharPtr("etime"));
5564	PyDict_SetItemString(d,"ATTR_aclgren", SWIG_FromCharPtr("acl_group_enable"));
5565	PyDict_SetItemString(d,"ATTR_aclgroup", SWIG_FromCharPtr("acl_groups"));
5566	PyDict_SetItemString(d,"ATTR_aclhten", SWIG_FromCharPtr("acl_host_enable"));
5567	PyDict_SetItemString(d,"ATTR_aclhost", SWIG_FromCharPtr("acl_hosts"));
5568	PyDict_SetItemString(d,"ATTR_acluren", SWIG_FromCharPtr("acl_user_enable"));
5569	PyDict_SetItemString(d,"ATTR_acluser", SWIG_FromCharPtr("acl_users"));
5570	PyDict_SetItemString(d,"ATTR_altrouter", SWIG_FromCharPtr("alt_router"));
5571	PyDict_SetItemString(d,"ATTR_chkptmin", SWIG_FromCharPtr("checkpoint_min"));
5572	PyDict_SetItemString(d,"ATTR_enable", SWIG_FromCharPtr("enabled"));
5573	PyDict_SetItemString(d,"ATTR_fromroute", SWIG_FromCharPtr("from_route_only"));
5574	PyDict_SetItemString(d,"ATTR_killdelay", SWIG_FromCharPtr("kill_delay"));
5575	PyDict_SetItemString(d,"ATTR_maxgrprun", SWIG_FromCharPtr("max_group_run"));
5576	PyDict_SetItemString(d,"ATTR_maxque", SWIG_FromCharPtr("max_queuable"));
5577	PyDict_SetItemString(d,"ATTR_maxuserrun", SWIG_FromCharPtr("max_user_run"));
5578	PyDict_SetItemString(d,"ATTR_qtype", SWIG_FromCharPtr("queue_type"));
5579	PyDict_SetItemString(d,"ATTR_rescassn", SWIG_FromCharPtr("resources_assigned"));
5580	PyDict_SetItemString(d,"ATTR_rescdflt", SWIG_FromCharPtr("resources_default"));
5581	PyDict_SetItemString(d,"ATTR_rescmax", SWIG_FromCharPtr("resources_max"));
5582	PyDict_SetItemString(d,"ATTR_rescmin", SWIG_FromCharPtr("resources_min"));
5583	PyDict_SetItemString(d,"ATTR_rndzretry", SWIG_FromCharPtr("rendezvous_retry"));
5584	PyDict_SetItemString(d,"ATTR_routedest", SWIG_FromCharPtr("route_destinations"));
5585	PyDict_SetItemString(d,"ATTR_routeheld", SWIG_FromCharPtr("route_held_jobs"));
5586	PyDict_SetItemString(d,"ATTR_routewait", SWIG_FromCharPtr("route_waiting_jobs"));
5587	PyDict_SetItemString(d,"ATTR_routeretry", SWIG_FromCharPtr("route_retry_time"));
5588	PyDict_SetItemString(d,"ATTR_routelife", SWIG_FromCharPtr("route_lifetime"));
5589	PyDict_SetItemString(d,"ATTR_rsvexpdt", SWIG_FromCharPtr("reserved_expedite"));
5590	PyDict_SetItemString(d,"ATTR_rsvsync", SWIG_FromCharPtr("reserved_sync"));
5591	PyDict_SetItemString(d,"ATTR_start", SWIG_FromCharPtr("started"));
5592	PyDict_SetItemString(d,"ATTR_count", SWIG_FromCharPtr("state_count"));
5593	PyDict_SetItemString(d,"ATTR_number", SWIG_FromCharPtr("number_jobs"));
5594	PyDict_SetItemString(d,"ATTR_reqprop", SWIG_FromCharPtr("required_property"));
5595	PyDict_SetItemString(d,"ATTR_aclroot", SWIG_FromCharPtr("acl_roots"));
5596	PyDict_SetItemString(d,"ATTR_managers", SWIG_FromCharPtr("managers"));
5597	PyDict_SetItemString(d,"ATTR_dfltque", SWIG_FromCharPtr("default_queue"));
5598	PyDict_SetItemString(d,"ATTR_defnode", SWIG_FromCharPtr("default_node"));
5599	PyDict_SetItemString(d,"ATTR_locsvrs", SWIG_FromCharPtr("location_servers"));
5600	PyDict_SetItemString(d,"ATTR_logevents", SWIG_FromCharPtr("log_events"));
5601	PyDict_SetItemString(d,"ATTR_logfile", SWIG_FromCharPtr("log_file"));
5602	PyDict_SetItemString(d,"ATTR_mailfrom", SWIG_FromCharPtr("mail_from"));
5603	PyDict_SetItemString(d,"ATTR_nodepack", SWIG_FromCharPtr("node_pack"));
5604	PyDict_SetItemString(d,"ATTR_operators", SWIG_FromCharPtr("operators"));
5605	PyDict_SetItemString(d,"ATTR_queryother", SWIG_FromCharPtr("query_other_jobs"));
5606	PyDict_SetItemString(d,"ATTR_resccost", SWIG_FromCharPtr("resources_cost"));
5607	PyDict_SetItemString(d,"ATTR_rescavail", SWIG_FromCharPtr("resources_available"));
5608	PyDict_SetItemString(d,"ATTR_schedit", SWIG_FromCharPtr("scheduler_iteration"));
5609	PyDict_SetItemString(d,"ATTR_scheduling", SWIG_FromCharPtr("scheduling"));
5610	PyDict_SetItemString(d,"ATTR_status", SWIG_FromCharPtr("server_state"));
5611	PyDict_SetItemString(d,"ATTR_syscost", SWIG_FromCharPtr("system_cost"));
5612	PyDict_SetItemString(d,"ATTR_pingrate", SWIG_FromCharPtr("node_ping_rate"));
5613	PyDict_SetItemString(d,"ATTR_ndchkrate", SWIG_FromCharPtr("node_check_rate"));
5614	PyDict_SetItemString(d,"ATTR_procpack", SWIG_FromCharPtr("proc_pack"));
5615	PyDict_SetItemString(d,"ATTR_NODE_state", SWIG_FromCharPtr("state"));
5616	PyDict_SetItemString(d,"ATTR_NODE_np", SWIG_FromCharPtr("np"));
5617	PyDict_SetItemString(d,"ATTR_NODE_properties", SWIG_FromCharPtr("properties"));
5618	PyDict_SetItemString(d,"ATTR_NODE_ntype", SWIG_FromCharPtr("ntype"));
5619	PyDict_SetItemString(d,"ATTR_NODE_jobs", SWIG_FromCharPtr("jobs"));
5620	PyDict_SetItemString(d,"CHECKPOINT_UNSPECIFIED", SWIG_FromCharPtr("u"));
5621	PyDict_SetItemString(d,"NO_HOLD", SWIG_FromCharPtr("n"));
5622	PyDict_SetItemString(d,"NO_JOIN", SWIG_FromCharPtr("n"));
5623	PyDict_SetItemString(d,"NO_KEEP", SWIG_FromCharPtr("n"));
5624	PyDict_SetItemString(d,"MAIL_AT_ABORT", SWIG_FromCharPtr("a"));
5625	PyDict_SetItemString(d,"DELDELAY", SWIG_FromCharPtr("deldelay="));
5626	PyDict_SetItemString(d,"USER_HOLD", SWIG_FromCharPtr("u"));
5627	PyDict_SetItemString(d,"OTHER_HOLD", SWIG_FromCharPtr("o"));
5628	PyDict_SetItemString(d,"SYSTEM_HOLD", SWIG_FromCharPtr("s"));
5629	PyDict_SetItemString(d,"ND_free", SWIG_FromCharPtr("free"));
5630	PyDict_SetItemString(d,"ND_offline", SWIG_FromCharPtr("offline"));
5631	PyDict_SetItemString(d,"ND_down", SWIG_FromCharPtr("down"));
5632	PyDict_SetItemString(d,"ND_reserve", SWIG_FromCharPtr("reserve"));
5633	PyDict_SetItemString(d,"ND_job_exclusive", SWIG_FromCharPtr("job-exclusive"));
5634	PyDict_SetItemString(d,"ND_job_sharing", SWIG_FromCharPtr("job-sharing"));
5635	PyDict_SetItemString(d,"ND_busy", SWIG_FromCharPtr("busy"));
5636	PyDict_SetItemString(d,"ND_state_unknown", SWIG_FromCharPtr("state-unknown"));
5637	PyDict_SetItemString(d,"ND_timeshared", SWIG_FromCharPtr("time-shared"));
5638	PyDict_SetItemString(d,"ND_cluster", SWIG_FromCharPtr("cluster"));
5639	{
5640	PyDict_SetItemString(d,"MAX_ENCODE_BFR", SWIG_From_int((int)(100)));
5641	}
5642	{
5643	PyDict_SetItemString(d,"MGR_CMD_CREATE", SWIG_From_int((int)(0)));
5644	}
5645	{
5646	PyDict_SetItemString(d,"MGR_CMD_DELETE", SWIG_From_int((int)(1)));
5647	}
5648	{
5649	PyDict_SetItemString(d,"MGR_CMD_SET", SWIG_From_int((int)(2)));
5650	}
5651	{
5652	PyDict_SetItemString(d,"MGR_CMD_UNSET", SWIG_From_int((int)(3)));
5653	}
5654	{
5655	PyDict_SetItemString(d,"MGR_CMD_LIST", SWIG_From_int((int)(4)));
5656	}
5657	{
5658	PyDict_SetItemString(d,"MGR_CMD_PRINT", SWIG_From_int((int)(5)));
5659	}
5660	{
5661	PyDict_SetItemString(d,"MGR_CMD_ACTIVE", SWIG_From_int((int)(6)));
5662	}
5663	{
5664	PyDict_SetItemString(d,"MGR_OBJ_NONE", SWIG_From_int((int)(-1)));
5665	}
5666	{
5667	PyDict_SetItemString(d,"MGR_OBJ_SERVER", SWIG_From_int((int)(0)));
5668	}
5669	{
5670	PyDict_SetItemString(d,"MGR_OBJ_QUEUE", SWIG_From_int((int)(1)));
5671	}
5672	{
5673	PyDict_SetItemString(d,"MGR_OBJ_JOB", SWIG_From_int((int)(2)));
5674	}
5675	{
5676	PyDict_SetItemString(d,"MGR_OBJ_NODE", SWIG_From_int((int)(3)));
5677	}
5678	{
5679	PyDict_SetItemString(d,"MSG_OUT", SWIG_From_int((int)(1)));
5680	}
5681	{
5682	PyDict_SetItemString(d,"MSG_ERR", SWIG_From_int((int)(2)));
5683	}
5684	{
5685	PyDict_SetItemString(d,"SHUT_SIG", SWIG_From_int((int)(-1)));
5686	}
5687	{
5688	PyDict_SetItemString(d,"SHUT_IMMEDIATE", SWIG_From_int((int)(0)));
5689	}
5690	{
5691	PyDict_SetItemString(d,"SHUT_DELAY", SWIG_From_int((int)(1)));
5692	}
5693	{
5694	PyDict_SetItemString(d,"SHUT_QUICK", SWIG_From_int((int)(2)));
5695	}
5696	PyDict_SetItemString(d,"SIG_RESUME", SWIG_FromCharPtr("resume"));
5697	PyDict_SetItemString(d,"SIG_SUSPEND", SWIG_FromCharPtr("suspend"));
5698	{
5699	PyDict_SetItemString(d,"PBS_MAXHOSTNAME", SWIG_From_int((int)(64)));
5700	}
5701	{
5702	PyDict_SetItemString(d,"MAXPATHLEN", SWIG_From_int((int)(1024)));
5703	}
5704	{
5705	PyDict_SetItemString(d,"MAXNAMLEN", SWIG_From_int((int)(255)));
5706	}
5707	{
5708	PyDict_SetItemString(d,"PBS_MAXUSER", SWIG_From_int((int)(16)));
5709	}
5710	{
5711	PyDict_SetItemString(d,"PBS_MAXGRPN", SWIG_From_int((int)(16)));
5712	}
5713	{
5714	PyDict_SetItemString(d,"PBS_MAXQUEUENAME", SWIG_From_int((int)(15)));
5715	}
5716	{
5717	PyDict_SetItemString(d,"PBS_MAXSERVERNAME", SWIG_From_int((int)(64)));
5718	}
5719	{
5720	PyDict_SetItemString(d,"PBS_MAXSEQNUM", SWIG_From_int((int)(6)));
5721	}
5722	{
5723	PyDict_SetItemString(d,"PBS_MAXPORTNUM", SWIG_From_int((int)(5)));
5724	}
5725	{
5726	PyDict_SetItemString(d,"PBS_MAXSVRJOBID", SWIG_From_int((int)((6+64+5+2))));
5727	}
5728	{
5729	PyDict_SetItemString(d,"PBS_MAXCLTJOBID", SWIG_From_int((int)(((6+64+5+2) +64+5+2))));
5730	}
5731	{
5732	PyDict_SetItemString(d,"PBS_MAXDEST", SWIG_From_int((int)(1024)));
5733	}
5734	{
5735	PyDict_SetItemString(d,"PBS_MAXROUTEDEST", SWIG_From_int((int)((15+64+5+2))));
5736	}
5737	{
5738	PyDict_SetItemString(d,"PBS_USE_IFF", SWIG_From_int((int)(1)));
5739	}
5740	{
5741	PyDict_SetItemString(d,"PBS_INTERACTIVE", SWIG_From_int((int)(1)));
5742	}
5743	{
5744	PyDict_SetItemString(d,"PBS_TERM_BUF_SZ", SWIG_From_int((int)(80)));
5745	}
5746	{
5747	PyDict_SetItemString(d,"PBS_TERM_CCA", SWIG_From_int((int)(6)));
5748	}
5749	PyDict_SetItemString(d,"PBS_BATCH_SERVICE_NAME", SWIG_FromCharPtr("pbs"));
5750	{
5751	PyDict_SetItemString(d,"PBS_BATCH_SERVICE_PORT", SWIG_From_int((int)(15001)));
5752	}
5753	PyDict_SetItemString(d,"PBS_BATCH_SERVICE_NAME_DIS", SWIG_FromCharPtr("pbs_dis"));
5754	{
5755	PyDict_SetItemString(d,"PBS_BATCH_SERVICE_PORT_DIS", SWIG_From_int((int)(15001)));
5756	}
5757	PyDict_SetItemString(d,"PBS_MOM_SERVICE_NAME", SWIG_FromCharPtr("pbs_mom"));
5758	{
5759	PyDict_SetItemString(d,"PBS_MOM_SERVICE_PORT", SWIG_From_int((int)(15002)));
5760	}
5761	PyDict_SetItemString(d,"PBS_MANAGER_SERVICE_NAME", SWIG_FromCharPtr("pbs_resmon"));
5762	{
5763	PyDict_SetItemString(d,"PBS_MANAGER_SERVICE_PORT", SWIG_From_int((int)(15003)));
5764	}
5765	PyDict_SetItemString(d,"PBS_SCHEDULER_SERVICE_NAME", SWIG_FromCharPtr("pbs_sched"));
5766	{
5767	PyDict_SetItemString(d,"PBS_SCHEDULER_SERVICE_PORT", SWIG_From_int((int)(15004)));
5768	}
5769	{
5770	PyDict_SetItemString(d,"SET", SWIG_From_int((int)(SET)));
5771	}
5772	{
5773	PyDict_SetItemString(d,"UNSET", SWIG_From_int((int)(UNSET)));
5774	}
5775	{
5776	PyDict_SetItemString(d,"INCR", SWIG_From_int((int)(INCR)));
5777	}
5778	{
5779	PyDict_SetItemString(d,"DECR", SWIG_From_int((int)(DECR)));
5780	}
5781	{
5782	PyDict_SetItemString(d,"EQ", SWIG_From_int((int)(EQ)));
5783	}
5784	{
5785	PyDict_SetItemString(d,"NE", SWIG_From_int((int)(NE)));
5786	}
5787	{
5788	PyDict_SetItemString(d,"GE", SWIG_From_int((int)(GE)));
5789	}
5790	{
5791	PyDict_SetItemString(d,"GT", SWIG_From_int((int)(GT)));
5792	}
5793	{
5794	PyDict_SetItemString(d,"LE", SWIG_From_int((int)(LE)));
5795	}
5796	{
5797	PyDict_SetItemString(d,"LT", SWIG_From_int((int)(LT)));
5798	}
5799	{
5800	PyDict_SetItemString(d,"DFLT", SWIG_From_int((int)(DFLT)));
5801	}
5802	{
5803	PyDict_SetItemString(d,"RESOURCE_T_NULL", SWIG_From_int((int)(0)));
5804	}
5805	{
5806	PyDict_SetItemString(d,"RESOURCE_T_ALL", SWIG_From_int((int)(-1)));
5807	}
5808	PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
5809	SWIG_addvarlink(SWIG_globals,(char*)"pbs_errno",_wrap_pbs_errno_get, _wrap_pbs_errno_set);
5810	SWIG_addvarlink(SWIG_globals,(char*)"pbs_server",_wrap_pbs_server_get, _wrap_pbs_server_set);
5811	{
5812	PyDict_SetItemString(d,"LOG_BUF_SIZE", SWIG_From_int((int)(4096)));
5813	}
5814	SWIG_addvarlink(SWIG_globals,(char*)"log_event_mask",_wrap_log_event_mask_get, _wrap_log_event_mask_set);
5815	SWIG_addvarlink(SWIG_globals,(char*)"log_buffer",_wrap_log_buffer_get, _wrap_log_buffer_set);
5816	{
5817	PyDict_SetItemString(d,"PBSEVENT_ERROR", SWIG_From_int((int)(0x0001)));
5818	}
5819	{
5820	PyDict_SetItemString(d,"PBSEVENT_SYSTEM", SWIG_From_int((int)(0x0002)));
5821	}
5822	{
5823	PyDict_SetItemString(d,"PBSEVENT_ADMIN", SWIG_From_int((int)(0x0004)));
5824	}
5825	{
5826	PyDict_SetItemString(d,"PBSEVENT_JOB", SWIG_From_int((int)(0x0008)));
5827	}
5828	{
5829	PyDict_SetItemString(d,"PBSEVENT_JOB_USAGE", SWIG_From_int((int)(0x0010)));
5830	}
5831	{
5832	PyDict_SetItemString(d,"PBSEVENT_SECURITY", SWIG_From_int((int)(0x0020)));
5833	}
5834	{
5835	PyDict_SetItemString(d,"PBSEVENT_SCHED", SWIG_From_int((int)(0x0040)));
5836	}
5837	{
5838	PyDict_SetItemString(d,"PBSEVENT_DEBUG", SWIG_From_int((int)(0x0080)));
5839	}
5840	{
5841	PyDict_SetItemString(d,"PBSEVENT_DEBUG2", SWIG_From_int((int)(0x0100)));
5842	}
5843	{
5844	PyDict_SetItemString(d,"PBSEVENT_FORCE", SWIG_From_int((int)(0x8000)));
5845	}
5846	{
5847	PyDict_SetItemString(d,"PBS_EVENTCLASS_SERVER", SWIG_From_int((int)(1)));
5848	}
5849	{
5850	PyDict_SetItemString(d,"PBS_EVENTCLASS_QUEUE", SWIG_From_int((int)(2)));
5851	}
5852	{
5853	PyDict_SetItemString(d,"PBS_EVENTCLASS_JOB", SWIG_From_int((int)(3)));
5854	}
5855	{
5856	PyDict_SetItemString(d,"PBS_EVENTCLASS_REQUEST", SWIG_From_int((int)(4)));
5857	}
5858	{
5859	PyDict_SetItemString(d,"PBS_EVENTCLASS_FILE", SWIG_From_int((int)(5)));
5860	}
5861	{
5862	PyDict_SetItemString(d,"PBS_EVENTCLASS_ACCT", SWIG_From_int((int)(6)));
5863	}
5864	{
5865	PyDict_SetItemString(d,"PBS_EVENTCLASS_NODE", SWIG_From_int((int)(7)));
5866	}
5867	{
5868	PyDict_SetItemString(d,"PBSEVENT_MASK", SWIG_From_int((int)(0x01ff)));
5869	}
5870	SWIG_addvarlink(SWIG_globals,(char*)"msg_daemonname",_wrap_msg_daemonname_get, _wrap_msg_daemonname_set);
5871	}
5872

Note: See TracBrowser for help on using the repository browser.

Download in other formats: