Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

source: branches/samba-3.5.x/source4/lib/wmi/wmi_wrap.c

Visit:

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago
Samba 3.5.0: Initial import
File size: 129.3 KB

Line
1	/* ----------------------------------------------------------------------------
2	* This file was automatically generated by SWIG (http://www.swig.org).
3	* Version 1.3.36
4	*
5	* This file is not intended to be easily readable and contains a number of
6	* coding conventions designed to improve portability and efficiency. Do not make
7	* changes to this file unless you know what you are doing--modify the SWIG
8	* interface file instead.
9	* ----------------------------------------------------------------------------- */
10
11	#define SWIGPYTHON
12	#define SWIG_PYTHON_NO_BUILD_NONE
13	/* -----------------------------------------------------------------------------
14	* This section contains generic SWIG labels for method/variable
15	* declarations/attributes, and other compiler dependent labels.
16	* ----------------------------------------------------------------------------- */
17
18	/* template workaround for compilers that cannot correctly implement the C++ standard */
19	#ifndef SWIGTEMPLATEDISAMBIGUATOR
20	# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
21	# define SWIGTEMPLATEDISAMBIGUATOR template
22	# elif defined(__HP_aCC)
23	/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
24	/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
25	# define SWIGTEMPLATEDISAMBIGUATOR template
26	# else
27	# define SWIGTEMPLATEDISAMBIGUATOR
28	# endif
29	#endif
30
31	/* inline attribute */
32	#ifndef SWIGINLINE
33	# if defined(__cplusplus) \|\| (defined(__GNUC__) && !defined(__STRICT_ANSI__))
34	# define SWIGINLINE inline
35	# else
36	# define SWIGINLINE
37	# endif
38	#endif
39
40	/* attribute recognised by some compilers to avoid 'unused' warnings */
41	#ifndef SWIGUNUSED
42	# if defined(__GNUC__)
43	# if !(defined(__cplusplus)) \|\| (__GNUC__ > 3 \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
44	# define SWIGUNUSED __attribute__ ((__unused__))
45	# else
46	# define SWIGUNUSED
47	# endif
48	# elif defined(__ICC)
49	# define SWIGUNUSED __attribute__ ((__unused__))
50	# else
51	# define SWIGUNUSED
52	# endif
53	#endif
54
55	#ifndef SWIG_MSC_UNSUPPRESS_4505
56	# if defined(_MSC_VER)
57	# pragma warning(disable : 4505) /* unreferenced local function has been removed */
58	# endif
59	#endif
60
61	#ifndef SWIGUNUSEDPARM
62	# ifdef __cplusplus
63	# define SWIGUNUSEDPARM(p)
64	# else
65	# define SWIGUNUSEDPARM(p) p SWIGUNUSED
66	# endif
67	#endif
68
69	/* internal SWIG method */
70	#ifndef SWIGINTERN
71	# define SWIGINTERN static SWIGUNUSED
72	#endif
73
74	/* internal inline SWIG method */
75	#ifndef SWIGINTERNINLINE
76	# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
77	#endif
78
79	/* exporting methods */
80	#if (__GNUC__ >= 4) \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
81	# ifndef GCC_HASCLASSVISIBILITY
82	# define GCC_HASCLASSVISIBILITY
83	# endif
84	#endif
85
86	#ifndef SWIGEXPORT
87	# if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
88	# if defined(STATIC_LINKED)
89	# define SWIGEXPORT
90	# else
91	# define SWIGEXPORT __declspec(dllexport)
92	# endif
93	# else
94	# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
95	# define SWIGEXPORT __attribute__ ((visibility("default")))
96	# else
97	# define SWIGEXPORT
98	# endif
99	# endif
100	#endif
101
102	/* calling conventions for Windows */
103	#ifndef SWIGSTDCALL
104	# if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
105	# define SWIGSTDCALL __stdcall
106	# else
107	# define SWIGSTDCALL
108	# endif
109	#endif
110
111	/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
112	#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
113	# define _CRT_SECURE_NO_DEPRECATE
114	#endif
115
116	/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
117	#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
118	# define _SCL_SECURE_NO_DEPRECATE
119	#endif
120
121
122
123	/* Python.h has to appear first */
124	#include <Python.h>
125
126	/* -----------------------------------------------------------------------------
127	* swigrun.swg
128	*
129	* This file contains generic CAPI SWIG runtime support for pointer
130	* type checking.
131	* ----------------------------------------------------------------------------- */
132
133	/* This should only be incremented when either the layout of swig_type_info changes,
134	or for whatever reason, the runtime changes incompatibly */
135	#define SWIG_RUNTIME_VERSION "4"
136
137	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
138	#ifdef SWIG_TYPE_TABLE
139	# define SWIG_QUOTE_STRING(x) #x
140	# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
141	# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
142	#else
143	# define SWIG_TYPE_TABLE_NAME
144	#endif
145
146	/*
147	You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
148	creating a static or dynamic library from the swig runtime code.
149	In 99.9% of the cases, swig just needs to declare them as 'static'.
150
151	But only do this if is strictly necessary, ie, if you have problems
152	with your compiler or so.
153	*/
154
155	#ifndef SWIGRUNTIME
156	# define SWIGRUNTIME SWIGINTERN
157	#endif
158
159	#ifndef SWIGRUNTIMEINLINE
160	# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
161	#endif
162
163	/* Generic buffer size */
164	#ifndef SWIG_BUFFER_SIZE
165	# define SWIG_BUFFER_SIZE 1024
166	#endif
167
168	/* Flags for pointer conversions */
169	#define SWIG_POINTER_DISOWN 0x1
170	#define SWIG_CAST_NEW_MEMORY 0x2
171
172	/* Flags for new pointer objects */
173	#define SWIG_POINTER_OWN 0x1
174
175
176	/*
177	Flags/methods for returning states.
178
179	The swig conversion methods, as ConvertPtr, return and integer
180	that tells if the conversion was successful or not. And if not,
181	an error code can be returned (see swigerrors.swg for the codes).
182
183	Use the following macros/flags to set or process the returning
184	states.
185
186	In old swig versions, you usually write code as:
187
188	if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
189	// success code
190	} else {
191	//fail code
192	}
193
194	Now you can be more explicit as:
195
196	int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
197	if (SWIG_IsOK(res)) {
198	// success code
199	} else {
200	// fail code
201	}
202
203	that seems to be the same, but now you can also do
204
205	Type *ptr;
206	int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
207	if (SWIG_IsOK(res)) {
208	// success code
209	if (SWIG_IsNewObj(res) {
210	...
211	delete *ptr;
212	} else {
213	...
214	}
215	} else {
216	// fail code
217	}
218
219	I.e., now SWIG_ConvertPtr can return new objects and you can
220	identify the case and take care of the deallocation. Of course that
221	requires also to SWIG_ConvertPtr to return new result values, as
222
223	int SWIG_ConvertPtr(obj, ptr,...) {
224	if (<obj is ok>) {
225	if (<need new object>) {
226	*ptr = <ptr to new allocated object>;
227	return SWIG_NEWOBJ;
228	} else {
229	*ptr = <ptr to old object>;
230	return SWIG_OLDOBJ;
231	}
232	} else {
233	return SWIG_BADOBJ;
234	}
235	}
236
237	Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
238	more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
239	swig errors code.
240
241	Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
242	allows to return the 'cast rank', for example, if you have this
243
244	int food(double)
245	int fooi(int);
246
247	and you call
248
249	food(1) // cast rank '1' (1 -> 1.0)
250	fooi(1) // cast rank '0'
251
252	just use the SWIG_AddCast()/SWIG_CheckState()
253
254
255	*/
256	#define SWIG_OK (0)
257	#define SWIG_ERROR (-1)
258	#define SWIG_IsOK(r) (r >= 0)
259	#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
260
261	/* The CastRankLimit says how many bits are used for the cast rank */
262	#define SWIG_CASTRANKLIMIT (1 << 8)
263	/* The NewMask denotes the object was created (using new/malloc) */
264	#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
265	/* The TmpMask is for in/out typemaps that use temporal objects */
266	#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
267	/* Simple returning values */
268	#define SWIG_BADOBJ (SWIG_ERROR)
269	#define SWIG_OLDOBJ (SWIG_OK)
270	#define SWIG_NEWOBJ (SWIG_OK \| SWIG_NEWOBJMASK)
271	#define SWIG_TMPOBJ (SWIG_OK \| SWIG_TMPOBJMASK)
272	/* Check, add and del mask methods */
273	#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r \| SWIG_NEWOBJMASK) : r)
274	#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
275	#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
276	#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r \| SWIG_TMPOBJMASK) : r)
277	#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
278	#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
279
280
281	/* Cast-Rank Mode */
282	#if defined(SWIG_CASTRANK_MODE)
283	# ifndef SWIG_TypeRank
284	# define SWIG_TypeRank unsigned long
285	# endif
286	# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
287	# define SWIG_MAXCASTRANK (2)
288	# endif
289	# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
290	# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
291	SWIGINTERNINLINE int SWIG_AddCast(int r) {
292	return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
293	}
294	SWIGINTERNINLINE int SWIG_CheckState(int r) {
295	return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
296	}
297	#else /* no cast-rank mode */
298	# define SWIG_AddCast
299	# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
300	#endif
301
302
303
304
305	#include <string.h>
306
307	#ifdef __cplusplus
308	extern "C" {
309	#endif
310
311	typedef void (swig_converter_func)(void , int );
312	typedef struct swig_type_info (swig_dycast_func)(void **);
313
314	/* Structure to store information on one type */
315	typedef struct swig_type_info {
316	const char name; / mangled name of this type */
317	const char str; / human readable name of this type */
318	swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
319	struct swig_cast_info cast; / linked list of types that can cast into this type */
320	void clientdata; / language specific type data */
321	int owndata; /* flag if the structure owns the clientdata */
322	} swig_type_info;
323
324	/* Structure to store a type and conversion function used for casting */
325	typedef struct swig_cast_info {
326	swig_type_info type; / pointer to type that is equivalent to this type */
327	swig_converter_func converter; /* function to cast the void pointers */
328	struct swig_cast_info next; / pointer to next cast in linked list */
329	struct swig_cast_info prev; / pointer to the previous cast */
330	} swig_cast_info;
331
332	/* Structure used to store module information
333	* Each module generates one structure like this, and the runtime collects
334	* all of these structures and stores them in a circularly linked list.*/
335	typedef struct swig_module_info {
336	swig_type_info *types; / Array of pointers to swig_type_info structures that are in this module */
337	size_t size; /* Number of types in this module */
338	struct swig_module_info next; / Pointer to next element in circularly linked list */
339	swig_type_info *type_initial; / Array of initially generated type structures */
340	swig_cast_info *cast_initial; / Array of initially generated casting structures */
341	void clientdata; / Language specific module data */
342	} swig_module_info;
343
344	/*
345	Compare two type names skipping the space characters, therefore
346	"char" == "char " and "Class<int>" == "Class<int >", etc.
347
348	Return 0 when the two name types are equivalent, as in
349	strncmp, but skipping ' '.
350	*/
351	SWIGRUNTIME int
352	SWIG_TypeNameComp(const char f1, const char l1,
353	const char f2, const char l2) {
354	for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
355	while ((*f1 == ' ') && (f1 != l1)) ++f1;
356	while ((*f2 == ' ') && (f2 != l2)) ++f2;
357	if (f1 != f2) return (f1 > f2) ? 1 : -1;
358	}
359	return (int)((l1 - f1) - (l2 - f2));
360	}
361
362	/*
363	Check type equivalence in a name list like <name1>\|<name2>\|...
364	Return 0 if not equal, 1 if equal
365	*/
366	SWIGRUNTIME int
367	SWIG_TypeEquiv(const char nb, const char tb) {
368	int equiv = 0;
369	const char* te = tb + strlen(tb);
370	const char* ne = nb;
371	while (!equiv && *ne) {
372	for (nb = ne; *ne; ++ne) {
373	if (*ne == '\|') break;
374	}
375	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
376	if (*ne) ++ne;
377	}
378	return equiv;
379	}
380
381	/*
382	Check type equivalence in a name list like <name1>\|<name2>\|...
383	Return 0 if equal, -1 if nb < tb, 1 if nb > tb
384	*/
385	SWIGRUNTIME int
386	SWIG_TypeCompare(const char nb, const char tb) {
387	int equiv = 0;
388	const char* te = tb + strlen(tb);
389	const char* ne = nb;
390	while (!equiv && *ne) {
391	for (nb = ne; *ne; ++ne) {
392	if (*ne == '\|') break;
393	}
394	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
395	if (*ne) ++ne;
396	}
397	return equiv;
398	}
399
400
401	/* think of this as a c++ template<> or a scheme macro */
402	#define SWIG_TypeCheck_Template(comparison, ty) \
403	if (ty) { \
404	swig_cast_info *iter = ty->cast; \
405	while (iter) { \
406	if (comparison) { \
407	if (iter == ty->cast) return iter; \
408	/* Move iter to the top of the linked list */ \
409	iter->prev->next = iter->next; \
410	if (iter->next) \
411	iter->next->prev = iter->prev; \
412	iter->next = ty->cast; \
413	iter->prev = 0; \
414	if (ty->cast) ty->cast->prev = iter; \
415	ty->cast = iter; \
416	return iter; \
417	} \
418	iter = iter->next; \
419	} \
420	} \
421	return 0
422
423	/*
424	Check the typename
425	*/
426	SWIGRUNTIME swig_cast_info *
427	SWIG_TypeCheck(const char c, swig_type_info ty) {
428	SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
429	}
430
431	/* Same as previous function, except strcmp is replaced with a pointer comparison */
432	SWIGRUNTIME swig_cast_info *
433	SWIG_TypeCheckStruct(swig_type_info from, swig_type_info into) {
434	SWIG_TypeCheck_Template(iter->type == from, into);
435	}
436
437	/*
438	Cast a pointer up an inheritance hierarchy
439	*/
440	SWIGRUNTIMEINLINE void *
441	SWIG_TypeCast(swig_cast_info ty, void ptr, int *newmemory) {
442	return ((!ty) \|\| (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
443	}
444
445	/*
446	Dynamic pointer casting. Down an inheritance hierarchy
447	*/
448	SWIGRUNTIME swig_type_info *
449	SWIG_TypeDynamicCast(swig_type_info ty, void *ptr) {
450	swig_type_info *lastty = ty;
451	if (!ty \|\| !ty->dcast) return ty;
452	while (ty && (ty->dcast)) {
453	ty = (*ty->dcast)(ptr);
454	if (ty) lastty = ty;
455	}
456	return lastty;
457	}
458
459	/*
460	Return the name associated with this type
461	*/
462	SWIGRUNTIMEINLINE const char *
463	SWIG_TypeName(const swig_type_info *ty) {
464	return ty->name;
465	}
466
467	/*
468	Return the pretty name associated with this type,
469	that is an unmangled type name in a form presentable to the user.
470	*/
471	SWIGRUNTIME const char *
472	SWIG_TypePrettyName(const swig_type_info *type) {
473	/* The "str" field contains the equivalent pretty names of the
474	type, separated by vertical-bar characters. We choose
475	to print the last name, as it is often (?) the most
476	specific. */
477	if (!type) return NULL;
478	if (type->str != NULL) {
479	const char *last_name = type->str;
480	const char *s;
481	for (s = type->str; *s; s++)
482	if (*s == '\|') last_name = s+1;
483	return last_name;
484	}
485	else
486	return type->name;
487	}
488
489	/*
490	Set the clientdata field for a type
491	*/
492	SWIGRUNTIME void
493	SWIG_TypeClientData(swig_type_info ti, void clientdata) {
494	swig_cast_info *cast = ti->cast;
495	/* if (ti->clientdata == clientdata) return; */
496	ti->clientdata = clientdata;
497
498	while (cast) {
499	if (!cast->converter) {
500	swig_type_info *tc = cast->type;
501	if (!tc->clientdata) {
502	SWIG_TypeClientData(tc, clientdata);
503	}
504	}
505	cast = cast->next;
506	}
507	}
508	SWIGRUNTIME void
509	SWIG_TypeNewClientData(swig_type_info ti, void clientdata) {
510	SWIG_TypeClientData(ti, clientdata);
511	ti->owndata = 1;
512	}
513
514	/*
515	Search for a swig_type_info structure only by mangled name
516	Search is a O(log #types)
517
518	We start searching at module start, and finish searching when start == end.
519	Note: if start == end at the beginning of the function, we go all the way around
520	the circular list.
521	*/
522	SWIGRUNTIME swig_type_info *
523	SWIG_MangledTypeQueryModule(swig_module_info *start,
524	swig_module_info *end,
525	const char *name) {
526	swig_module_info *iter = start;
527	do {
528	if (iter->size) {
529	register size_t l = 0;
530	register size_t r = iter->size - 1;
531	do {
532	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
533	register size_t i = (l + r) >> 1;
534	const char *iname = iter->types[i]->name;
535	if (iname) {
536	register int compare = strcmp(name, iname);
537	if (compare == 0) {
538	return iter->types[i];
539	} else if (compare < 0) {
540	if (i) {
541	r = i - 1;
542	} else {
543	break;
544	}
545	} else if (compare > 0) {
546	l = i + 1;
547	}
548	} else {
549	break; /* should never happen */
550	}
551	} while (l <= r);
552	}
553	iter = iter->next;
554	} while (iter != end);
555	return 0;
556	}
557
558	/*
559	Search for a swig_type_info structure for either a mangled name or a human readable name.
560	It first searches the mangled names of the types, which is a O(log #types)
561	If a type is not found it then searches the human readable names, which is O(#types).
562
563	We start searching at module start, and finish searching when start == end.
564	Note: if start == end at the beginning of the function, we go all the way around
565	the circular list.
566	*/
567	SWIGRUNTIME swig_type_info *
568	SWIG_TypeQueryModule(swig_module_info *start,
569	swig_module_info *end,
570	const char *name) {
571	/* STEP 1: Search the name field using binary search */
572	swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
573	if (ret) {
574	return ret;
575	} else {
576	/* STEP 2: If the type hasn't been found, do a complete search
577	of the str field (the human readable name) */
578	swig_module_info *iter = start;
579	do {
580	register size_t i = 0;
581	for (; i < iter->size; ++i) {
582	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
583	return iter->types[i];
584	}
585	iter = iter->next;
586	} while (iter != end);
587	}
588
589	/* neither found a match */
590	return 0;
591	}
592
593	/*
594	Pack binary data into a string
595	*/
596	SWIGRUNTIME char *
597	SWIG_PackData(char c, void ptr, size_t sz) {
598	static const char hex[17] = "0123456789abcdef";
599	register const unsigned char u = (unsigned char ) ptr;
600	register const unsigned char *eu = u + sz;
601	for (; u != eu; ++u) {
602	register unsigned char uu = *u;
603	*(c++) = hex[(uu & 0xf0) >> 4];
604	*(c++) = hex[uu & 0xf];
605	}
606	return c;
607	}
608
609	/*
610	Unpack binary data from a string
611	*/
612	SWIGRUNTIME const char *
613	SWIG_UnpackData(const char c, void ptr, size_t sz) {
614	register unsigned char u = (unsigned char ) ptr;
615	register const unsigned char *eu = u + sz;
616	for (; u != eu; ++u) {
617	register char d = *(c++);
618	register unsigned char uu;
619	if ((d >= '0') && (d <= '9'))
620	uu = ((d - '0') << 4);
621	else if ((d >= 'a') && (d <= 'f'))
622	uu = ((d - ('a'-10)) << 4);
623	else
624	return (char *) 0;
625	d = *(c++);
626	if ((d >= '0') && (d <= '9'))
627	uu \|= (d - '0');
628	else if ((d >= 'a') && (d <= 'f'))
629	uu \|= (d - ('a'-10));
630	else
631	return (char *) 0;
632	*u = uu;
633	}
634	return c;
635	}
636
637	/*
638	Pack 'void *' into a string buffer.
639	*/
640	SWIGRUNTIME char *
641	SWIG_PackVoidPtr(char buff, void ptr, const char *name, size_t bsz) {
642	char *r = buff;
643	if ((2sizeof(void ) + 2) > bsz) return 0;
644	*(r++) = '_';
645	r = SWIG_PackData(r,&ptr,sizeof(void *));
646	if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
647	strcpy(r,name);
648	return buff;
649	}
650
651	SWIGRUNTIME const char *
652	SWIG_UnpackVoidPtr(const char c, void ptr, const char name) {
653	if (*c != '_') {
654	if (strcmp(c,"NULL") == 0) {
655	ptr = (void ) 0;
656	return name;
657	} else {
658	return 0;
659	}
660	}
661	return SWIG_UnpackData(++c,ptr,sizeof(void *));
662	}
663
664	SWIGRUNTIME char *
665	SWIG_PackDataName(char buff, void ptr, size_t sz, const char *name, size_t bsz) {
666	char *r = buff;
667	size_t lname = (name ? strlen(name) : 0);
668	if ((2*sz + 2 + lname) > bsz) return 0;
669	*(r++) = '_';
670	r = SWIG_PackData(r,ptr,sz);
671	if (lname) {
672	strncpy(r,name,lname+1);
673	} else {
674	*r = 0;
675	}
676	return buff;
677	}
678
679	SWIGRUNTIME const char *
680	SWIG_UnpackDataName(const char c, void ptr, size_t sz, const char *name) {
681	if (*c != '_') {
682	if (strcmp(c,"NULL") == 0) {
683	memset(ptr,0,sz);
684	return name;
685	} else {
686	return 0;
687	}
688	}
689	return SWIG_UnpackData(++c,ptr,sz);
690	}
691
692	#ifdef __cplusplus
693	}
694	#endif
695
696	/* Errors in SWIG */
697	#define SWIG_UnknownError -1
698	#define SWIG_IOError -2
699	#define SWIG_RuntimeError -3
700	#define SWIG_IndexError -4
701	#define SWIG_TypeError -5
702	#define SWIG_DivisionByZero -6
703	#define SWIG_OverflowError -7
704	#define SWIG_SyntaxError -8
705	#define SWIG_ValueError -9
706	#define SWIG_SystemError -10
707	#define SWIG_AttributeError -11
708	#define SWIG_MemoryError -12
709	#define SWIG_NullReferenceError -13
710
711
712
713
714	/* Add PyOS_snprintf for old Pythons */
715	#if PY_VERSION_HEX < 0x02020000
716	# if defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(_WATCOM)
717	# define PyOS_snprintf _snprintf
718	# else
719	# define PyOS_snprintf snprintf
720	# endif
721	#endif
722
723	/* A crude PyString_FromFormat implementation for old Pythons */
724	#if PY_VERSION_HEX < 0x02020000
725
726	#ifndef SWIG_PYBUFFER_SIZE
727	# define SWIG_PYBUFFER_SIZE 1024
728	#endif
729
730	static PyObject *
731	PyString_FromFormat(const char *fmt, ...) {
732	va_list ap;
733	char buf[SWIG_PYBUFFER_SIZE * 2];
734	int res;
735	va_start(ap, fmt);
736	res = vsnprintf(buf, sizeof(buf), fmt, ap);
737	va_end(ap);
738	return (res < 0 \|\| res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
739	}
740	#endif
741
742	/* Add PyObject_Del for old Pythons */
743	#if PY_VERSION_HEX < 0x01060000
744	# define PyObject_Del(op) PyMem_DEL((op))
745	#endif
746	#ifndef PyObject_DEL
747	# define PyObject_DEL PyObject_Del
748	#endif
749
750	/* A crude PyExc_StopIteration exception for old Pythons */
751	#if PY_VERSION_HEX < 0x02020000
752	# ifndef PyExc_StopIteration
753	# define PyExc_StopIteration PyExc_RuntimeError
754	# endif
755	# ifndef PyObject_GenericGetAttr
756	# define PyObject_GenericGetAttr 0
757	# endif
758	#endif
759	/* Py_NotImplemented is defined in 2.1 and up. */
760	#if PY_VERSION_HEX < 0x02010000
761	# ifndef Py_NotImplemented
762	# define Py_NotImplemented PyExc_RuntimeError
763	# endif
764	#endif
765
766
767	/* A crude PyString_AsStringAndSize implementation for old Pythons */
768	#if PY_VERSION_HEX < 0x02010000
769	# ifndef PyString_AsStringAndSize
770	# define PyString_AsStringAndSize(obj, s, len) {s = PyString_AsString(obj); len = s ? strlen(s) : 0;}
771	# endif
772	#endif
773
774	/* PySequence_Size for old Pythons */
775	#if PY_VERSION_HEX < 0x02000000
776	# ifndef PySequence_Size
777	# define PySequence_Size PySequence_Length
778	# endif
779	#endif
780
781
782	/* PyBool_FromLong for old Pythons */
783	#if PY_VERSION_HEX < 0x02030000
784	static
785	PyObject *PyBool_FromLong(long ok)
786	{
787	PyObject *result = ok ? Py_True : Py_False;
788	Py_INCREF(result);
789	return result;
790	}
791	#endif
792
793	/* Py_ssize_t for old Pythons */
794	/* This code is as recommended by: */
795	/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
796	#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
797	typedef int Py_ssize_t;
798	# define PY_SSIZE_T_MAX INT_MAX
799	# define PY_SSIZE_T_MIN INT_MIN
800	#endif
801
802	/* -----------------------------------------------------------------------------
803	* error manipulation
804	* ----------------------------------------------------------------------------- */
805
806	SWIGRUNTIME PyObject*
807	SWIG_Python_ErrorType(int code) {
808	PyObject* type = 0;
809	switch(code) {
810	case SWIG_MemoryError:
811	type = PyExc_MemoryError;
812	break;
813	case SWIG_IOError:
814	type = PyExc_IOError;
815	break;
816	case SWIG_RuntimeError:
817	type = PyExc_RuntimeError;
818	break;
819	case SWIG_IndexError:
820	type = PyExc_IndexError;
821	break;
822	case SWIG_TypeError:
823	type = PyExc_TypeError;
824	break;
825	case SWIG_DivisionByZero:
826	type = PyExc_ZeroDivisionError;
827	break;
828	case SWIG_OverflowError:
829	type = PyExc_OverflowError;
830	break;
831	case SWIG_SyntaxError:
832	type = PyExc_SyntaxError;
833	break;
834	case SWIG_ValueError:
835	type = PyExc_ValueError;
836	break;
837	case SWIG_SystemError:
838	type = PyExc_SystemError;
839	break;
840	case SWIG_AttributeError:
841	type = PyExc_AttributeError;
842	break;
843	default:
844	type = PyExc_RuntimeError;
845	}
846	return type;
847	}
848
849
850	SWIGRUNTIME void
851	SWIG_Python_AddErrorMsg(const char* mesg)
852	{
853	PyObject *type = 0;
854	PyObject *value = 0;
855	PyObject *traceback = 0;
856
857	if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
858	if (value) {
859	PyObject *old_str = PyObject_Str(value);
860	PyErr_Clear();
861	Py_XINCREF(type);
862	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
863	Py_DECREF(old_str);
864	Py_DECREF(value);
865	} else {
866	PyErr_SetString(PyExc_RuntimeError, mesg);
867	}
868	}
869
870
871
872	#if defined(SWIG_PYTHON_NO_THREADS)
873	# if defined(SWIG_PYTHON_THREADS)
874	# undef SWIG_PYTHON_THREADS
875	# endif
876	#endif
877	#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
878	# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
879	# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
880	# define SWIG_PYTHON_USE_GIL
881	# endif
882	# endif
883	# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
884	# ifndef SWIG_PYTHON_INITIALIZE_THREADS
885	# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
886	# endif
887	# ifdef __cplusplus /* C++ code */
888	class SWIG_Python_Thread_Block {
889	bool status;
890	PyGILState_STATE state;
891	public:
892	void end() { if (status) { PyGILState_Release(state); status = false;} }
893	SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
894	~SWIG_Python_Thread_Block() { end(); }
895	};
896	class SWIG_Python_Thread_Allow {
897	bool status;
898	PyThreadState *save;
899	public:
900	void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
901	SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
902	~SWIG_Python_Thread_Allow() { end(); }
903	};
904	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
905	# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
906	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
907	# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
908	# else /* C code */
909	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
910	# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
911	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
912	# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
913	# endif
914	# else /* Old thread way, not implemented, user must provide it */
915	# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
916	# define SWIG_PYTHON_INITIALIZE_THREADS
917	# endif
918	# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
919	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
920	# endif
921	# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
922	# define SWIG_PYTHON_THREAD_END_BLOCK
923	# endif
924	# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
925	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
926	# endif
927	# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
928	# define SWIG_PYTHON_THREAD_END_ALLOW
929	# endif
930	# endif
931	#else /* No thread support */
932	# define SWIG_PYTHON_INITIALIZE_THREADS
933	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
934	# define SWIG_PYTHON_THREAD_END_BLOCK
935	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
936	# define SWIG_PYTHON_THREAD_END_ALLOW
937	#endif
938
939	/* -----------------------------------------------------------------------------
940	* Python API portion that goes into the runtime
941	* ----------------------------------------------------------------------------- */
942
943	#ifdef __cplusplus
944	extern "C" {
945	#if 0
946	} /* cc-mode */
947	#endif
948	#endif
949
950	/* -----------------------------------------------------------------------------
951	* Constant declarations
952	* ----------------------------------------------------------------------------- */
953
954	/* Constant Types */
955	#define SWIG_PY_POINTER 4
956	#define SWIG_PY_BINARY 5
957
958	/* Constant information structure */
959	typedef struct swig_const_info {
960	int type;
961	char *name;
962	long lvalue;
963	double dvalue;
964	void *pvalue;
965	swig_type_info **ptype;
966	} swig_const_info;
967
968	#ifdef __cplusplus
969	#if 0
970	{ /* cc-mode */
971	#endif
972	}
973	#endif
974
975
976	/* -----------------------------------------------------------------------------
977	* See the LICENSE file for information on copyright, usage and redistribution
978	* of SWIG, and the README file for authors - http://www.swig.org/release.html.
979	*
980	* pyrun.swg
981	*
982	* This file contains the runtime support for Python modules
983	* and includes code for managing global variables and pointer
984	* type checking.
985	*
986	* ----------------------------------------------------------------------------- */
987
988	/* Common SWIG API */
989
990	/* for raw pointers */
991	#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
992	#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
993	#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
994	#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
995	#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
996	#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
997	#define swig_owntype int
998
999	/* for raw packed data */
1000	#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1001	#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1002
1003	/* for class or struct pointers */
1004	#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1005	#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1006
1007	/* for C or C++ function pointers */
1008	#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1009	#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1010
1011	/* for C++ member pointers, ie, member methods */
1012	#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1013	#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1014
1015
1016	/* Runtime API */
1017
1018	#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1019	#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1020	#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1021
1022	#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1023	#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1024	#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1025	#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1026	#define SWIG_fail goto fail
1027
1028
1029	/* Runtime API implementation */
1030
1031	/* Error manipulation */
1032
1033	SWIGINTERN void
1034	SWIG_Python_SetErrorObj(PyObject errtype, PyObject obj) {
1035	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1036	PyErr_SetObject(errtype, obj);
1037	Py_DECREF(obj);
1038	SWIG_PYTHON_THREAD_END_BLOCK;
1039	}
1040
1041	SWIGINTERN void
1042	SWIG_Python_SetErrorMsg(PyObject errtype, const char msg) {
1043	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1044	PyErr_SetString(errtype, (char *) msg);
1045	SWIG_PYTHON_THREAD_END_BLOCK;
1046	}
1047
1048	#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1049
1050	/* Set a constant value */
1051
1052	SWIGINTERN void
1053	SWIG_Python_SetConstant(PyObject d, const char name, PyObject *obj) {
1054	PyDict_SetItemString(d, (char*) name, obj);
1055	Py_DECREF(obj);
1056	}
1057
1058	/* Append a value to the result obj */
1059
1060	SWIGINTERN PyObject*
1061	SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1062	#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1063	if (!result) {
1064	result = obj;
1065	} else if (result == Py_None) {
1066	Py_DECREF(result);
1067	result = obj;
1068	} else {
1069	if (!PyList_Check(result)) {
1070	PyObject *o2 = result;
1071	result = PyList_New(1);
1072	PyList_SetItem(result, 0, o2);
1073	}
1074	PyList_Append(result,obj);
1075	Py_DECREF(obj);
1076	}
1077	return result;
1078	#else
1079	PyObject* o2;
1080	PyObject* o3;
1081	if (!result) {
1082	result = obj;
1083	} else if (result == Py_None) {
1084	Py_DECREF(result);
1085	result = obj;
1086	} else {
1087	if (!PyTuple_Check(result)) {
1088	o2 = result;
1089	result = PyTuple_New(1);
1090	PyTuple_SET_ITEM(result, 0, o2);
1091	}
1092	o3 = PyTuple_New(1);
1093	PyTuple_SET_ITEM(o3, 0, obj);
1094	o2 = result;
1095	result = PySequence_Concat(o2, o3);
1096	Py_DECREF(o2);
1097	Py_DECREF(o3);
1098	}
1099	return result;
1100	#endif
1101	}
1102
1103	/* Unpack the argument tuple */
1104
1105	SWIGINTERN int
1106	SWIG_Python_UnpackTuple(PyObject args, const char name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1107	{
1108	if (!args) {
1109	if (!min && !max) {
1110	return 1;
1111	} else {
1112	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1113	name, (min == max ? "" : "at least "), (int)min);
1114	return 0;
1115	}
1116	}
1117	if (!PyTuple_Check(args)) {
1118	PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1119	return 0;
1120	} else {
1121	register Py_ssize_t l = PyTuple_GET_SIZE(args);
1122	if (l < min) {
1123	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1124	name, (min == max ? "" : "at least "), (int)min, (int)l);
1125	return 0;
1126	} else if (l > max) {
1127	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1128	name, (min == max ? "" : "at most "), (int)max, (int)l);
1129	return 0;
1130	} else {
1131	register int i;
1132	for (i = 0; i < l; ++i) {
1133	objs[i] = PyTuple_GET_ITEM(args, i);
1134	}
1135	for (; l < max; ++l) {
1136	objs[l] = 0;
1137	}
1138	return i + 1;
1139	}
1140	}
1141	}
1142
1143	/* A functor is a function object with one single object argument */
1144	#if PY_VERSION_HEX >= 0x02020000
1145	#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1146	#else
1147	#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1148	#endif
1149
1150	/*
1151	Helper for static pointer initialization for both C and C++ code, for example
1152	static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1153	*/
1154	#ifdef __cplusplus
1155	#define SWIG_STATIC_POINTER(var) var
1156	#else
1157	#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1158	#endif
1159
1160	/* -----------------------------------------------------------------------------
1161	* Pointer declarations
1162	* ----------------------------------------------------------------------------- */
1163
1164	/* Flags for new pointer objects */
1165	#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1166	#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW \| SWIG_POINTER_OWN)
1167
1168	#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1169
1170	#ifdef __cplusplus
1171	extern "C" {
1172	#if 0
1173	} /* cc-mode */
1174	#endif
1175	#endif
1176
1177	/* How to access Py_None */
1178	#if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
1179	# ifndef SWIG_PYTHON_NO_BUILD_NONE
1180	# ifndef SWIG_PYTHON_BUILD_NONE
1181	# define SWIG_PYTHON_BUILD_NONE
1182	# endif
1183	# endif
1184	#endif
1185
1186	#ifdef SWIG_PYTHON_BUILD_NONE
1187	# ifdef Py_None
1188	# undef Py_None
1189	# define Py_None SWIG_Py_None()
1190	# endif
1191	SWIGRUNTIMEINLINE PyObject *
1192	_SWIG_Py_None(void)
1193	{
1194	PyObject none = Py_BuildValue((char)"");
1195	Py_DECREF(none);
1196	return none;
1197	}
1198	SWIGRUNTIME PyObject *
1199	SWIG_Py_None(void)
1200	{
1201	static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1202	return none;
1203	}
1204	#endif
1205
1206	/* The python void return value */
1207
1208	SWIGRUNTIMEINLINE PyObject *
1209	SWIG_Py_Void(void)
1210	{
1211	PyObject *none = Py_None;
1212	Py_INCREF(none);
1213	return none;
1214	}
1215
1216	/* PySwigClientData */
1217
1218	typedef struct {
1219	PyObject *klass;
1220	PyObject *newraw;
1221	PyObject *newargs;
1222	PyObject *destroy;
1223	int delargs;
1224	int implicitconv;
1225	} PySwigClientData;
1226
1227	SWIGRUNTIMEINLINE int
1228	SWIG_Python_CheckImplicit(swig_type_info *ty)
1229	{
1230	PySwigClientData data = (PySwigClientData )ty->clientdata;
1231	return data ? data->implicitconv : 0;
1232	}
1233
1234	SWIGRUNTIMEINLINE PyObject *
1235	SWIG_Python_ExceptionType(swig_type_info *desc) {
1236	PySwigClientData data = desc ? (PySwigClientData ) desc->clientdata : 0;
1237	PyObject *klass = data ? data->klass : 0;
1238	return (klass ? klass : PyExc_RuntimeError);
1239	}
1240
1241
1242	SWIGRUNTIME PySwigClientData *
1243	PySwigClientData_New(PyObject* obj)
1244	{
1245	if (!obj) {
1246	return 0;
1247	} else {
1248	PySwigClientData data = (PySwigClientData )malloc(sizeof(PySwigClientData));
1249	/* the klass element */
1250	data->klass = obj;
1251	Py_INCREF(data->klass);
1252	/* the newraw method and newargs arguments used to create a new raw instance */
1253	if (PyClass_Check(obj)) {
1254	data->newraw = 0;
1255	data->newargs = obj;
1256	Py_INCREF(obj);
1257	} else {
1258	#if (PY_VERSION_HEX < 0x02020000)
1259	data->newraw = 0;
1260	#else
1261	data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1262	#endif
1263	if (data->newraw) {
1264	Py_INCREF(data->newraw);
1265	data->newargs = PyTuple_New(1);
1266	PyTuple_SetItem(data->newargs, 0, obj);
1267	} else {
1268	data->newargs = obj;
1269	}
1270	Py_INCREF(data->newargs);
1271	}
1272	/* the destroy method, aka as the C++ delete method */
1273	data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1274	if (PyErr_Occurred()) {
1275	PyErr_Clear();
1276	data->destroy = 0;
1277	}
1278	if (data->destroy) {
1279	int flags;
1280	Py_INCREF(data->destroy);
1281	flags = PyCFunction_GET_FLAGS(data->destroy);
1282	#ifdef METH_O
1283	data->delargs = !(flags & (METH_O));
1284	#else
1285	data->delargs = 0;
1286	#endif
1287	} else {
1288	data->delargs = 0;
1289	}
1290	data->implicitconv = 0;
1291	return data;
1292	}
1293	}
1294
1295	SWIGRUNTIME void
1296	PySwigClientData_Del(PySwigClientData* data)
1297	{
1298	Py_XDECREF(data->newraw);
1299	Py_XDECREF(data->newargs);
1300	Py_XDECREF(data->destroy);
1301	}
1302
1303	/* =============== PySwigObject =====================*/
1304
1305	typedef struct {
1306	PyObject_HEAD
1307	void *ptr;
1308	swig_type_info *ty;
1309	int own;
1310	PyObject *next;
1311	} PySwigObject;
1312
1313	SWIGRUNTIME PyObject *
1314	PySwigObject_long(PySwigObject *v)
1315	{
1316	return PyLong_FromVoidPtr(v->ptr);
1317	}
1318
1319	SWIGRUNTIME PyObject *
1320	PySwigObject_format(const char* fmt, PySwigObject *v)
1321	{
1322	PyObject *res = NULL;
1323	PyObject *args = PyTuple_New(1);
1324	if (args) {
1325	if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1326	PyObject *ofmt = PyString_FromString(fmt);
1327	if (ofmt) {
1328	res = PyString_Format(ofmt,args);
1329	Py_DECREF(ofmt);
1330	}
1331	Py_DECREF(args);
1332	}
1333	}
1334	return res;
1335	}
1336
1337	SWIGRUNTIME PyObject *
1338	PySwigObject_oct(PySwigObject *v)
1339	{
1340	return PySwigObject_format("%o",v);
1341	}
1342
1343	SWIGRUNTIME PyObject *
1344	PySwigObject_hex(PySwigObject *v)
1345	{
1346	return PySwigObject_format("%x",v);
1347	}
1348
1349	SWIGRUNTIME PyObject *
1350	#ifdef METH_NOARGS
1351	PySwigObject_repr(PySwigObject *v)
1352	#else
1353	PySwigObject_repr(PySwigObject v, PyObject args)
1354	#endif
1355	{
1356	const char *name = SWIG_TypePrettyName(v->ty);
1357	PyObject *hex = PySwigObject_hex(v);
1358	PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1359	Py_DECREF(hex);
1360	if (v->next) {
1361	#ifdef METH_NOARGS
1362	PyObject nrep = PySwigObject_repr((PySwigObject )v->next);
1363	#else
1364	PyObject nrep = PySwigObject_repr((PySwigObject )v->next, args);
1365	#endif
1366	PyString_ConcatAndDel(&repr,nrep);
1367	}
1368	return repr;
1369	}
1370
1371	SWIGRUNTIME int
1372	PySwigObject_print(PySwigObject v, FILE fp, int SWIGUNUSEDPARM(flags))
1373	{
1374	#ifdef METH_NOARGS
1375	PyObject *repr = PySwigObject_repr(v);
1376	#else
1377	PyObject *repr = PySwigObject_repr(v, NULL);
1378	#endif
1379	if (repr) {
1380	fputs(PyString_AsString(repr), fp);
1381	Py_DECREF(repr);
1382	return 0;
1383	} else {
1384	return 1;
1385	}
1386	}
1387
1388	SWIGRUNTIME PyObject *
1389	PySwigObject_str(PySwigObject *v)
1390	{
1391	char result[SWIG_BUFFER_SIZE];
1392	return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1393	PyString_FromString(result) : 0;
1394	}
1395
1396	SWIGRUNTIME int
1397	PySwigObject_compare(PySwigObject v, PySwigObject w)
1398	{
1399	void *i = v->ptr;
1400	void *j = w->ptr;
1401	return (i < j) ? -1 : ((i > j) ? 1 : 0);
1402	}
1403
1404	SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1405
1406	SWIGRUNTIME PyTypeObject*
1407	PySwigObject_type(void) {
1408	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1409	return type;
1410	}
1411
1412	SWIGRUNTIMEINLINE int
1413	PySwigObject_Check(PyObject *op) {
1414	return ((op)->ob_type == PySwigObject_type())
1415	\|\| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1416	}
1417
1418	SWIGRUNTIME PyObject *
1419	PySwigObject_New(void ptr, swig_type_info ty, int own);
1420
1421	SWIGRUNTIME void
1422	PySwigObject_dealloc(PyObject *v)
1423	{
1424	PySwigObject sobj = (PySwigObject ) v;
1425	PyObject *next = sobj->next;
1426	if (sobj->own == SWIG_POINTER_OWN) {
1427	swig_type_info *ty = sobj->ty;
1428	PySwigClientData data = ty ? (PySwigClientData ) ty->clientdata : 0;
1429	PyObject *destroy = data ? data->destroy : 0;
1430	if (destroy) {
1431	/* destroy is always a VARARGS method */
1432	PyObject *res;
1433	if (data->delargs) {
1434	/* we need to create a temporal object to carry the destroy operation */
1435	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1436	res = SWIG_Python_CallFunctor(destroy, tmp);
1437	Py_DECREF(tmp);
1438	} else {
1439	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1440	PyObject *mself = PyCFunction_GET_SELF(destroy);
1441	res = ((*meth)(mself, v));
1442	}
1443	Py_XDECREF(res);
1444	}
1445	#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1446	else {
1447	const char *name = SWIG_TypePrettyName(ty);
1448	printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1449	}
1450	#endif
1451	}
1452	Py_XDECREF(next);
1453	PyObject_DEL(v);
1454	}
1455
1456	SWIGRUNTIME PyObject*
1457	PySwigObject_append(PyObject* v, PyObject* next)
1458	{
1459	PySwigObject sobj = (PySwigObject ) v;
1460	#ifndef METH_O
1461	PyObject *tmp = 0;
1462	if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1463	next = tmp;
1464	#endif
1465	if (!PySwigObject_Check(next)) {
1466	return NULL;
1467	}
1468	sobj->next = next;
1469	Py_INCREF(next);
1470	return SWIG_Py_Void();
1471	}
1472
1473	SWIGRUNTIME PyObject*
1474	#ifdef METH_NOARGS
1475	PySwigObject_next(PyObject* v)
1476	#else
1477	PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1478	#endif
1479	{
1480	PySwigObject sobj = (PySwigObject ) v;
1481	if (sobj->next) {
1482	Py_INCREF(sobj->next);
1483	return sobj->next;
1484	} else {
1485	return SWIG_Py_Void();
1486	}
1487	}
1488
1489	SWIGINTERN PyObject*
1490	#ifdef METH_NOARGS
1491	PySwigObject_disown(PyObject *v)
1492	#else
1493	PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1494	#endif
1495	{
1496	PySwigObject sobj = (PySwigObject )v;
1497	sobj->own = 0;
1498	return SWIG_Py_Void();
1499	}
1500
1501	SWIGINTERN PyObject*
1502	#ifdef METH_NOARGS
1503	PySwigObject_acquire(PyObject *v)
1504	#else
1505	PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1506	#endif
1507	{
1508	PySwigObject sobj = (PySwigObject )v;
1509	sobj->own = SWIG_POINTER_OWN;
1510	return SWIG_Py_Void();
1511	}
1512
1513	SWIGINTERN PyObject*
1514	PySwigObject_own(PyObject v, PyObject args)
1515	{
1516	PyObject *val = 0;
1517	#if (PY_VERSION_HEX < 0x02020000)
1518	if (!PyArg_ParseTuple(args,(char *)"\|O:own",&val))
1519	#else
1520	if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1521	#endif
1522	{
1523	return NULL;
1524	}
1525	else
1526	{
1527	PySwigObject sobj = (PySwigObject )v;
1528	PyObject *obj = PyBool_FromLong(sobj->own);
1529	if (val) {
1530	#ifdef METH_NOARGS
1531	if (PyObject_IsTrue(val)) {
1532	PySwigObject_acquire(v);
1533	} else {
1534	PySwigObject_disown(v);
1535	}
1536	#else
1537	if (PyObject_IsTrue(val)) {
1538	PySwigObject_acquire(v,args);
1539	} else {
1540	PySwigObject_disown(v,args);
1541	}
1542	#endif
1543	}
1544	return obj;
1545	}
1546	}
1547
1548	#ifdef METH_O
1549	static PyMethodDef
1550	swigobject_methods[] = {
1551	{(char )"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char )"releases ownership of the pointer"},
1552	{(char )"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char )"aquires ownership of the pointer"},
1553	{(char )"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char )"returns/sets ownership of the pointer"},
1554	{(char )"append", (PyCFunction)PySwigObject_append, METH_O, (char )"appends another 'this' object"},
1555	{(char )"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char )"returns the next 'this' object"},
1556	{(char )"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char )"returns object representation"},
1557	{0, 0, 0, 0}
1558	};
1559	#else
1560	static PyMethodDef
1561	swigobject_methods[] = {
1562	{(char )"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char )"releases ownership of the pointer"},
1563	{(char )"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char )"aquires ownership of the pointer"},
1564	{(char )"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char )"returns/sets ownership of the pointer"},
1565	{(char )"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char )"appends another 'this' object"},
1566	{(char )"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char )"returns the next 'this' object"},
1567	{(char )"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char )"returns object representation"},
1568	{0, 0, 0, 0}
1569	};
1570	#endif
1571
1572	#if PY_VERSION_HEX < 0x02020000
1573	SWIGINTERN PyObject *
1574	PySwigObject_getattr(PySwigObject sobj,char name)
1575	{
1576	return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1577	}
1578	#endif
1579
1580	SWIGRUNTIME PyTypeObject*
1581	_PySwigObject_type(void) {
1582	static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1583
1584	static PyNumberMethods PySwigObject_as_number = {
1585	(binaryfunc)0, /nb_add/
1586	(binaryfunc)0, /nb_subtract/
1587	(binaryfunc)0, /nb_multiply/
1588	(binaryfunc)0, /nb_divide/
1589	(binaryfunc)0, /nb_remainder/
1590	(binaryfunc)0, /nb_divmod/
1591	(ternaryfunc)0,/nb_power/
1592	(unaryfunc)0, /nb_negative/
1593	(unaryfunc)0, /nb_positive/
1594	(unaryfunc)0, /nb_absolute/
1595	(inquiry)0, /nb_nonzero/
1596	0, /nb_invert/
1597	0, /nb_lshift/
1598	0, /nb_rshift/
1599	0, /nb_and/
1600	0, /nb_xor/
1601	0, /nb_or/
1602	(coercion)0, /nb_coerce/
1603	(unaryfunc)PySwigObject_long, /nb_int/
1604	(unaryfunc)PySwigObject_long, /nb_long/
1605	(unaryfunc)0, /nb_float/
1606	(unaryfunc)PySwigObject_oct, /nb_oct/
1607	(unaryfunc)PySwigObject_hex, /nb_hex/
1608	#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1609	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1610	#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1611	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1612	#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1613	0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1614	#endif
1615	};
1616
1617	static PyTypeObject pyswigobject_type;
1618	static int type_init = 0;
1619	if (!type_init) {
1620	const PyTypeObject tmp
1621	= {
1622	PyObject_HEAD_INIT(NULL)
1623	0, /* ob_size */
1624	(char )"PySwigObject", / tp_name */
1625	sizeof(PySwigObject), /* tp_basicsize */
1626	0, /* tp_itemsize */
1627	(destructor)PySwigObject_dealloc, /* tp_dealloc */
1628	(printfunc)PySwigObject_print, /* tp_print */
1629	#if PY_VERSION_HEX < 0x02020000
1630	(getattrfunc)PySwigObject_getattr, /* tp_getattr */
1631	#else
1632	(getattrfunc)0, /* tp_getattr */
1633	#endif
1634	(setattrfunc)0, /* tp_setattr */
1635	(cmpfunc)PySwigObject_compare, /* tp_compare */
1636	(reprfunc)PySwigObject_repr, /* tp_repr */
1637	&PySwigObject_as_number, /* tp_as_number */
1638	0, /* tp_as_sequence */
1639	0, /* tp_as_mapping */
1640	(hashfunc)0, /* tp_hash */
1641	(ternaryfunc)0, /* tp_call */
1642	(reprfunc)PySwigObject_str, /* tp_str */
1643	PyObject_GenericGetAttr, /* tp_getattro */
1644	0, /* tp_setattro */
1645	0, /* tp_as_buffer */
1646	Py_TPFLAGS_DEFAULT, /* tp_flags */
1647	swigobject_doc, /* tp_doc */
1648	0, /* tp_traverse */
1649	0, /* tp_clear */
1650	0, /* tp_richcompare */
1651	0, /* tp_weaklistoffset */
1652	#if PY_VERSION_HEX >= 0x02020000
1653	0, /* tp_iter */
1654	0, /* tp_iternext */
1655	swigobject_methods, /* tp_methods */
1656	0, /* tp_members */
1657	0, /* tp_getset */
1658	0, /* tp_base */
1659	0, /* tp_dict */
1660	0, /* tp_descr_get */
1661	0, /* tp_descr_set */
1662	0, /* tp_dictoffset */
1663	0, /* tp_init */
1664	0, /* tp_alloc */
1665	0, /* tp_new */
1666	0, /* tp_free */
1667	0, /* tp_is_gc */
1668	0, /* tp_bases */
1669	0, /* tp_mro */
1670	0, /* tp_cache */
1671	0, /* tp_subclasses */
1672	0, /* tp_weaklist */
1673	#endif
1674	#if PY_VERSION_HEX >= 0x02030000
1675	0, /* tp_del */
1676	#endif
1677	#ifdef COUNT_ALLOCS
1678	0,0,0,0 /* tp_alloc -> tp_next */
1679	#endif
1680	};
1681	pyswigobject_type = tmp;
1682	pyswigobject_type.ob_type = &PyType_Type;
1683	type_init = 1;
1684	}
1685	return &pyswigobject_type;
1686	}
1687
1688	SWIGRUNTIME PyObject *
1689	PySwigObject_New(void ptr, swig_type_info ty, int own)
1690	{
1691	PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1692	if (sobj) {
1693	sobj->ptr = ptr;
1694	sobj->ty = ty;
1695	sobj->own = own;
1696	sobj->next = 0;
1697	}
1698	return (PyObject *)sobj;
1699	}
1700
1701	/* -----------------------------------------------------------------------------
1702	* Implements a simple Swig Packed type, and use it instead of string
1703	* ----------------------------------------------------------------------------- */
1704
1705	typedef struct {
1706	PyObject_HEAD
1707	void *pack;
1708	swig_type_info *ty;
1709	size_t size;
1710	} PySwigPacked;
1711
1712	SWIGRUNTIME int
1713	PySwigPacked_print(PySwigPacked v, FILE fp, int SWIGUNUSEDPARM(flags))
1714	{
1715	char result[SWIG_BUFFER_SIZE];
1716	fputs("<Swig Packed ", fp);
1717	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1718	fputs("at ", fp);
1719	fputs(result, fp);
1720	}
1721	fputs(v->ty->name,fp);
1722	fputs(">", fp);
1723	return 0;
1724	}
1725
1726	SWIGRUNTIME PyObject *
1727	PySwigPacked_repr(PySwigPacked *v)
1728	{
1729	char result[SWIG_BUFFER_SIZE];
1730	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1731	return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1732	} else {
1733	return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1734	}
1735	}
1736
1737	SWIGRUNTIME PyObject *
1738	PySwigPacked_str(PySwigPacked *v)
1739	{
1740	char result[SWIG_BUFFER_SIZE];
1741	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1742	return PyString_FromFormat("%s%s", result, v->ty->name);
1743	} else {
1744	return PyString_FromString(v->ty->name);
1745	}
1746	}
1747
1748	SWIGRUNTIME int
1749	PySwigPacked_compare(PySwigPacked v, PySwigPacked w)
1750	{
1751	size_t i = v->size;
1752	size_t j = w->size;
1753	int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1754	return s ? s : strncmp((char )v->pack, (char )w->pack, 2*v->size);
1755	}
1756
1757	SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1758
1759	SWIGRUNTIME PyTypeObject*
1760	PySwigPacked_type(void) {
1761	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1762	return type;
1763	}
1764
1765	SWIGRUNTIMEINLINE int
1766	PySwigPacked_Check(PyObject *op) {
1767	return ((op)->ob_type == _PySwigPacked_type())
1768	\|\| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1769	}
1770
1771	SWIGRUNTIME void
1772	PySwigPacked_dealloc(PyObject *v)
1773	{
1774	if (PySwigPacked_Check(v)) {
1775	PySwigPacked sobj = (PySwigPacked ) v;
1776	free(sobj->pack);
1777	}
1778	PyObject_DEL(v);
1779	}
1780
1781	SWIGRUNTIME PyTypeObject*
1782	_PySwigPacked_type(void) {
1783	static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1784	static PyTypeObject pyswigpacked_type;
1785	static int type_init = 0;
1786	if (!type_init) {
1787	const PyTypeObject tmp
1788	= {
1789	PyObject_HEAD_INIT(NULL)
1790	0, /* ob_size */
1791	(char )"PySwigPacked", / tp_name */
1792	sizeof(PySwigPacked), /* tp_basicsize */
1793	0, /* tp_itemsize */
1794	(destructor)PySwigPacked_dealloc, /* tp_dealloc */
1795	(printfunc)PySwigPacked_print, /* tp_print */
1796	(getattrfunc)0, /* tp_getattr */
1797	(setattrfunc)0, /* tp_setattr */
1798	(cmpfunc)PySwigPacked_compare, /* tp_compare */
1799	(reprfunc)PySwigPacked_repr, /* tp_repr */
1800	0, /* tp_as_number */
1801	0, /* tp_as_sequence */
1802	0, /* tp_as_mapping */
1803	(hashfunc)0, /* tp_hash */
1804	(ternaryfunc)0, /* tp_call */
1805	(reprfunc)PySwigPacked_str, /* tp_str */
1806	PyObject_GenericGetAttr, /* tp_getattro */
1807	0, /* tp_setattro */
1808	0, /* tp_as_buffer */
1809	Py_TPFLAGS_DEFAULT, /* tp_flags */
1810	swigpacked_doc, /* tp_doc */
1811	0, /* tp_traverse */
1812	0, /* tp_clear */
1813	0, /* tp_richcompare */
1814	0, /* tp_weaklistoffset */
1815	#if PY_VERSION_HEX >= 0x02020000
1816	0, /* tp_iter */
1817	0, /* tp_iternext */
1818	0, /* tp_methods */
1819	0, /* tp_members */
1820	0, /* tp_getset */
1821	0, /* tp_base */
1822	0, /* tp_dict */
1823	0, /* tp_descr_get */
1824	0, /* tp_descr_set */
1825	0, /* tp_dictoffset */
1826	0, /* tp_init */
1827	0, /* tp_alloc */
1828	0, /* tp_new */
1829	0, /* tp_free */
1830	0, /* tp_is_gc */
1831	0, /* tp_bases */
1832	0, /* tp_mro */
1833	0, /* tp_cache */
1834	0, /* tp_subclasses */
1835	0, /* tp_weaklist */
1836	#endif
1837	#if PY_VERSION_HEX >= 0x02030000
1838	0, /* tp_del */
1839	#endif
1840	#ifdef COUNT_ALLOCS
1841	0,0,0,0 /* tp_alloc -> tp_next */
1842	#endif
1843	};
1844	pyswigpacked_type = tmp;
1845	pyswigpacked_type.ob_type = &PyType_Type;
1846	type_init = 1;
1847	}
1848	return &pyswigpacked_type;
1849	}
1850
1851	SWIGRUNTIME PyObject *
1852	PySwigPacked_New(void ptr, size_t size, swig_type_info ty)
1853	{
1854	PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1855	if (sobj) {
1856	void *pack = malloc(size);
1857	if (pack) {
1858	memcpy(pack, ptr, size);
1859	sobj->pack = pack;
1860	sobj->ty = ty;
1861	sobj->size = size;
1862	} else {
1863	PyObject_DEL((PyObject *) sobj);
1864	sobj = 0;
1865	}
1866	}
1867	return (PyObject *) sobj;
1868	}
1869
1870	SWIGRUNTIME swig_type_info *
1871	PySwigPacked_UnpackData(PyObject obj, void ptr, size_t size)
1872	{
1873	if (PySwigPacked_Check(obj)) {
1874	PySwigPacked sobj = (PySwigPacked )obj;
1875	if (sobj->size != size) return 0;
1876	memcpy(ptr, sobj->pack, size);
1877	return sobj->ty;
1878	} else {
1879	return 0;
1880	}
1881	}
1882
1883	/* -----------------------------------------------------------------------------
1884	* pointers/data manipulation
1885	* ----------------------------------------------------------------------------- */
1886
1887	SWIGRUNTIMEINLINE PyObject *
1888	_SWIG_This(void)
1889	{
1890	return PyString_FromString("this");
1891	}
1892
1893	SWIGRUNTIME PyObject *
1894	SWIG_This(void)
1895	{
1896	static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1897	return swig_this;
1898	}
1899
1900	/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1901
1902	SWIGRUNTIME PySwigObject *
1903	SWIG_Python_GetSwigThis(PyObject *pyobj)
1904	{
1905	if (PySwigObject_Check(pyobj)) {
1906	return (PySwigObject *) pyobj;
1907	} else {
1908	PyObject *obj = 0;
1909	#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1910	if (PyInstance_Check(pyobj)) {
1911	obj = _PyInstance_Lookup(pyobj, SWIG_This());
1912	} else {
1913	PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1914	if (dictptr != NULL) {
1915	PyObject dict = dictptr;
1916	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1917	} else {
1918	#ifdef PyWeakref_CheckProxy
1919	if (PyWeakref_CheckProxy(pyobj)) {
1920	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1921	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1922	}
1923	#endif
1924	obj = PyObject_GetAttr(pyobj,SWIG_This());
1925	if (obj) {
1926	Py_DECREF(obj);
1927	} else {
1928	if (PyErr_Occurred()) PyErr_Clear();
1929	return 0;
1930	}
1931	}
1932	}
1933	#else
1934	obj = PyObject_GetAttr(pyobj,SWIG_This());
1935	if (obj) {
1936	Py_DECREF(obj);
1937	} else {
1938	if (PyErr_Occurred()) PyErr_Clear();
1939	return 0;
1940	}
1941	#endif
1942	if (obj && !PySwigObject_Check(obj)) {
1943	/* a PyObject is called 'this', try to get the 'real this'
1944	PySwigObject from it */
1945	return SWIG_Python_GetSwigThis(obj);
1946	}
1947	return (PySwigObject *)obj;
1948	}
1949	}
1950
1951	/* Acquire a pointer value */
1952
1953	SWIGRUNTIME int
1954	SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1955	if (own == SWIG_POINTER_OWN) {
1956	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1957	if (sobj) {
1958	int oldown = sobj->own;
1959	sobj->own = own;
1960	return oldown;
1961	}
1962	}
1963	return 0;
1964	}
1965
1966	/* Convert a pointer value */
1967
1968	SWIGRUNTIME int
1969	SWIG_Python_ConvertPtrAndOwn(PyObject obj, void ptr, swig_type_info ty, int flags, int *own) {
1970	if (!obj) return SWIG_ERROR;
1971	if (obj == Py_None) {
1972	if (ptr) *ptr = 0;
1973	return SWIG_OK;
1974	} else {
1975	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1976	if (own)
1977	*own = 0;
1978	while (sobj) {
1979	void *vptr = sobj->ptr;
1980	if (ty) {
1981	swig_type_info *to = sobj->ty;
1982	if (to == ty) {
1983	/* no type cast needed */
1984	if (ptr) *ptr = vptr;
1985	break;
1986	} else {
1987	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1988	if (!tc) {
1989	sobj = (PySwigObject *)sobj->next;
1990	} else {
1991	if (ptr) {
1992	int newmemory = 0;
1993	*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
1994	if (newmemory == SWIG_CAST_NEW_MEMORY) {
1995	assert(own);
1996	if (own)
1997	own = own \| SWIG_CAST_NEW_MEMORY;
1998	}
1999	}
2000	break;
2001	}
2002	}
2003	} else {
2004	if (ptr) *ptr = vptr;
2005	break;
2006	}
2007	}
2008	if (sobj) {
2009	if (own)
2010	own = own \| sobj->own;
2011	if (flags & SWIG_POINTER_DISOWN) {
2012	sobj->own = 0;
2013	}
2014	return SWIG_OK;
2015	} else {
2016	int res = SWIG_ERROR;
2017	if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2018	PySwigClientData data = ty ? (PySwigClientData ) ty->clientdata : 0;
2019	if (data && !data->implicitconv) {
2020	PyObject *klass = data->klass;
2021	if (klass) {
2022	PyObject *impconv;
2023	data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2024	impconv = SWIG_Python_CallFunctor(klass, obj);
2025	data->implicitconv = 0;
2026	if (PyErr_Occurred()) {
2027	PyErr_Clear();
2028	impconv = 0;
2029	}
2030	if (impconv) {
2031	PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2032	if (iobj) {
2033	void *vptr;
2034	res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2035	if (SWIG_IsOK(res)) {
2036	if (ptr) {
2037	*ptr = vptr;
2038	/* transfer the ownership to 'ptr' */
2039	iobj->own = 0;
2040	res = SWIG_AddCast(res);
2041	res = SWIG_AddNewMask(res);
2042	} else {
2043	res = SWIG_AddCast(res);
2044	}
2045	}
2046	}
2047	Py_DECREF(impconv);
2048	}
2049	}
2050	}
2051	}
2052	return res;
2053	}
2054	}
2055	}
2056
2057	/* Convert a function ptr value */
2058
2059	SWIGRUNTIME int
2060	SWIG_Python_ConvertFunctionPtr(PyObject obj, void ptr, swig_type_info ty) {
2061	if (!PyCFunction_Check(obj)) {
2062	return SWIG_ConvertPtr(obj, ptr, ty, 0);
2063	} else {
2064	void *vptr = 0;
2065
2066	/* here we get the method pointer for callbacks */
2067	const char doc = (((PyCFunctionObject )obj) -> m_ml -> ml_doc);
2068	const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2069	if (desc) {
2070	desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2071	if (!desc) return SWIG_ERROR;
2072	}
2073	if (ty) {
2074	swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2075	if (tc) {
2076	int newmemory = 0;
2077	*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2078	assert(!newmemory); /* newmemory handling not yet implemented */
2079	} else {
2080	return SWIG_ERROR;
2081	}
2082	} else {
2083	*ptr = vptr;
2084	}
2085	return SWIG_OK;
2086	}
2087	}
2088
2089	/* Convert a packed value value */
2090
2091	SWIGRUNTIME int
2092	SWIG_Python_ConvertPacked(PyObject obj, void ptr, size_t sz, swig_type_info *ty) {
2093	swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2094	if (!to) return SWIG_ERROR;
2095	if (ty) {
2096	if (to != ty) {
2097	/* check type cast? */
2098	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2099	if (!tc) return SWIG_ERROR;
2100	}
2101	}
2102	return SWIG_OK;
2103	}
2104
2105	/* -----------------------------------------------------------------------------
2106	* Create a new pointer object
2107	* ----------------------------------------------------------------------------- */
2108
2109	/*
2110	Create a new instance object, whitout calling __init__, and set the
2111	'this' attribute.
2112	*/
2113
2114	SWIGRUNTIME PyObject*
2115	SWIG_Python_NewShadowInstance(PySwigClientData data, PyObject swig_this)
2116	{
2117	#if (PY_VERSION_HEX >= 0x02020000)
2118	PyObject *inst = 0;
2119	PyObject *newraw = data->newraw;
2120	if (newraw) {
2121	inst = PyObject_Call(newraw, data->newargs, NULL);
2122	if (inst) {
2123	#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2124	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2125	if (dictptr != NULL) {
2126	PyObject dict = dictptr;
2127	if (dict == NULL) {
2128	dict = PyDict_New();
2129	*dictptr = dict;
2130	PyDict_SetItem(dict, SWIG_This(), swig_this);
2131	}
2132	}
2133	#else
2134	PyObject *key = SWIG_This();
2135	PyObject_SetAttr(inst, key, swig_this);
2136	#endif
2137	}
2138	} else {
2139	PyObject *dict = PyDict_New();
2140	PyDict_SetItem(dict, SWIG_This(), swig_this);
2141	inst = PyInstance_NewRaw(data->newargs, dict);
2142	Py_DECREF(dict);
2143	}
2144	return inst;
2145	#else
2146	#if (PY_VERSION_HEX >= 0x02010000)
2147	PyObject *inst;
2148	PyObject *dict = PyDict_New();
2149	PyDict_SetItem(dict, SWIG_This(), swig_this);
2150	inst = PyInstance_NewRaw(data->newargs, dict);
2151	Py_DECREF(dict);
2152	return (PyObject *) inst;
2153	#else
2154	PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2155	if (inst == NULL) {
2156	return NULL;
2157	}
2158	inst->in_class = (PyClassObject *)data->newargs;
2159	Py_INCREF(inst->in_class);
2160	inst->in_dict = PyDict_New();
2161	if (inst->in_dict == NULL) {
2162	Py_DECREF(inst);
2163	return NULL;
2164	}
2165	#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2166	inst->in_weakreflist = NULL;
2167	#endif
2168	#ifdef Py_TPFLAGS_GC
2169	PyObject_GC_Init(inst);
2170	#endif
2171	PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2172	return (PyObject *) inst;
2173	#endif
2174	#endif
2175	}
2176
2177	SWIGRUNTIME void
2178	SWIG_Python_SetSwigThis(PyObject inst, PyObject swig_this)
2179	{
2180	PyObject *dict;
2181	#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2182	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2183	if (dictptr != NULL) {
2184	dict = *dictptr;
2185	if (dict == NULL) {
2186	dict = PyDict_New();
2187	*dictptr = dict;
2188	}
2189	PyDict_SetItem(dict, SWIG_This(), swig_this);
2190	return;
2191	}
2192	#endif
2193	dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2194	PyDict_SetItem(dict, SWIG_This(), swig_this);
2195	Py_DECREF(dict);
2196	}
2197
2198
2199	SWIGINTERN PyObject *
2200	SWIG_Python_InitShadowInstance(PyObject *args) {
2201	PyObject *obj[2];
2202	if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2203	return NULL;
2204	} else {
2205	PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2206	if (sthis) {
2207	PySwigObject_append((PyObject*) sthis, obj[1]);
2208	} else {
2209	SWIG_Python_SetSwigThis(obj[0], obj[1]);
2210	}
2211	return SWIG_Py_Void();
2212	}
2213	}
2214
2215	/* Create a new pointer object */
2216
2217	SWIGRUNTIME PyObject *
2218	SWIG_Python_NewPointerObj(void ptr, swig_type_info type, int flags) {
2219	if (!ptr) {
2220	return SWIG_Py_Void();
2221	} else {
2222	int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2223	PyObject *robj = PySwigObject_New(ptr, type, own);
2224	PySwigClientData clientdata = type ? (PySwigClientData )(type->clientdata) : 0;
2225	if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2226	PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2227	if (inst) {
2228	Py_DECREF(robj);
2229	robj = inst;
2230	}
2231	}
2232	return robj;
2233	}
2234	}
2235
2236	/* Create a new packed object */
2237
2238	SWIGRUNTIMEINLINE PyObject *
2239	SWIG_Python_NewPackedObj(void ptr, size_t sz, swig_type_info type) {
2240	return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2241	}
2242
2243	/* -----------------------------------------------------------------------------*
2244	* Get type list
2245	* -----------------------------------------------------------------------------*/
2246
2247	#ifdef SWIG_LINK_RUNTIME
2248	void SWIG_ReturnGlobalTypeList(void );
2249	#endif
2250
2251	SWIGRUNTIME swig_module_info *
2252	SWIG_Python_GetModule(void) {
2253	static void type_pointer = (void )0;
2254	/* first check if module already created */
2255	if (!type_pointer) {
2256	#ifdef SWIG_LINK_RUNTIME
2257	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2258	#else
2259	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2260	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2261	if (PyErr_Occurred()) {
2262	PyErr_Clear();
2263	type_pointer = (void *)0;
2264	}
2265	#endif
2266	}
2267	return (swig_module_info *) type_pointer;
2268	}
2269
2270	#if PY_MAJOR_VERSION < 2
2271	/* PyModule_AddObject function was introduced in Python 2.0. The following function
2272	is copied out of Python/modsupport.c in python version 2.3.4 */
2273	SWIGINTERN int
2274	PyModule_AddObject(PyObject m, char name, PyObject *o)
2275	{
2276	PyObject *dict;
2277	if (!PyModule_Check(m)) {
2278	PyErr_SetString(PyExc_TypeError,
2279	"PyModule_AddObject() needs module as first arg");
2280	return SWIG_ERROR;
2281	}
2282	if (!o) {
2283	PyErr_SetString(PyExc_TypeError,
2284	"PyModule_AddObject() needs non-NULL value");
2285	return SWIG_ERROR;
2286	}
2287
2288	dict = PyModule_GetDict(m);
2289	if (dict == NULL) {
2290	/* Internal error -- modules must have a dict! */
2291	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2292	PyModule_GetName(m));
2293	return SWIG_ERROR;
2294	}
2295	if (PyDict_SetItemString(dict, name, o))
2296	return SWIG_ERROR;
2297	Py_DECREF(o);
2298	return SWIG_OK;
2299	}
2300	#endif
2301
2302	SWIGRUNTIME void
2303	SWIG_Python_DestroyModule(void *vptr)
2304	{
2305	swig_module_info swig_module = (swig_module_info ) vptr;
2306	swig_type_info **types = swig_module->types;
2307	size_t i;
2308	for (i =0; i < swig_module->size; ++i) {
2309	swig_type_info *ty = types[i];
2310	if (ty->owndata) {
2311	PySwigClientData data = (PySwigClientData ) ty->clientdata;
2312	if (data) PySwigClientData_Del(data);
2313	}
2314	}
2315	Py_DECREF(SWIG_This());
2316	}
2317
2318	SWIGRUNTIME void
2319	SWIG_Python_SetModule(swig_module_info *swig_module) {
2320	static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2321
2322	PyObject module = Py_InitModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2323	swig_empty_runtime_method_table);
2324	PyObject pointer = PyCObject_FromVoidPtr((void ) swig_module, SWIG_Python_DestroyModule);
2325	if (pointer && module) {
2326	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2327	} else {
2328	Py_XDECREF(pointer);
2329	}
2330	}
2331
2332	/* The python cached type query */
2333	SWIGRUNTIME PyObject *
2334	SWIG_Python_TypeCache(void) {
2335	static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2336	return cache;
2337	}
2338
2339	SWIGRUNTIME swig_type_info *
2340	SWIG_Python_TypeQuery(const char *type)
2341	{
2342	PyObject *cache = SWIG_Python_TypeCache();
2343	PyObject *key = PyString_FromString(type);
2344	PyObject *obj = PyDict_GetItem(cache, key);
2345	swig_type_info *descriptor;
2346	if (obj) {
2347	descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2348	} else {
2349	swig_module_info *swig_module = SWIG_Python_GetModule();
2350	descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2351	if (descriptor) {
2352	obj = PyCObject_FromVoidPtr(descriptor, NULL);
2353	PyDict_SetItem(cache, key, obj);
2354	Py_DECREF(obj);
2355	}
2356	}
2357	Py_DECREF(key);
2358	return descriptor;
2359	}
2360
2361	/*
2362	For backward compatibility only
2363	*/
2364	#define SWIG_POINTER_EXCEPTION 0
2365	#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2366	#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2367
2368	SWIGRUNTIME int
2369	SWIG_Python_AddErrMesg(const char* mesg, int infront)
2370	{
2371	if (PyErr_Occurred()) {
2372	PyObject *type = 0;
2373	PyObject *value = 0;
2374	PyObject *traceback = 0;
2375	PyErr_Fetch(&type, &value, &traceback);
2376	if (value) {
2377	PyObject *old_str = PyObject_Str(value);
2378	Py_XINCREF(type);
2379	PyErr_Clear();
2380	if (infront) {
2381	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2382	} else {
2383	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2384	}
2385	Py_DECREF(old_str);
2386	}
2387	return 1;
2388	} else {
2389	return 0;
2390	}
2391	}
2392
2393	SWIGRUNTIME int
2394	SWIG_Python_ArgFail(int argnum)
2395	{
2396	if (PyErr_Occurred()) {
2397	/* add information about failing argument */
2398	char mesg[256];
2399	PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2400	return SWIG_Python_AddErrMesg(mesg, 1);
2401	} else {
2402	return 0;
2403	}
2404	}
2405
2406	SWIGRUNTIMEINLINE const char *
2407	PySwigObject_GetDesc(PyObject *self)
2408	{
2409	PySwigObject v = (PySwigObject )self;
2410	swig_type_info *ty = v ? v->ty : 0;
2411	return ty ? ty->str : (char*)"";
2412	}
2413
2414	SWIGRUNTIME void
2415	SWIG_Python_TypeError(const char type, PyObject obj)
2416	{
2417	if (type) {
2418	#if defined(SWIG_COBJECT_TYPES)
2419	if (obj && PySwigObject_Check(obj)) {
2420	const char otype = (const char ) PySwigObject_GetDesc(obj);
2421	if (otype) {
2422	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2423	type, otype);
2424	return;
2425	}
2426	} else
2427	#endif
2428	{
2429	const char *otype = (obj ? obj->ob_type->tp_name : 0);
2430	if (otype) {
2431	PyObject *str = PyObject_Str(obj);
2432	const char *cstr = str ? PyString_AsString(str) : 0;
2433	if (cstr) {
2434	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2435	type, otype, cstr);
2436	} else {
2437	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2438	type, otype);
2439	}
2440	Py_XDECREF(str);
2441	return;
2442	}
2443	}
2444	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2445	} else {
2446	PyErr_Format(PyExc_TypeError, "unexpected type is received");
2447	}
2448	}
2449
2450
2451	/* Convert a pointer value, signal an exception on a type mismatch */
2452	SWIGRUNTIME void *
2453	SWIG_Python_MustGetPtr(PyObject obj, swig_type_info ty, int argnum, int flags) {
2454	void *result;
2455	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2456	PyErr_Clear();
2457	if (flags & SWIG_POINTER_EXCEPTION) {
2458	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2459	SWIG_Python_ArgFail(argnum);
2460	}
2461	}
2462	return result;
2463	}
2464
2465
2466	#ifdef __cplusplus
2467	#if 0
2468	{ /* cc-mode */
2469	#endif
2470	}
2471	#endif
2472
2473
2474
2475	#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2476
2477	#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2478
2479
2480
2481	void push_object(PyObject *stack, PyObject o)
2482	{
2483	if ((!stack) \|\| (stack == Py_None)) {
2484	*stack = o;
2485	} else {
2486	PyObject o2, o3;
2487	if (!PyTuple_Check(*stack)) {
2488	o2 = *stack;
2489	*stack = PyTuple_New(1);
2490	PyTuple_SetItem(*stack,0,o2);
2491	}
2492	o3 = PyTuple_New(1);
2493	PyTuple_SetItem(o3,0,o);
2494	o2 = *stack;
2495	*stack = PySequence_Concat(o2,o3);
2496	Py_DECREF(o2);
2497	Py_DECREF(o3);
2498	}
2499	}
2500
2501
2502	/* -------- TYPES TABLE (BEGIN) -------- */
2503
2504	#define SWIGTYPE_p_BSTR swig_types[0]
2505	#define SWIGTYPE_p_IEnumWbemClassObject swig_types[1]
2506	#define SWIGTYPE_p_IUnknown swig_types[2]
2507	#define SWIGTYPE_p_IWbemContext swig_types[3]
2508	#define SWIGTYPE_p_IWbemServices swig_types[4]
2509	#define SWIGTYPE_p_TALLOC_CTX swig_types[5]
2510	#define SWIGTYPE_p_char swig_types[6]
2511	#define SWIGTYPE_p_com_context swig_types[7]
2512	#define SWIGTYPE_p_int swig_types[8]
2513	#define SWIGTYPE_p_long_long swig_types[9]
2514	#define SWIGTYPE_p_p_IEnumWbemClassObject swig_types[10]
2515	#define SWIGTYPE_p_p_IWbemServices swig_types[11]
2516	#define SWIGTYPE_p_p_WbemClassObject swig_types[12]
2517	#define SWIGTYPE_p_short swig_types[13]
2518	#define SWIGTYPE_p_signed_char swig_types[14]
2519	#define SWIGTYPE_p_unsigned_char swig_types[15]
2520	#define SWIGTYPE_p_unsigned_int swig_types[16]
2521	#define SWIGTYPE_p_unsigned_long_long swig_types[17]
2522	#define SWIGTYPE_p_unsigned_short swig_types[18]
2523	static swig_type_info *swig_types[20];
2524	static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0};
2525	#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2526	#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2527
2528	/* -------- TYPES TABLE (END) -------- */
2529
2530	#if (PY_VERSION_HEX <= 0x02000000)
2531	# if !defined(SWIG_PYTHON_CLASSIC)
2532	# error "This python version requires swig to be run with the '-classic' option"
2533	# endif
2534	#endif
2535	#if (PY_VERSION_HEX <= 0x02020000)
2536	# error "This python version requires swig to be run with the '-nomodern' option"
2537	#endif
2538	#if (PY_VERSION_HEX <= 0x02020000)
2539	# error "This python version requires swig to be run with the '-nomodernargs' option"
2540	#endif
2541	#ifndef METH_O
2542	# error "This python version requires swig to be run with the '-nofastunpack' option"
2543	#endif
2544	#ifdef SWIG_TypeQuery
2545	# undef SWIG_TypeQuery
2546	#endif
2547	#define SWIG_TypeQuery SWIG_Python_TypeQuery
2548
2549	/*-----------------------------------------------
2550	@(target):= _wmi.so
2551	------------------------------------------------*/
2552	#define SWIG_init init_wmi
2553
2554	#define SWIG_name "_wmi"
2555
2556	#define SWIGVERSION 0x010336
2557	#define SWIG_VERSION SWIGVERSION
2558
2559
2560	#define SWIG_as_voidptr(a) (void )((const void )(a))
2561	#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(a),(void*)(a))
2562
2563
2564	#include "libcli/util/pyerrors.h"
2565
2566
2567	#include "includes.h"
2568	#include "librpc/gen_ndr/misc.h"
2569	#include "librpc/rpc/dcerpc.h"
2570	#include "lib/com/dcom/dcom.h"
2571	#include "librpc/gen_ndr/com_dcom.h"
2572	#include "lib/wmi/wmi.h"
2573
2574
2575	WERROR WBEM_ConnectServer(struct com_context ctx, const char server, const char nspace, const char user, const char *password,
2576	const char locale, uint32_t flags, const char authority, struct IWbemContext* wbem_ctx, struct IWbemServices** services);
2577	WERROR IEnumWbemClassObject_SmartNext(struct IEnumWbemClassObject d, TALLOC_CTX mem_ctx, int32_t lTimeout,uint32_t uCount,
2578	struct WbemClassObject *apObjects, uint32_t puReturned);
2579
2580	static PyObject PyObject_FromCVAR(uint32_t cimtype, union CIMVAR cvar);
2581	static PyObject PySWbemObject_FromWbemClassObject(struct WbemClassObject wco);
2582
2583	static struct com_context *com_ctx;
2584	static PyObject *ComError;
2585	static PyObject *mod_win32_client;
2586	static PyObject *mod_pywintypes;
2587
2588	typedef struct IUnknown IUnknown;
2589	typedef struct IWbemServices IWbemServices;
2590	typedef struct IWbemClassObject IWbemClassObject;
2591	typedef struct IEnumWbemClassObject IEnumWbemClassObject;
2592
2593
2594	SWIGINTERN swig_type_info*
2595	SWIG_pchar_descriptor(void)
2596	{
2597	static int init = 0;
2598	static swig_type_info* info = 0;
2599	if (!init) {
2600	info = SWIG_TypeQuery("_p_char");
2601	init = 1;
2602	}
2603	return info;
2604	}
2605
2606
2607	SWIGINTERN int
2608	SWIG_AsCharPtrAndSize(PyObject obj, char* cptr, size_t* psize, int *alloc)
2609	{
2610	if (PyString_Check(obj)) {
2611	char *cstr; Py_ssize_t len;
2612	PyString_AsStringAndSize(obj, &cstr, &len);
2613	if (cptr) {
2614	if (alloc) {
2615	/*
2616	In python the user should not be able to modify the inner
2617	string representation. To warranty that, if you define
2618	SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2619	buffer is always returned.
2620
2621	The default behavior is just to return the pointer value,
2622	so, be careful.
2623	*/
2624	#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2625	if (*alloc != SWIG_OLDOBJ)
2626	#else
2627	if (*alloc == SWIG_NEWOBJ)
2628	#endif
2629	{
2630	cptr = (char )memcpy((char )malloc((len + 1)sizeof(char)), cstr, sizeof(char)*(len + 1));
2631	*alloc = SWIG_NEWOBJ;
2632	}
2633	else {
2634	*cptr = cstr;
2635	*alloc = SWIG_OLDOBJ;
2636	}
2637	} else {
2638	*cptr = PyString_AsString(obj);
2639	}
2640	}
2641	if (psize) *psize = len + 1;
2642	return SWIG_OK;
2643	} else {
2644	swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2645	if (pchar_descriptor) {
2646	void* vptr = 0;
2647	if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2648	if (cptr) cptr = (char ) vptr;
2649	if (psize) psize = vptr ? (strlen((char )vptr) + 1) : 0;
2650	if (alloc) *alloc = SWIG_OLDOBJ;
2651	return SWIG_OK;
2652	}
2653	}
2654	}
2655	return SWIG_TypeError;
2656	}
2657
2658
2659
2660
2661
2662	#include <limits.h>
2663	#if !defined(SWIG_NO_LLONG_MAX)
2664	# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2665	# define LLONG_MAX __LONG_LONG_MAX__
2666	# define LLONG_MIN (-LLONG_MAX - 1LL)
2667	# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2668	# endif
2669	#endif
2670
2671
2672	SWIGINTERN int
2673	SWIG_AsVal_double (PyObject obj, double val)
2674	{
2675	int res = SWIG_TypeError;
2676	if (PyFloat_Check(obj)) {
2677	if (val) *val = PyFloat_AsDouble(obj);
2678	return SWIG_OK;
2679	} else if (PyInt_Check(obj)) {
2680	if (val) *val = PyInt_AsLong(obj);
2681	return SWIG_OK;
2682	} else if (PyLong_Check(obj)) {
2683	double v = PyLong_AsDouble(obj);
2684	if (!PyErr_Occurred()) {
2685	if (val) *val = v;
2686	return SWIG_OK;
2687	} else {
2688	PyErr_Clear();
2689	}
2690	}
2691	#ifdef SWIG_PYTHON_CAST_MODE
2692	{
2693	int dispatch = 0;
2694	double d = PyFloat_AsDouble(obj);
2695	if (!PyErr_Occurred()) {
2696	if (val) *val = d;
2697	return SWIG_AddCast(SWIG_OK);
2698	} else {
2699	PyErr_Clear();
2700	}
2701	if (!dispatch) {
2702	long v = PyLong_AsLong(obj);
2703	if (!PyErr_Occurred()) {
2704	if (val) *val = v;
2705	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2706	} else {
2707	PyErr_Clear();
2708	}
2709	}
2710	}
2711	#endif
2712	return res;
2713	}
2714
2715
2716	#include <float.h>
2717
2718
2719	#include <math.h>
2720
2721
2722	SWIGINTERNINLINE int
2723	SWIG_CanCastAsInteger(double *d, double min, double max) {
2724	double x = *d;
2725	if ((min <= x && x <= max)) {
2726	double fx = floor(x);
2727	double cx = ceil(x);
2728	double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2729	if ((errno == EDOM) \|\| (errno == ERANGE)) {
2730	errno = 0;
2731	} else {
2732	double summ, reps, diff;
2733	if (rd < x) {
2734	diff = x - rd;
2735	} else if (rd > x) {
2736	diff = rd - x;
2737	} else {
2738	return 1;
2739	}
2740	summ = rd + x;
2741	reps = diff/summ;
2742	if (reps < 8*DBL_EPSILON) {
2743	*d = rd;
2744	return 1;
2745	}
2746	}
2747	}
2748	return 0;
2749	}
2750
2751
2752	SWIGINTERN int
2753	SWIG_AsVal_unsigned_SS_long (PyObject obj, unsigned long val)
2754	{
2755	if (PyInt_Check(obj)) {
2756	long v = PyInt_AsLong(obj);
2757	if (v >= 0) {
2758	if (val) *val = v;
2759	return SWIG_OK;
2760	} else {
2761	return SWIG_OverflowError;
2762	}
2763	} else if (PyLong_Check(obj)) {
2764	unsigned long v = PyLong_AsUnsignedLong(obj);
2765	if (!PyErr_Occurred()) {
2766	if (val) *val = v;
2767	return SWIG_OK;
2768	} else {
2769	PyErr_Clear();
2770	}
2771	}
2772	#ifdef SWIG_PYTHON_CAST_MODE
2773	{
2774	int dispatch = 0;
2775	unsigned long v = PyLong_AsUnsignedLong(obj);
2776	if (!PyErr_Occurred()) {
2777	if (val) *val = v;
2778	return SWIG_AddCast(SWIG_OK);
2779	} else {
2780	PyErr_Clear();
2781	}
2782	if (!dispatch) {
2783	double d;
2784	int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2785	if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2786	if (val) *val = (unsigned long)(d);
2787	return res;
2788	}
2789	}
2790	}
2791	#endif
2792	return SWIG_TypeError;
2793	}
2794
2795
2796	SWIGINTERN int
2797	SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
2798	{
2799	unsigned long v;
2800	int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2801	if (SWIG_IsOK(res)) {
2802	if ((v > UINT_MAX)) {
2803	return SWIG_OverflowError;
2804	} else {
2805	if (val) *val = (unsigned int)(v);
2806	}
2807	}
2808	return res;
2809	}
2810
2811
2812	#define SWIG_From_long PyInt_FromLong
2813
2814
2815	SWIGINTERNINLINE PyObject*
2816	SWIG_From_unsigned_SS_long (unsigned long value)
2817	{
2818	return (value > LONG_MAX) ?
2819	PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
2820	}
2821
2822
2823	SWIGINTERNINLINE PyObject *
2824	SWIG_From_unsigned_SS_int (unsigned int value)
2825	{
2826	return SWIG_From_unsigned_SS_long (value);
2827	}
2828
2829
2830	SWIGINTERN int
2831	SWIG_AsVal_long (PyObject obj, long val)
2832	{
2833	if (PyInt_Check(obj)) {
2834	if (val) *val = PyInt_AsLong(obj);
2835	return SWIG_OK;
2836	} else if (PyLong_Check(obj)) {
2837	long v = PyLong_AsLong(obj);
2838	if (!PyErr_Occurred()) {
2839	if (val) *val = v;
2840	return SWIG_OK;
2841	} else {
2842	PyErr_Clear();
2843	}
2844	}
2845	#ifdef SWIG_PYTHON_CAST_MODE
2846	{
2847	int dispatch = 0;
2848	long v = PyInt_AsLong(obj);
2849	if (!PyErr_Occurred()) {
2850	if (val) *val = v;
2851	return SWIG_AddCast(SWIG_OK);
2852	} else {
2853	PyErr_Clear();
2854	}
2855	if (!dispatch) {
2856	double d;
2857	int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2858	if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2859	if (val) *val = (long)(d);
2860	return res;
2861	}
2862	}
2863	}
2864	#endif
2865	return SWIG_TypeError;
2866	}
2867
2868
2869	SWIGINTERN int
2870	SWIG_AsVal_int (PyObject * obj, int *val)
2871	{
2872	long v;
2873	int res = SWIG_AsVal_long (obj, &v);
2874	if (SWIG_IsOK(res)) {
2875	if ((v < INT_MIN \|\| v > INT_MAX)) {
2876	return SWIG_OverflowError;
2877	} else {
2878	if (val) *val = (int)(v);
2879	}
2880	}
2881	return res;
2882	}
2883
2884	#ifdef __cplusplus
2885	extern "C" {
2886	#endif
2887
2888
2889	#define RETURN_CVAR_ARRAY(fmt, arr) {\
2890	PyObject l, o;\
2891	uint32_t i;\
2892	\
2893	if (!arr) {\
2894	Py_INCREF(Py_None);\
2895	return Py_None;\
2896	}\
2897	l = PyList_New(arr->count);\
2898	if (!l) return NULL;\
2899	for (i = 0; i < arr->count; ++i) {\
2900	o = _Py_BuildValue(fmt, arr->item[i]);\
2901	if (!o) {\
2902	Py_DECREF(l);\
2903	return NULL;\
2904	}\
2905	PyList_SET_ITEM(l, i, o);\
2906	}\
2907	return l;\
2908	}
2909
2910	static PyObject _Py_BuildValue(char str, ...)
2911	{
2912	PyObject * result = NULL;
2913	va_list lst;
2914	va_start(lst, str);
2915	if (str && *str == 'I') {
2916	uint32_t value = va_arg(lst, uint32_t);
2917	if (value & 0x80000000) {
2918	result = Py_BuildValue("L", (long)value);
2919	} else {
2920	result = Py_BuildValue("i", value);
2921	}
2922	} else {
2923	result = Py_VaBuildValue(str, lst);
2924	}
2925	va_end(lst);
2926	return result;
2927	}
2928
2929
2930	static PyObject PyObject_FromCVAR(uint32_t cimtype, union CIMVAR cvar)
2931	{
2932	switch (cimtype) {
2933	case CIM_SINT8: return Py_BuildValue("b", cvar->v_sint8);
2934	case CIM_UINT8: return Py_BuildValue("B", cvar->v_uint8);
2935	case CIM_SINT16: return Py_BuildValue("h", cvar->v_sint16);
2936	case CIM_UINT16: return Py_BuildValue("H", cvar->v_uint16);
2937	case CIM_SINT32: return Py_BuildValue("i", cvar->v_sint32);
2938	case CIM_UINT32: return _Py_BuildValue("I", cvar->v_uint32);
2939	case CIM_SINT64: return Py_BuildValue("L", cvar->v_sint64);
2940	case CIM_UINT64: return Py_BuildValue("K", cvar->v_uint64);
2941	case CIM_REAL32: return Py_BuildValue("f", cvar->v_real32);
2942	case CIM_REAL64: return Py_BuildValue("d", cvar->v_real64);
2943	case CIM_BOOLEAN: return Py_BuildValue("h", cvar->v_boolean);
2944	case CIM_STRING: return Py_BuildValue("s", cvar->v_string);
2945	case CIM_DATETIME: return Py_BuildValue("s", cvar->v_datetime);
2946	case CIM_REFERENCE: return Py_BuildValue("s", cvar->v_reference);
2947	case CIM_OBJECT: return PySWbemObject_FromWbemClassObject(cvar->v_object);
2948	case CIM_ARR_SINT8: RETURN_CVAR_ARRAY("b", cvar->a_sint8);
2949	case CIM_ARR_UINT8: RETURN_CVAR_ARRAY("B", cvar->a_uint8);
2950	case CIM_ARR_SINT16: RETURN_CVAR_ARRAY("h", cvar->a_sint16);
2951	case CIM_ARR_UINT16: RETURN_CVAR_ARRAY("H", cvar->a_uint16);
2952	case CIM_ARR_SINT32: RETURN_CVAR_ARRAY("i", cvar->a_sint32);
2953	case CIM_ARR_UINT32: RETURN_CVAR_ARRAY("I", cvar->a_uint32);
2954	case CIM_ARR_SINT64: RETURN_CVAR_ARRAY("L", cvar->a_sint64);
2955	case CIM_ARR_UINT64: RETURN_CVAR_ARRAY("K", cvar->a_uint64);
2956	case CIM_ARR_REAL32: RETURN_CVAR_ARRAY("f", cvar->a_real32);
2957	case CIM_ARR_REAL64: RETURN_CVAR_ARRAY("d", cvar->a_real64);
2958	case CIM_ARR_BOOLEAN: RETURN_CVAR_ARRAY("h", cvar->a_boolean);
2959	case CIM_ARR_STRING: RETURN_CVAR_ARRAY("s", cvar->a_string);
2960	case CIM_ARR_DATETIME: RETURN_CVAR_ARRAY("s", cvar->a_datetime);
2961	case CIM_ARR_REFERENCE: RETURN_CVAR_ARRAY("s", cvar->a_reference);
2962	default:
2963	{
2964	char *str;
2965	str = talloc_asprintf(NULL, "Unsupported CIMTYPE(0x%04X)", cimtype);
2966	PyErr_SetString(PyExc_RuntimeError, str);
2967	talloc_free(str);
2968	return NULL;
2969	}
2970	}
2971	}
2972
2973	#undef RETURN_CVAR_ARRAY
2974
2975	PyObject PySWbemObject_InitProperites(PyObject o, struct WbemClassObject *wco)
2976	{
2977	PyObject *properties;
2978	PyObject *addProp;
2979	uint32_t i;
2980	int32_t r;
2981	PyObject *result;
2982
2983	result = NULL;
2984	properties = PyObject_GetAttrString(o, "Properties_");
2985	if (!properties) return NULL;
2986	addProp = PyObject_GetAttrString(properties, "Add");
2987	if (!addProp) {
2988	Py_DECREF(properties);
2989	return NULL;
2990	}
2991
2992	for (i = 0; i < wco->obj_class->__PROPERTY_COUNT; ++i) {
2993	PyObject args, property;
2994
2995	args = Py_BuildValue("(si)", wco->obj_class->properties[i].property.name, wco->obj_class->properties[i].property.desc->cimtype & CIM_TYPEMASK);
2996	if (!args) goto finish;
2997	property = PyObject_CallObject(addProp, args);
2998	Py_DECREF(args);
2999	if (!property) goto finish;
3000	if (wco->flags & WCF_INSTANCE) {
3001	PyObject *value;
3002
3003	if (wco->instance->default_flags[i] & 1) {
3004	value = Py_None;
3005	Py_INCREF(Py_None);
3006	} else
3007	value = PyObject_FromCVAR(wco->obj_class->properties[i].property.desc->cimtype & CIM_TYPEMASK, &wco->instance->data[i]);
3008	if (!value) {
3009	Py_DECREF(property);
3010	goto finish;
3011	}
3012	r = PyObject_SetAttrString(property, "Value", value);
3013	Py_DECREF(value);
3014	if (r == -1) {
3015	PyErr_SetString(PyExc_RuntimeError, "Error setting value of property");
3016	goto finish;
3017	}
3018	}
3019	Py_DECREF(property);
3020	}
3021
3022	Py_INCREF(Py_None);
3023	result = Py_None;
3024	finish:
3025	Py_DECREF(addProp);
3026	Py_DECREF(properties);
3027	return result;
3028	}
3029
3030	static PyObject PySWbemObject_FromWbemClassObject(struct WbemClassObject wco)
3031	{
3032	PyObject swo_class, swo, args, result;
3033
3034	swo_class = PyObject_GetAttrString(mod_win32_client, "SWbemObject");
3035	if (!swo_class) return NULL;
3036	args = PyTuple_New(0);
3037	if (!args) {
3038	Py_DECREF(swo_class);
3039	return NULL;
3040	}
3041	swo = PyObject_CallObject(swo_class, args);
3042	Py_DECREF(args);
3043	Py_DECREF(swo_class);
3044	if (!swo) return NULL;
3045
3046	result = PySWbemObject_InitProperites(swo, wco);
3047	if (!result) {
3048	Py_DECREF(swo);
3049	return NULL;
3050	}
3051	Py_DECREF(result);
3052
3053	return swo;
3054	}
3055
3056
3057	SWIGINTERN PyObject _wrap_WBEM_ConnectServer(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3058	PyObject *resultobj = 0;
3059	struct com_context arg1 = (struct com_context ) 0 ;
3060	char arg2 = (char ) 0 ;
3061	char arg3 = (char ) 0 ;
3062	char arg4 = (char ) 0 ;
3063	char arg5 = (char ) 0 ;
3064	char arg6 = (char ) 0 ;
3065	uint32_t arg7 ;
3066	char arg8 = (char ) 0 ;
3067	struct IWbemContext arg9 = (struct IWbemContext ) 0 ;
3068	struct IWbemServices arg10 = (struct IWbemServices ) 0 ;
3069	int res2 ;
3070	char *buf2 = 0 ;
3071	int alloc2 = 0 ;
3072	int res3 ;
3073	char *buf3 = 0 ;
3074	int alloc3 = 0 ;
3075	int res4 ;
3076	char *buf4 = 0 ;
3077	int alloc4 = 0 ;
3078	int res5 ;
3079	char *buf5 = 0 ;
3080	int alloc5 = 0 ;
3081	int res6 ;
3082	char *buf6 = 0 ;
3083	int alloc6 = 0 ;
3084	unsigned int val7 ;
3085	int ecode7 = 0 ;
3086	int res8 ;
3087	char *buf8 = 0 ;
3088	int alloc8 = 0 ;
3089	void *argp9 = 0 ;
3090	int res9 = 0 ;
3091	struct IWbemServices *temp10 ;
3092	PyObject * obj0 = 0 ;
3093	PyObject * obj1 = 0 ;
3094	PyObject * obj2 = 0 ;
3095	PyObject * obj3 = 0 ;
3096	PyObject * obj4 = 0 ;
3097	PyObject * obj5 = 0 ;
3098	PyObject * obj6 = 0 ;
3099	PyObject * obj7 = 0 ;
3100	char * kwnames[] = {
3101	(char ) "server",(char ) "nspace",(char ) "user",(char ) "password",(char ) "locale",(char ) "flags",(char ) "authority",(char ) "wbem_ctx", NULL
3102	};
3103	WERROR result;
3104
3105	{
3106	arg1 = com_ctx;
3107	}
3108	{
3109	arg10 = &temp10;
3110	}
3111	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:WBEM_ConnectServer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
3112	res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
3113	if (!SWIG_IsOK(res2)) {
3114	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WBEM_ConnectServer" "', argument " "2"" of type '" "char const *""'");
3115	}
3116	arg2 = (char *)(buf2);
3117	res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
3118	if (!SWIG_IsOK(res3)) {
3119	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WBEM_ConnectServer" "', argument " "3"" of type '" "char const *""'");
3120	}
3121	arg3 = (char *)(buf3);
3122	res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
3123	if (!SWIG_IsOK(res4)) {
3124	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "WBEM_ConnectServer" "', argument " "4"" of type '" "char const *""'");
3125	}
3126	arg4 = (char *)(buf4);
3127	res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
3128	if (!SWIG_IsOK(res5)) {
3129	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "WBEM_ConnectServer" "', argument " "5"" of type '" "char const *""'");
3130	}
3131	arg5 = (char *)(buf5);
3132	res6 = SWIG_AsCharPtrAndSize(obj4, &buf6, NULL, &alloc6);
3133	if (!SWIG_IsOK(res6)) {
3134	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "WBEM_ConnectServer" "', argument " "6"" of type '" "char const *""'");
3135	}
3136	arg6 = (char *)(buf6);
3137	ecode7 = SWIG_AsVal_unsigned_SS_int(obj5, &val7);
3138	if (!SWIG_IsOK(ecode7)) {
3139	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "WBEM_ConnectServer" "', argument " "7"" of type '" "uint32_t""'");
3140	}
3141	arg7 = (uint32_t)(val7);
3142	res8 = SWIG_AsCharPtrAndSize(obj6, &buf8, NULL, &alloc8);
3143	if (!SWIG_IsOK(res8)) {
3144	SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "WBEM_ConnectServer" "', argument " "8"" of type '" "char const *""'");
3145	}
3146	arg8 = (char *)(buf8);
3147	res9 = SWIG_ConvertPtr(obj7, &argp9,SWIGTYPE_p_IWbemContext, 0 \| 0 );
3148	if (!SWIG_IsOK(res9)) {
3149	SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "WBEM_ConnectServer" "', argument " "9"" of type '" "struct IWbemContext *""'");
3150	}
3151	arg9 = (struct IWbemContext *)(argp9);
3152	result = WBEM_ConnectServer(arg1,(char const )arg2,(char const )arg3,(char const )arg4,(char const )arg5,(char const )arg6,arg7,(char const )arg8,arg9,arg10);
3153	if (!W_ERROR_IS_OK(result)) {
3154	PyErr_SetWERROR(result);
3155	SWIG_fail;
3156	} else if (resultobj == NULL) {
3157	resultobj = Py_None;
3158	}
3159	{
3160	PyObject *o;
3161	o = SWIG_NewPointerObj(*arg10, SWIGTYPE_p_IWbemServices, 0);
3162	push_object(&resultobj, o);
3163	}
3164	if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3165	if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3166	if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3167	if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
3168	if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
3169	if (alloc8 == SWIG_NEWOBJ) free((char*)buf8);
3170	return resultobj;
3171	fail:
3172	if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3173	if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3174	if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3175	if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
3176	if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
3177	if (alloc8 == SWIG_NEWOBJ) free((char*)buf8);
3178	return NULL;
3179	}
3180
3181
3182	SWIGINTERN PyObject _wrap_IUnknown_Release(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3183	PyObject *resultobj = 0;
3184	IUnknown arg1 = (IUnknown ) 0 ;
3185	TALLOC_CTX arg2 = (TALLOC_CTX ) 0 ;
3186	void *argp1 = 0 ;
3187	int res1 = 0 ;
3188	PyObject *swig_obj[1] ;
3189	uint32_t result;
3190
3191	arg2 = NULL;
3192	if (!args) SWIG_fail;
3193	swig_obj[0] = args;
3194	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IUnknown, 0 \| 0 );
3195	if (!SWIG_IsOK(res1)) {
3196	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IUnknown_Release" "', argument " "1"" of type '" "IUnknown *""'");
3197	}
3198	arg1 = (IUnknown *)(argp1);
3199	result = (uint32_t)IUnknown_Release(arg1,arg2);
3200	resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
3201	return resultobj;
3202	fail:
3203	return NULL;
3204	}
3205
3206
3207	SWIGINTERN PyObject _wrap_new_IUnknown(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3208	PyObject *resultobj = 0;
3209	IUnknown *result = 0 ;
3210
3211	if (!SWIG_Python_UnpackTuple(args,"new_IUnknown",0,0,0)) SWIG_fail;
3212	result = (IUnknown *)calloc(1, sizeof(IUnknown));
3213	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IUnknown, SWIG_POINTER_NEW \| 0 );
3214	return resultobj;
3215	fail:
3216	return NULL;
3217	}
3218
3219
3220	SWIGINTERN PyObject _wrap_delete_IUnknown(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3221	PyObject *resultobj = 0;
3222	IUnknown arg1 = (IUnknown ) 0 ;
3223	void *argp1 = 0 ;
3224	int res1 = 0 ;
3225	PyObject *swig_obj[1] ;
3226
3227	if (!args) SWIG_fail;
3228	swig_obj[0] = args;
3229	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IUnknown, SWIG_POINTER_DISOWN \| 0 );
3230	if (!SWIG_IsOK(res1)) {
3231	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IUnknown" "', argument " "1"" of type '" "IUnknown *""'");
3232	}
3233	arg1 = (IUnknown *)(argp1);
3234	free((char *) arg1);
3235	resultobj = SWIG_Py_Void();
3236	return resultobj;
3237	fail:
3238	return NULL;
3239	}
3240
3241
3242	SWIGINTERN PyObject IUnknown_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3243	PyObject *obj;
3244	if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3245	SWIG_TypeNewClientData(SWIGTYPE_p_IUnknown, SWIG_NewClientData(obj));
3246	return SWIG_Py_Void();
3247	}
3248
3249	SWIGINTERN PyObject IUnknown_swiginit(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3250	return SWIG_Python_InitShadowInstance(args);
3251	}
3252
3253	SWIGINTERN PyObject _wrap_IWbemServices_ExecQuery(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3254	PyObject *resultobj = 0;
3255	IWbemServices arg1 = (IWbemServices ) 0 ;
3256	TALLOC_CTX arg2 = (TALLOC_CTX ) 0 ;
3257	struct BSTR arg3 ;
3258	struct BSTR arg4 ;
3259	int32_t arg5 ;
3260	struct IWbemContext arg6 = (struct IWbemContext ) 0 ;
3261	struct IEnumWbemClassObject arg7 = (struct IEnumWbemClassObject ) 0 ;
3262	void *argp1 = 0 ;
3263	int res1 = 0 ;
3264	int val5 ;
3265	int ecode5 = 0 ;
3266	void *argp6 = 0 ;
3267	int res6 = 0 ;
3268	struct IEnumWbemClassObject *temp7 ;
3269	PyObject * obj0 = 0 ;
3270	PyObject * obj1 = 0 ;
3271	PyObject * obj2 = 0 ;
3272	PyObject * obj3 = 0 ;
3273	PyObject * obj4 = 0 ;
3274	char * kwnames[] = {
3275	(char ) "self",(char ) "strQueryLanguage",(char ) "strQuery",(char ) "lFlags",(char *) "pCtx", NULL
3276	};
3277	WERROR result;
3278
3279	arg2 = NULL;
3280	{
3281	arg7 = &temp7;
3282	}
3283	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:IWbemServices_ExecQuery",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
3284	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IWbemServices, 0 \| 0 );
3285	if (!SWIG_IsOK(res1)) {
3286	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IWbemServices_ExecQuery" "', argument " "1"" of type '" "IWbemServices *""'");
3287	}
3288	arg1 = (IWbemServices *)(argp1);
3289	{
3290	(&arg3)->data = PyString_AsString(obj1);
3291	}
3292	{
3293	(&arg4)->data = PyString_AsString(obj2);
3294	}
3295	ecode5 = SWIG_AsVal_int(obj3, &val5);
3296	if (!SWIG_IsOK(ecode5)) {
3297	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IWbemServices_ExecQuery" "', argument " "5"" of type '" "int32_t""'");
3298	}
3299	arg5 = (int32_t)(val5);
3300	res6 = SWIG_ConvertPtr(obj4, &argp6,SWIGTYPE_p_IWbemContext, 0 \| 0 );
3301	if (!SWIG_IsOK(res6)) {
3302	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "IWbemServices_ExecQuery" "', argument " "6"" of type '" "struct IWbemContext *""'");
3303	}
3304	arg6 = (struct IWbemContext *)(argp6);
3305	result = IWbemServices_ExecQuery(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
3306	if (!W_ERROR_IS_OK(result)) {
3307	PyErr_SetWERROR(result);
3308	SWIG_fail;
3309	} else if (resultobj == NULL) {
3310	resultobj = Py_None;
3311	}
3312	{
3313	PyObject *o;
3314	o = SWIG_NewPointerObj(*arg7, SWIGTYPE_p_IEnumWbemClassObject, 0);
3315	push_object(&resultobj, o);
3316	}
3317	return resultobj;
3318	fail:
3319	return NULL;
3320	}
3321
3322
3323	SWIGINTERN PyObject _wrap_IWbemServices_ExecNotificationQuery(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3324	PyObject *resultobj = 0;
3325	IWbemServices arg1 = (IWbemServices ) 0 ;
3326	TALLOC_CTX arg2 = (TALLOC_CTX ) 0 ;
3327	struct BSTR arg3 ;
3328	struct BSTR arg4 ;
3329	int32_t arg5 ;
3330	struct IWbemContext arg6 = (struct IWbemContext ) 0 ;
3331	struct IEnumWbemClassObject arg7 = (struct IEnumWbemClassObject ) 0 ;
3332	void *argp1 = 0 ;
3333	int res1 = 0 ;
3334	int val5 ;
3335	int ecode5 = 0 ;
3336	void *argp6 = 0 ;
3337	int res6 = 0 ;
3338	struct IEnumWbemClassObject *temp7 ;
3339	PyObject * obj0 = 0 ;
3340	PyObject * obj1 = 0 ;
3341	PyObject * obj2 = 0 ;
3342	PyObject * obj3 = 0 ;
3343	PyObject * obj4 = 0 ;
3344	char * kwnames[] = {
3345	(char ) "self",(char ) "strQueryLanguage",(char ) "strQuery",(char ) "lFlags",(char *) "pCtx", NULL
3346	};
3347	WERROR result;
3348
3349	arg2 = NULL;
3350	{
3351	arg7 = &temp7;
3352	}
3353	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:IWbemServices_ExecNotificationQuery",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
3354	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IWbemServices, 0 \| 0 );
3355	if (!SWIG_IsOK(res1)) {
3356	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IWbemServices_ExecNotificationQuery" "', argument " "1"" of type '" "IWbemServices *""'");
3357	}
3358	arg1 = (IWbemServices *)(argp1);
3359	{
3360	(&arg3)->data = PyString_AsString(obj1);
3361	}
3362	{
3363	(&arg4)->data = PyString_AsString(obj2);
3364	}
3365	ecode5 = SWIG_AsVal_int(obj3, &val5);
3366	if (!SWIG_IsOK(ecode5)) {
3367	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IWbemServices_ExecNotificationQuery" "', argument " "5"" of type '" "int32_t""'");
3368	}
3369	arg5 = (int32_t)(val5);
3370	res6 = SWIG_ConvertPtr(obj4, &argp6,SWIGTYPE_p_IWbemContext, 0 \| 0 );
3371	if (!SWIG_IsOK(res6)) {
3372	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "IWbemServices_ExecNotificationQuery" "', argument " "6"" of type '" "struct IWbemContext *""'");
3373	}
3374	arg6 = (struct IWbemContext *)(argp6);
3375	result = IWbemServices_ExecNotificationQuery(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
3376	if (!W_ERROR_IS_OK(result)) {
3377	PyErr_SetWERROR(result);
3378	SWIG_fail;
3379	} else if (resultobj == NULL) {
3380	resultobj = Py_None;
3381	}
3382	{
3383	PyObject *o;
3384	o = SWIG_NewPointerObj(*arg7, SWIGTYPE_p_IEnumWbemClassObject, 0);
3385	push_object(&resultobj, o);
3386	}
3387	return resultobj;
3388	fail:
3389	return NULL;
3390	}
3391
3392
3393	SWIGINTERN PyObject _wrap_IWbemServices_CreateInstanceEnum(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3394	PyObject *resultobj = 0;
3395	IWbemServices arg1 = (IWbemServices ) 0 ;
3396	TALLOC_CTX arg2 = (TALLOC_CTX ) 0 ;
3397	struct BSTR arg3 ;
3398	int32_t arg4 ;
3399	struct IWbemContext arg5 = (struct IWbemContext ) 0 ;
3400	struct IEnumWbemClassObject arg6 = (struct IEnumWbemClassObject ) 0 ;
3401	void *argp1 = 0 ;
3402	int res1 = 0 ;
3403	int val4 ;
3404	int ecode4 = 0 ;
3405	void *argp5 = 0 ;
3406	int res5 = 0 ;
3407	struct IEnumWbemClassObject *temp6 ;
3408	PyObject * obj0 = 0 ;
3409	PyObject * obj1 = 0 ;
3410	PyObject * obj2 = 0 ;
3411	PyObject * obj3 = 0 ;
3412	char * kwnames[] = {
3413	(char ) "self",(char ) "strClass",(char ) "lFlags",(char ) "pCtx", NULL
3414	};
3415	WERROR result;
3416
3417	arg2 = NULL;
3418	{
3419	arg6 = &temp6;
3420	}
3421	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IWbemServices_CreateInstanceEnum",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3422	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IWbemServices, 0 \| 0 );
3423	if (!SWIG_IsOK(res1)) {
3424	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IWbemServices_CreateInstanceEnum" "', argument " "1"" of type '" "IWbemServices *""'");
3425	}
3426	arg1 = (IWbemServices *)(argp1);
3427	{
3428	(&arg3)->data = PyString_AsString(obj1);
3429	}
3430	ecode4 = SWIG_AsVal_int(obj2, &val4);
3431	if (!SWIG_IsOK(ecode4)) {
3432	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IWbemServices_CreateInstanceEnum" "', argument " "4"" of type '" "int32_t""'");
3433	}
3434	arg4 = (int32_t)(val4);
3435	res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_IWbemContext, 0 \| 0 );
3436	if (!SWIG_IsOK(res5)) {
3437	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IWbemServices_CreateInstanceEnum" "', argument " "5"" of type '" "struct IWbemContext *""'");
3438	}
3439	arg5 = (struct IWbemContext *)(argp5);
3440	result = IWbemServices_CreateInstanceEnum(arg1,arg2,arg3,arg4,arg5,arg6);
3441	if (!W_ERROR_IS_OK(result)) {
3442	PyErr_SetWERROR(result);
3443	SWIG_fail;
3444	} else if (resultobj == NULL) {
3445	resultobj = Py_None;
3446	}
3447	{
3448	PyObject *o;
3449	o = SWIG_NewPointerObj(*arg6, SWIGTYPE_p_IEnumWbemClassObject, 0);
3450	push_object(&resultobj, o);
3451	}
3452	return resultobj;
3453	fail:
3454	return NULL;
3455	}
3456
3457
3458	SWIGINTERN PyObject _wrap_new_IWbemServices(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3459	PyObject *resultobj = 0;
3460	IWbemServices *result = 0 ;
3461
3462	if (!SWIG_Python_UnpackTuple(args,"new_IWbemServices",0,0,0)) SWIG_fail;
3463	result = (IWbemServices *)calloc(1, sizeof(IWbemServices));
3464	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IWbemServices, SWIG_POINTER_NEW \| 0 );
3465	return resultobj;
3466	fail:
3467	return NULL;
3468	}
3469
3470
3471	SWIGINTERN PyObject _wrap_delete_IWbemServices(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3472	PyObject *resultobj = 0;
3473	IWbemServices arg1 = (IWbemServices ) 0 ;
3474	void *argp1 = 0 ;
3475	int res1 = 0 ;
3476	PyObject *swig_obj[1] ;
3477
3478	if (!args) SWIG_fail;
3479	swig_obj[0] = args;
3480	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IWbemServices, SWIG_POINTER_DISOWN \| 0 );
3481	if (!SWIG_IsOK(res1)) {
3482	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IWbemServices" "', argument " "1"" of type '" "IWbemServices *""'");
3483	}
3484	arg1 = (IWbemServices *)(argp1);
3485	free((char *) arg1);
3486	resultobj = SWIG_Py_Void();
3487	return resultobj;
3488	fail:
3489	return NULL;
3490	}
3491
3492
3493	SWIGINTERN PyObject IWbemServices_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3494	PyObject *obj;
3495	if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3496	SWIG_TypeNewClientData(SWIGTYPE_p_IWbemServices, SWIG_NewClientData(obj));
3497	return SWIG_Py_Void();
3498	}
3499
3500	SWIGINTERN PyObject IWbemServices_swiginit(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3501	return SWIG_Python_InitShadowInstance(args);
3502	}
3503
3504	SWIGINTERN PyObject _wrap_IEnumWbemClassObject_Reset(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3505	PyObject *resultobj = 0;
3506	IEnumWbemClassObject arg1 = (IEnumWbemClassObject ) 0 ;
3507	TALLOC_CTX arg2 = (TALLOC_CTX ) 0 ;
3508	void *argp1 = 0 ;
3509	int res1 = 0 ;
3510	PyObject *swig_obj[1] ;
3511	WERROR result;
3512
3513	arg2 = NULL;
3514	if (!args) SWIG_fail;
3515	swig_obj[0] = args;
3516	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IEnumWbemClassObject, 0 \| 0 );
3517	if (!SWIG_IsOK(res1)) {
3518	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnumWbemClassObject_Reset" "', argument " "1"" of type '" "IEnumWbemClassObject *""'");
3519	}
3520	arg1 = (IEnumWbemClassObject *)(argp1);
3521	result = IEnumWbemClassObject_Reset(arg1,arg2);
3522	if (!W_ERROR_IS_OK(result)) {
3523	PyErr_SetWERROR(result);
3524	SWIG_fail;
3525	} else if (resultobj == NULL) {
3526	resultobj = Py_None;
3527	}
3528	return resultobj;
3529	fail:
3530	return NULL;
3531	}
3532
3533
3534	SWIGINTERN PyObject _wrap_new_IEnumWbemClassObject(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3535	PyObject *resultobj = 0;
3536	IEnumWbemClassObject *result = 0 ;
3537
3538	if (!SWIG_Python_UnpackTuple(args,"new_IEnumWbemClassObject",0,0,0)) SWIG_fail;
3539	result = (IEnumWbemClassObject *)calloc(1, sizeof(IEnumWbemClassObject));
3540	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IEnumWbemClassObject, SWIG_POINTER_NEW \| 0 );
3541	return resultobj;
3542	fail:
3543	return NULL;
3544	}
3545
3546
3547	SWIGINTERN PyObject _wrap_delete_IEnumWbemClassObject(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3548	PyObject *resultobj = 0;
3549	IEnumWbemClassObject arg1 = (IEnumWbemClassObject ) 0 ;
3550	void *argp1 = 0 ;
3551	int res1 = 0 ;
3552	PyObject *swig_obj[1] ;
3553
3554	if (!args) SWIG_fail;
3555	swig_obj[0] = args;
3556	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IEnumWbemClassObject, SWIG_POINTER_DISOWN \| 0 );
3557	if (!SWIG_IsOK(res1)) {
3558	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IEnumWbemClassObject" "', argument " "1"" of type '" "IEnumWbemClassObject *""'");
3559	}
3560	arg1 = (IEnumWbemClassObject *)(argp1);
3561	free((char *) arg1);
3562	resultobj = SWIG_Py_Void();
3563	return resultobj;
3564	fail:
3565	return NULL;
3566	}
3567
3568
3569	SWIGINTERN PyObject IEnumWbemClassObject_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3570	PyObject *obj;
3571	if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3572	SWIG_TypeNewClientData(SWIGTYPE_p_IEnumWbemClassObject, SWIG_NewClientData(obj));
3573	return SWIG_Py_Void();
3574	}
3575
3576	SWIGINTERN PyObject IEnumWbemClassObject_swiginit(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3577	return SWIG_Python_InitShadowInstance(args);
3578	}
3579
3580	SWIGINTERN PyObject _wrap_IEnumWbemClassObject_SmartNext(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3581	PyObject *resultobj = 0;
3582	struct IEnumWbemClassObject arg1 = (struct IEnumWbemClassObject ) 0 ;
3583	TALLOC_CTX arg2 = (TALLOC_CTX ) 0 ;
3584	int32_t arg3 ;
3585	uint32_t arg4 ;
3586	struct WbemClassObject arg5 = (struct WbemClassObject ) 0 ;
3587	uint32_t arg6 = (uint32_t ) 0 ;
3588	void *argp1 = 0 ;
3589	int res1 = 0 ;
3590	int val3 ;
3591	int ecode3 = 0 ;
3592	uint32_t uReturned4 ;
3593	PyObject * obj0 = 0 ;
3594	PyObject * obj1 = 0 ;
3595	PyObject * obj2 = 0 ;
3596	char * kwnames[] = {
3597	(char ) "d",(char ) "lTimeout",(char *) "uCount", NULL
3598	};
3599	WERROR result;
3600
3601	arg2 = NULL;
3602	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IEnumWbemClassObject_SmartNext",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3603	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IEnumWbemClassObject, 0 \| 0 );
3604	if (!SWIG_IsOK(res1)) {
3605	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnumWbemClassObject_SmartNext" "', argument " "1"" of type '" "struct IEnumWbemClassObject *""'");
3606	}
3607	arg1 = (struct IEnumWbemClassObject *)(argp1);
3608	ecode3 = SWIG_AsVal_int(obj1, &val3);
3609	if (!SWIG_IsOK(ecode3)) {
3610	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IEnumWbemClassObject_SmartNext" "', argument " "3"" of type '" "int32_t""'");
3611	}
3612	arg3 = (int32_t)(val3);
3613	{
3614	if (PyLong_Check(obj2))
3615	arg4 = PyLong_AsUnsignedLong(obj2);
3616	else if (PyInt_Check(obj2))
3617	arg4 = PyInt_AsLong(obj2);
3618	else {
3619	PyErr_SetString(PyExc_TypeError,"Expected a long or an int");
3620	return NULL;
3621	}
3622	arg5 = talloc_array(NULL, struct WbemClassObject *, arg4);
3623	arg6 = &uReturned4;
3624	}
3625	result = IEnumWbemClassObject_SmartNext(arg1,arg2,arg3,arg4,arg5,arg6);
3626	if (!W_ERROR_IS_OK(result)) {
3627	PyErr_SetWERROR(result);
3628	SWIG_fail;
3629	} else if (resultobj == NULL) {
3630	resultobj = Py_None;
3631	}
3632	{
3633	uint32_t i;
3634	PyObject *o;
3635	int32_t error;
3636
3637	error = 0;
3638
3639	resultobj = PyTuple_New(*arg6);
3640	for (i = 0; i < *arg6; ++i) {
3641	if (!error) {
3642	o = PySWbemObject_FromWbemClassObject(arg5[i]);
3643	if (!o)
3644	--error;
3645	else
3646	error = PyTuple_SetItem(resultobj, i, o);
3647	}
3648	talloc_free(arg5[i]);
3649	}
3650	talloc_free(arg5);
3651	if (error) return NULL;
3652	}
3653	return resultobj;
3654	fail:
3655	return NULL;
3656	}
3657
3658
3659	static PyMethodDef SwigMethods[] = {
3660	{ (char *)"WBEM_ConnectServer", (PyCFunction) _wrap_WBEM_ConnectServer, METH_VARARGS \| METH_KEYWORDS, NULL},
3661	{ (char *)"IUnknown_Release", (PyCFunction)_wrap_IUnknown_Release, METH_O, NULL},
3662	{ (char *)"new_IUnknown", (PyCFunction)_wrap_new_IUnknown, METH_NOARGS, NULL},
3663	{ (char *)"delete_IUnknown", (PyCFunction)_wrap_delete_IUnknown, METH_O, NULL},
3664	{ (char *)"IUnknown_swigregister", IUnknown_swigregister, METH_VARARGS, NULL},
3665	{ (char *)"IUnknown_swiginit", IUnknown_swiginit, METH_VARARGS, NULL},
3666	{ (char *)"IWbemServices_ExecQuery", (PyCFunction) _wrap_IWbemServices_ExecQuery, METH_VARARGS \| METH_KEYWORDS, NULL},
3667	{ (char *)"IWbemServices_ExecNotificationQuery", (PyCFunction) _wrap_IWbemServices_ExecNotificationQuery, METH_VARARGS \| METH_KEYWORDS, NULL},
3668	{ (char *)"IWbemServices_CreateInstanceEnum", (PyCFunction) _wrap_IWbemServices_CreateInstanceEnum, METH_VARARGS \| METH_KEYWORDS, NULL},
3669	{ (char *)"new_IWbemServices", (PyCFunction)_wrap_new_IWbemServices, METH_NOARGS, NULL},
3670	{ (char *)"delete_IWbemServices", (PyCFunction)_wrap_delete_IWbemServices, METH_O, NULL},
3671	{ (char *)"IWbemServices_swigregister", IWbemServices_swigregister, METH_VARARGS, NULL},
3672	{ (char *)"IWbemServices_swiginit", IWbemServices_swiginit, METH_VARARGS, NULL},
3673	{ (char *)"IEnumWbemClassObject_Reset", (PyCFunction)_wrap_IEnumWbemClassObject_Reset, METH_O, NULL},
3674	{ (char *)"new_IEnumWbemClassObject", (PyCFunction)_wrap_new_IEnumWbemClassObject, METH_NOARGS, NULL},
3675	{ (char *)"delete_IEnumWbemClassObject", (PyCFunction)_wrap_delete_IEnumWbemClassObject, METH_O, NULL},
3676	{ (char *)"IEnumWbemClassObject_swigregister", IEnumWbemClassObject_swigregister, METH_VARARGS, NULL},
3677	{ (char *)"IEnumWbemClassObject_swiginit", IEnumWbemClassObject_swiginit, METH_VARARGS, NULL},
3678	{ (char *)"IEnumWbemClassObject_SmartNext", (PyCFunction) _wrap_IEnumWbemClassObject_SmartNext, METH_VARARGS \| METH_KEYWORDS, NULL},
3679	{ NULL, NULL, 0, NULL }
3680	};
3681
3682
3683	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3684
3685	static swig_type_info _swigt__p_BSTR = {"_p_BSTR", "struct BSTR ", 0, 0, (void)0, 0};
3686	static swig_type_info _swigt__p_IEnumWbemClassObject = {"_p_IEnumWbemClassObject", "struct IEnumWbemClassObject \|IEnumWbemClassObject ", 0, 0, (void*)0, 0};
3687	static swig_type_info _swigt__p_IUnknown = {"_p_IUnknown", "struct IUnknown \|IUnknown ", 0, 0, (void*)0, 0};
3688	static swig_type_info _swigt__p_IWbemContext = {"_p_IWbemContext", "struct IWbemContext ", 0, 0, (void)0, 0};
3689	static swig_type_info _swigt__p_IWbemServices = {"_p_IWbemServices", "struct IWbemServices \|IWbemServices ", 0, 0, (void*)0, 0};
3690	static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX ", 0, 0, (void)0, 0};
3691	static swig_type_info _swigt__p_char = {"_p_char", "char ", 0, 0, (void)0, 0};
3692	static swig_type_info _swigt__p_com_context = {"_p_com_context", "struct com_context ", 0, 0, (void)0, 0};
3693	static swig_type_info _swigt__p_int = {"_p_int", "intptr_t \|int \|int_least32_t \|int_fast32_t \|int32_t \|int_fast16_t ", 0, 0, (void*)0, 0};
3694	static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t \|int_fast64_t \|int64_t \|long long \|intmax_t ", 0, 0, (void)0, 0};
3695	static swig_type_info _swigt__p_p_IEnumWbemClassObject = {"_p_p_IEnumWbemClassObject", "struct IEnumWbemClassObject *", 0, 0, (void)0, 0};
3696	static swig_type_info _swigt__p_p_IWbemServices = {"_p_p_IWbemServices", "struct IWbemServices *", 0, 0, (void)0, 0};
3697	static swig_type_info _swigt__p_p_WbemClassObject = {"_p_p_WbemClassObject", "struct WbemClassObject *", 0, 0, (void)0, 0};
3698	static swig_type_info _swigt__p_short = {"_p_short", "short \|int_least16_t \|int16_t ", 0, 0, (void)0, 0};
3699	static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char \|int_least8_t \|int_fast8_t \|int8_t ", 0, 0, (void*)0, 0};
3700	static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char \|uint_least8_t \|uint_fast8_t \|uint8_t ", 0, 0, (void*)0, 0};
3701	static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t \|uint_least32_t \|uint_fast32_t \|uint32_t \|unsigned int \|uint_fast16_t ", 0, 0, (void*)0, 0};
3702	static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t \|uint_fast64_t \|uint64_t \|unsigned long long \|uintmax_t ", 0, 0, (void)0, 0};
3703	static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short \|uint_least16_t \|uint16_t ", 0, 0, (void)0, 0};
3704
3705	static swig_type_info *swig_type_initial[] = {
3706	&_swigt__p_BSTR,
3707	&_swigt__p_IEnumWbemClassObject,
3708	&_swigt__p_IUnknown,
3709	&_swigt__p_IWbemContext,
3710	&_swigt__p_IWbemServices,
3711	&_swigt__p_TALLOC_CTX,
3712	&_swigt__p_char,
3713	&_swigt__p_com_context,
3714	&_swigt__p_int,
3715	&_swigt__p_long_long,
3716	&_swigt__p_p_IEnumWbemClassObject,
3717	&_swigt__p_p_IWbemServices,
3718	&_swigt__p_p_WbemClassObject,
3719	&_swigt__p_short,
3720	&_swigt__p_signed_char,
3721	&_swigt__p_unsigned_char,
3722	&_swigt__p_unsigned_int,
3723	&_swigt__p_unsigned_long_long,
3724	&_swigt__p_unsigned_short,
3725	};
3726
3727	static swig_cast_info _swigc__p_BSTR[] = { {&_swigt__p_BSTR, 0, 0, 0},{0, 0, 0, 0}};
3728	static swig_cast_info _swigc__p_IEnumWbemClassObject[] = { {&_swigt__p_IEnumWbemClassObject, 0, 0, 0},{0, 0, 0, 0}};
3729	static swig_cast_info _swigc__p_IUnknown[] = { {&_swigt__p_IUnknown, 0, 0, 0},{0, 0, 0, 0}};
3730	static swig_cast_info _swigc__p_IWbemContext[] = { {&_swigt__p_IWbemContext, 0, 0, 0},{0, 0, 0, 0}};
3731	static swig_cast_info _swigc__p_IWbemServices[] = { {&_swigt__p_IWbemServices, 0, 0, 0},{0, 0, 0, 0}};
3732	static swig_cast_info _swigc__p_TALLOC_CTX[] = { {&_swigt__p_TALLOC_CTX, 0, 0, 0},{0, 0, 0, 0}};
3733	static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3734	static swig_cast_info _swigc__p_com_context[] = { {&_swigt__p_com_context, 0, 0, 0},{0, 0, 0, 0}};
3735	static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
3736	static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
3737	static swig_cast_info _swigc__p_p_IEnumWbemClassObject[] = { {&_swigt__p_p_IEnumWbemClassObject, 0, 0, 0},{0, 0, 0, 0}};
3738	static swig_cast_info _swigc__p_p_IWbemServices[] = { {&_swigt__p_p_IWbemServices, 0, 0, 0},{0, 0, 0, 0}};
3739	static swig_cast_info _swigc__p_p_WbemClassObject[] = { {&_swigt__p_p_WbemClassObject, 0, 0, 0},{0, 0, 0, 0}};
3740	static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
3741	static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
3742	static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
3743	static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
3744	static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
3745	static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
3746
3747	static swig_cast_info *swig_cast_initial[] = {
3748	_swigc__p_BSTR,
3749	_swigc__p_IEnumWbemClassObject,
3750	_swigc__p_IUnknown,
3751	_swigc__p_IWbemContext,
3752	_swigc__p_IWbemServices,
3753	_swigc__p_TALLOC_CTX,
3754	_swigc__p_char,
3755	_swigc__p_com_context,
3756	_swigc__p_int,
3757	_swigc__p_long_long,
3758	_swigc__p_p_IEnumWbemClassObject,
3759	_swigc__p_p_IWbemServices,
3760	_swigc__p_p_WbemClassObject,
3761	_swigc__p_short,
3762	_swigc__p_signed_char,
3763	_swigc__p_unsigned_char,
3764	_swigc__p_unsigned_int,
3765	_swigc__p_unsigned_long_long,
3766	_swigc__p_unsigned_short,
3767	};
3768
3769
3770	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3771
3772	static swig_const_info swig_const_table[] = {
3773	{0, 0, 0, 0.0, 0, 0}};
3774
3775	#ifdef __cplusplus
3776	}
3777	#endif
3778	/* -----------------------------------------------------------------------------
3779	* Type initialization:
3780	* This problem is tough by the requirement that no dynamic
3781	* memory is used. Also, since swig_type_info structures store pointers to
3782	* swig_cast_info structures and swig_cast_info structures store pointers back
3783	* to swig_type_info structures, we need some lookup code at initialization.
3784	* The idea is that swig generates all the structures that are needed.
3785	* The runtime then collects these partially filled structures.
3786	* The SWIG_InitializeModule function takes these initial arrays out of
3787	* swig_module, and does all the lookup, filling in the swig_module.types
3788	* array with the correct data and linking the correct swig_cast_info
3789	* structures together.
3790	*
3791	* The generated swig_type_info structures are assigned staticly to an initial
3792	* array. We just loop through that array, and handle each type individually.
3793	* First we lookup if this type has been already loaded, and if so, use the
3794	* loaded structure instead of the generated one. Then we have to fill in the
3795	* cast linked list. The cast data is initially stored in something like a
3796	* two-dimensional array. Each row corresponds to a type (there are the same
3797	* number of rows as there are in the swig_type_initial array). Each entry in
3798	* a column is one of the swig_cast_info structures for that type.
3799	* The cast_initial array is actually an array of arrays, because each row has
3800	* a variable number of columns. So to actually build the cast linked list,
3801	* we find the array of casts associated with the type, and loop through it
3802	* adding the casts to the list. The one last trick we need to do is making
3803	* sure the type pointer in the swig_cast_info struct is correct.
3804	*
3805	* First off, we lookup the cast->type name to see if it is already loaded.
3806	* There are three cases to handle:
3807	* 1) If the cast->type has already been loaded AND the type we are adding
3808	* casting info to has not been loaded (it is in this module), THEN we
3809	* replace the cast->type pointer with the type pointer that has already
3810	* been loaded.
3811	* 2) If BOTH types (the one we are adding casting info to, and the
3812	* cast->type) are loaded, THEN the cast info has already been loaded by
3813	* the previous module so we just ignore it.
3814	* 3) Finally, if cast->type has not already been loaded, then we add that
3815	* swig_cast_info to the linked list (because the cast->type) pointer will
3816	* be correct.
3817	* ----------------------------------------------------------------------------- */
3818
3819	#ifdef __cplusplus
3820	extern "C" {
3821	#if 0
3822	} /* c-mode */
3823	#endif
3824	#endif
3825
3826	#if 0
3827	#define SWIGRUNTIME_DEBUG
3828	#endif
3829
3830
3831	SWIGRUNTIME void
3832	SWIG_InitializeModule(void *clientdata) {
3833	size_t i;
3834	swig_module_info module_head, iter;
3835	int found, init;
3836
3837	clientdata = clientdata;
3838
3839	/* check to see if the circular list has been setup, if not, set it up */
3840	if (swig_module.next==0) {
3841	/* Initialize the swig_module */
3842	swig_module.type_initial = swig_type_initial;
3843	swig_module.cast_initial = swig_cast_initial;
3844	swig_module.next = &swig_module;
3845	init = 1;
3846	} else {
3847	init = 0;
3848	}
3849
3850	/* Try and load any already created modules */
3851	module_head = SWIG_GetModule(clientdata);
3852	if (!module_head) {
3853	/* This is the first module loaded for this interpreter */
3854	/* so set the swig module into the interpreter */
3855	SWIG_SetModule(clientdata, &swig_module);
3856	module_head = &swig_module;
3857	} else {
3858	/* the interpreter has loaded a SWIG module, but has it loaded this one? */
3859	found=0;
3860	iter=module_head;
3861	do {
3862	if (iter==&swig_module) {
3863	found=1;
3864	break;
3865	}
3866	iter=iter->next;
3867	} while (iter!= module_head);
3868
3869	/* if the is found in the list, then all is done and we may leave */
3870	if (found) return;
3871	/* otherwise we must add out module into the list */
3872	swig_module.next = module_head->next;
3873	module_head->next = &swig_module;
3874	}
3875
3876	/* When multiple interpeters are used, a module could have already been initialized in
3877	a different interpreter, but not yet have a pointer in this interpreter.
3878	In this case, we do not want to continue adding types... everything should be
3879	set up already */
3880	if (init == 0) return;
3881
3882	/* Now work on filling in swig_module.types */
3883	#ifdef SWIGRUNTIME_DEBUG
3884	printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3885	#endif
3886	for (i = 0; i < swig_module.size; ++i) {
3887	swig_type_info *type = 0;
3888	swig_type_info *ret;
3889	swig_cast_info *cast;
3890
3891	#ifdef SWIGRUNTIME_DEBUG
3892	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3893	#endif
3894
3895	/* if there is another module already loaded */
3896	if (swig_module.next != &swig_module) {
3897	type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3898	}
3899	if (type) {
3900	/* Overwrite clientdata field */
3901	#ifdef SWIGRUNTIME_DEBUG
3902	printf("SWIG_InitializeModule: found type %s\n", type->name);
3903	#endif
3904	if (swig_module.type_initial[i]->clientdata) {
3905	type->clientdata = swig_module.type_initial[i]->clientdata;
3906	#ifdef SWIGRUNTIME_DEBUG
3907	printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3908	#endif
3909	}
3910	} else {
3911	type = swig_module.type_initial[i];
3912	}
3913
3914	/* Insert casting types */
3915	cast = swig_module.cast_initial[i];
3916	while (cast->type) {
3917	/* Don't need to add information already in the list */
3918	ret = 0;
3919	#ifdef SWIGRUNTIME_DEBUG
3920	printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3921	#endif
3922	if (swig_module.next != &swig_module) {
3923	ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3924	#ifdef SWIGRUNTIME_DEBUG
3925	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3926	#endif
3927	}
3928	if (ret) {
3929	if (type == swig_module.type_initial[i]) {
3930	#ifdef SWIGRUNTIME_DEBUG
3931	printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3932	#endif
3933	cast->type = ret;
3934	ret = 0;
3935	} else {
3936	/* Check for casting already in the list */
3937	swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3938	#ifdef SWIGRUNTIME_DEBUG
3939	if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3940	#endif
3941	if (!ocast) ret = 0;
3942	}
3943	}
3944
3945	if (!ret) {
3946	#ifdef SWIGRUNTIME_DEBUG
3947	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3948	#endif
3949	if (type->cast) {
3950	type->cast->prev = cast;
3951	cast->next = type->cast;
3952	}
3953	type->cast = cast;
3954	}
3955	cast++;
3956	}
3957	/* Set entry in modules->types array equal to the type */
3958	swig_module.types[i] = type;
3959	}
3960	swig_module.types[i] = 0;
3961
3962	#ifdef SWIGRUNTIME_DEBUG
3963	printf("** SWIG_InitializeModule: Cast List ****\n");
3964	for (i = 0; i < swig_module.size; ++i) {
3965	int j = 0;
3966	swig_cast_info *cast = swig_module.cast_initial[i];
3967	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3968	while (cast->type) {
3969	printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3970	cast++;
3971	++j;
3972	}
3973	printf("---- Total casts: %d\n",j);
3974	}
3975	printf("** SWIG_InitializeModule: Cast List ****\n");
3976	#endif
3977	}
3978
3979	/* This function will propagate the clientdata field of type to
3980	* any new swig_type_info structures that have been added into the list
3981	* of equivalent types. It is like calling
3982	* SWIG_TypeClientData(type, clientdata) a second time.
3983	*/
3984	SWIGRUNTIME void
3985	SWIG_PropagateClientData(void) {
3986	size_t i;
3987	swig_cast_info *equiv;
3988	static int init_run = 0;
3989
3990	if (init_run) return;
3991	init_run = 1;
3992
3993	for (i = 0; i < swig_module.size; i++) {
3994	if (swig_module.types[i]->clientdata) {
3995	equiv = swig_module.types[i]->cast;
3996	while (equiv) {
3997	if (!equiv->converter) {
3998	if (equiv->type && !equiv->type->clientdata)
3999	SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4000	}
4001	equiv = equiv->next;
4002	}
4003	}
4004	}
4005	}
4006
4007	#ifdef __cplusplus
4008	#if 0
4009	{
4010	/* c-mode */
4011	#endif
4012	}
4013	#endif
4014
4015
4016
4017	#ifdef __cplusplus
4018	extern "C" {
4019	#endif
4020
4021	/* Python-specific SWIG API */
4022	#define SWIG_newvarlink() SWIG_Python_newvarlink()
4023	#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
4024	#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
4025
4026	/* -----------------------------------------------------------------------------
4027	* global variable support code.
4028	* ----------------------------------------------------------------------------- */
4029
4030	typedef struct swig_globalvar {
4031	char name; / Name of global variable */
4032	PyObject (get_attr)(void); /* Return the current value */
4033	int (set_attr)(PyObject ); /* Set the value */
4034	struct swig_globalvar *next;
4035	} swig_globalvar;
4036
4037	typedef struct swig_varlinkobject {
4038	PyObject_HEAD
4039	swig_globalvar *vars;
4040	} swig_varlinkobject;
4041
4042	SWIGINTERN PyObject *
4043	swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
4044	return PyString_FromString("<Swig global variables>");
4045	}
4046
4047	SWIGINTERN PyObject *
4048	swig_varlink_str(swig_varlinkobject *v) {
4049	PyObject *str = PyString_FromString("(");
4050	swig_globalvar *var;
4051	for (var = v->vars; var; var=var->next) {
4052	PyString_ConcatAndDel(&str,PyString_FromString(var->name));
4053	if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
4054	}
4055	PyString_ConcatAndDel(&str,PyString_FromString(")"));
4056	return str;
4057	}
4058
4059	SWIGINTERN int
4060	swig_varlink_print(swig_varlinkobject v, FILE fp, int SWIGUNUSEDPARM(flags)) {
4061	PyObject *str = swig_varlink_str(v);
4062	fprintf(fp,"Swig global variables ");
4063	fprintf(fp,"%s\n", PyString_AsString(str));
4064	Py_DECREF(str);
4065	return 0;
4066	}
4067
4068	SWIGINTERN void
4069	swig_varlink_dealloc(swig_varlinkobject *v) {
4070	swig_globalvar *var = v->vars;
4071	while (var) {
4072	swig_globalvar *n = var->next;
4073	free(var->name);
4074	free(var);
4075	var = n;
4076	}
4077	}
4078
4079	SWIGINTERN PyObject *
4080	swig_varlink_getattr(swig_varlinkobject v, char n) {
4081	PyObject *res = NULL;
4082	swig_globalvar *var = v->vars;
4083	while (var) {
4084	if (strcmp(var->name,n) == 0) {
4085	res = (*var->get_attr)();
4086	break;
4087	}
4088	var = var->next;
4089	}
4090	if (res == NULL && !PyErr_Occurred()) {
4091	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4092	}
4093	return res;
4094	}
4095
4096	SWIGINTERN int
4097	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {
4098	int res = 1;
4099	swig_globalvar *var = v->vars;
4100	while (var) {
4101	if (strcmp(var->name,n) == 0) {
4102	res = (*var->set_attr)(p);
4103	break;
4104	}
4105	var = var->next;
4106	}
4107	if (res == 1 && !PyErr_Occurred()) {
4108	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4109	}
4110	return res;
4111	}
4112
4113	SWIGINTERN PyTypeObject*
4114	swig_varlink_type(void) {
4115	static char varlink__doc__[] = "Swig var link object";
4116	static PyTypeObject varlink_type;
4117	static int type_init = 0;
4118	if (!type_init) {
4119	const PyTypeObject tmp
4120	= {
4121	PyObject_HEAD_INIT(NULL)
4122	0, /* Number of items in variable part (ob_size) */
4123	(char )"swigvarlink", / Type name (tp_name) */
4124	sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
4125	0, /* Itemsize (tp_itemsize) */
4126	(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
4127	(printfunc) swig_varlink_print, /* Print (tp_print) */
4128	(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
4129	(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
4130	0, /* tp_compare */
4131	(reprfunc) swig_varlink_repr, /* tp_repr */
4132	0, /* tp_as_number */
4133	0, /* tp_as_sequence */
4134	0, /* tp_as_mapping */
4135	0, /* tp_hash */
4136	0, /* tp_call */
4137	(reprfunc)swig_varlink_str, /* tp_str */
4138	0, /* tp_getattro */
4139	0, /* tp_setattro */
4140	0, /* tp_as_buffer */
4141	0, /* tp_flags */
4142	varlink__doc__, /* tp_doc */
4143	0, /* tp_traverse */
4144	0, /* tp_clear */
4145	0, /* tp_richcompare */
4146	0, /* tp_weaklistoffset */
4147	#if PY_VERSION_HEX >= 0x02020000
4148	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
4149	#endif
4150	#if PY_VERSION_HEX >= 0x02030000
4151	0, /* tp_del */
4152	#endif
4153	#ifdef COUNT_ALLOCS
4154	0,0,0,0 /* tp_alloc -> tp_next */
4155	#endif
4156	};
4157	varlink_type = tmp;
4158	varlink_type.ob_type = &PyType_Type;
4159	type_init = 1;
4160	}
4161	return &varlink_type;
4162	}
4163
4164	/* Create a variable linking object for use later */
4165	SWIGINTERN PyObject *
4166	SWIG_Python_newvarlink(void) {
4167	swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
4168	if (result) {
4169	result->vars = 0;
4170	}
4171	return ((PyObject*) result);
4172	}
4173
4174	SWIGINTERN void
4175	SWIG_Python_addvarlink(PyObject p, char name, PyObject (get_attr)(void), int (set_attr)(PyObject p)) {
4176	swig_varlinkobject v = (swig_varlinkobject ) p;
4177	swig_globalvar gv = (swig_globalvar ) malloc(sizeof(swig_globalvar));
4178	if (gv) {
4179	size_t size = strlen(name)+1;
4180	gv->name = (char *)malloc(size);
4181	if (gv->name) {
4182	strncpy(gv->name,name,size);
4183	gv->get_attr = get_attr;
4184	gv->set_attr = set_attr;
4185	gv->next = v->vars;
4186	}
4187	}
4188	v->vars = gv;
4189	}
4190
4191	SWIGINTERN PyObject *
4192	SWIG_globals(void) {
4193	static PyObject *_SWIG_globals = 0;
4194	if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
4195	return _SWIG_globals;
4196	}
4197
4198	/* -----------------------------------------------------------------------------
4199	* constants/methods manipulation
4200	* ----------------------------------------------------------------------------- */
4201
4202	/* Install Constants */
4203	SWIGINTERN void
4204	SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
4205	PyObject *obj = 0;
4206	size_t i;
4207	for (i = 0; constants[i].type; ++i) {
4208	switch(constants[i].type) {
4209	case SWIG_PY_POINTER:
4210	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
4211	break;
4212	case SWIG_PY_BINARY:
4213	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
4214	break;
4215	default:
4216	obj = 0;
4217	break;
4218	}
4219	if (obj) {
4220	PyDict_SetItemString(d, constants[i].name, obj);
4221	Py_DECREF(obj);
4222	}
4223	}
4224	}
4225
4226	/* -----------------------------------------------------------------------------*/
4227	/* Fix SwigMethods to carry the callback ptrs when needed */
4228	/* -----------------------------------------------------------------------------*/
4229
4230	SWIGINTERN void
4231	SWIG_Python_FixMethods(PyMethodDef *methods,
4232	swig_const_info *const_table,
4233	swig_type_info **types,
4234	swig_type_info **types_initial) {
4235	size_t i;
4236	for (i = 0; methods[i].ml_name; ++i) {
4237	const char *c = methods[i].ml_doc;
4238	if (c && (c = strstr(c, "swig_ptr: "))) {
4239	int j;
4240	swig_const_info *ci = 0;
4241	const char *name = c + 10;
4242	for (j = 0; const_table[j].type; ++j) {
4243	if (strncmp(const_table[j].name, name,
4244	strlen(const_table[j].name)) == 0) {
4245	ci = &(const_table[j]);
4246	break;
4247	}
4248	}
4249	if (ci) {
4250	size_t shift = (ci->ptype) - types;
4251	swig_type_info *ty = types_initial[shift];
4252	size_t ldoc = (c - methods[i].ml_doc);
4253	size_t lptr = strlen(ty->name)+2sizeof(void)+2;
4254	char ndoc = (char)malloc(ldoc + lptr + 10);
4255	if (ndoc) {
4256	char *buff = ndoc;
4257	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
4258	if (ptr) {
4259	strncpy(buff, methods[i].ml_doc, ldoc);
4260	buff += ldoc;
4261	strncpy(buff, "swig_ptr: ", 10);
4262	buff += 10;
4263	SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
4264	methods[i].ml_doc = ndoc;
4265	}
4266	}
4267	}
4268	}
4269	}
4270	}
4271
4272	#ifdef __cplusplus
4273	}
4274	#endif
4275
4276	/* -----------------------------------------------------------------------------*
4277	* Partial Init method
4278	* -----------------------------------------------------------------------------*/
4279
4280	#ifdef __cplusplus
4281	extern "C"
4282	#endif
4283	SWIGEXPORT void SWIG_init(void) {
4284	PyObject m, d;
4285
4286	/* Fix SwigMethods to carry the callback ptrs when needed */
4287	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
4288
4289	m = Py_InitModule((char *) SWIG_name, SwigMethods);
4290	d = PyModule_GetDict(m);
4291
4292	SWIG_InitializeModule(0);
4293	SWIG_InstallConstants(d,swig_const_table);
4294
4295
4296
4297
4298	mod_win32_client = PyImport_ImportModule("win32com.client");
4299	mod_pywintypes = PyImport_ImportModule("pywintypes");
4300	ComError = PyObject_GetAttrString(mod_pywintypes, "com_error");
4301
4302	wmi_init(&com_ctx, NULL);
4303	{
4304	PyObject *pModule;
4305
4306	pModule = PyImport_ImportModule( "win32com.client" );
4307	}
4308
4309	}
4310

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

Download in other formats: