File: | /shared/playproj/i2c/src/swig/ddc_swig_wrap.c |
Location: | line 4517, column 7 |
Description: | Potential leak of memory pointed to by 'result' |
1 | /* ---------------------------------------------------------------------------- | |||
2 | * This file was automatically generated by SWIG (http://www.swig.org). | |||
3 | * Version 3.0.11 | |||
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 | ||||
12 | #ifndef SWIGPYTHON | |||
13 | #define SWIGPYTHON | |||
14 | #endif | |||
15 | ||||
16 | #define SWIG_PYTHON_DIRECTOR_NO_VTABLE | |||
17 | ||||
18 | /* ----------------------------------------------------------------------------- | |||
19 | * This section contains generic SWIG labels for method/variable | |||
20 | * declarations/attributes, and other compiler dependent labels. | |||
21 | * ----------------------------------------------------------------------------- */ | |||
22 | ||||
23 | /* template workaround for compilers that cannot correctly implement the C++ standard */ | |||
24 | #ifndef SWIGTEMPLATEDISAMBIGUATOR | |||
25 | # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) | |||
26 | # define SWIGTEMPLATEDISAMBIGUATOR template | |||
27 | # elif defined(__HP_aCC) | |||
28 | /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ | |||
29 | /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ | |||
30 | # define SWIGTEMPLATEDISAMBIGUATOR template | |||
31 | # else | |||
32 | # define SWIGTEMPLATEDISAMBIGUATOR | |||
33 | # endif | |||
34 | #endif | |||
35 | ||||
36 | /* inline attribute */ | |||
37 | #ifndef SWIGINLINEinline | |||
38 | # if defined(__cplusplus) || (defined(__GNUC__4) && !defined(__STRICT_ANSI__)) | |||
39 | # define SWIGINLINEinline inline | |||
40 | # else | |||
41 | # define SWIGINLINEinline | |||
42 | # endif | |||
43 | #endif | |||
44 | ||||
45 | /* attribute recognised by some compilers to avoid 'unused' warnings */ | |||
46 | #ifndef SWIGUNUSED__attribute__ ((__unused__)) | |||
47 | # if defined(__GNUC__4) | |||
48 | # if !(defined(__cplusplus)) || (__GNUC__4 > 3 || (__GNUC__4 == 3 && __GNUC_MINOR__2 >= 4)) | |||
49 | # define SWIGUNUSED__attribute__ ((__unused__)) __attribute__ ((__unused__)) | |||
50 | # else | |||
51 | # define SWIGUNUSED__attribute__ ((__unused__)) | |||
52 | # endif | |||
53 | # elif defined(__ICC) | |||
54 | # define SWIGUNUSED__attribute__ ((__unused__)) __attribute__ ((__unused__)) | |||
55 | # else | |||
56 | # define SWIGUNUSED__attribute__ ((__unused__)) | |||
57 | # endif | |||
58 | #endif | |||
59 | ||||
60 | #ifndef SWIG_MSC_UNSUPPRESS_4505 | |||
61 | # if defined(_MSC_VER) | |||
62 | # pragma warning(disable : 4505) /* unreferenced local function has been removed */ | |||
63 | # endif | |||
64 | #endif | |||
65 | ||||
66 | #ifndef SWIGUNUSEDPARM | |||
67 | # ifdef __cplusplus | |||
68 | # define SWIGUNUSEDPARM(p)p __attribute__ ((__unused__)) | |||
69 | # else | |||
70 | # define SWIGUNUSEDPARM(p)p __attribute__ ((__unused__)) p SWIGUNUSED__attribute__ ((__unused__)) | |||
71 | # endif | |||
72 | #endif | |||
73 | ||||
74 | /* internal SWIG method */ | |||
75 | #ifndef SWIGINTERNstatic __attribute__ ((__unused__)) | |||
76 | # define SWIGINTERNstatic __attribute__ ((__unused__)) static SWIGUNUSED__attribute__ ((__unused__)) | |||
77 | #endif | |||
78 | ||||
79 | /* internal inline SWIG method */ | |||
80 | #ifndef SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline | |||
81 | # define SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline SWIGINTERNstatic __attribute__ ((__unused__)) SWIGINLINEinline | |||
82 | #endif | |||
83 | ||||
84 | /* exporting methods */ | |||
85 | #if defined(__GNUC__4) | |||
86 | # if (__GNUC__4 >= 4) || (__GNUC__4 == 3 && __GNUC_MINOR__2 >= 4) | |||
87 | # ifndef GCC_HASCLASSVISIBILITY | |||
88 | # define GCC_HASCLASSVISIBILITY | |||
89 | # endif | |||
90 | # endif | |||
91 | #endif | |||
92 | ||||
93 | #ifndef SWIGEXPORT__attribute__ ((visibility("default"))) | |||
94 | # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) | |||
95 | # if defined(STATIC_LINKED) | |||
96 | # define SWIGEXPORT__attribute__ ((visibility("default"))) | |||
97 | # else | |||
98 | # define SWIGEXPORT__attribute__ ((visibility("default"))) __declspec(dllexport) | |||
99 | # endif | |||
100 | # else | |||
101 | # if defined(__GNUC__4) && defined(GCC_HASCLASSVISIBILITY) | |||
102 | # define SWIGEXPORT__attribute__ ((visibility("default"))) __attribute__ ((visibility("default"))) | |||
103 | # else | |||
104 | # define SWIGEXPORT__attribute__ ((visibility("default"))) | |||
105 | # endif | |||
106 | # endif | |||
107 | #endif | |||
108 | ||||
109 | /* calling conventions for Windows */ | |||
110 | #ifndef SWIGSTDCALL | |||
111 | # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) | |||
112 | # define SWIGSTDCALL __stdcall | |||
113 | # else | |||
114 | # define SWIGSTDCALL | |||
115 | # endif | |||
116 | #endif | |||
117 | ||||
118 | /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ | |||
119 | #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) | |||
120 | # define _CRT_SECURE_NO_DEPRECATE | |||
121 | #endif | |||
122 | ||||
123 | /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ | |||
124 | #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) | |||
125 | # define _SCL_SECURE_NO_DEPRECATE | |||
126 | #endif | |||
127 | ||||
128 | /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ | |||
129 | #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) | |||
130 | # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 | |||
131 | #endif | |||
132 | ||||
133 | /* Intel's compiler complains if a variable which was never initialised is | |||
134 | * cast to void, which is a common idiom which we use to indicate that we | |||
135 | * are aware a variable isn't used. So we just silence that warning. | |||
136 | * See: https://github.com/swig/swig/issues/192 for more discussion. | |||
137 | */ | |||
138 | #ifdef __INTEL_COMPILER | |||
139 | # pragma warning disable 592 | |||
140 | #endif | |||
141 | ||||
142 | ||||
143 | #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) | |||
144 | /* Use debug wrappers with the Python release dll */ | |||
145 | # undef _DEBUG | |||
146 | # include <Python.h> | |||
147 | # define _DEBUG | |||
148 | #else | |||
149 | # include <Python.h> | |||
150 | #endif | |||
151 | ||||
152 | /* ----------------------------------------------------------------------------- | |||
153 | * swigrun.swg | |||
154 | * | |||
155 | * This file contains generic C API SWIG runtime support for pointer | |||
156 | * type checking. | |||
157 | * ----------------------------------------------------------------------------- */ | |||
158 | ||||
159 | /* This should only be incremented when either the layout of swig_type_info changes, | |||
160 | or for whatever reason, the runtime changes incompatibly */ | |||
161 | #define SWIG_RUNTIME_VERSION"4" "4" | |||
162 | ||||
163 | /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ | |||
164 | #ifdef SWIG_TYPE_TABLE | |||
165 | # define SWIG_QUOTE_STRING(x) #x | |||
166 | # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) | |||
167 | # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) | |||
168 | #else | |||
169 | # define SWIG_TYPE_TABLE_NAME | |||
170 | #endif | |||
171 | ||||
172 | /* | |||
173 | You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for | |||
174 | creating a static or dynamic library from the SWIG runtime code. | |||
175 | In 99.9% of the cases, SWIG just needs to declare them as 'static'. | |||
176 | ||||
177 | But only do this if strictly necessary, ie, if you have problems | |||
178 | with your compiler or suchlike. | |||
179 | */ | |||
180 | ||||
181 | #ifndef SWIGRUNTIMEstatic __attribute__ ((__unused__)) | |||
182 | # define SWIGRUNTIMEstatic __attribute__ ((__unused__)) SWIGINTERNstatic __attribute__ ((__unused__)) | |||
183 | #endif | |||
184 | ||||
185 | #ifndef SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline | |||
186 | # define SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline SWIGRUNTIMEstatic __attribute__ ((__unused__)) SWIGINLINEinline | |||
187 | #endif | |||
188 | ||||
189 | /* Generic buffer size */ | |||
190 | #ifndef SWIG_BUFFER_SIZE1024 | |||
191 | # define SWIG_BUFFER_SIZE1024 1024 | |||
192 | #endif | |||
193 | ||||
194 | /* Flags for pointer conversions */ | |||
195 | #define SWIG_POINTER_DISOWN0x1 0x1 | |||
196 | #define SWIG_CAST_NEW_MEMORY0x2 0x2 | |||
197 | ||||
198 | /* Flags for new pointer objects */ | |||
199 | #define SWIG_POINTER_OWN0x1 0x1 | |||
200 | ||||
201 | ||||
202 | /* | |||
203 | Flags/methods for returning states. | |||
204 | ||||
205 | The SWIG conversion methods, as ConvertPtr, return an integer | |||
206 | that tells if the conversion was successful or not. And if not, | |||
207 | an error code can be returned (see swigerrors.swg for the codes). | |||
208 | ||||
209 | Use the following macros/flags to set or process the returning | |||
210 | states. | |||
211 | ||||
212 | In old versions of SWIG, code such as the following was usually written: | |||
213 | ||||
214 | if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { | |||
215 | // success code | |||
216 | } else { | |||
217 | //fail code | |||
218 | } | |||
219 | ||||
220 | Now you can be more explicit: | |||
221 | ||||
222 | int res = SWIG_ConvertPtr(obj,vptr,ty.flags); | |||
223 | if (SWIG_IsOK(res)) { | |||
224 | // success code | |||
225 | } else { | |||
226 | // fail code | |||
227 | } | |||
228 | ||||
229 | which is the same really, but now you can also do | |||
230 | ||||
231 | Type *ptr; | |||
232 | int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); | |||
233 | if (SWIG_IsOK(res)) { | |||
234 | // success code | |||
235 | if (SWIG_IsNewObj(res) { | |||
236 | ... | |||
237 | delete *ptr; | |||
238 | } else { | |||
239 | ... | |||
240 | } | |||
241 | } else { | |||
242 | // fail code | |||
243 | } | |||
244 | ||||
245 | I.e., now SWIG_ConvertPtr can return new objects and you can | |||
246 | identify the case and take care of the deallocation. Of course that | |||
247 | also requires SWIG_ConvertPtr to return new result values, such as | |||
248 | ||||
249 | int SWIG_ConvertPtr(obj, ptr,...) { | |||
250 | if (<obj is ok>) { | |||
251 | if (<need new object>) { | |||
252 | *ptr = <ptr to new allocated object>; | |||
253 | return SWIG_NEWOBJ; | |||
254 | } else { | |||
255 | *ptr = <ptr to old object>; | |||
256 | return SWIG_OLDOBJ; | |||
257 | } | |||
258 | } else { | |||
259 | return SWIG_BADOBJ; | |||
260 | } | |||
261 | } | |||
262 | ||||
263 | Of course, returning the plain '0(success)/-1(fail)' still works, but you can be | |||
264 | more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the | |||
265 | SWIG errors code. | |||
266 | ||||
267 | Finally, if the SWIG_CASTRANK_MODE is enabled, the result code | |||
268 | allows to return the 'cast rank', for example, if you have this | |||
269 | ||||
270 | int food(double) | |||
271 | int fooi(int); | |||
272 | ||||
273 | and you call | |||
274 | ||||
275 | food(1) // cast rank '1' (1 -> 1.0) | |||
276 | fooi(1) // cast rank '0' | |||
277 | ||||
278 | just use the SWIG_AddCast()/SWIG_CheckState() | |||
279 | */ | |||
280 | ||||
281 | #define SWIG_OK(0) (0) | |||
282 | #define SWIG_ERROR(-1) (-1) | |||
283 | #define SWIG_IsOK(r)(r >= 0) (r >= 0) | |||
284 | #define SWIG_ArgError(r)((r != (-1)) ? r : -5) ((r != SWIG_ERROR(-1)) ? r : SWIG_TypeError-5) | |||
285 | ||||
286 | /* The CastRankLimit says how many bits are used for the cast rank */ | |||
287 | #define SWIG_CASTRANKLIMIT(1 << 8) (1 << 8) | |||
288 | /* The NewMask denotes the object was created (using new/malloc) */ | |||
289 | #define SWIG_NEWOBJMASK((1 << 8) << 1) (SWIG_CASTRANKLIMIT(1 << 8) << 1) | |||
290 | /* The TmpMask is for in/out typemaps that use temporal objects */ | |||
291 | #define SWIG_TMPOBJMASK(((1 << 8) << 1) << 1) (SWIG_NEWOBJMASK((1 << 8) << 1) << 1) | |||
292 | /* Simple returning values */ | |||
293 | #define SWIG_BADOBJ((-1)) (SWIG_ERROR(-1)) | |||
294 | #define SWIG_OLDOBJ((0)) (SWIG_OK(0)) | |||
295 | #define SWIG_NEWOBJ((0) | ((1 << 8) << 1)) (SWIG_OK(0) | SWIG_NEWOBJMASK((1 << 8) << 1)) | |||
296 | #define SWIG_TMPOBJ((0) | (((1 << 8) << 1) << 1)) (SWIG_OK(0) | SWIG_TMPOBJMASK(((1 << 8) << 1) << 1)) | |||
297 | /* Check, add and del mask methods */ | |||
298 | #define SWIG_AddNewMask(r)((r >= 0) ? (r | ((1 << 8) << 1)) : r) (SWIG_IsOK(r)(r >= 0) ? (r | SWIG_NEWOBJMASK((1 << 8) << 1)) : r) | |||
299 | #define SWIG_DelNewMask(r)((r >= 0) ? (r & ~((1 << 8) << 1)) : r) (SWIG_IsOK(r)(r >= 0) ? (r & ~SWIG_NEWOBJMASK((1 << 8) << 1)) : r) | |||
300 | #define SWIG_IsNewObj(r)((r >= 0) && (r & ((1 << 8) << 1)) ) (SWIG_IsOK(r)(r >= 0) && (r & SWIG_NEWOBJMASK((1 << 8) << 1))) | |||
301 | #define SWIG_AddTmpMask(r)((r >= 0) ? (r | (((1 << 8) << 1) << 1)) : r) (SWIG_IsOK(r)(r >= 0) ? (r | SWIG_TMPOBJMASK(((1 << 8) << 1) << 1)) : r) | |||
302 | #define SWIG_DelTmpMask(r)((r >= 0) ? (r & ~(((1 << 8) << 1) << 1)) : r) (SWIG_IsOK(r)(r >= 0) ? (r & ~SWIG_TMPOBJMASK(((1 << 8) << 1) << 1)) : r) | |||
303 | #define SWIG_IsTmpObj(r)((r >= 0) && (r & (((1 << 8) << 1) << 1))) (SWIG_IsOK(r)(r >= 0) && (r & SWIG_TMPOBJMASK(((1 << 8) << 1) << 1))) | |||
304 | ||||
305 | /* Cast-Rank Mode */ | |||
306 | #if defined(SWIG_CASTRANK_MODE) | |||
307 | # ifndef SWIG_TypeRank | |||
308 | # define SWIG_TypeRank unsigned long | |||
309 | # endif | |||
310 | # ifndef SWIG_MAXCASTRANK /* Default cast allowed */ | |||
311 | # define SWIG_MAXCASTRANK (2) | |||
312 | # endif | |||
313 | # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT(1 << 8)) -1) | |||
314 | # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) | |||
315 | SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline int SWIG_AddCast(int r)(int r) { | |||
316 | return SWIG_IsOK(r)(r >= 0) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR(-1)) : r; | |||
317 | } | |||
318 | SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline int SWIG_CheckState(int r)((int r >= 0) ? 1 : 0) { | |||
319 | return SWIG_IsOK(r)(r >= 0) ? SWIG_CastRank(r) + 1 : 0; | |||
320 | } | |||
321 | #else /* no cast-rank mode */ | |||
322 | # define SWIG_AddCast(r)(r) (r) | |||
323 | # define SWIG_CheckState(r)((r >= 0) ? 1 : 0) (SWIG_IsOK(r)(r >= 0) ? 1 : 0) | |||
324 | #endif | |||
325 | ||||
326 | ||||
327 | #include <string.h> | |||
328 | ||||
329 | #ifdef __cplusplus | |||
330 | extern "C" { | |||
331 | #endif | |||
332 | ||||
333 | typedef void *(*swig_converter_func)(void *, int *); | |||
334 | typedef struct swig_type_info *(*swig_dycast_func)(void **); | |||
335 | ||||
336 | /* Structure to store information on one type */ | |||
337 | typedef struct swig_type_info { | |||
338 | const char *name; /* mangled name of this type */ | |||
339 | const char *str; /* human readable name of this type */ | |||
340 | swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ | |||
341 | struct swig_cast_info *cast; /* linked list of types that can cast into this type */ | |||
342 | void *clientdata; /* language specific type data */ | |||
343 | int owndata; /* flag if the structure owns the clientdata */ | |||
344 | } swig_type_info; | |||
345 | ||||
346 | /* Structure to store a type and conversion function used for casting */ | |||
347 | typedef struct swig_cast_info { | |||
348 | swig_type_info *type; /* pointer to type that is equivalent to this type */ | |||
349 | swig_converter_func converter; /* function to cast the void pointers */ | |||
350 | struct swig_cast_info *next; /* pointer to next cast in linked list */ | |||
351 | struct swig_cast_info *prev; /* pointer to the previous cast */ | |||
352 | } swig_cast_info; | |||
353 | ||||
354 | /* Structure used to store module information | |||
355 | * Each module generates one structure like this, and the runtime collects | |||
356 | * all of these structures and stores them in a circularly linked list.*/ | |||
357 | typedef struct swig_module_info { | |||
358 | swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ | |||
359 | size_t size; /* Number of types in this module */ | |||
360 | struct swig_module_info *next; /* Pointer to next element in circularly linked list */ | |||
361 | swig_type_info **type_initial; /* Array of initially generated type structures */ | |||
362 | swig_cast_info **cast_initial; /* Array of initially generated casting structures */ | |||
363 | void *clientdata; /* Language specific module data */ | |||
364 | } swig_module_info; | |||
365 | ||||
366 | /* | |||
367 | Compare two type names skipping the space characters, therefore | |||
368 | "char*" == "char *" and "Class<int>" == "Class<int >", etc. | |||
369 | ||||
370 | Return 0 when the two name types are equivalent, as in | |||
371 | strncmp, but skipping ' '. | |||
372 | */ | |||
373 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
374 | SWIG_TypeNameComp(const char *f1, const char *l1, | |||
375 | const char *f2, const char *l2) { | |||
376 | for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { | |||
377 | while ((*f1 == ' ') && (f1 != l1)) ++f1; | |||
378 | while ((*f2 == ' ') && (f2 != l2)) ++f2; | |||
379 | if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; | |||
380 | } | |||
381 | return (int)((l1 - f1) - (l2 - f2)); | |||
382 | } | |||
383 | ||||
384 | /* | |||
385 | Check type equivalence in a name list like <name1>|<name2>|... | |||
386 | Return 0 if equal, -1 if nb < tb, 1 if nb > tb | |||
387 | */ | |||
388 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
389 | SWIG_TypeCmp(const char *nb, const char *tb) { | |||
390 | int equiv = 1; | |||
391 | const char* te = tb + strlen(tb); | |||
392 | const char* ne = nb; | |||
393 | while (equiv != 0 && *ne) { | |||
394 | for (nb = ne; *ne; ++ne) { | |||
395 | if (*ne == '|') break; | |||
396 | } | |||
397 | equiv = SWIG_TypeNameComp(nb, ne, tb, te); | |||
398 | if (*ne) ++ne; | |||
399 | } | |||
400 | return equiv; | |||
401 | } | |||
402 | ||||
403 | /* | |||
404 | Check type equivalence in a name list like <name1>|<name2>|... | |||
405 | Return 0 if not equal, 1 if equal | |||
406 | */ | |||
407 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
408 | SWIG_TypeEquiv(const char *nb, const char *tb) { | |||
409 | return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; | |||
410 | } | |||
411 | ||||
412 | /* | |||
413 | Check the typename | |||
414 | */ | |||
415 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) swig_cast_info * | |||
416 | SWIG_TypeCheck(const char *c, swig_type_info *ty) { | |||
417 | if (ty) { | |||
418 | swig_cast_info *iter = ty->cast; | |||
419 | while (iter) { | |||
420 | if (strcmp(iter->type->name, c)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (iter->type->name) && __builtin_constant_p (c) && (__s1_len = strlen (iter->type->name), __s2_len = strlen (c), (!((size_t)(const void *)((iter->type->name ) + 1) - (size_t)(const void *)(iter->type->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((c ) + 1) - (size_t)(const void *)(c) == 1) || __s2_len >= 4) ) ? __builtin_strcmp (iter->type->name, c) : (__builtin_constant_p (iter->type->name) && ((size_t)(const void *)( (iter->type->name) + 1) - (size_t)(const void *)(iter-> type->name) == 1) && (__s1_len = strlen (iter-> type->name), __s1_len < 4) ? (__builtin_constant_p (c) && ((size_t)(const void *)((c) + 1) - (size_t)(const void *)(c) == 1) ? __builtin_strcmp (iter->type->name, c) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (c); int __result = (((const unsigned char *) (const char *) (iter->type->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (iter->type->name))[1] - __s2[1 ]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (iter->type-> name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (iter ->type->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (c) && ((size_t)(const void *)((c) + 1) - (size_t)(const void *)(c) == 1) && (__s2_len = strlen (c), __s2_len < 4) ? (__builtin_constant_p (iter->type->name) && ((size_t)(const void *)((iter->type->name) + 1) - (size_t )(const void *)(iter->type->name) == 1) ? __builtin_strcmp (iter->type->name, c) : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (iter-> type->name); int __result = (((const unsigned char *) (const char *) (c))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ( c))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (c) )[2] - __s2[2]); if (__s2_len > 2 && __result == 0 ) __result = (((const unsigned char *) (const char *) (c))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (iter-> type->name, c)))); }) == 0) { | |||
421 | if (iter == ty->cast) | |||
422 | return iter; | |||
423 | /* Move iter to the top of the linked list */ | |||
424 | iter->prev->next = iter->next; | |||
425 | if (iter->next) | |||
426 | iter->next->prev = iter->prev; | |||
427 | iter->next = ty->cast; | |||
428 | iter->prev = 0; | |||
429 | if (ty->cast) ty->cast->prev = iter; | |||
430 | ty->cast = iter; | |||
431 | return iter; | |||
432 | } | |||
433 | iter = iter->next; | |||
434 | } | |||
435 | } | |||
436 | return 0; | |||
437 | } | |||
438 | ||||
439 | /* | |||
440 | Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison | |||
441 | */ | |||
442 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) swig_cast_info * | |||
443 | SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { | |||
444 | if (ty) { | |||
445 | swig_cast_info *iter = ty->cast; | |||
446 | while (iter) { | |||
447 | if (iter->type == from) { | |||
448 | if (iter == ty->cast) | |||
449 | return iter; | |||
450 | /* Move iter to the top of the linked list */ | |||
451 | iter->prev->next = iter->next; | |||
452 | if (iter->next) | |||
453 | iter->next->prev = iter->prev; | |||
454 | iter->next = ty->cast; | |||
455 | iter->prev = 0; | |||
456 | if (ty->cast) ty->cast->prev = iter; | |||
457 | ty->cast = iter; | |||
458 | return iter; | |||
459 | } | |||
460 | iter = iter->next; | |||
461 | } | |||
462 | } | |||
463 | return 0; | |||
464 | } | |||
465 | ||||
466 | /* | |||
467 | Cast a pointer up an inheritance hierarchy | |||
468 | */ | |||
469 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline void * | |||
470 | SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { | |||
471 | return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); | |||
472 | } | |||
473 | ||||
474 | /* | |||
475 | Dynamic pointer casting. Down an inheritance hierarchy | |||
476 | */ | |||
477 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) swig_type_info * | |||
478 | SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { | |||
479 | swig_type_info *lastty = ty; | |||
480 | if (!ty || !ty->dcast) return ty; | |||
481 | while (ty && (ty->dcast)) { | |||
482 | ty = (*ty->dcast)(ptr); | |||
483 | if (ty) lastty = ty; | |||
484 | } | |||
485 | return lastty; | |||
486 | } | |||
487 | ||||
488 | /* | |||
489 | Return the name associated with this type | |||
490 | */ | |||
491 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline const char * | |||
492 | SWIG_TypeName(const swig_type_info *ty) { | |||
493 | return ty->name; | |||
494 | } | |||
495 | ||||
496 | /* | |||
497 | Return the pretty name associated with this type, | |||
498 | that is an unmangled type name in a form presentable to the user. | |||
499 | */ | |||
500 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) const char * | |||
501 | SWIG_TypePrettyName(const swig_type_info *type) { | |||
502 | /* The "str" field contains the equivalent pretty names of the | |||
503 | type, separated by vertical-bar characters. We choose | |||
504 | to print the last name, as it is often (?) the most | |||
505 | specific. */ | |||
506 | if (!type) return NULL((void*)0); | |||
507 | if (type->str != NULL((void*)0)) { | |||
508 | const char *last_name = type->str; | |||
509 | const char *s; | |||
510 | for (s = type->str; *s; s++) | |||
511 | if (*s == '|') last_name = s+1; | |||
512 | return last_name; | |||
513 | } | |||
514 | else | |||
515 | return type->name; | |||
516 | } | |||
517 | ||||
518 | /* | |||
519 | Set the clientdata field for a type | |||
520 | */ | |||
521 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
522 | SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { | |||
523 | swig_cast_info *cast = ti->cast; | |||
524 | /* if (ti->clientdata == clientdata) return; */ | |||
525 | ti->clientdata = clientdata; | |||
526 | ||||
527 | while (cast) { | |||
528 | if (!cast->converter) { | |||
529 | swig_type_info *tc = cast->type; | |||
530 | if (!tc->clientdata) { | |||
531 | SWIG_TypeClientData(tc, clientdata); | |||
532 | } | |||
533 | } | |||
534 | cast = cast->next; | |||
535 | } | |||
536 | } | |||
537 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
538 | SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { | |||
539 | SWIG_TypeClientData(ti, clientdata); | |||
540 | ti->owndata = 1; | |||
541 | } | |||
542 | ||||
543 | /* | |||
544 | Search for a swig_type_info structure only by mangled name | |||
545 | Search is a O(log #types) | |||
546 | ||||
547 | We start searching at module start, and finish searching when start == end. | |||
548 | Note: if start == end at the beginning of the function, we go all the way around | |||
549 | the circular list. | |||
550 | */ | |||
551 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) swig_type_info * | |||
552 | SWIG_MangledTypeQueryModule(swig_module_info *start, | |||
553 | swig_module_info *end, | |||
554 | const char *name) { | |||
555 | swig_module_info *iter = start; | |||
556 | do { | |||
557 | if (iter->size) { | |||
558 | size_t l = 0; | |||
559 | size_t r = iter->size - 1; | |||
560 | do { | |||
561 | /* since l+r >= 0, we can (>> 1) instead (/ 2) */ | |||
562 | size_t i = (l + r) >> 1; | |||
563 | const char *iname = iter->types[i]->name; | |||
564 | if (iname) { | |||
565 | int compare = strcmp(name, iname)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (name) && __builtin_constant_p (iname) && (__s1_len = strlen (name), __s2_len = strlen (iname), (!((size_t)(const void *)((name) + 1) - (size_t)(const void *)(name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((iname) + 1) - (size_t)(const void *)(iname) == 1) || __s2_len >= 4)) ? __builtin_strcmp (name, iname) : (__builtin_constant_p (name) && ((size_t )(const void *)((name) + 1) - (size_t)(const void *)(name) == 1) && (__s1_len = strlen (name), __s1_len < 4) ? ( __builtin_constant_p (iname) && ((size_t)(const void * )((iname) + 1) - (size_t)(const void *)(iname) == 1) ? __builtin_strcmp (name, iname) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (iname); int __result = (((const unsigned char *) (const char *) (name))[0] - __s2 [0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (name))[1] - __s2 [1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (name))[2] - __s2 [2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (name))[3] - __s2[3 ]); } } __result; }))) : (__builtin_constant_p (iname) && ((size_t)(const void *)((iname) + 1) - (size_t)(const void * )(iname) == 1) && (__s2_len = strlen (iname), __s2_len < 4) ? (__builtin_constant_p (name) && ((size_t)( const void *)((name) + 1) - (size_t)(const void *)(name) == 1 ) ? __builtin_strcmp (name, iname) : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (name); int __result = (((const unsigned char *) (const char *) (iname))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ( iname))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ( iname))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (iname ))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (name , iname)))); }); | |||
566 | if (compare == 0) { | |||
567 | return iter->types[i]; | |||
568 | } else if (compare < 0) { | |||
569 | if (i) { | |||
570 | r = i - 1; | |||
571 | } else { | |||
572 | break; | |||
573 | } | |||
574 | } else if (compare > 0) { | |||
575 | l = i + 1; | |||
576 | } | |||
577 | } else { | |||
578 | break; /* should never happen */ | |||
579 | } | |||
580 | } while (l <= r); | |||
581 | } | |||
582 | iter = iter->next; | |||
583 | } while (iter != end); | |||
584 | return 0; | |||
585 | } | |||
586 | ||||
587 | /* | |||
588 | Search for a swig_type_info structure for either a mangled name or a human readable name. | |||
589 | It first searches the mangled names of the types, which is a O(log #types) | |||
590 | If a type is not found it then searches the human readable names, which is O(#types). | |||
591 | ||||
592 | We start searching at module start, and finish searching when start == end. | |||
593 | Note: if start == end at the beginning of the function, we go all the way around | |||
594 | the circular list. | |||
595 | */ | |||
596 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) swig_type_info * | |||
597 | SWIG_TypeQueryModule(swig_module_info *start, | |||
598 | swig_module_info *end, | |||
599 | const char *name) { | |||
600 | /* STEP 1: Search the name field using binary search */ | |||
601 | swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); | |||
602 | if (ret) { | |||
603 | return ret; | |||
604 | } else { | |||
605 | /* STEP 2: If the type hasn't been found, do a complete search | |||
606 | of the str field (the human readable name) */ | |||
607 | swig_module_info *iter = start; | |||
608 | do { | |||
609 | size_t i = 0; | |||
610 | for (; i < iter->size; ++i) { | |||
611 | if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) | |||
612 | return iter->types[i]; | |||
613 | } | |||
614 | iter = iter->next; | |||
615 | } while (iter != end); | |||
616 | } | |||
617 | ||||
618 | /* neither found a match */ | |||
619 | return 0; | |||
620 | } | |||
621 | ||||
622 | /* | |||
623 | Pack binary data into a string | |||
624 | */ | |||
625 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) char * | |||
626 | SWIG_PackData(char *c, void *ptr, size_t sz) { | |||
627 | static const char hex[17] = "0123456789abcdef"; | |||
628 | const unsigned char *u = (unsigned char *) ptr; | |||
629 | const unsigned char *eu = u + sz; | |||
630 | for (; u != eu; ++u) { | |||
631 | unsigned char uu = *u; | |||
632 | *(c++) = hex[(uu & 0xf0) >> 4]; | |||
633 | *(c++) = hex[uu & 0xf]; | |||
634 | } | |||
635 | return c; | |||
636 | } | |||
637 | ||||
638 | /* | |||
639 | Unpack binary data from a string | |||
640 | */ | |||
641 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) const char * | |||
642 | SWIG_UnpackData(const char *c, void *ptr, size_t sz) { | |||
643 | unsigned char *u = (unsigned char *) ptr; | |||
644 | const unsigned char *eu = u + sz; | |||
645 | for (; u != eu; ++u) { | |||
646 | char d = *(c++); | |||
647 | unsigned char uu; | |||
648 | if ((d >= '0') && (d <= '9')) | |||
649 | uu = (unsigned char)((d - '0') << 4); | |||
650 | else if ((d >= 'a') && (d <= 'f')) | |||
651 | uu = (unsigned char)((d - ('a'-10)) << 4); | |||
652 | else | |||
653 | return (char *) 0; | |||
654 | d = *(c++); | |||
655 | if ((d >= '0') && (d <= '9')) | |||
656 | uu |= (unsigned char)(d - '0'); | |||
657 | else if ((d >= 'a') && (d <= 'f')) | |||
658 | uu |= (unsigned char)(d - ('a'-10)); | |||
659 | else | |||
660 | return (char *) 0; | |||
661 | *u = uu; | |||
662 | } | |||
663 | return c; | |||
664 | } | |||
665 | ||||
666 | /* | |||
667 | Pack 'void *' into a string buffer. | |||
668 | */ | |||
669 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) char * | |||
670 | SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { | |||
671 | char *r = buff; | |||
672 | if ((2*sizeof(void *) + 2) > bsz) return 0; | |||
673 | *(r++) = '_'; | |||
674 | r = SWIG_PackData(r,&ptr,sizeof(void *)); | |||
675 | if (strlen(name) + 1 > (bsz - (r - buff))) return 0; | |||
676 | strcpy(r,name); | |||
677 | return buff; | |||
678 | } | |||
679 | ||||
680 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) const char * | |||
681 | SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { | |||
682 | if (*c != '_') { | |||
683 | if (strcmp(c,"NULL")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (c) && __builtin_constant_p ("NULL") && (__s1_len = strlen (c), __s2_len = strlen ("NULL"), (!((size_t)(const void *)((c) + 1) - (size_t)(const void *)(c) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("NULL") + 1) - (size_t )(const void *)("NULL") == 1) || __s2_len >= 4)) ? __builtin_strcmp (c, "NULL") : (__builtin_constant_p (c) && ((size_t) (const void *)((c) + 1) - (size_t)(const void *)(c) == 1) && (__s1_len = strlen (c), __s1_len < 4) ? (__builtin_constant_p ("NULL") && ((size_t)(const void *)(("NULL") + 1) - ( size_t)(const void *)("NULL") == 1) ? __builtin_strcmp (c, "NULL" ) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("NULL"); int __result = (((const unsigned char *) (const char *) (c))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (c))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (c))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (c ))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ( "NULL") && ((size_t)(const void *)(("NULL") + 1) - (size_t )(const void *)("NULL") == 1) && (__s2_len = strlen ( "NULL"), __s2_len < 4) ? (__builtin_constant_p (c) && ((size_t)(const void *)((c) + 1) - (size_t)(const void *)(c) == 1) ? __builtin_strcmp (c, "NULL") : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (c); int __result = (((const unsigned char *) (const char *) ("NULL"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ( "NULL"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ( "NULL"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("NULL" ))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (c, "NULL" )))); }) == 0) { | |||
684 | *ptr = (void *) 0; | |||
685 | return name; | |||
686 | } else { | |||
687 | return 0; | |||
688 | } | |||
689 | } | |||
690 | return SWIG_UnpackData(++c,ptr,sizeof(void *)); | |||
691 | } | |||
692 | ||||
693 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) char * | |||
694 | SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { | |||
695 | char *r = buff; | |||
696 | size_t lname = (name ? strlen(name) : 0); | |||
697 | if ((2*sz + 2 + lname) > bsz) return 0; | |||
698 | *(r++) = '_'; | |||
699 | r = SWIG_PackData(r,ptr,sz); | |||
700 | if (lname) { | |||
701 | strncpy(r,name,lname+1)__builtin_strncpy (r, name, lname+1); | |||
702 | } else { | |||
703 | *r = 0; | |||
704 | } | |||
705 | return buff; | |||
706 | } | |||
707 | ||||
708 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) const char * | |||
709 | SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { | |||
710 | if (*c != '_') { | |||
711 | if (strcmp(c,"NULL")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (c) && __builtin_constant_p ("NULL") && (__s1_len = strlen (c), __s2_len = strlen ("NULL"), (!((size_t)(const void *)((c) + 1) - (size_t)(const void *)(c) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("NULL") + 1) - (size_t )(const void *)("NULL") == 1) || __s2_len >= 4)) ? __builtin_strcmp (c, "NULL") : (__builtin_constant_p (c) && ((size_t) (const void *)((c) + 1) - (size_t)(const void *)(c) == 1) && (__s1_len = strlen (c), __s1_len < 4) ? (__builtin_constant_p ("NULL") && ((size_t)(const void *)(("NULL") + 1) - ( size_t)(const void *)("NULL") == 1) ? __builtin_strcmp (c, "NULL" ) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("NULL"); int __result = (((const unsigned char *) (const char *) (c))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (c))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (c))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (c ))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ( "NULL") && ((size_t)(const void *)(("NULL") + 1) - (size_t )(const void *)("NULL") == 1) && (__s2_len = strlen ( "NULL"), __s2_len < 4) ? (__builtin_constant_p (c) && ((size_t)(const void *)((c) + 1) - (size_t)(const void *)(c) == 1) ? __builtin_strcmp (c, "NULL") : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (c); int __result = (((const unsigned char *) (const char *) ("NULL"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ( "NULL"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ( "NULL"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("NULL" ))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (c, "NULL" )))); }) == 0) { | |||
712 | memset(ptr,0,sz); | |||
713 | return name; | |||
714 | } else { | |||
715 | return 0; | |||
716 | } | |||
717 | } | |||
718 | return SWIG_UnpackData(++c,ptr,sz); | |||
719 | } | |||
720 | ||||
721 | #ifdef __cplusplus | |||
722 | } | |||
723 | #endif | |||
724 | ||||
725 | /* Errors in SWIG */ | |||
726 | #define SWIG_UnknownError-1 -1 | |||
727 | #define SWIG_IOError-2 -2 | |||
728 | #define SWIG_RuntimeError-3 -3 | |||
729 | #define SWIG_IndexError-4 -4 | |||
730 | #define SWIG_TypeError-5 -5 | |||
731 | #define SWIG_DivisionByZero-6 -6 | |||
732 | #define SWIG_OverflowError-7 -7 | |||
733 | #define SWIG_SyntaxError-8 -8 | |||
734 | #define SWIG_ValueError-9 -9 | |||
735 | #define SWIG_SystemError-10 -10 | |||
736 | #define SWIG_AttributeError-11 -11 | |||
737 | #define SWIG_MemoryError-12 -12 | |||
738 | #define SWIG_NullReferenceError-13 -13 | |||
739 | ||||
740 | ||||
741 | ||||
742 | /* Compatibility macros for Python 3 */ | |||
743 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
744 | ||||
745 | #define PyClass_Check(obj)((obj)->ob_type == &PyClass_Type) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) | |||
746 | #define PyInt_Check(x)((((x)->ob_type)->tp_flags & ((1L<<23))) != 0 ) PyLong_Check(x)((((((PyObject*)(x))->ob_type))->tp_flags & ((1L<< 24))) != 0) | |||
747 | #define PyInt_AsLong(x) PyLong_AsLong(x) | |||
748 | #define PyInt_FromLong(x) PyLong_FromLong(x) | |||
749 | #define PyInt_FromSize_t(x) PyLong_FromSize_t(x) | |||
750 | #define PyString_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L <<27))) != 0) PyBytes_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L <<27))) != 0) | |||
751 | #define PyString_FromString(x) PyUnicode_FromStringPyUnicodeUCS4_FromString(x) | |||
752 | #define PyString_Format(fmt, args) PyUnicode_FormatPyUnicodeUCS4_Format(fmt, args) | |||
753 | #define PyString_AsString(str) PyBytes_AsStringPyString_AsString(str) | |||
754 | #define PyString_Size(str) PyBytes_SizePyString_Size(str) | |||
755 | #define PyString_InternFromString(key) PyUnicode_InternFromString(key) | |||
756 | #define Py_TPFLAGS_HAVE_CLASS(1L<<8) Py_TPFLAGS_BASETYPE(1L<<10) | |||
757 | #define PyString_AS_STRING(x)(((PyStringObject *)(x))->ob_sval) PyUnicode_AS_STRING(x) | |||
758 | #define _PyLong_FromSsize_tPyLong_FromSsize_t(x) PyLong_FromSsize_t(x) | |||
759 | ||||
760 | #endif | |||
761 | ||||
762 | #ifndef Py_TYPE | |||
763 | # define Py_TYPE(op)(((PyObject*)(op))->ob_type) ((op)->ob_type) | |||
764 | #endif | |||
765 | ||||
766 | /* SWIG APIs for compatibility of both Python 2 & 3 */ | |||
767 | ||||
768 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
769 | # define SWIG_Python_str_FromFormatPyString_FromFormat PyUnicode_FromFormatPyUnicodeUCS4_FromFormat | |||
770 | #else | |||
771 | # define SWIG_Python_str_FromFormatPyString_FromFormat PyString_FromFormat | |||
772 | #endif | |||
773 | ||||
774 | ||||
775 | /* Warning: This function will allocate a new string in Python 3, | |||
776 | * so please call SWIG_Python_str_DelForPy3(x) to free the space. | |||
777 | */ | |||
778 | SWIGINTERNstatic __attribute__ ((__unused__)) char* | |||
779 | SWIG_Python_str_AsChar(PyObject *str) | |||
780 | { | |||
781 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
782 | char *cstr; | |||
783 | char *newstr; | |||
784 | Py_ssize_t len; | |||
785 | str = PyUnicode_AsUTF8StringPyUnicodeUCS4_AsUTF8String(str); | |||
786 | PyBytes_AsStringAndSizePyString_AsStringAndSize(str, &cstr, &len); | |||
787 | newstr = (char *) malloc(len+1); | |||
788 | memcpy(newstr, cstr, len+1); | |||
789 | Py_XDECREF(str)do { if ((str) == ((void*)0)) ; else do { if ( --((PyObject*) (str))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(str)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(str)))); } while (0); } while (0); | |||
790 | return newstr; | |||
791 | #else | |||
792 | return PyString_AsString(str); | |||
793 | #endif | |||
794 | } | |||
795 | ||||
796 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
797 | # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) | |||
798 | #else | |||
799 | # define SWIG_Python_str_DelForPy3(x) | |||
800 | #endif | |||
801 | ||||
802 | ||||
803 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject* | |||
804 | SWIG_Python_str_FromChar(const char *c) | |||
805 | { | |||
806 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
807 | return PyUnicode_FromStringPyUnicodeUCS4_FromString(c); | |||
808 | #else | |||
809 | return PyString_FromString(c); | |||
810 | #endif | |||
811 | } | |||
812 | ||||
813 | /* Add PyOS_snprintf for old Pythons */ | |||
814 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000 | |||
815 | # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) | |||
816 | # define PyOS_snprintf _snprintf | |||
817 | # else | |||
818 | # define PyOS_snprintf snprintf | |||
819 | # endif | |||
820 | #endif | |||
821 | ||||
822 | /* A crude PyString_FromFormat implementation for old Pythons */ | |||
823 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000 | |||
824 | ||||
825 | #ifndef SWIG_PYBUFFER_SIZE | |||
826 | # define SWIG_PYBUFFER_SIZE 1024 | |||
827 | #endif | |||
828 | ||||
829 | static PyObject * | |||
830 | PyString_FromFormat(const char *fmt, ...) { | |||
831 | va_list ap; | |||
832 | char buf[SWIG_PYBUFFER_SIZE * 2]; | |||
833 | int res; | |||
834 | va_start(ap, fmt)__builtin_va_start(ap, fmt); | |||
835 | res = vsnprintf(buf, sizeof(buf), fmt, ap); | |||
836 | va_end(ap)__builtin_va_end(ap); | |||
837 | return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); | |||
838 | } | |||
839 | #endif | |||
840 | ||||
841 | #ifndef PyObject_DELPyObject_Free | |||
842 | # define PyObject_DELPyObject_Free PyObject_DelPyObject_Free | |||
843 | #endif | |||
844 | ||||
845 | /* A crude PyExc_StopIteration exception for old Pythons */ | |||
846 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000 | |||
847 | # ifndef PyExc_StopIteration | |||
848 | # define PyExc_StopIteration PyExc_RuntimeError | |||
849 | # endif | |||
850 | # ifndef PyObject_GenericGetAttr | |||
851 | # define PyObject_GenericGetAttr 0 | |||
852 | # endif | |||
853 | #endif | |||
854 | ||||
855 | /* Py_NotImplemented is defined in 2.1 and up. */ | |||
856 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02010000 | |||
857 | # ifndef Py_NotImplemented(&_Py_NotImplementedStruct) | |||
858 | # define Py_NotImplemented(&_Py_NotImplementedStruct) PyExc_RuntimeError | |||
859 | # endif | |||
860 | #endif | |||
861 | ||||
862 | /* A crude PyString_AsStringAndSize implementation for old Pythons */ | |||
863 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02010000 | |||
864 | # ifndef PyString_AsStringAndSize | |||
865 | # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} | |||
866 | # endif | |||
867 | #endif | |||
868 | ||||
869 | /* PySequence_Size for old Pythons */ | |||
870 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02000000 | |||
871 | # ifndef PySequence_Size | |||
872 | # define PySequence_Size PySequence_LengthPySequence_Size | |||
873 | # endif | |||
874 | #endif | |||
875 | ||||
876 | /* PyBool_FromLong for old Pythons */ | |||
877 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02030000 | |||
878 | static | |||
879 | PyObject *PyBool_FromLong(long ok) | |||
880 | { | |||
881 | PyObject *result = ok ? Py_True((PyObject *) &_Py_TrueStruct) : Py_False((PyObject *) &_Py_ZeroStruct); | |||
882 | Py_INCREF(result)( ((PyObject*)(result))->ob_refcnt++); | |||
883 | return result; | |||
884 | } | |||
885 | #endif | |||
886 | ||||
887 | /* Py_ssize_t for old Pythons */ | |||
888 | /* This code is as recommended by: */ | |||
889 | /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ | |||
890 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02050000 && !defined(PY_SSIZE_T_MIN(-((Py_ssize_t)(((size_t)-1)>>1))-1)) | |||
891 | typedef int Py_ssize_t; | |||
892 | # define PY_SSIZE_T_MAX((Py_ssize_t)(((size_t)-1)>>1)) INT_MAX2147483647 | |||
893 | # define PY_SSIZE_T_MIN(-((Py_ssize_t)(((size_t)-1)>>1))-1) INT_MIN(-2147483647 -1) | |||
894 | typedef inquiry lenfunc; | |||
895 | typedef intargfunc ssizeargfunc; | |||
896 | typedef intintargfunc ssizessizeargfunc; | |||
897 | typedef intobjargproc ssizeobjargproc; | |||
898 | typedef intintobjargproc ssizessizeobjargproc; | |||
899 | typedef getreadbufferproc readbufferproc; | |||
900 | typedef getwritebufferproc writebufferproc; | |||
901 | typedef getsegcountproc segcountproc; | |||
902 | typedef getcharbufferproc charbufferproc; | |||
903 | static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)exc __attribute__ ((__unused__))) | |||
904 | { | |||
905 | long result = 0; | |||
906 | PyObject *i = PyNumber_Int(x); | |||
907 | if (i) { | |||
908 | result = PyInt_AsLong(i); | |||
909 | Py_DECREF(i)do { if ( --((PyObject*)(i))->ob_refcnt != 0) ; else ( (*( ((PyObject*)((PyObject *)(i)))->ob_type)->tp_dealloc)(( PyObject *)((PyObject *)(i)))); } while (0); | |||
910 | } | |||
911 | return result; | |||
912 | } | |||
913 | #endif | |||
914 | ||||
915 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02050000 | |||
916 | #define PyInt_FromSize_t(x) PyInt_FromLong((long)x) | |||
917 | #endif | |||
918 | ||||
919 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02040000 | |||
920 | #define Py_VISIT(op)do { if (op) { int vret = visit((PyObject *)(op), arg); if (vret ) return vret; } } while (0) \ | |||
921 | do { \ | |||
922 | if (op) { \ | |||
923 | int vret = visit((op), arg); \ | |||
924 | if (vret) \ | |||
925 | return vret; \ | |||
926 | } \ | |||
927 | } while (0) | |||
928 | #endif | |||
929 | ||||
930 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02030000 | |||
931 | typedef struct { | |||
932 | PyTypeObject type; | |||
933 | PyNumberMethods as_number; | |||
934 | PyMappingMethods as_mapping; | |||
935 | PySequenceMethods as_sequence; | |||
936 | PyBufferProcs as_buffer; | |||
937 | PyObject *name, *slots; | |||
938 | } PyHeapTypeObject; | |||
939 | #endif | |||
940 | ||||
941 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02030000 | |||
942 | typedef destructor freefunc; | |||
943 | #endif | |||
944 | ||||
945 | #if ((PY_MAJOR_VERSION2 == 2 && PY_MINOR_VERSION7 > 6) || \ | |||
946 | (PY_MAJOR_VERSION2 == 3 && PY_MINOR_VERSION7 > 0) || \ | |||
947 | (PY_MAJOR_VERSION2 > 3)) | |||
948 | # define SWIGPY_USE_CAPSULE | |||
949 | # define SWIGPY_CAPSULE_NAME((char*)"swig_runtime_data" "4" ".type_pointer_capsule" ) ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION"4" ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) | |||
950 | #endif | |||
951 | ||||
952 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x03020000 | |||
953 | #define PyDescr_TYPE(x)(((PyDescrObject *)(x))->d_type) (((PyDescrObject *)(x))->d_type) | |||
954 | #define PyDescr_NAME(x)(((PyDescrObject *)(x))->d_name) (((PyDescrObject *)(x))->d_name) | |||
955 | #define Py_hash_tlong long | |||
956 | #endif | |||
957 | ||||
958 | /* ----------------------------------------------------------------------------- | |||
959 | * error manipulation | |||
960 | * ----------------------------------------------------------------------------- */ | |||
961 | ||||
962 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject* | |||
963 | SWIG_Python_ErrorType(int code) { | |||
964 | PyObject* type = 0; | |||
965 | switch(code) { | |||
966 | case SWIG_MemoryError-12: | |||
967 | type = PyExc_MemoryError; | |||
968 | break; | |||
969 | case SWIG_IOError-2: | |||
970 | type = PyExc_IOError; | |||
971 | break; | |||
972 | case SWIG_RuntimeError-3: | |||
973 | type = PyExc_RuntimeError; | |||
974 | break; | |||
975 | case SWIG_IndexError-4: | |||
976 | type = PyExc_IndexError; | |||
977 | break; | |||
978 | case SWIG_TypeError-5: | |||
979 | type = PyExc_TypeError; | |||
980 | break; | |||
981 | case SWIG_DivisionByZero-6: | |||
982 | type = PyExc_ZeroDivisionError; | |||
983 | break; | |||
984 | case SWIG_OverflowError-7: | |||
985 | type = PyExc_OverflowError; | |||
986 | break; | |||
987 | case SWIG_SyntaxError-8: | |||
988 | type = PyExc_SyntaxError; | |||
989 | break; | |||
990 | case SWIG_ValueError-9: | |||
991 | type = PyExc_ValueError; | |||
992 | break; | |||
993 | case SWIG_SystemError-10: | |||
994 | type = PyExc_SystemError; | |||
995 | break; | |||
996 | case SWIG_AttributeError-11: | |||
997 | type = PyExc_AttributeError; | |||
998 | break; | |||
999 | default: | |||
1000 | type = PyExc_RuntimeError; | |||
1001 | } | |||
1002 | return type; | |||
1003 | } | |||
1004 | ||||
1005 | ||||
1006 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
1007 | SWIG_Python_AddErrorMsg(const char* mesg) | |||
1008 | { | |||
1009 | PyObject *type = 0; | |||
1010 | PyObject *value = 0; | |||
1011 | PyObject *traceback = 0; | |||
1012 | ||||
1013 | if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); | |||
1014 | if (value) { | |||
1015 | char *tmp; | |||
1016 | PyObject *old_str = PyObject_Str(value); | |||
1017 | PyErr_Clear(); | |||
1018 | Py_XINCREF(type)do { if ((type) == ((void*)0)) ; else ( ((PyObject*)(type))-> ob_refcnt++); } while (0); | |||
1019 | ||||
1020 | PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); | |||
1021 | SWIG_Python_str_DelForPy3(tmp); | |||
1022 | Py_DECREF(old_str)do { if ( --((PyObject*)(old_str))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(old_str)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(old_str)))); } while (0); | |||
1023 | Py_DECREF(value)do { if ( --((PyObject*)(value))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(value)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(value)))); } while (0); | |||
1024 | } else { | |||
1025 | PyErr_SetString(PyExc_RuntimeError, mesg); | |||
1026 | } | |||
1027 | } | |||
1028 | ||||
1029 | #if defined(SWIG_PYTHON_NO_THREADS) | |||
1030 | # if defined(SWIG_PYTHON_THREADS) | |||
1031 | # undef SWIG_PYTHON_THREADS | |||
1032 | # endif | |||
1033 | #endif | |||
1034 | #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ | |||
1035 | # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) | |||
1036 | # if (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ | |||
1037 | # define SWIG_PYTHON_USE_GIL | |||
1038 | # endif | |||
1039 | # endif | |||
1040 | # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ | |||
1041 | # ifndef SWIG_PYTHON_INITIALIZE_THREADS | |||
1042 | # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() | |||
1043 | # endif | |||
1044 | # ifdef __cplusplus /* C++ code */ | |||
1045 | class SWIG_Python_Thread_Block { | |||
1046 | bool_Bool status; | |||
1047 | PyGILState_STATE state; | |||
1048 | public: | |||
1049 | void end() { if (status) { PyGILState_Release(state); status = false0;} } | |||
1050 | SWIG_Python_Thread_Block() : status(true1), state(PyGILState_Ensure()) {} | |||
1051 | ~SWIG_Python_Thread_Block() { end(); } | |||
1052 | }; | |||
1053 | class SWIG_Python_Thread_Allow { | |||
1054 | bool_Bool status; | |||
1055 | PyThreadState *save; | |||
1056 | public: | |||
1057 | void end() { if (status) { PyEval_RestoreThread(save); status = false0; }} | |||
1058 | SWIG_Python_Thread_Allow() : status(true1), save(PyEval_SaveThread()) {} | |||
1059 | ~SWIG_Python_Thread_Allow() { end(); } | |||
1060 | }; | |||
1061 | # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block | |||
1062 | # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() | |||
1063 | # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow | |||
1064 | # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() | |||
1065 | # else /* C code */ | |||
1066 | # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() | |||
1067 | # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) | |||
1068 | # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() | |||
1069 | # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) | |||
1070 | # endif | |||
1071 | # else /* Old thread way, not implemented, user must provide it */ | |||
1072 | # if !defined(SWIG_PYTHON_INITIALIZE_THREADS) | |||
1073 | # define SWIG_PYTHON_INITIALIZE_THREADS | |||
1074 | # endif | |||
1075 | # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) | |||
1076 | # define SWIG_PYTHON_THREAD_BEGIN_BLOCK | |||
1077 | # endif | |||
1078 | # if !defined(SWIG_PYTHON_THREAD_END_BLOCK) | |||
1079 | # define SWIG_PYTHON_THREAD_END_BLOCK | |||
1080 | # endif | |||
1081 | # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) | |||
1082 | # define SWIG_PYTHON_THREAD_BEGIN_ALLOW | |||
1083 | # endif | |||
1084 | # if !defined(SWIG_PYTHON_THREAD_END_ALLOW) | |||
1085 | # define SWIG_PYTHON_THREAD_END_ALLOW | |||
1086 | # endif | |||
1087 | # endif | |||
1088 | #else /* No thread support */ | |||
1089 | # define SWIG_PYTHON_INITIALIZE_THREADS | |||
1090 | # define SWIG_PYTHON_THREAD_BEGIN_BLOCK | |||
1091 | # define SWIG_PYTHON_THREAD_END_BLOCK | |||
1092 | # define SWIG_PYTHON_THREAD_BEGIN_ALLOW | |||
1093 | # define SWIG_PYTHON_THREAD_END_ALLOW | |||
1094 | #endif | |||
1095 | ||||
1096 | /* ----------------------------------------------------------------------------- | |||
1097 | * Python API portion that goes into the runtime | |||
1098 | * ----------------------------------------------------------------------------- */ | |||
1099 | ||||
1100 | #ifdef __cplusplus | |||
1101 | extern "C" { | |||
1102 | #endif | |||
1103 | ||||
1104 | /* ----------------------------------------------------------------------------- | |||
1105 | * Constant declarations | |||
1106 | * ----------------------------------------------------------------------------- */ | |||
1107 | ||||
1108 | /* Constant Types */ | |||
1109 | #define SWIG_PY_POINTER4 4 | |||
1110 | #define SWIG_PY_BINARY5 5 | |||
1111 | ||||
1112 | /* Constant information structure */ | |||
1113 | typedef struct swig_const_info { | |||
1114 | int type; | |||
1115 | char *name; | |||
1116 | long lvalue; | |||
1117 | double dvalue; | |||
1118 | void *pvalue; | |||
1119 | swig_type_info **ptype; | |||
1120 | } swig_const_info; | |||
1121 | ||||
1122 | ||||
1123 | /* ----------------------------------------------------------------------------- | |||
1124 | * Wrapper of PyInstanceMethod_New() used in Python 3 | |||
1125 | * It is exported to the generated module, used for -fastproxy | |||
1126 | * ----------------------------------------------------------------------------- */ | |||
1127 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
1128 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *func) | |||
1129 | { | |||
1130 | return PyInstanceMethod_New(func); | |||
1131 | } | |||
1132 | #else | |||
1133 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *SWIGUNUSEDPARM(func)func __attribute__ ((__unused__))) | |||
1134 | { | |||
1135 | return NULL((void*)0); | |||
1136 | } | |||
1137 | #endif | |||
1138 | ||||
1139 | #ifdef __cplusplus | |||
1140 | } | |||
1141 | #endif | |||
1142 | ||||
1143 | ||||
1144 | /* ----------------------------------------------------------------------------- | |||
1145 | * pyrun.swg | |||
1146 | * | |||
1147 | * This file contains the runtime support for Python modules | |||
1148 | * and includes code for managing global variables and pointer | |||
1149 | * type checking. | |||
1150 | * | |||
1151 | * ----------------------------------------------------------------------------- */ | |||
1152 | ||||
1153 | /* Common SWIG API */ | |||
1154 | ||||
1155 | /* for raw pointers */ | |||
1156 | #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) | |||
1157 | #define SWIG_ConvertPtr(obj, pptr, type, flags)SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) SWIG_Python_ConvertPtr(obj, pptr, type, flags)SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) | |||
1158 | #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) | |||
1159 | ||||
1160 | #ifdef SWIGPYTHON_BUILTIN | |||
1161 | #define SWIG_NewPointerObj(ptr, type, flags)SWIG_Python_NewPointerObj(((void*)0), ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) | |||
1162 | #else | |||
1163 | #define SWIG_NewPointerObj(ptr, type, flags)SWIG_Python_NewPointerObj(((void*)0), ptr, type, flags) SWIG_Python_NewPointerObj(NULL((void*)0), ptr, type, flags) | |||
1164 | #endif | |||
1165 | ||||
1166 | #define SWIG_InternalNewPointerObj(ptr, type, flags)SWIG_Python_NewPointerObj(((void*)0), ptr, type, flags) SWIG_Python_NewPointerObj(NULL((void*)0), ptr, type, flags) | |||
1167 | ||||
1168 | #define SWIG_CheckImplicit(ty)SWIG_Python_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) | |||
1169 | #define SWIG_AcquirePtr(ptr, src)SWIG_Python_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) | |||
1170 | #define swig_owntypeint int | |||
1171 | ||||
1172 | /* for raw packed data */ | |||
1173 | #define SWIG_ConvertPacked(obj, ptr, sz, ty)SWIG_Python_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) | |||
1174 | #define SWIG_NewPackedObj(ptr, sz, type)SWIG_Python_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) | |||
1175 | ||||
1176 | /* for class or struct pointers */ | |||
1177 | #define SWIG_ConvertInstance(obj, pptr, type, flags)SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) SWIG_ConvertPtr(obj, pptr, type, flags)SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) | |||
1178 | #define SWIG_NewInstanceObj(ptr, type, flags)SWIG_Python_NewPointerObj(((void*)0), ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)SWIG_Python_NewPointerObj(((void*)0), ptr, type, flags) | |||
1179 | ||||
1180 | /* for C or C++ function pointers */ | |||
1181 | #define SWIG_ConvertFunctionPtr(obj, pptr, type)SWIG_Python_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) | |||
1182 | #define SWIG_NewFunctionPtrObj(ptr, type)SWIG_Python_NewPointerObj(((void*)0), ptr, type, 0) SWIG_Python_NewPointerObj(NULL((void*)0), ptr, type, 0) | |||
1183 | ||||
1184 | /* for C++ member pointers, ie, member methods */ | |||
1185 | #define SWIG_ConvertMember(obj, ptr, sz, ty)SWIG_Python_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) | |||
1186 | #define SWIG_NewMemberObj(ptr, sz, type)SWIG_Python_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) | |||
1187 | ||||
1188 | ||||
1189 | /* Runtime API */ | |||
1190 | ||||
1191 | #define SWIG_GetModule(clientdata)SWIG_Python_GetModule(clientdata) SWIG_Python_GetModule(clientdata) | |||
1192 | #define SWIG_SetModule(clientdata, pointer)SWIG_Python_SetModule(pointer) SWIG_Python_SetModule(pointer) | |||
1193 | #define SWIG_NewClientData(obj)SwigPyClientData_New(obj) SwigPyClientData_New(obj) | |||
1194 | ||||
1195 | #define SWIG_SetErrorObjSWIG_Python_SetErrorObj SWIG_Python_SetErrorObj | |||
1196 | #define SWIG_SetErrorMsgSWIG_Python_SetErrorMsg SWIG_Python_SetErrorMsg | |||
1197 | #define SWIG_ErrorType(code)SWIG_Python_ErrorType(code) SWIG_Python_ErrorType(code) | |||
1198 | #define SWIG_Error(code, msg)SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(code), msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code)SWIG_Python_ErrorType(code), msg) | |||
1199 | #define SWIG_failgoto fail goto fail | |||
1200 | ||||
1201 | ||||
1202 | /* Runtime API implementation */ | |||
1203 | ||||
1204 | /* Error manipulation */ | |||
1205 | ||||
1206 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
1207 | SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { | |||
1208 | SWIG_PYTHON_THREAD_BEGIN_BLOCK; | |||
1209 | PyErr_SetObject(errtype, obj); | |||
1210 | Py_DECREF(obj)do { if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(obj)))); } while (0); | |||
1211 | SWIG_PYTHON_THREAD_END_BLOCK; | |||
1212 | } | |||
1213 | ||||
1214 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
1215 | SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { | |||
1216 | SWIG_PYTHON_THREAD_BEGIN_BLOCK; | |||
1217 | PyErr_SetString(errtype, msg); | |||
1218 | SWIG_PYTHON_THREAD_END_BLOCK; | |||
1219 | } | |||
1220 | ||||
1221 | #define SWIG_Python_Raise(obj, type, desc)SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) | |||
1222 | ||||
1223 | /* Set a constant value */ | |||
1224 | ||||
1225 | #if defined(SWIGPYTHON_BUILTIN) | |||
1226 | ||||
1227 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
1228 | SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { | |||
1229 | PyObject *s = PyString_InternFromString(key); | |||
1230 | PyList_Append(seq, s); | |||
1231 | Py_DECREF(s)do { if ( --((PyObject*)(s))->ob_refcnt != 0) ; else ( (*( ((PyObject*)((PyObject *)(s)))->ob_type)->tp_dealloc)(( PyObject *)((PyObject *)(s)))); } while (0); | |||
1232 | } | |||
1233 | ||||
1234 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
1235 | SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { | |||
1236 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02030000 | |||
1237 | PyDict_SetItemString(d, (char *)name, obj); | |||
1238 | #else | |||
1239 | PyDict_SetItemString(d, name, obj); | |||
1240 | #endif | |||
1241 | Py_DECREF(obj)do { if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(obj)))); } while (0); | |||
1242 | if (public_interface) | |||
1243 | SwigPyBuiltin_AddPublicSymbol(public_interface, name); | |||
1244 | } | |||
1245 | ||||
1246 | #else | |||
1247 | ||||
1248 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
1249 | SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { | |||
1250 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02030000 | |||
1251 | PyDict_SetItemString(d, (char *)name, obj); | |||
1252 | #else | |||
1253 | PyDict_SetItemString(d, name, obj); | |||
1254 | #endif | |||
1255 | Py_DECREF(obj)do { if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(obj)))); } while (0); | |||
1256 | } | |||
1257 | ||||
1258 | #endif | |||
1259 | ||||
1260 | /* Append a value to the result obj */ | |||
1261 | ||||
1262 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject* | |||
1263 | SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { | |||
1264 | #if !defined(SWIG_PYTHON_OUTPUT_TUPLE) | |||
1265 | if (!result) { | |||
1266 | result = obj; | |||
1267 | } else if (result == Py_None(&_Py_NoneStruct)) { | |||
1268 | Py_DECREF(result)do { if ( --((PyObject*)(result))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(result)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(result)))); } while (0); | |||
1269 | result = obj; | |||
1270 | } else { | |||
1271 | if (!PyList_Check(result)((((((PyObject*)(result))->ob_type))->tp_flags & (( 1L<<25))) != 0)) { | |||
1272 | PyObject *o2 = result; | |||
1273 | result = PyList_New(1); | |||
1274 | PyList_SetItem(result, 0, o2); | |||
1275 | } | |||
1276 | PyList_Append(result,obj); | |||
1277 | Py_DECREF(obj)do { if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(obj)))); } while (0); | |||
1278 | } | |||
1279 | return result; | |||
1280 | #else | |||
1281 | PyObject* o2; | |||
1282 | PyObject* o3; | |||
1283 | if (!result) { | |||
1284 | result = obj; | |||
1285 | } else if (result == Py_None(&_Py_NoneStruct)) { | |||
1286 | Py_DECREF(result)do { if ( --((PyObject*)(result))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(result)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(result)))); } while (0); | |||
1287 | result = obj; | |||
1288 | } else { | |||
1289 | if (!PyTuple_Check(result)((((((PyObject*)(result))->ob_type))->tp_flags & (( 1L<<26))) != 0)) { | |||
1290 | o2 = result; | |||
1291 | result = PyTuple_New(1); | |||
1292 | PyTuple_SET_ITEM(result, 0, o2)(((PyTupleObject *)(result))->ob_item[0] = o2); | |||
1293 | } | |||
1294 | o3 = PyTuple_New(1); | |||
1295 | PyTuple_SET_ITEM(o3, 0, obj)(((PyTupleObject *)(o3))->ob_item[0] = obj); | |||
1296 | o2 = result; | |||
1297 | result = PySequence_Concat(o2, o3); | |||
1298 | Py_DECREF(o2)do { if ( --((PyObject*)(o2))->ob_refcnt != 0) ; else ( (* (((PyObject*)((PyObject *)(o2)))->ob_type)->tp_dealloc) ((PyObject *)((PyObject *)(o2)))); } while (0); | |||
1299 | Py_DECREF(o3)do { if ( --((PyObject*)(o3))->ob_refcnt != 0) ; else ( (* (((PyObject*)((PyObject *)(o3)))->ob_type)->tp_dealloc) ((PyObject *)((PyObject *)(o3)))); } while (0); | |||
1300 | } | |||
1301 | return result; | |||
1302 | #endif | |||
1303 | } | |||
1304 | ||||
1305 | /* Unpack the argument tuple */ | |||
1306 | ||||
1307 | SWIGINTERNstatic __attribute__ ((__unused__)) Py_ssize_t | |||
1308 | SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) | |||
1309 | { | |||
1310 | if (!args) { | |||
1311 | if (!min && !max) { | |||
1312 | return 1; | |||
1313 | } else { | |||
1314 | PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", | |||
1315 | name, (min == max ? "" : "at least "), (int)min); | |||
1316 | return 0; | |||
1317 | } | |||
1318 | } | |||
1319 | if (!PyTuple_Check(args)((((((PyObject*)(args))->ob_type))->tp_flags & ((1L <<26))) != 0)) { | |||
1320 | if (min <= 1 && max >= 1) { | |||
1321 | Py_ssize_t i; | |||
1322 | objs[0] = args; | |||
1323 | for (i = 1; i < max; ++i) { | |||
1324 | objs[i] = 0; | |||
1325 | } | |||
1326 | return 2; | |||
1327 | } | |||
1328 | PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); | |||
1329 | return 0; | |||
1330 | } else { | |||
1331 | Py_ssize_t l = PyTuple_GET_SIZE(args)(((PyVarObject*)(args))->ob_size); | |||
1332 | if (l < min) { | |||
1333 | PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", | |||
1334 | name, (min == max ? "" : "at least "), (int)min, (int)l); | |||
1335 | return 0; | |||
1336 | } else if (l > max) { | |||
1337 | PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", | |||
1338 | name, (min == max ? "" : "at most "), (int)max, (int)l); | |||
1339 | return 0; | |||
1340 | } else { | |||
1341 | Py_ssize_t i; | |||
1342 | for (i = 0; i < l; ++i) { | |||
1343 | objs[i] = PyTuple_GET_ITEM(args, i)(((PyTupleObject *)(args))->ob_item[i]); | |||
1344 | } | |||
1345 | for (; l < max; ++l) { | |||
1346 | objs[l] = 0; | |||
1347 | } | |||
1348 | return i + 1; | |||
1349 | } | |||
1350 | } | |||
1351 | } | |||
1352 | ||||
1353 | /* A functor is a function object with one single object argument */ | |||
1354 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02020000 | |||
1355 | #define SWIG_Python_CallFunctor(functor, obj)PyObject_CallFunctionObjArgs(functor, obj, ((void*)0)); PyObject_CallFunctionObjArgs(functor, obj, NULL((void*)0)); | |||
1356 | #else | |||
1357 | #define SWIG_Python_CallFunctor(functor, obj)PyObject_CallFunctionObjArgs(functor, obj, ((void*)0)); PyObject_CallFunction(functor, "O", obj); | |||
1358 | #endif | |||
1359 | ||||
1360 | /* | |||
1361 | Helper for static pointer initialization for both C and C++ code, for example | |||
1362 | static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); | |||
1363 | */ | |||
1364 | #ifdef __cplusplus | |||
1365 | #define SWIG_STATIC_POINTER(var)var = 0; if (!var) var var | |||
1366 | #else | |||
1367 | #define SWIG_STATIC_POINTER(var)var = 0; if (!var) var var = 0; if (!var) var | |||
1368 | #endif | |||
1369 | ||||
1370 | /* ----------------------------------------------------------------------------- | |||
1371 | * Pointer declarations | |||
1372 | * ----------------------------------------------------------------------------- */ | |||
1373 | ||||
1374 | /* Flags for new pointer objects */ | |||
1375 | #define SWIG_POINTER_NOSHADOW(0x1 << 1) (SWIG_POINTER_OWN0x1 << 1) | |||
1376 | #define SWIG_POINTER_NEW((0x1 << 1) | 0x1) (SWIG_POINTER_NOSHADOW(0x1 << 1) | SWIG_POINTER_OWN0x1) | |||
1377 | ||||
1378 | #define SWIG_POINTER_IMPLICIT_CONV(0x1 << 1) (SWIG_POINTER_DISOWN0x1 << 1) | |||
1379 | ||||
1380 | #define SWIG_BUILTIN_TP_INIT(0x1 << 2) (SWIG_POINTER_OWN0x1 << 2) | |||
1381 | #define SWIG_BUILTIN_INIT((0x1 << 2) | 0x1) (SWIG_BUILTIN_TP_INIT(0x1 << 2) | SWIG_POINTER_OWN0x1) | |||
1382 | ||||
1383 | #ifdef __cplusplus | |||
1384 | extern "C" { | |||
1385 | #endif | |||
1386 | ||||
1387 | /* How to access Py_None */ | |||
1388 | #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) | |||
1389 | # ifndef SWIG_PYTHON_NO_BUILD_NONE | |||
1390 | # ifndef SWIG_PYTHON_BUILD_NONE | |||
1391 | # define SWIG_PYTHON_BUILD_NONE | |||
1392 | # endif | |||
1393 | # endif | |||
1394 | #endif | |||
1395 | ||||
1396 | #ifdef SWIG_PYTHON_BUILD_NONE | |||
1397 | # ifdef Py_None(&_Py_NoneStruct) | |||
1398 | # undef Py_None(&_Py_NoneStruct) | |||
1399 | # define Py_None(&_Py_NoneStruct) SWIG_Py_None() | |||
1400 | # endif | |||
1401 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline PyObject * | |||
1402 | _SWIG_Py_None(void) | |||
1403 | { | |||
1404 | PyObject *none = Py_BuildValue((char*)""); | |||
1405 | Py_DECREF(none)do { if ( --((PyObject*)(none))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(none)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(none)))); } while (0); | |||
1406 | return none; | |||
1407 | } | |||
1408 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1409 | SWIG_Py_None(void) | |||
1410 | { | |||
1411 | static PyObject *SWIG_STATIC_POINTER(none)none = 0; if (!none) none = _SWIG_Py_None(); | |||
1412 | return none; | |||
1413 | } | |||
1414 | #endif | |||
1415 | ||||
1416 | /* The python void return value */ | |||
1417 | ||||
1418 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline PyObject * | |||
1419 | SWIG_Py_Void(void) | |||
1420 | { | |||
1421 | PyObject *none = Py_None(&_Py_NoneStruct); | |||
1422 | Py_INCREF(none)( ((PyObject*)(none))->ob_refcnt++); | |||
1423 | return none; | |||
1424 | } | |||
1425 | ||||
1426 | /* SwigPyClientData */ | |||
1427 | ||||
1428 | typedef struct { | |||
1429 | PyObject *klass; | |||
1430 | PyObject *newraw; | |||
1431 | PyObject *newargs; | |||
1432 | PyObject *destroy; | |||
1433 | int delargs; | |||
1434 | int implicitconv; | |||
1435 | PyTypeObject *pytype; | |||
1436 | } SwigPyClientData; | |||
1437 | ||||
1438 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline int | |||
1439 | SWIG_Python_CheckImplicit(swig_type_info *ty) | |||
1440 | { | |||
1441 | SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; | |||
1442 | return data ? data->implicitconv : 0; | |||
1443 | } | |||
1444 | ||||
1445 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline PyObject * | |||
1446 | SWIG_Python_ExceptionType(swig_type_info *desc) { | |||
1447 | SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; | |||
1448 | PyObject *klass = data ? data->klass : 0; | |||
1449 | return (klass ? klass : PyExc_RuntimeError); | |||
1450 | } | |||
1451 | ||||
1452 | ||||
1453 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) SwigPyClientData * | |||
1454 | SwigPyClientData_New(PyObject* obj) | |||
1455 | { | |||
1456 | if (!obj) { | |||
1457 | return 0; | |||
1458 | } else { | |||
1459 | SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); | |||
1460 | /* the klass element */ | |||
1461 | data->klass = obj; | |||
1462 | Py_INCREF(data->klass)( ((PyObject*)(data->klass))->ob_refcnt++); | |||
1463 | /* the newraw method and newargs arguments used to create a new raw instance */ | |||
1464 | if (PyClass_Check(obj)((obj)->ob_type == &PyClass_Type)) { | |||
1465 | data->newraw = 0; | |||
1466 | data->newargs = obj; | |||
1467 | Py_INCREF(obj)( ((PyObject*)(obj))->ob_refcnt++); | |||
1468 | } else { | |||
1469 | #if (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000) | |||
1470 | data->newraw = 0; | |||
1471 | #else | |||
1472 | data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); | |||
1473 | #endif | |||
1474 | if (data->newraw) { | |||
1475 | Py_INCREF(data->newraw)( ((PyObject*)(data->newraw))->ob_refcnt++); | |||
1476 | data->newargs = PyTuple_New(1); | |||
1477 | PyTuple_SetItem(data->newargs, 0, obj); | |||
1478 | } else { | |||
1479 | data->newargs = obj; | |||
1480 | } | |||
1481 | Py_INCREF(data->newargs)( ((PyObject*)(data->newargs))->ob_refcnt++); | |||
1482 | } | |||
1483 | /* the destroy method, aka as the C++ delete method */ | |||
1484 | data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); | |||
1485 | if (PyErr_Occurred()) { | |||
1486 | PyErr_Clear(); | |||
1487 | data->destroy = 0; | |||
1488 | } | |||
1489 | if (data->destroy) { | |||
1490 | int flags; | |||
1491 | Py_INCREF(data->destroy)( ((PyObject*)(data->destroy))->ob_refcnt++); | |||
1492 | flags = PyCFunction_GET_FLAGS(data->destroy)(((PyCFunctionObject *)data->destroy) -> m_ml -> ml_flags ); | |||
1493 | #ifdef METH_O0x0008 | |||
1494 | data->delargs = !(flags & (METH_O0x0008)); | |||
1495 | #else | |||
1496 | data->delargs = 0; | |||
1497 | #endif | |||
1498 | } else { | |||
1499 | data->delargs = 0; | |||
1500 | } | |||
1501 | data->implicitconv = 0; | |||
1502 | data->pytype = 0; | |||
1503 | return data; | |||
1504 | } | |||
1505 | } | |||
1506 | ||||
1507 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
1508 | SwigPyClientData_Del(SwigPyClientData *data) { | |||
1509 | Py_XDECREF(data->newraw)do { if ((data->newraw) == ((void*)0)) ; else do { if ( -- ((PyObject*)(data->newraw))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(data->newraw)))->ob_type)-> tp_dealloc)((PyObject *)((PyObject *)(data->newraw)))); } while (0); } while (0); | |||
1510 | Py_XDECREF(data->newargs)do { if ((data->newargs) == ((void*)0)) ; else do { if ( -- ((PyObject*)(data->newargs))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(data->newargs)))->ob_type)-> tp_dealloc)((PyObject *)((PyObject *)(data->newargs)))); } while (0); } while (0); | |||
1511 | Py_XDECREF(data->destroy)do { if ((data->destroy) == ((void*)0)) ; else do { if ( -- ((PyObject*)(data->destroy))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(data->destroy)))->ob_type)-> tp_dealloc)((PyObject *)((PyObject *)(data->destroy)))); } while (0); } while (0); | |||
1512 | } | |||
1513 | ||||
1514 | /* =============== SwigPyObject =====================*/ | |||
1515 | ||||
1516 | typedef struct { | |||
1517 | PyObject_HEADPy_ssize_t ob_refcnt; struct _typeobject *ob_type; | |||
1518 | void *ptr; | |||
1519 | swig_type_info *ty; | |||
1520 | int own; | |||
1521 | PyObject *next; | |||
1522 | #ifdef SWIGPYTHON_BUILTIN | |||
1523 | PyObject *dict; | |||
1524 | #endif | |||
1525 | } SwigPyObject; | |||
1526 | ||||
1527 | ||||
1528 | #ifdef SWIGPYTHON_BUILTIN | |||
1529 | ||||
1530 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1531 | SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)args __attribute__ ((__unused__))) | |||
1532 | { | |||
1533 | SwigPyObject *sobj = (SwigPyObject *)v; | |||
1534 | ||||
1535 | if (!sobj->dict) | |||
1536 | sobj->dict = PyDict_New(); | |||
1537 | ||||
1538 | Py_INCREF(sobj->dict)( ((PyObject*)(sobj->dict))->ob_refcnt++); | |||
1539 | return sobj->dict; | |||
1540 | } | |||
1541 | ||||
1542 | #endif | |||
1543 | ||||
1544 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1545 | SwigPyObject_long(SwigPyObject *v) | |||
1546 | { | |||
1547 | return PyLong_FromVoidPtr(v->ptr); | |||
1548 | } | |||
1549 | ||||
1550 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1551 | SwigPyObject_format(const char* fmt, SwigPyObject *v) | |||
1552 | { | |||
1553 | PyObject *res = NULL((void*)0); | |||
1554 | PyObject *args = PyTuple_New(1); | |||
1555 | if (args) { | |||
1556 | if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { | |||
1557 | PyObject *ofmt = SWIG_Python_str_FromChar(fmt); | |||
1558 | if (ofmt) { | |||
1559 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
1560 | res = PyUnicode_FormatPyUnicodeUCS4_Format(ofmt,args); | |||
1561 | #else | |||
1562 | res = PyString_Format(ofmt,args); | |||
1563 | #endif | |||
1564 | Py_DECREF(ofmt)do { if ( --((PyObject*)(ofmt))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(ofmt)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(ofmt)))); } while (0); | |||
1565 | } | |||
1566 | Py_DECREF(args)do { if ( --((PyObject*)(args))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(args)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(args)))); } while (0); | |||
1567 | } | |||
1568 | } | |||
1569 | return res; | |||
1570 | } | |||
1571 | ||||
1572 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1573 | SwigPyObject_oct(SwigPyObject *v) | |||
1574 | { | |||
1575 | return SwigPyObject_format("%o",v); | |||
1576 | } | |||
1577 | ||||
1578 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1579 | SwigPyObject_hex(SwigPyObject *v) | |||
1580 | { | |||
1581 | return SwigPyObject_format("%x",v); | |||
1582 | } | |||
1583 | ||||
1584 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1585 | #ifdef METH_NOARGS0x0004 | |||
1586 | SwigPyObject_repr(SwigPyObject *v) | |||
1587 | #else | |||
1588 | SwigPyObject_repr(SwigPyObject *v, PyObject *args) | |||
1589 | #endif | |||
1590 | { | |||
1591 | const char *name = SWIG_TypePrettyName(v->ty); | |||
1592 | PyObject *repr = SWIG_Python_str_FromFormatPyString_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v); | |||
1593 | if (v->next) { | |||
1594 | # ifdef METH_NOARGS0x0004 | |||
1595 | PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); | |||
1596 | # else | |||
1597 | PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); | |||
1598 | # endif | |||
1599 | # if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
1600 | PyObject *joined = PyUnicode_ConcatPyUnicodeUCS4_Concat(repr, nrep); | |||
1601 | Py_DecRef(repr); | |||
1602 | Py_DecRef(nrep); | |||
1603 | repr = joined; | |||
1604 | # else | |||
1605 | PyString_ConcatAndDel(&repr,nrep); | |||
1606 | # endif | |||
1607 | } | |||
1608 | return repr; | |||
1609 | } | |||
1610 | ||||
1611 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
1612 | SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) | |||
1613 | { | |||
1614 | void *i = v->ptr; | |||
1615 | void *j = w->ptr; | |||
1616 | return (i < j) ? -1 : ((i > j) ? 1 : 0); | |||
1617 | } | |||
1618 | ||||
1619 | /* Added for Python 3.x, would it also be useful for Python 2.x? */ | |||
1620 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject* | |||
1621 | SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) | |||
1622 | { | |||
1623 | PyObject* res; | |||
1624 | if( op != Py_EQ2 && op != Py_NE3 ) { | |||
1625 | Py_INCREF(Py_NotImplemented)( ((PyObject*)((&_Py_NotImplementedStruct)))->ob_refcnt ++); | |||
1626 | return Py_NotImplemented(&_Py_NotImplementedStruct); | |||
1627 | } | |||
1628 | res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ2) ? 1 : 0); | |||
1629 | return res; | |||
1630 | } | |||
1631 | ||||
1632 | ||||
1633 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyTypeObject* SwigPyObject_TypeOnce(void); | |||
1634 | ||||
1635 | #ifdef SWIGPYTHON_BUILTIN | |||
1636 | static swig_type_info *SwigPyObject_stype = 0; | |||
1637 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyTypeObject* | |||
1638 | SwigPyObject_type(void) { | |||
1639 | SwigPyClientData *cd; | |||
1640 | assert(SwigPyObject_stype)((SwigPyObject_stype) ? (void) (0) : __assert_fail ("SwigPyObject_stype" , "ddc_swig_wrap.c", 1640, __PRETTY_FUNCTION__)); | |||
1641 | cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; | |||
1642 | assert(cd)((cd) ? (void) (0) : __assert_fail ("cd", "ddc_swig_wrap.c", 1642 , __PRETTY_FUNCTION__)); | |||
1643 | assert(cd->pytype)((cd->pytype) ? (void) (0) : __assert_fail ("cd->pytype" , "ddc_swig_wrap.c", 1643, __PRETTY_FUNCTION__)); | |||
1644 | return cd->pytype; | |||
1645 | } | |||
1646 | #else | |||
1647 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyTypeObject* | |||
1648 | SwigPyObject_type(void) { | |||
1649 | static PyTypeObject *SWIG_STATIC_POINTER(type)type = 0; if (!type) type = SwigPyObject_TypeOnce(); | |||
1650 | return type; | |||
1651 | } | |||
1652 | #endif | |||
1653 | ||||
1654 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline int | |||
1655 | SwigPyObject_Check(PyObject *op) { | |||
1656 | #ifdef SWIGPYTHON_BUILTIN | |||
1657 | PyTypeObject *target_tp = SwigPyObject_type(); | |||
1658 | if (PyType_IsSubtype(op->ob_type, target_tp)) | |||
1659 | return 1; | |||
1660 | return (strcmp(op->ob_type->tp_name, "SwigPyObject")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (op->ob_type->tp_name) && __builtin_constant_p ("SwigPyObject") && (__s1_len = strlen (op->ob_type ->tp_name), __s2_len = strlen ("SwigPyObject"), (!((size_t )(const void *)((op->ob_type->tp_name) + 1) - (size_t)( const void *)(op->ob_type->tp_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("SwigPyObject") + 1 ) - (size_t)(const void *)("SwigPyObject") == 1) || __s2_len >= 4)) ? __builtin_strcmp (op->ob_type->tp_name, "SwigPyObject" ) : (__builtin_constant_p (op->ob_type->tp_name) && ((size_t)(const void *)((op->ob_type->tp_name) + 1) - ( size_t)(const void *)(op->ob_type->tp_name) == 1) && (__s1_len = strlen (op->ob_type->tp_name), __s1_len < 4) ? (__builtin_constant_p ("SwigPyObject") && ((size_t )(const void *)(("SwigPyObject") + 1) - (size_t)(const void * )("SwigPyObject") == 1) ? __builtin_strcmp (op->ob_type-> tp_name, "SwigPyObject") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("SwigPyObject" ); int __result = (((const unsigned char *) (const char *) (op ->ob_type->tp_name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (op->ob_type->tp_name))[1] - __s2[1] ); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (op->ob_type-> tp_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (op ->ob_type->tp_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("SwigPyObject") && ((size_t)( const void *)(("SwigPyObject") + 1) - (size_t)(const void *)( "SwigPyObject") == 1) && (__s2_len = strlen ("SwigPyObject" ), __s2_len < 4) ? (__builtin_constant_p (op->ob_type-> tp_name) && ((size_t)(const void *)((op->ob_type-> tp_name) + 1) - (size_t)(const void *)(op->ob_type->tp_name ) == 1) ? __builtin_strcmp (op->ob_type->tp_name, "SwigPyObject" ) : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (op->ob_type->tp_name); int __result = (((const unsigned char *) (const char *) ("SwigPyObject")) [0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("SwigPyObject" ))[1] - __s2[1]); if (__s2_len > 1 && __result == 0 ) { __result = (((const unsigned char *) (const char *) ("SwigPyObject" ))[2] - __s2[2]); if (__s2_len > 2 && __result == 0 ) __result = (((const unsigned char *) (const char *) ("SwigPyObject" ))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (op-> ob_type->tp_name, "SwigPyObject")))); }) == 0); | |||
1661 | #else | |||
1662 | return (Py_TYPE(op)(((PyObject*)(op))->ob_type) == SwigPyObject_type()) | |||
1663 | || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ((((PyObject*)(op))->ob_type)->tp_name) && __builtin_constant_p ("SwigPyObject") && (__s1_len = strlen ((((PyObject* )(op))->ob_type)->tp_name), __s2_len = strlen ("SwigPyObject" ), (!((size_t)(const void *)(((((PyObject*)(op))->ob_type) ->tp_name) + 1) - (size_t)(const void *)((((PyObject*)(op) )->ob_type)->tp_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("SwigPyObject") + 1) - (size_t)(const void *)("SwigPyObject") == 1) || __s2_len >= 4)) ? __builtin_strcmp ((((PyObject*)(op))->ob_type)->tp_name, "SwigPyObject" ) : (__builtin_constant_p ((((PyObject*)(op))->ob_type)-> tp_name) && ((size_t)(const void *)(((((PyObject*)(op ))->ob_type)->tp_name) + 1) - (size_t)(const void *)((( (PyObject*)(op))->ob_type)->tp_name) == 1) && ( __s1_len = strlen ((((PyObject*)(op))->ob_type)->tp_name ), __s1_len < 4) ? (__builtin_constant_p ("SwigPyObject") && ((size_t)(const void *)(("SwigPyObject") + 1) - (size_t)(const void *)("SwigPyObject") == 1) ? __builtin_strcmp ((((PyObject *)(op))->ob_type)->tp_name, "SwigPyObject") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("SwigPyObject"); int __result = (((const unsigned char *) (const char *) ((((PyObject*)(op))->ob_type)->tp_name ))[0] - __s2[0]); if (__s1_len > 0 && __result == 0 ) { __result = (((const unsigned char *) (const char *) ((((PyObject *)(op))->ob_type)->tp_name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ((((PyObject*)(op))->ob_type)-> tp_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (( ((PyObject*)(op))->ob_type)->tp_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("SwigPyObject") && ((size_t)(const void *)(("SwigPyObject") + 1) - (size_t)(const void *)("SwigPyObject") == 1) && (__s2_len = strlen ( "SwigPyObject"), __s2_len < 4) ? (__builtin_constant_p ((( (PyObject*)(op))->ob_type)->tp_name) && ((size_t )(const void *)(((((PyObject*)(op))->ob_type)->tp_name) + 1) - (size_t)(const void *)((((PyObject*)(op))->ob_type )->tp_name) == 1) ? __builtin_strcmp ((((PyObject*)(op))-> ob_type)->tp_name, "SwigPyObject") : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ((((PyObject*)(op))->ob_type)->tp_name); int __result = (((const unsigned char *) (const char *) ("SwigPyObject"))[0 ] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("SwigPyObject" ))[1] - __s2[1]); if (__s2_len > 1 && __result == 0 ) { __result = (((const unsigned char *) (const char *) ("SwigPyObject" ))[2] - __s2[2]); if (__s2_len > 2 && __result == 0 ) __result = (((const unsigned char *) (const char *) ("SwigPyObject" ))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp ((((PyObject *)(op))->ob_type)->tp_name, "SwigPyObject")))); }) == 0); | |||
1664 | #endif | |||
1665 | } | |||
1666 | ||||
1667 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1668 | SwigPyObject_New(void *ptr, swig_type_info *ty, int own); | |||
1669 | ||||
1670 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
1671 | SwigPyObject_dealloc(PyObject *v) | |||
1672 | { | |||
1673 | SwigPyObject *sobj = (SwigPyObject *) v; | |||
1674 | PyObject *next = sobj->next; | |||
1675 | if (sobj->own == SWIG_POINTER_OWN0x1) { | |||
1676 | swig_type_info *ty = sobj->ty; | |||
1677 | SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; | |||
1678 | PyObject *destroy = data ? data->destroy : 0; | |||
1679 | if (destroy) { | |||
1680 | /* destroy is always a VARARGS method */ | |||
1681 | PyObject *res; | |||
1682 | ||||
1683 | /* PyObject_CallFunction() has the potential to silently drop | |||
1684 | the active active exception. In cases of unnamed temporary | |||
1685 | variable or where we just finished iterating over a generator | |||
1686 | StopIteration will be active right now, and this needs to | |||
1687 | remain true upon return from SwigPyObject_dealloc. So save | |||
1688 | and restore. */ | |||
1689 | ||||
1690 | PyObject *val = NULL((void*)0), *type = NULL((void*)0), *tb = NULL((void*)0); | |||
1691 | PyErr_Fetch(&val, &type, &tb); | |||
1692 | ||||
1693 | if (data->delargs) { | |||
1694 | /* we need to create a temporary object to carry the destroy operation */ | |||
1695 | PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); | |||
1696 | res = SWIG_Python_CallFunctor(destroy, tmp)PyObject_CallFunctionObjArgs(destroy, tmp, ((void*)0));; | |||
1697 | Py_DECREF(tmp)do { if ( --((PyObject*)(tmp))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(tmp)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(tmp)))); } while (0); | |||
1698 | } else { | |||
1699 | PyCFunction meth = PyCFunction_GET_FUNCTION(destroy)(((PyCFunctionObject *)destroy) -> m_ml -> ml_meth); | |||
1700 | PyObject *mself = PyCFunction_GET_SELF(destroy)(((PyCFunctionObject *)destroy) -> m_self); | |||
1701 | res = ((*meth)(mself, v)); | |||
1702 | } | |||
1703 | if (!res) | |||
1704 | PyErr_WriteUnraisable(destroy); | |||
1705 | ||||
1706 | PyErr_Restore(val, type, tb); | |||
1707 | ||||
1708 | Py_XDECREF(res)do { if ((res) == ((void*)0)) ; else do { if ( --((PyObject*) (res))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(res)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(res)))); } while (0); } while (0); | |||
1709 | } | |||
1710 | #if !defined(SWIG_PYTHON_SILENT_MEMLEAK) | |||
1711 | else { | |||
1712 | const char *name = SWIG_TypePrettyName(ty); | |||
1713 | printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); | |||
1714 | } | |||
1715 | #endif | |||
1716 | } | |||
1717 | Py_XDECREF(next)do { if ((next) == ((void*)0)) ; else do { if ( --((PyObject* )(next))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(next)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(next)))); } while (0); } while (0); | |||
1718 | PyObject_DELPyObject_Free(v); | |||
1719 | } | |||
1720 | ||||
1721 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject* | |||
1722 | SwigPyObject_append(PyObject* v, PyObject* next) | |||
1723 | { | |||
1724 | SwigPyObject *sobj = (SwigPyObject *) v; | |||
1725 | #ifndef METH_O0x0008 | |||
1726 | PyObject *tmp = 0; | |||
1727 | if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL((void*)0); | |||
1728 | next = tmp; | |||
1729 | #endif | |||
1730 | if (!SwigPyObject_Check(next)) { | |||
1731 | PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); | |||
1732 | return NULL((void*)0); | |||
1733 | } | |||
1734 | sobj->next = next; | |||
1735 | Py_INCREF(next)( ((PyObject*)(next))->ob_refcnt++); | |||
1736 | return SWIG_Py_Void(); | |||
1737 | } | |||
1738 | ||||
1739 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject* | |||
1740 | #ifdef METH_NOARGS0x0004 | |||
1741 | SwigPyObject_next(PyObject* v) | |||
1742 | #else | |||
1743 | SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)args __attribute__ ((__unused__))) | |||
1744 | #endif | |||
1745 | { | |||
1746 | SwigPyObject *sobj = (SwigPyObject *) v; | |||
1747 | if (sobj->next) { | |||
1748 | Py_INCREF(sobj->next)( ((PyObject*)(sobj->next))->ob_refcnt++); | |||
1749 | return sobj->next; | |||
1750 | } else { | |||
1751 | return SWIG_Py_Void(); | |||
1752 | } | |||
1753 | } | |||
1754 | ||||
1755 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject* | |||
1756 | #ifdef METH_NOARGS0x0004 | |||
1757 | SwigPyObject_disown(PyObject *v) | |||
1758 | #else | |||
1759 | SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)args __attribute__ ((__unused__))) | |||
1760 | #endif | |||
1761 | { | |||
1762 | SwigPyObject *sobj = (SwigPyObject *)v; | |||
1763 | sobj->own = 0; | |||
1764 | return SWIG_Py_Void(); | |||
1765 | } | |||
1766 | ||||
1767 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject* | |||
1768 | #ifdef METH_NOARGS0x0004 | |||
1769 | SwigPyObject_acquire(PyObject *v) | |||
1770 | #else | |||
1771 | SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)args __attribute__ ((__unused__))) | |||
1772 | #endif | |||
1773 | { | |||
1774 | SwigPyObject *sobj = (SwigPyObject *)v; | |||
1775 | sobj->own = SWIG_POINTER_OWN0x1; | |||
1776 | return SWIG_Py_Void(); | |||
1777 | } | |||
1778 | ||||
1779 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject* | |||
1780 | SwigPyObject_own(PyObject *v, PyObject *args) | |||
1781 | { | |||
1782 | PyObject *val = 0; | |||
1783 | #if (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000) | |||
1784 | if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) | |||
1785 | #elif (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02050000) | |||
1786 | if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) | |||
1787 | #else | |||
1788 | if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) | |||
1789 | #endif | |||
1790 | { | |||
1791 | return NULL((void*)0); | |||
1792 | } | |||
1793 | else | |||
1794 | { | |||
1795 | SwigPyObject *sobj = (SwigPyObject *)v; | |||
1796 | PyObject *obj = PyBool_FromLong(sobj->own); | |||
1797 | if (val) { | |||
1798 | #ifdef METH_NOARGS0x0004 | |||
1799 | if (PyObject_IsTrue(val)) { | |||
1800 | SwigPyObject_acquire(v); | |||
1801 | } else { | |||
1802 | SwigPyObject_disown(v); | |||
1803 | } | |||
1804 | #else | |||
1805 | if (PyObject_IsTrue(val)) { | |||
1806 | SwigPyObject_acquire(v,args); | |||
1807 | } else { | |||
1808 | SwigPyObject_disown(v,args); | |||
1809 | } | |||
1810 | #endif | |||
1811 | } | |||
1812 | return obj; | |||
1813 | } | |||
1814 | } | |||
1815 | ||||
1816 | #ifdef METH_O0x0008 | |||
1817 | static PyMethodDef | |||
1818 | swigobject_methods[] = { | |||
1819 | {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS0x0004, (char *)"releases ownership of the pointer"}, | |||
1820 | {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS0x0004, (char *)"acquires ownership of the pointer"}, | |||
1821 | {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS0x0001, (char *)"returns/sets ownership of the pointer"}, | |||
1822 | {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O0x0008, (char *)"appends another 'this' object"}, | |||
1823 | {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS0x0004, (char *)"returns the next 'this' object"}, | |||
1824 | {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS0x0004, (char *)"returns object representation"}, | |||
1825 | {0, 0, 0, 0} | |||
1826 | }; | |||
1827 | #else | |||
1828 | static PyMethodDef | |||
1829 | swigobject_methods[] = { | |||
1830 | {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS0x0001, (char *)"releases ownership of the pointer"}, | |||
1831 | {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS0x0001, (char *)"acquires ownership of the pointer"}, | |||
1832 | {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS0x0001, (char *)"returns/sets ownership of the pointer"}, | |||
1833 | {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS0x0001, (char *)"appends another 'this' object"}, | |||
1834 | {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS0x0001, (char *)"returns the next 'this' object"}, | |||
1835 | {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS0x0001, (char *)"returns object representation"}, | |||
1836 | {0, 0, 0, 0} | |||
1837 | }; | |||
1838 | #endif | |||
1839 | ||||
1840 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000 | |||
1841 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject * | |||
1842 | SwigPyObject_getattr(SwigPyObject *sobj,char *name) | |||
1843 | { | |||
1844 | return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); | |||
1845 | } | |||
1846 | #endif | |||
1847 | ||||
1848 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyTypeObject* | |||
1849 | SwigPyObject_TypeOnce(void) { | |||
1850 | static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; | |||
1851 | ||||
1852 | static PyNumberMethods SwigPyObject_as_number = { | |||
1853 | (binaryfunc)0, /*nb_add*/ | |||
1854 | (binaryfunc)0, /*nb_subtract*/ | |||
1855 | (binaryfunc)0, /*nb_multiply*/ | |||
1856 | /* nb_divide removed in Python 3 */ | |||
1857 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x03000000 | |||
1858 | (binaryfunc)0, /*nb_divide*/ | |||
1859 | #endif | |||
1860 | (binaryfunc)0, /*nb_remainder*/ | |||
1861 | (binaryfunc)0, /*nb_divmod*/ | |||
1862 | (ternaryfunc)0,/*nb_power*/ | |||
1863 | (unaryfunc)0, /*nb_negative*/ | |||
1864 | (unaryfunc)0, /*nb_positive*/ | |||
1865 | (unaryfunc)0, /*nb_absolute*/ | |||
1866 | (inquiry)0, /*nb_nonzero*/ | |||
1867 | 0, /*nb_invert*/ | |||
1868 | 0, /*nb_lshift*/ | |||
1869 | 0, /*nb_rshift*/ | |||
1870 | 0, /*nb_and*/ | |||
1871 | 0, /*nb_xor*/ | |||
1872 | 0, /*nb_or*/ | |||
1873 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x03000000 | |||
1874 | 0, /*nb_coerce*/ | |||
1875 | #endif | |||
1876 | (unaryfunc)SwigPyObject_long, /*nb_int*/ | |||
1877 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x03000000 | |||
1878 | (unaryfunc)SwigPyObject_long, /*nb_long*/ | |||
1879 | #else | |||
1880 | 0, /*nb_reserved*/ | |||
1881 | #endif | |||
1882 | (unaryfunc)0, /*nb_float*/ | |||
1883 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x03000000 | |||
1884 | (unaryfunc)SwigPyObject_oct, /*nb_oct*/ | |||
1885 | (unaryfunc)SwigPyObject_hex, /*nb_hex*/ | |||
1886 | #endif | |||
1887 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03050000 /* 3.5 */ | |||
1888 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ | |||
1889 | #elif PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 /* 3.0 */ | |||
1890 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ | |||
1891 | #elif PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02050000 /* 2.5.0 */ | |||
1892 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ | |||
1893 | #elif PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02020000 /* 2.2.0 */ | |||
1894 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ | |||
1895 | #elif PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02000000 /* 2.0.0 */ | |||
1896 | 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ | |||
1897 | #endif | |||
1898 | }; | |||
1899 | ||||
1900 | static PyTypeObject swigpyobject_type; | |||
1901 | static int type_init = 0; | |||
1902 | if (!type_init) { | |||
1903 | const PyTypeObject tmp = { | |||
1904 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
1905 | PyVarObject_HEAD_INIT(NULL, 0)1, ((void*)0), 0, | |||
1906 | #else | |||
1907 | PyObject_HEAD_INIT(NULL)1, ((void*)0), | |||
1908 | 0, /* ob_size */ | |||
1909 | #endif | |||
1910 | (char *)"SwigPyObject", /* tp_name */ | |||
1911 | sizeof(SwigPyObject), /* tp_basicsize */ | |||
1912 | 0, /* tp_itemsize */ | |||
1913 | (destructor)SwigPyObject_dealloc, /* tp_dealloc */ | |||
1914 | 0, /* tp_print */ | |||
1915 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000 | |||
1916 | (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ | |||
1917 | #else | |||
1918 | (getattrfunc)0, /* tp_getattr */ | |||
1919 | #endif | |||
1920 | (setattrfunc)0, /* tp_setattr */ | |||
1921 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
1922 | 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ | |||
1923 | #else | |||
1924 | (cmpfunc)SwigPyObject_compare, /* tp_compare */ | |||
1925 | #endif | |||
1926 | (reprfunc)SwigPyObject_repr, /* tp_repr */ | |||
1927 | &SwigPyObject_as_number, /* tp_as_number */ | |||
1928 | 0, /* tp_as_sequence */ | |||
1929 | 0, /* tp_as_mapping */ | |||
1930 | (hashfunc)0, /* tp_hash */ | |||
1931 | (ternaryfunc)0, /* tp_call */ | |||
1932 | 0, /* tp_str */ | |||
1933 | PyObject_GenericGetAttr, /* tp_getattro */ | |||
1934 | 0, /* tp_setattro */ | |||
1935 | 0, /* tp_as_buffer */ | |||
1936 | Py_TPFLAGS_DEFAULT( (1L<<0) | (1L<<1) | (1L<<3) | (1L<< 5) | (1L<<6) | (1L<<7) | (1L<<8) | 0 | (1L<< 17) | 0), /* tp_flags */ | |||
1937 | swigobject_doc, /* tp_doc */ | |||
1938 | 0, /* tp_traverse */ | |||
1939 | 0, /* tp_clear */ | |||
1940 | (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ | |||
1941 | 0, /* tp_weaklistoffset */ | |||
1942 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02020000 | |||
1943 | 0, /* tp_iter */ | |||
1944 | 0, /* tp_iternext */ | |||
1945 | swigobject_methods, /* tp_methods */ | |||
1946 | 0, /* tp_members */ | |||
1947 | 0, /* tp_getset */ | |||
1948 | 0, /* tp_base */ | |||
1949 | 0, /* tp_dict */ | |||
1950 | 0, /* tp_descr_get */ | |||
1951 | 0, /* tp_descr_set */ | |||
1952 | 0, /* tp_dictoffset */ | |||
1953 | 0, /* tp_init */ | |||
1954 | 0, /* tp_alloc */ | |||
1955 | 0, /* tp_new */ | |||
1956 | 0, /* tp_free */ | |||
1957 | 0, /* tp_is_gc */ | |||
1958 | 0, /* tp_bases */ | |||
1959 | 0, /* tp_mro */ | |||
1960 | 0, /* tp_cache */ | |||
1961 | 0, /* tp_subclasses */ | |||
1962 | 0, /* tp_weaklist */ | |||
1963 | #endif | |||
1964 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02030000 | |||
1965 | 0, /* tp_del */ | |||
1966 | #endif | |||
1967 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02060000 | |||
1968 | 0, /* tp_version_tag */ | |||
1969 | #endif | |||
1970 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03040000 | |||
1971 | 0, /* tp_finalize */ | |||
1972 | #endif | |||
1973 | #ifdef COUNT_ALLOCS | |||
1974 | 0, /* tp_allocs */ | |||
1975 | 0, /* tp_frees */ | |||
1976 | 0, /* tp_maxalloc */ | |||
1977 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02050000 | |||
1978 | 0, /* tp_prev */ | |||
1979 | #endif | |||
1980 | 0 /* tp_next */ | |||
1981 | #endif | |||
1982 | }; | |||
1983 | swigpyobject_type = tmp; | |||
1984 | type_init = 1; | |||
1985 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000 | |||
1986 | swigpyobject_type.ob_type = &PyType_Type; | |||
1987 | #else | |||
1988 | if (PyType_Ready(&swigpyobject_type) < 0) | |||
1989 | return NULL((void*)0); | |||
1990 | #endif | |||
1991 | } | |||
1992 | return &swigpyobject_type; | |||
1993 | } | |||
1994 | ||||
1995 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
1996 | SwigPyObject_New(void *ptr, swig_type_info *ty, int own) | |||
1997 | { | |||
1998 | SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type())( (SwigPyObject *) PyObject_Init( (PyObject *) PyObject_Malloc ( ( (SwigPyObject_type())->tp_basicsize ) ), (SwigPyObject_type ())) ); | |||
1999 | if (sobj) { | |||
2000 | sobj->ptr = ptr; | |||
2001 | sobj->ty = ty; | |||
2002 | sobj->own = own; | |||
2003 | sobj->next = 0; | |||
2004 | } | |||
2005 | return (PyObject *)sobj; | |||
2006 | } | |||
2007 | ||||
2008 | /* ----------------------------------------------------------------------------- | |||
2009 | * Implements a simple Swig Packed type, and use it instead of string | |||
2010 | * ----------------------------------------------------------------------------- */ | |||
2011 | ||||
2012 | typedef struct { | |||
2013 | PyObject_HEADPy_ssize_t ob_refcnt; struct _typeobject *ob_type; | |||
2014 | void *pack; | |||
2015 | swig_type_info *ty; | |||
2016 | size_t size; | |||
2017 | } SwigPyPacked; | |||
2018 | ||||
2019 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2020 | SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)flags __attribute__ ((__unused__))) | |||
2021 | { | |||
2022 | char result[SWIG_BUFFER_SIZE1024]; | |||
2023 | fputs("<Swig Packed ", fp); | |||
2024 | if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { | |||
2025 | fputs("at ", fp); | |||
2026 | fputs(result, fp); | |||
2027 | } | |||
2028 | fputs(v->ty->name,fp); | |||
2029 | fputs(">", fp); | |||
2030 | return 0; | |||
2031 | } | |||
2032 | ||||
2033 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
2034 | SwigPyPacked_repr(SwigPyPacked *v) | |||
2035 | { | |||
2036 | char result[SWIG_BUFFER_SIZE1024]; | |||
2037 | if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { | |||
2038 | return SWIG_Python_str_FromFormatPyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name); | |||
2039 | } else { | |||
2040 | return SWIG_Python_str_FromFormatPyString_FromFormat("<Swig Packed %s>", v->ty->name); | |||
2041 | } | |||
2042 | } | |||
2043 | ||||
2044 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
2045 | SwigPyPacked_str(SwigPyPacked *v) | |||
2046 | { | |||
2047 | char result[SWIG_BUFFER_SIZE1024]; | |||
2048 | if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ | |||
2049 | return SWIG_Python_str_FromFormatPyString_FromFormat("%s%s", result, v->ty->name); | |||
2050 | } else { | |||
2051 | return SWIG_Python_str_FromChar(v->ty->name); | |||
2052 | } | |||
2053 | } | |||
2054 | ||||
2055 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2056 | SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) | |||
2057 | { | |||
2058 | size_t i = v->size; | |||
2059 | size_t j = w->size; | |||
2060 | int s = (i < j) ? -1 : ((i > j) ? 1 : 0); | |||
2061 | return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size)(__extension__ (__builtin_constant_p (2*v->size) && ((__builtin_constant_p ((char *)v->pack) && strlen ((char *)v->pack) < ((size_t) (2*v->size))) || (__builtin_constant_p ((char *)w->pack) && strlen ((char *)w->pack) < ((size_t) (2*v->size)))) ? __extension__ ({ size_t __s1_len , __s2_len; (__builtin_constant_p ((char *)v->pack) && __builtin_constant_p ((char *)w->pack) && (__s1_len = strlen ((char *)v->pack), __s2_len = strlen ((char *)w-> pack), (!((size_t)(const void *)(((char *)v->pack) + 1) - ( size_t)(const void *)((char *)v->pack) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(((char *)w->pack) + 1) - (size_t)(const void *)((char *)w->pack) == 1) || __s2_len >= 4)) ? __builtin_strcmp ((char *)v->pack, (char *)w-> pack) : (__builtin_constant_p ((char *)v->pack) && ((size_t)(const void *)(((char *)v->pack) + 1) - (size_t) (const void *)((char *)v->pack) == 1) && (__s1_len = strlen ((char *)v->pack), __s1_len < 4) ? (__builtin_constant_p ((char *)w->pack) && ((size_t)(const void *)(((char *)w->pack) + 1) - (size_t)(const void *)((char *)w->pack ) == 1) ? __builtin_strcmp ((char *)v->pack, (char *)w-> pack) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ((char *)w->pack); int __result = ( ((const unsigned char *) (const char *) ((char *)v->pack)) [0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ((char *)v->pack))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ((char *)v->pack))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ((char *)v->pack))[3] - __s2[3]); } } __result ; }))) : (__builtin_constant_p ((char *)w->pack) && ((size_t)(const void *)(((char *)w->pack) + 1) - (size_t) (const void *)((char *)w->pack) == 1) && (__s2_len = strlen ((char *)w->pack), __s2_len < 4) ? (__builtin_constant_p ((char *)v->pack) && ((size_t)(const void *)(((char *)v->pack) + 1) - (size_t)(const void *)((char *)v->pack ) == 1) ? __builtin_strcmp ((char *)v->pack, (char *)w-> pack) : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ((char *)v->pack); int __result = (((const unsigned char *) (const char *) ((char *)w->pack ))[0] - __s2[0]); if (__s2_len > 0 && __result == 0 ) { __result = (((const unsigned char *) (const char *) ((char *)w->pack))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ((char *)w->pack))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ((char *)w->pack))[3] - __s2[3]); } } __result ; }))) : __builtin_strcmp ((char *)v->pack, (char *)w-> pack)))); }) : strncmp ((char *)v->pack, (char *)w->pack , 2*v->size))); | |||
2062 | } | |||
2063 | ||||
2064 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyTypeObject* SwigPyPacked_TypeOnce(void); | |||
2065 | ||||
2066 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyTypeObject* | |||
2067 | SwigPyPacked_type(void) { | |||
2068 | static PyTypeObject *SWIG_STATIC_POINTER(type)type = 0; if (!type) type = SwigPyPacked_TypeOnce(); | |||
2069 | return type; | |||
2070 | } | |||
2071 | ||||
2072 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline int | |||
2073 | SwigPyPacked_Check(PyObject *op) { | |||
2074 | return ((op)->ob_type == SwigPyPacked_TypeOnce()) | |||
2075 | || (strcmp((op)->ob_type->tp_name,"SwigPyPacked")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ((op)->ob_type->tp_name) && __builtin_constant_p ("SwigPyPacked") && (__s1_len = strlen ((op)->ob_type ->tp_name), __s2_len = strlen ("SwigPyPacked"), (!((size_t )(const void *)(((op)->ob_type->tp_name) + 1) - (size_t )(const void *)((op)->ob_type->tp_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("SwigPyPacked" ) + 1) - (size_t)(const void *)("SwigPyPacked") == 1) || __s2_len >= 4)) ? __builtin_strcmp ((op)->ob_type->tp_name, "SwigPyPacked" ) : (__builtin_constant_p ((op)->ob_type->tp_name) && ((size_t)(const void *)(((op)->ob_type->tp_name) + 1) - (size_t)(const void *)((op)->ob_type->tp_name) == 1) && (__s1_len = strlen ((op)->ob_type->tp_name), __s1_len < 4) ? (__builtin_constant_p ("SwigPyPacked") && ((size_t )(const void *)(("SwigPyPacked") + 1) - (size_t)(const void * )("SwigPyPacked") == 1) ? __builtin_strcmp ((op)->ob_type-> tp_name, "SwigPyPacked") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("SwigPyPacked" ); int __result = (((const unsigned char *) (const char *) (( op)->ob_type->tp_name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ((op)->ob_type->tp_name))[1] - __s2[ 1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ((op)->ob_type ->tp_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (( op)->ob_type->tp_name))[3] - __s2[3]); } } __result; }) )) : (__builtin_constant_p ("SwigPyPacked") && ((size_t )(const void *)(("SwigPyPacked") + 1) - (size_t)(const void * )("SwigPyPacked") == 1) && (__s2_len = strlen ("SwigPyPacked" ), __s2_len < 4) ? (__builtin_constant_p ((op)->ob_type ->tp_name) && ((size_t)(const void *)(((op)->ob_type ->tp_name) + 1) - (size_t)(const void *)((op)->ob_type-> tp_name) == 1) ? __builtin_strcmp ((op)->ob_type->tp_name , "SwigPyPacked") : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ((op)->ob_type-> tp_name); int __result = (((const unsigned char *) (const char *) ("SwigPyPacked"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("SwigPyPacked"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("SwigPyPacked"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("SwigPyPacked"))[3] - __s2[3]); } } __result ; }))) : __builtin_strcmp ((op)->ob_type->tp_name, "SwigPyPacked" )))); }) == 0); | |||
2076 | } | |||
2077 | ||||
2078 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
2079 | SwigPyPacked_dealloc(PyObject *v) | |||
2080 | { | |||
2081 | if (SwigPyPacked_Check(v)) { | |||
2082 | SwigPyPacked *sobj = (SwigPyPacked *) v; | |||
2083 | free(sobj->pack); | |||
2084 | } | |||
2085 | PyObject_DELPyObject_Free(v); | |||
2086 | } | |||
2087 | ||||
2088 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyTypeObject* | |||
2089 | SwigPyPacked_TypeOnce(void) { | |||
2090 | static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; | |||
2091 | static PyTypeObject swigpypacked_type; | |||
2092 | static int type_init = 0; | |||
2093 | if (!type_init) { | |||
2094 | const PyTypeObject tmp = { | |||
2095 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0))>=0x03000000 | |||
2096 | PyVarObject_HEAD_INIT(NULL, 0)1, ((void*)0), 0, | |||
2097 | #else | |||
2098 | PyObject_HEAD_INIT(NULL)1, ((void*)0), | |||
2099 | 0, /* ob_size */ | |||
2100 | #endif | |||
2101 | (char *)"SwigPyPacked", /* tp_name */ | |||
2102 | sizeof(SwigPyPacked), /* tp_basicsize */ | |||
2103 | 0, /* tp_itemsize */ | |||
2104 | (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ | |||
2105 | (printfunc)SwigPyPacked_print, /* tp_print */ | |||
2106 | (getattrfunc)0, /* tp_getattr */ | |||
2107 | (setattrfunc)0, /* tp_setattr */ | |||
2108 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0))>=0x03000000 | |||
2109 | 0, /* tp_reserved in 3.0.1 */ | |||
2110 | #else | |||
2111 | (cmpfunc)SwigPyPacked_compare, /* tp_compare */ | |||
2112 | #endif | |||
2113 | (reprfunc)SwigPyPacked_repr, /* tp_repr */ | |||
2114 | 0, /* tp_as_number */ | |||
2115 | 0, /* tp_as_sequence */ | |||
2116 | 0, /* tp_as_mapping */ | |||
2117 | (hashfunc)0, /* tp_hash */ | |||
2118 | (ternaryfunc)0, /* tp_call */ | |||
2119 | (reprfunc)SwigPyPacked_str, /* tp_str */ | |||
2120 | PyObject_GenericGetAttr, /* tp_getattro */ | |||
2121 | 0, /* tp_setattro */ | |||
2122 | 0, /* tp_as_buffer */ | |||
2123 | Py_TPFLAGS_DEFAULT( (1L<<0) | (1L<<1) | (1L<<3) | (1L<< 5) | (1L<<6) | (1L<<7) | (1L<<8) | 0 | (1L<< 17) | 0), /* tp_flags */ | |||
2124 | swigpacked_doc, /* tp_doc */ | |||
2125 | 0, /* tp_traverse */ | |||
2126 | 0, /* tp_clear */ | |||
2127 | 0, /* tp_richcompare */ | |||
2128 | 0, /* tp_weaklistoffset */ | |||
2129 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02020000 | |||
2130 | 0, /* tp_iter */ | |||
2131 | 0, /* tp_iternext */ | |||
2132 | 0, /* tp_methods */ | |||
2133 | 0, /* tp_members */ | |||
2134 | 0, /* tp_getset */ | |||
2135 | 0, /* tp_base */ | |||
2136 | 0, /* tp_dict */ | |||
2137 | 0, /* tp_descr_get */ | |||
2138 | 0, /* tp_descr_set */ | |||
2139 | 0, /* tp_dictoffset */ | |||
2140 | 0, /* tp_init */ | |||
2141 | 0, /* tp_alloc */ | |||
2142 | 0, /* tp_new */ | |||
2143 | 0, /* tp_free */ | |||
2144 | 0, /* tp_is_gc */ | |||
2145 | 0, /* tp_bases */ | |||
2146 | 0, /* tp_mro */ | |||
2147 | 0, /* tp_cache */ | |||
2148 | 0, /* tp_subclasses */ | |||
2149 | 0, /* tp_weaklist */ | |||
2150 | #endif | |||
2151 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02030000 | |||
2152 | 0, /* tp_del */ | |||
2153 | #endif | |||
2154 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02060000 | |||
2155 | 0, /* tp_version_tag */ | |||
2156 | #endif | |||
2157 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03040000 | |||
2158 | 0, /* tp_finalize */ | |||
2159 | #endif | |||
2160 | #ifdef COUNT_ALLOCS | |||
2161 | 0, /* tp_allocs */ | |||
2162 | 0, /* tp_frees */ | |||
2163 | 0, /* tp_maxalloc */ | |||
2164 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02050000 | |||
2165 | 0, /* tp_prev */ | |||
2166 | #endif | |||
2167 | 0 /* tp_next */ | |||
2168 | #endif | |||
2169 | }; | |||
2170 | swigpypacked_type = tmp; | |||
2171 | type_init = 1; | |||
2172 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000 | |||
2173 | swigpypacked_type.ob_type = &PyType_Type; | |||
2174 | #else | |||
2175 | if (PyType_Ready(&swigpypacked_type) < 0) | |||
2176 | return NULL((void*)0); | |||
2177 | #endif | |||
2178 | } | |||
2179 | return &swigpypacked_type; | |||
2180 | } | |||
2181 | ||||
2182 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
2183 | SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) | |||
2184 | { | |||
2185 | SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type())( (SwigPyPacked *) PyObject_Init( (PyObject *) PyObject_Malloc ( ( (SwigPyPacked_type())->tp_basicsize ) ), (SwigPyPacked_type ())) ); | |||
2186 | if (sobj) { | |||
2187 | void *pack = malloc(size); | |||
2188 | if (pack) { | |||
2189 | memcpy(pack, ptr, size); | |||
2190 | sobj->pack = pack; | |||
2191 | sobj->ty = ty; | |||
2192 | sobj->size = size; | |||
2193 | } else { | |||
2194 | PyObject_DELPyObject_Free((PyObject *) sobj); | |||
2195 | sobj = 0; | |||
2196 | } | |||
2197 | } | |||
2198 | return (PyObject *) sobj; | |||
2199 | } | |||
2200 | ||||
2201 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) swig_type_info * | |||
2202 | SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) | |||
2203 | { | |||
2204 | if (SwigPyPacked_Check(obj)) { | |||
2205 | SwigPyPacked *sobj = (SwigPyPacked *)obj; | |||
2206 | if (sobj->size != size) return 0; | |||
2207 | memcpy(ptr, sobj->pack, size); | |||
2208 | return sobj->ty; | |||
2209 | } else { | |||
2210 | return 0; | |||
2211 | } | |||
2212 | } | |||
2213 | ||||
2214 | /* ----------------------------------------------------------------------------- | |||
2215 | * pointers/data manipulation | |||
2216 | * ----------------------------------------------------------------------------- */ | |||
2217 | ||||
2218 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline PyObject * | |||
2219 | _SWIG_This(void) | |||
2220 | { | |||
2221 | return SWIG_Python_str_FromChar("this"); | |||
2222 | } | |||
2223 | ||||
2224 | static PyObject *swig_this = NULL((void*)0); | |||
2225 | ||||
2226 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
2227 | SWIG_This(void) | |||
2228 | { | |||
2229 | if (swig_this == NULL((void*)0)) | |||
2230 | swig_this = _SWIG_This(); | |||
2231 | return swig_this; | |||
2232 | } | |||
2233 | ||||
2234 | /* #define SWIG_PYTHON_SLOW_GETSET_THIS */ | |||
2235 | ||||
2236 | /* TODO: I don't know how to implement the fast getset in Python 3 right now */ | |||
2237 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0))>=0x03000000 | |||
2238 | #define SWIG_PYTHON_SLOW_GETSET_THIS | |||
2239 | #endif | |||
2240 | ||||
2241 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) SwigPyObject * | |||
2242 | SWIG_Python_GetSwigThis(PyObject *pyobj) | |||
2243 | { | |||
2244 | PyObject *obj; | |||
2245 | ||||
2246 | if (SwigPyObject_Check(pyobj)) | |||
2247 | return (SwigPyObject *) pyobj; | |||
2248 | ||||
2249 | #ifdef SWIGPYTHON_BUILTIN | |||
2250 | (void)obj; | |||
2251 | # ifdef PyWeakref_CheckProxy | |||
2252 | if (PyWeakref_CheckProxy(pyobj)(((((PyObject*)(pyobj))->ob_type) == &_PyWeakref_ProxyType ) || ((((PyObject*)(pyobj))->ob_type) == &_PyWeakref_CallableProxyType ))) { | |||
2253 | pyobj = PyWeakref_GET_OBJECT(pyobj)((((PyObject*)(((PyWeakReference *)(pyobj))->wr_object))-> ob_refcnt) > 0 ? ((PyWeakReference *)(pyobj))->wr_object : (&_Py_NoneStruct)); | |||
2254 | if (pyobj && SwigPyObject_Check(pyobj)) | |||
2255 | return (SwigPyObject*) pyobj; | |||
2256 | } | |||
2257 | # endif | |||
2258 | return NULL((void*)0); | |||
2259 | #else | |||
2260 | ||||
2261 | obj = 0; | |||
2262 | ||||
2263 | #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02030000)) | |||
2264 | if (PyInstance_Check(pyobj)((pyobj)->ob_type == &PyInstance_Type)) { | |||
2265 | obj = _PyInstance_Lookup(pyobj, SWIG_This()); | |||
2266 | } else { | |||
2267 | PyObject **dictptr = _PyObject_GetDictPtr(pyobj); | |||
2268 | if (dictptr != NULL((void*)0)) { | |||
2269 | PyObject *dict = *dictptr; | |||
2270 | obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; | |||
2271 | } else { | |||
2272 | #ifdef PyWeakref_CheckProxy | |||
2273 | if (PyWeakref_CheckProxy(pyobj)(((((PyObject*)(pyobj))->ob_type) == &_PyWeakref_ProxyType ) || ((((PyObject*)(pyobj))->ob_type) == &_PyWeakref_CallableProxyType ))) { | |||
2274 | PyObject *wobj = PyWeakref_GET_OBJECT(pyobj)((((PyObject*)(((PyWeakReference *)(pyobj))->wr_object))-> ob_refcnt) > 0 ? ((PyWeakReference *)(pyobj))->wr_object : (&_Py_NoneStruct)); | |||
2275 | return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; | |||
2276 | } | |||
2277 | #endif | |||
2278 | obj = PyObject_GetAttr(pyobj,SWIG_This()); | |||
2279 | if (obj) { | |||
2280 | Py_DECREF(obj)do { if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(obj)))); } while (0); | |||
2281 | } else { | |||
2282 | if (PyErr_Occurred()) PyErr_Clear(); | |||
2283 | return 0; | |||
2284 | } | |||
2285 | } | |||
2286 | } | |||
2287 | #else | |||
2288 | obj = PyObject_GetAttr(pyobj,SWIG_This()); | |||
2289 | if (obj) { | |||
2290 | Py_DECREF(obj)do { if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(obj)))); } while (0); | |||
2291 | } else { | |||
2292 | if (PyErr_Occurred()) PyErr_Clear(); | |||
2293 | return 0; | |||
2294 | } | |||
2295 | #endif | |||
2296 | if (obj && !SwigPyObject_Check(obj)) { | |||
2297 | /* a PyObject is called 'this', try to get the 'real this' | |||
2298 | SwigPyObject from it */ | |||
2299 | return SWIG_Python_GetSwigThis(obj); | |||
2300 | } | |||
2301 | return (SwigPyObject *)obj; | |||
2302 | #endif | |||
2303 | } | |||
2304 | ||||
2305 | /* Acquire a pointer value */ | |||
2306 | ||||
2307 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2308 | SWIG_Python_AcquirePtr(PyObject *obj, int own) { | |||
2309 | if (own == SWIG_POINTER_OWN0x1) { | |||
2310 | SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); | |||
2311 | if (sobj) { | |||
2312 | int oldown = sobj->own; | |||
2313 | sobj->own = own; | |||
2314 | return oldown; | |||
2315 | } | |||
2316 | } | |||
2317 | return 0; | |||
2318 | } | |||
2319 | ||||
2320 | /* Convert a pointer value */ | |||
2321 | ||||
2322 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2323 | SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { | |||
2324 | int res; | |||
2325 | SwigPyObject *sobj; | |||
2326 | int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV(0x1 << 1)) != 0; | |||
2327 | ||||
2328 | if (!obj) | |||
2329 | return SWIG_ERROR(-1); | |||
2330 | if (obj == Py_None(&_Py_NoneStruct) && !implicit_conv) { | |||
2331 | if (ptr) | |||
2332 | *ptr = 0; | |||
2333 | return SWIG_OK(0); | |||
2334 | } | |||
2335 | ||||
2336 | res = SWIG_ERROR(-1); | |||
2337 | ||||
2338 | sobj = SWIG_Python_GetSwigThis(obj); | |||
2339 | if (own) | |||
2340 | *own = 0; | |||
2341 | while (sobj) { | |||
2342 | void *vptr = sobj->ptr; | |||
2343 | if (ty) { | |||
2344 | swig_type_info *to = sobj->ty; | |||
2345 | if (to == ty) { | |||
2346 | /* no type cast needed */ | |||
2347 | if (ptr) *ptr = vptr; | |||
2348 | break; | |||
2349 | } else { | |||
2350 | swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); | |||
2351 | if (!tc) { | |||
2352 | sobj = (SwigPyObject *)sobj->next; | |||
2353 | } else { | |||
2354 | if (ptr) { | |||
2355 | int newmemory = 0; | |||
2356 | *ptr = SWIG_TypeCast(tc,vptr,&newmemory); | |||
2357 | if (newmemory == SWIG_CAST_NEW_MEMORY0x2) { | |||
2358 | assert(own)((own) ? (void) (0) : __assert_fail ("own", "ddc_swig_wrap.c" , 2358, __PRETTY_FUNCTION__)); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ | |||
2359 | if (own) | |||
2360 | *own = *own | SWIG_CAST_NEW_MEMORY0x2; | |||
2361 | } | |||
2362 | } | |||
2363 | break; | |||
2364 | } | |||
2365 | } | |||
2366 | } else { | |||
2367 | if (ptr) *ptr = vptr; | |||
2368 | break; | |||
2369 | } | |||
2370 | } | |||
2371 | if (sobj) { | |||
2372 | if (own) | |||
2373 | *own = *own | sobj->own; | |||
2374 | if (flags & SWIG_POINTER_DISOWN0x1) { | |||
2375 | sobj->own = 0; | |||
2376 | } | |||
2377 | res = SWIG_OK(0); | |||
2378 | } else { | |||
2379 | if (implicit_conv) { | |||
2380 | SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; | |||
2381 | if (data && !data->implicitconv) { | |||
2382 | PyObject *klass = data->klass; | |||
2383 | if (klass) { | |||
2384 | PyObject *impconv; | |||
2385 | data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ | |||
2386 | impconv = SWIG_Python_CallFunctor(klass, obj)PyObject_CallFunctionObjArgs(klass, obj, ((void*)0));; | |||
2387 | data->implicitconv = 0; | |||
2388 | if (PyErr_Occurred()) { | |||
2389 | PyErr_Clear(); | |||
2390 | impconv = 0; | |||
2391 | } | |||
2392 | if (impconv) { | |||
2393 | SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); | |||
2394 | if (iobj) { | |||
2395 | void *vptr; | |||
2396 | res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); | |||
2397 | if (SWIG_IsOK(res)(res >= 0)) { | |||
2398 | if (ptr) { | |||
2399 | *ptr = vptr; | |||
2400 | /* transfer the ownership to 'ptr' */ | |||
2401 | iobj->own = 0; | |||
2402 | res = SWIG_AddCast(res)(res); | |||
2403 | res = SWIG_AddNewMask(res)((res >= 0) ? (res | ((1 << 8) << 1)) : res); | |||
2404 | } else { | |||
2405 | res = SWIG_AddCast(res)(res); | |||
2406 | } | |||
2407 | } | |||
2408 | } | |||
2409 | Py_DECREF(impconv)do { if ( --((PyObject*)(impconv))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(impconv)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(impconv)))); } while (0); | |||
2410 | } | |||
2411 | } | |||
2412 | } | |||
2413 | } | |||
2414 | if (!SWIG_IsOK(res)(res >= 0) && obj == Py_None(&_Py_NoneStruct)) { | |||
2415 | if (ptr) | |||
2416 | *ptr = 0; | |||
2417 | if (PyErr_Occurred()) | |||
2418 | PyErr_Clear(); | |||
2419 | res = SWIG_OK(0); | |||
2420 | } | |||
2421 | } | |||
2422 | return res; | |||
2423 | } | |||
2424 | ||||
2425 | /* Convert a function ptr value */ | |||
2426 | ||||
2427 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2428 | SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { | |||
2429 | if (!PyCFunction_Check(obj)((((PyObject*)(obj))->ob_type) == &PyCFunction_Type)) { | |||
2430 | return SWIG_ConvertPtr(obj, ptr, ty, 0)SWIG_Python_ConvertPtrAndOwn(obj, ptr, ty, 0, 0); | |||
2431 | } else { | |||
2432 | void *vptr = 0; | |||
2433 | ||||
2434 | /* here we get the method pointer for callbacks */ | |||
2435 | const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); | |||
2436 | const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; | |||
2437 | if (desc) | |||
2438 | desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; | |||
2439 | if (!desc) | |||
2440 | return SWIG_ERROR(-1); | |||
2441 | if (ty) { | |||
2442 | swig_cast_info *tc = SWIG_TypeCheck(desc,ty); | |||
2443 | if (tc) { | |||
2444 | int newmemory = 0; | |||
2445 | *ptr = SWIG_TypeCast(tc,vptr,&newmemory); | |||
2446 | assert(!newmemory)((!newmemory) ? (void) (0) : __assert_fail ("!newmemory", "ddc_swig_wrap.c" , 2446, __PRETTY_FUNCTION__)); /* newmemory handling not yet implemented */ | |||
2447 | } else { | |||
2448 | return SWIG_ERROR(-1); | |||
2449 | } | |||
2450 | } else { | |||
2451 | *ptr = vptr; | |||
2452 | } | |||
2453 | return SWIG_OK(0); | |||
2454 | } | |||
2455 | } | |||
2456 | ||||
2457 | /* Convert a packed value value */ | |||
2458 | ||||
2459 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2460 | SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { | |||
2461 | swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); | |||
2462 | if (!to) return SWIG_ERROR(-1); | |||
2463 | if (ty) { | |||
2464 | if (to != ty) { | |||
2465 | /* check type cast? */ | |||
2466 | swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); | |||
2467 | if (!tc) return SWIG_ERROR(-1); | |||
2468 | } | |||
2469 | } | |||
2470 | return SWIG_OK(0); | |||
2471 | } | |||
2472 | ||||
2473 | /* ----------------------------------------------------------------------------- | |||
2474 | * Create a new pointer object | |||
2475 | * ----------------------------------------------------------------------------- */ | |||
2476 | ||||
2477 | /* | |||
2478 | Create a new instance object, without calling __init__, and set the | |||
2479 | 'this' attribute. | |||
2480 | */ | |||
2481 | ||||
2482 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject* | |||
2483 | SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) | |||
2484 | { | |||
2485 | #if (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02020000) | |||
2486 | PyObject *inst = 0; | |||
2487 | PyObject *newraw = data->newraw; | |||
2488 | if (newraw) { | |||
2489 | inst = PyObject_Call(newraw, data->newargs, NULL((void*)0)); | |||
2490 | if (inst) { | |||
2491 | #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) | |||
2492 | PyObject **dictptr = _PyObject_GetDictPtr(inst); | |||
2493 | if (dictptr != NULL((void*)0)) { | |||
2494 | PyObject *dict = *dictptr; | |||
2495 | if (dict == NULL((void*)0)) { | |||
2496 | dict = PyDict_New(); | |||
2497 | *dictptr = dict; | |||
2498 | PyDict_SetItem(dict, SWIG_This(), swig_this); | |||
2499 | } | |||
2500 | } | |||
2501 | #else | |||
2502 | PyObject *key = SWIG_This(); | |||
2503 | PyObject_SetAttr(inst, key, swig_this); | |||
2504 | #endif | |||
2505 | } | |||
2506 | } else { | |||
2507 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
2508 | inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None(&_Py_NoneStruct), Py_None(&_Py_NoneStruct)); | |||
2509 | if (inst) { | |||
2510 | PyObject_SetAttr(inst, SWIG_This(), swig_this); | |||
2511 | Py_TYPE(inst)(((PyObject*)(inst))->ob_type)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG(1L<<19); | |||
2512 | } | |||
2513 | #else | |||
2514 | PyObject *dict = PyDict_New(); | |||
2515 | if (dict) { | |||
2516 | PyDict_SetItem(dict, SWIG_This(), swig_this); | |||
2517 | inst = PyInstance_NewRaw(data->newargs, dict); | |||
2518 | Py_DECREF(dict)do { if ( --((PyObject*)(dict))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(dict)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(dict)))); } while (0); | |||
2519 | } | |||
2520 | #endif | |||
2521 | } | |||
2522 | return inst; | |||
2523 | #else | |||
2524 | #if (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02010000) | |||
2525 | PyObject *inst = 0; | |||
2526 | PyObject *dict = PyDict_New(); | |||
2527 | if (dict) { | |||
2528 | PyDict_SetItem(dict, SWIG_This(), swig_this); | |||
2529 | inst = PyInstance_NewRaw(data->newargs, dict); | |||
2530 | Py_DECREF(dict)do { if ( --((PyObject*)(dict))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(dict)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(dict)))); } while (0); | |||
2531 | } | |||
2532 | return (PyObject *) inst; | |||
2533 | #else | |||
2534 | PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type)( (PyInstanceObject *) PyObject_Init( (PyObject *) PyObject_Malloc ( ( (&PyInstance_Type)->tp_basicsize ) ), (&PyInstance_Type )) ); | |||
2535 | if (inst == NULL((void*)0)) { | |||
2536 | return NULL((void*)0); | |||
2537 | } | |||
2538 | inst->in_class = (PyClassObject *)data->newargs; | |||
2539 | Py_INCREF(inst->in_class)( ((PyObject*)(inst->in_class))->ob_refcnt++); | |||
2540 | inst->in_dict = PyDict_New(); | |||
2541 | if (inst->in_dict == NULL((void*)0)) { | |||
2542 | Py_DECREF(inst)do { if ( --((PyObject*)(inst))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(inst)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(inst)))); } while (0); | |||
2543 | return NULL((void*)0); | |||
2544 | } | |||
2545 | #ifdef Py_TPFLAGS_HAVE_WEAKREFS(1L<<6) | |||
2546 | inst->in_weakreflist = NULL((void*)0); | |||
2547 | #endif | |||
2548 | #ifdef Py_TPFLAGS_GC0 | |||
2549 | PyObject_GC_Init(inst); | |||
2550 | #endif | |||
2551 | PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); | |||
2552 | return (PyObject *) inst; | |||
2553 | #endif | |||
2554 | #endif | |||
2555 | } | |||
2556 | ||||
2557 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
2558 | SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) | |||
2559 | { | |||
2560 | PyObject *dict; | |||
2561 | #if (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) | |||
2562 | PyObject **dictptr = _PyObject_GetDictPtr(inst); | |||
2563 | if (dictptr != NULL((void*)0)) { | |||
2564 | dict = *dictptr; | |||
2565 | if (dict == NULL((void*)0)) { | |||
2566 | dict = PyDict_New(); | |||
2567 | *dictptr = dict; | |||
2568 | } | |||
2569 | PyDict_SetItem(dict, SWIG_This(), swig_this); | |||
2570 | return; | |||
2571 | } | |||
2572 | #endif | |||
2573 | dict = PyObject_GetAttrString(inst, (char*)"__dict__"); | |||
2574 | PyDict_SetItem(dict, SWIG_This(), swig_this); | |||
2575 | Py_DECREF(dict)do { if ( --((PyObject*)(dict))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(dict)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(dict)))); } while (0); | |||
2576 | } | |||
2577 | ||||
2578 | ||||
2579 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject * | |||
2580 | SWIG_Python_InitShadowInstance(PyObject *args) { | |||
2581 | PyObject *obj[2]; | |||
2582 | if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { | |||
2583 | return NULL((void*)0); | |||
2584 | } else { | |||
2585 | SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); | |||
2586 | if (sthis) { | |||
2587 | SwigPyObject_append((PyObject*) sthis, obj[1]); | |||
2588 | } else { | |||
2589 | SWIG_Python_SetSwigThis(obj[0], obj[1]); | |||
2590 | } | |||
2591 | return SWIG_Py_Void(); | |||
2592 | } | |||
2593 | } | |||
2594 | ||||
2595 | /* Create a new pointer object */ | |||
2596 | ||||
2597 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
2598 | SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { | |||
2599 | SwigPyClientData *clientdata; | |||
2600 | PyObject * robj; | |||
2601 | int own; | |||
2602 | ||||
2603 | if (!ptr) | |||
2604 | return SWIG_Py_Void(); | |||
2605 | ||||
2606 | clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; | |||
2607 | own = (flags & SWIG_POINTER_OWN0x1) ? SWIG_POINTER_OWN0x1 : 0; | |||
2608 | if (clientdata && clientdata->pytype) { | |||
2609 | SwigPyObject *newobj; | |||
2610 | if (flags & SWIG_BUILTIN_TP_INIT(0x1 << 2)) { | |||
2611 | newobj = (SwigPyObject*) self; | |||
2612 | if (newobj->ptr) { | |||
2613 | PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); | |||
2614 | while (newobj->next) | |||
2615 | newobj = (SwigPyObject *) newobj->next; | |||
2616 | newobj->next = next_self; | |||
2617 | newobj = (SwigPyObject *)next_self; | |||
2618 | #ifdef SWIGPYTHON_BUILTIN | |||
2619 | newobj->dict = 0; | |||
2620 | #endif | |||
2621 | } | |||
2622 | } else { | |||
2623 | newobj = PyObject_New(SwigPyObject, clientdata->pytype)( (SwigPyObject *) _PyObject_New(clientdata->pytype) ); | |||
2624 | #ifdef SWIGPYTHON_BUILTIN | |||
2625 | newobj->dict = 0; | |||
2626 | #endif | |||
2627 | } | |||
2628 | if (newobj) { | |||
2629 | newobj->ptr = ptr; | |||
2630 | newobj->ty = type; | |||
2631 | newobj->own = own; | |||
2632 | newobj->next = 0; | |||
2633 | return (PyObject*) newobj; | |||
2634 | } | |||
2635 | return SWIG_Py_Void(); | |||
2636 | } | |||
2637 | ||||
2638 | assert(!(flags & SWIG_BUILTIN_TP_INIT))((!(flags & (0x1 << 2))) ? (void) (0) : __assert_fail ("!(flags & SWIG_BUILTIN_TP_INIT)", "ddc_swig_wrap.c", 2638 , __PRETTY_FUNCTION__)); | |||
2639 | ||||
2640 | robj = SwigPyObject_New(ptr, type, own); | |||
2641 | if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW(0x1 << 1))) { | |||
2642 | PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); | |||
2643 | Py_DECREF(robj)do { if ( --((PyObject*)(robj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(robj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(robj)))); } while (0); | |||
2644 | robj = inst; | |||
2645 | } | |||
2646 | return robj; | |||
2647 | } | |||
2648 | ||||
2649 | /* Create a new packed object */ | |||
2650 | ||||
2651 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline PyObject * | |||
2652 | SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { | |||
2653 | return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); | |||
2654 | } | |||
2655 | ||||
2656 | /* -----------------------------------------------------------------------------* | |||
2657 | * Get type list | |||
2658 | * -----------------------------------------------------------------------------*/ | |||
2659 | ||||
2660 | #ifdef SWIG_LINK_RUNTIME | |||
2661 | void *SWIG_ReturnGlobalTypeList(void *); | |||
2662 | #endif | |||
2663 | ||||
2664 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) swig_module_info * | |||
2665 | SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)clientdata __attribute__ ((__unused__))) { | |||
2666 | static void *type_pointer = (void *)0; | |||
2667 | /* first check if module already created */ | |||
2668 | if (!type_pointer) { | |||
2669 | #ifdef SWIG_LINK_RUNTIME | |||
2670 | type_pointer = SWIG_ReturnGlobalTypeList((void *)0); | |||
2671 | #else | |||
2672 | # ifdef SWIGPY_USE_CAPSULE | |||
2673 | type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME((char*)"swig_runtime_data" "4" ".type_pointer_capsule" ), 0); | |||
2674 | # else | |||
2675 | type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION"4", | |||
2676 | (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); | |||
2677 | # endif | |||
2678 | if (PyErr_Occurred()) { | |||
2679 | PyErr_Clear(); | |||
2680 | type_pointer = (void *)0; | |||
2681 | } | |||
2682 | #endif | |||
2683 | } | |||
2684 | return (swig_module_info *) type_pointer; | |||
2685 | } | |||
2686 | ||||
2687 | #if PY_MAJOR_VERSION2 < 2 | |||
2688 | /* PyModule_AddObject function was introduced in Python 2.0. The following function | |||
2689 | is copied out of Python/modsupport.c in python version 2.3.4 */ | |||
2690 | SWIGINTERNstatic __attribute__ ((__unused__)) int | |||
2691 | PyModule_AddObject(PyObject *m, char *name, PyObject *o) | |||
2692 | { | |||
2693 | PyObject *dict; | |||
2694 | if (!PyModule_Check(m)((((PyObject*)(m))->ob_type) == (&PyModule_Type) || PyType_IsSubtype ((((PyObject*)(m))->ob_type), (&PyModule_Type)))) { | |||
2695 | PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg"); | |||
2696 | return SWIG_ERROR(-1); | |||
2697 | } | |||
2698 | if (!o) { | |||
2699 | PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value"); | |||
2700 | return SWIG_ERROR(-1); | |||
2701 | } | |||
2702 | ||||
2703 | dict = PyModule_GetDict(m); | |||
2704 | if (dict == NULL((void*)0)) { | |||
2705 | /* Internal error -- modules must have a dict! */ | |||
2706 | PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", | |||
2707 | PyModule_GetName(m)); | |||
2708 | return SWIG_ERROR(-1); | |||
2709 | } | |||
2710 | if (PyDict_SetItemString(dict, name, o)) | |||
2711 | return SWIG_ERROR(-1); | |||
2712 | Py_DECREF(o)do { if ( --((PyObject*)(o))->ob_refcnt != 0) ; else ( (*( ((PyObject*)((PyObject *)(o)))->ob_type)->tp_dealloc)(( PyObject *)((PyObject *)(o)))); } while (0); | |||
2713 | return SWIG_OK(0); | |||
2714 | } | |||
2715 | #endif | |||
2716 | ||||
2717 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
2718 | #ifdef SWIGPY_USE_CAPSULE | |||
2719 | SWIG_Python_DestroyModule(PyObject *obj) | |||
2720 | #else | |||
2721 | SWIG_Python_DestroyModule(void *vptr) | |||
2722 | #endif | |||
2723 | { | |||
2724 | #ifdef SWIGPY_USE_CAPSULE | |||
2725 | swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME((char*)"swig_runtime_data" "4" ".type_pointer_capsule" )); | |||
2726 | #else | |||
2727 | swig_module_info *swig_module = (swig_module_info *) vptr; | |||
2728 | #endif | |||
2729 | swig_type_info **types = swig_module->types; | |||
2730 | size_t i; | |||
2731 | for (i =0; i < swig_module->size; ++i) { | |||
2732 | swig_type_info *ty = types[i]; | |||
2733 | if (ty->owndata) { | |||
2734 | SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; | |||
2735 | if (data) SwigPyClientData_Del(data); | |||
2736 | } | |||
2737 | } | |||
2738 | Py_DECREF(SWIG_This())do { if ( --((PyObject*)(SWIG_This()))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(SWIG_This())))->ob_type)-> tp_dealloc)((PyObject *)((PyObject *)(SWIG_This())))); } while (0); | |||
2739 | swig_this = NULL((void*)0); | |||
2740 | } | |||
2741 | ||||
2742 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
2743 | SWIG_Python_SetModule(swig_module_info *swig_module) { | |||
2744 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
2745 | /* Add a dummy module object into sys.modules */ | |||
2746 | PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION"4"); | |||
2747 | #else | |||
2748 | static PyMethodDef swig_empty_runtime_method_table[] = { {NULL((void*)0), NULL((void*)0), 0, NULL((void*)0)} }; /* Sentinel */ | |||
2749 | PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table)Py_InitModule4_64((char*)"swig_runtime_data" "4", swig_empty_runtime_method_table , (char *)((void*)0), (PyObject *)((void*)0), 1013); | |||
2750 | #endif | |||
2751 | #ifdef SWIGPY_USE_CAPSULE | |||
2752 | PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME((char*)"swig_runtime_data" "4" ".type_pointer_capsule" ), SWIG_Python_DestroyModule); | |||
2753 | if (pointer && module) { | |||
2754 | PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); | |||
2755 | } else { | |||
2756 | Py_XDECREF(pointer)do { if ((pointer) == ((void*)0)) ; else do { if ( --((PyObject *)(pointer))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(pointer)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(pointer)))); } while (0); } while (0); | |||
2757 | } | |||
2758 | #else | |||
2759 | PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); | |||
2760 | if (pointer && module) { | |||
2761 | PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); | |||
2762 | } else { | |||
2763 | Py_XDECREF(pointer)do { if ((pointer) == ((void*)0)) ; else do { if ( --((PyObject *)(pointer))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(pointer)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(pointer)))); } while (0); } while (0); | |||
2764 | } | |||
2765 | #endif | |||
2766 | } | |||
2767 | ||||
2768 | /* The python cached type query */ | |||
2769 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) PyObject * | |||
2770 | SWIG_Python_TypeCache(void) { | |||
2771 | static PyObject *SWIG_STATIC_POINTER(cache)cache = 0; if (!cache) cache = PyDict_New(); | |||
2772 | return cache; | |||
2773 | } | |||
2774 | ||||
2775 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) swig_type_info * | |||
2776 | SWIG_Python_TypeQuery(const char *type) | |||
2777 | { | |||
2778 | PyObject *cache = SWIG_Python_TypeCache(); | |||
2779 | PyObject *key = SWIG_Python_str_FromChar(type); | |||
2780 | PyObject *obj = PyDict_GetItem(cache, key); | |||
2781 | swig_type_info *descriptor; | |||
2782 | if (obj) { | |||
2783 | #ifdef SWIGPY_USE_CAPSULE | |||
2784 | descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL((void*)0)); | |||
2785 | #else | |||
2786 | descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); | |||
2787 | #endif | |||
2788 | } else { | |||
2789 | swig_module_info *swig_module = SWIG_GetModule(0)SWIG_Python_GetModule(0); | |||
2790 | descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); | |||
2791 | if (descriptor) { | |||
2792 | #ifdef SWIGPY_USE_CAPSULE | |||
2793 | obj = PyCapsule_New((void*) descriptor, NULL((void*)0), NULL((void*)0)); | |||
2794 | #else | |||
2795 | obj = PyCObject_FromVoidPtr(descriptor, NULL((void*)0)); | |||
2796 | #endif | |||
2797 | PyDict_SetItem(cache, key, obj); | |||
2798 | Py_DECREF(obj)do { if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(obj)))); } while (0); | |||
2799 | } | |||
2800 | } | |||
2801 | Py_DECREF(key)do { if ( --((PyObject*)(key))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(key)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(key)))); } while (0); | |||
2802 | return descriptor; | |||
2803 | } | |||
2804 | ||||
2805 | /* | |||
2806 | For backward compatibility only | |||
2807 | */ | |||
2808 | #define SWIG_POINTER_EXCEPTION0 0 | |||
2809 | #define SWIG_arg_fail(arg)SWIG_Python_ArgFail(arg) SWIG_Python_ArgFail(arg) | |||
2810 | #define SWIG_MustGetPtr(p, type, argnum, flags)SWIG_Python_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) | |||
2811 | ||||
2812 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2813 | SWIG_Python_AddErrMesg(const char* mesg, int infront) | |||
2814 | { | |||
2815 | if (PyErr_Occurred()) { | |||
2816 | PyObject *type = 0; | |||
2817 | PyObject *value = 0; | |||
2818 | PyObject *traceback = 0; | |||
2819 | PyErr_Fetch(&type, &value, &traceback); | |||
2820 | if (value) { | |||
2821 | char *tmp; | |||
2822 | PyObject *old_str = PyObject_Str(value); | |||
2823 | Py_XINCREF(type)do { if ((type) == ((void*)0)) ; else ( ((PyObject*)(type))-> ob_refcnt++); } while (0); | |||
2824 | PyErr_Clear(); | |||
2825 | if (infront) { | |||
2826 | PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); | |||
2827 | } else { | |||
2828 | PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); | |||
2829 | } | |||
2830 | SWIG_Python_str_DelForPy3(tmp); | |||
2831 | Py_DECREF(old_str)do { if ( --((PyObject*)(old_str))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(old_str)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(old_str)))); } while (0); | |||
2832 | } | |||
2833 | return 1; | |||
2834 | } else { | |||
2835 | return 0; | |||
2836 | } | |||
2837 | } | |||
2838 | ||||
2839 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2840 | SWIG_Python_ArgFail(int argnum) | |||
2841 | { | |||
2842 | if (PyErr_Occurred()) { | |||
2843 | /* add information about failing argument */ | |||
2844 | char mesg[256]; | |||
2845 | PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); | |||
2846 | return SWIG_Python_AddErrMesg(mesg, 1); | |||
2847 | } else { | |||
2848 | return 0; | |||
2849 | } | |||
2850 | } | |||
2851 | ||||
2852 | SWIGRUNTIMEINLINEstatic __attribute__ ((__unused__)) inline const char * | |||
2853 | SwigPyObject_GetDesc(PyObject *self) | |||
2854 | { | |||
2855 | SwigPyObject *v = (SwigPyObject *)self; | |||
2856 | swig_type_info *ty = v ? v->ty : 0; | |||
2857 | return ty ? ty->str : ""; | |||
2858 | } | |||
2859 | ||||
2860 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
2861 | SWIG_Python_TypeError(const char *type, PyObject *obj) | |||
2862 | { | |||
2863 | if (type) { | |||
2864 | #if defined(SWIG_COBJECT_TYPES) | |||
2865 | if (obj && SwigPyObject_Check(obj)) { | |||
2866 | const char *otype = (const char *) SwigPyObject_GetDesc(obj); | |||
2867 | if (otype) { | |||
2868 | PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", | |||
2869 | type, otype); | |||
2870 | return; | |||
2871 | } | |||
2872 | } else | |||
2873 | #endif | |||
2874 | { | |||
2875 | const char *otype = (obj ? obj->ob_type->tp_name : 0); | |||
2876 | if (otype) { | |||
2877 | PyObject *str = PyObject_Str(obj); | |||
2878 | const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; | |||
2879 | if (cstr) { | |||
2880 | PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", | |||
2881 | type, otype, cstr); | |||
2882 | SWIG_Python_str_DelForPy3(cstr); | |||
2883 | } else { | |||
2884 | PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", | |||
2885 | type, otype); | |||
2886 | } | |||
2887 | Py_XDECREF(str)do { if ((str) == ((void*)0)) ; else do { if ( --((PyObject*) (str))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(str)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(str)))); } while (0); } while (0); | |||
2888 | return; | |||
2889 | } | |||
2890 | } | |||
2891 | PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); | |||
2892 | } else { | |||
2893 | PyErr_Format(PyExc_TypeError, "unexpected type is received"); | |||
2894 | } | |||
2895 | } | |||
2896 | ||||
2897 | ||||
2898 | /* Convert a pointer value, signal an exception on a type mismatch */ | |||
2899 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void * | |||
2900 | SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum)argnum __attribute__ ((__unused__)), int flags) { | |||
2901 | void *result; | |||
2902 | if (SWIG_Python_ConvertPtr(obj, &result, ty, flags)SWIG_Python_ConvertPtrAndOwn(obj, &result, ty, flags, 0) == -1) { | |||
2903 | PyErr_Clear(); | |||
2904 | #if SWIG_POINTER_EXCEPTION0 | |||
2905 | if (flags) { | |||
2906 | SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); | |||
2907 | SWIG_Python_ArgFail(argnum); | |||
2908 | } | |||
2909 | #endif | |||
2910 | } | |||
2911 | return result; | |||
2912 | } | |||
2913 | ||||
2914 | #ifdef SWIGPYTHON_BUILTIN | |||
2915 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) int | |||
2916 | SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { | |||
2917 | PyTypeObject *tp = obj->ob_type; | |||
2918 | PyObject *descr; | |||
2919 | PyObject *encoded_name; | |||
2920 | descrsetfunc f; | |||
2921 | int res = -1; | |||
2922 | ||||
2923 | # ifdef Py_USING_UNICODE1 | |||
2924 | if (PyString_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L <<27))) != 0)) { | |||
2925 | name = PyUnicode_DecodePyUnicodeUCS4_Decode(PyString_AsString(name), PyString_Size(name), NULL((void*)0), NULL((void*)0)); | |||
2926 | if (!name) | |||
2927 | return -1; | |||
2928 | } else if (!PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L <<28))) != 0)) | |||
2929 | # else | |||
2930 | if (!PyString_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L <<27))) != 0)) | |||
2931 | # endif | |||
2932 | { | |||
2933 | PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); | |||
2934 | return -1; | |||
2935 | } else { | |||
2936 | Py_INCREF(name)( ((PyObject*)(name))->ob_refcnt++); | |||
2937 | } | |||
2938 | ||||
2939 | if (!tp->tp_dict) { | |||
2940 | if (PyType_Ready(tp) < 0) | |||
2941 | goto done; | |||
2942 | } | |||
2943 | ||||
2944 | descr = _PyType_Lookup(tp, name); | |||
2945 | f = NULL((void*)0); | |||
2946 | if (descr != NULL((void*)0)) | |||
2947 | f = descr->ob_type->tp_descr_set; | |||
2948 | if (!f) { | |||
2949 | if (PyString_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L <<27))) != 0)) { | |||
2950 | encoded_name = name; | |||
2951 | Py_INCREF(name)( ((PyObject*)(name))->ob_refcnt++); | |||
2952 | } else { | |||
2953 | encoded_name = PyUnicode_AsUTF8StringPyUnicodeUCS4_AsUTF8String(name); | |||
2954 | } | |||
2955 | PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); | |||
2956 | Py_DECREF(encoded_name)do { if ( --((PyObject*)(encoded_name))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(encoded_name)))->ob_type )->tp_dealloc)((PyObject *)((PyObject *)(encoded_name)))); } while (0); | |||
2957 | } else { | |||
2958 | res = f(descr, obj, value); | |||
2959 | } | |||
2960 | ||||
2961 | done: | |||
2962 | Py_DECREF(name)do { if ( --((PyObject*)(name))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(name)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(name)))); } while (0); | |||
2963 | return res; | |||
2964 | } | |||
2965 | #endif | |||
2966 | ||||
2967 | ||||
2968 | #ifdef __cplusplus | |||
2969 | } | |||
2970 | #endif | |||
2971 | ||||
2972 | ||||
2973 | ||||
2974 | #define SWIG_exception_fail(code, msg)do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(code), msg ); goto fail; } while(0) do { SWIG_Error(code, msg)SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(code), msg); SWIG_failgoto fail; } while(0) | |||
2975 | ||||
2976 | #define SWIG_contract_assert(expr, msg)if (!(expr)) { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType( -3), msg); goto fail; } else if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg)SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(-3), msg); SWIG_failgoto fail; } else | |||
2977 | ||||
2978 | ||||
2979 | ||||
2980 | /* -------- TYPES TABLE (BEGIN) -------- */ | |||
2981 | ||||
2982 | #define SWIGTYPE_p_DDCA_Output_Levelswig_types[0] swig_types[0] | |||
2983 | #define SWIGTYPE_p_DDCA_Retry_Typeswig_types[1] swig_types[1] | |||
2984 | #define SWIGTYPE_p_DDCS_Build_Flagsswig_types[2] swig_types[2] | |||
2985 | #define SWIGTYPE_p_DDCS_MCCS_Version_Specswig_types[3] swig_types[3] | |||
2986 | #define SWIGTYPE_p_DDCS_Non_Table_Value_Responseswig_types[4] swig_types[4] | |||
2987 | #define SWIGTYPE_p_FILEswig_types[5] swig_types[5] | |||
2988 | #define SWIGTYPE_p_charswig_types[6] swig_types[6] | |||
2989 | #define SWIGTYPE_p_intswig_types[7] swig_types[7] | |||
2990 | #define SWIGTYPE_p_uint8_tswig_types[8] swig_types[8] | |||
2991 | #define SWIGTYPE_p_voidswig_types[9] swig_types[9] | |||
2992 | static swig_type_info *swig_types[11]; | |||
2993 | static swig_module_info swig_module = {swig_types, 10, 0, 0, 0, 0}; | |||
2994 | #define SWIG_TypeQuery(name)SWIG_TypeQueryModule(&swig_module, &swig_module, name ) SWIG_TypeQueryModule(&swig_module, &swig_module, name) | |||
2995 | #define SWIG_MangledTypeQuery(name)SWIG_MangledTypeQueryModule(&swig_module, &swig_module , name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) | |||
2996 | ||||
2997 | /* -------- TYPES TABLE (END) -------- */ | |||
2998 | ||||
2999 | #if (PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) <= 0x02000000) | |||
3000 | # if !defined(SWIG_PYTHON_CLASSIC) | |||
3001 | # error "This python version requires swig to be run with the '-classic' option" | |||
3002 | # endif | |||
3003 | #endif | |||
3004 | ||||
3005 | /*----------------------------------------------- | |||
3006 | @(target):= _ddc_swig.so | |||
3007 | ------------------------------------------------*/ | |||
3008 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
3009 | # define SWIG_initinit_ddc_swig PyInit__ddc_swig | |||
3010 | ||||
3011 | #else | |||
3012 | # define SWIG_initinit_ddc_swig init_ddc_swig | |||
3013 | ||||
3014 | #endif | |||
3015 | #define SWIG_name"_ddc_swig" "_ddc_swig" | |||
3016 | ||||
3017 | #define SWIGVERSION0x030011 0x030011 | |||
3018 | #define SWIG_VERSION0x030011 SWIGVERSION0x030011 | |||
3019 | ||||
3020 | ||||
3021 | #define SWIG_as_voidptr(a)(void *)((const void *)(a)) (void *)((const void *)(a)) | |||
3022 | #define SWIG_as_voidptrptr(a)((void)(void *)((const void *)(*a)),(void**)(a)) ((void)SWIG_as_voidptr(*a)(void *)((const void *)(*a)),(void**)(a)) | |||
3023 | ||||
3024 | ||||
3025 | // Start of copy block | |||
3026 | #include "swig/ddc_swig.h" | |||
3027 | // void ddca_init(void); | |||
3028 | // bool ddcs_built_with_adl(void); | |||
3029 | const char * ddcutil_version(void); | |||
3030 | // enum Retries{DDCT_WRITE_ONLY_TRIES3, DDCT_WRITE_READ_TRIES3, DDCT_MULTI_PART_TRIES3}; | |||
3031 | // end of copy block | |||
3032 | ||||
3033 | ||||
3034 | SWIGINTERNstatic __attribute__ ((__unused__)) swig_type_info* | |||
3035 | SWIG_pchar_descriptor(void) | |||
3036 | { | |||
3037 | static int init = 0; | |||
3038 | static swig_type_info* info = 0; | |||
3039 | if (!init) { | |||
3040 | info = SWIG_TypeQuery("_p_char")SWIG_TypeQueryModule(&swig_module, &swig_module, "_p_char" ); | |||
3041 | init = 1; | |||
3042 | } | |||
3043 | return info; | |||
3044 | } | |||
3045 | ||||
3046 | ||||
3047 | SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline PyObject * | |||
3048 | SWIG_FromCharPtrAndSize(const char* carray, size_t size) | |||
3049 | { | |||
3050 | if (carray) { | |||
3051 | if (size > INT_MAX2147483647) { | |||
3052 | swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); | |||
3053 | return pchar_descriptor ? | |||
3054 | SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0)SWIG_Python_NewPointerObj(((void*)0), (char *)(carray), pchar_descriptor , 0) : SWIG_Py_Void(); | |||
3055 | } else { | |||
3056 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
3057 | #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) | |||
3058 | return PyBytes_FromStringAndSizePyString_FromStringAndSize(carray, (Py_ssize_t)(size)); | |||
3059 | #else | |||
3060 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03010000 | |||
3061 | return PyUnicode_DecodeUTF8PyUnicodeUCS4_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape"); | |||
3062 | #else | |||
3063 | return PyUnicode_FromStringAndSizePyUnicodeUCS4_FromStringAndSize(carray, (Py_ssize_t)(size)); | |||
3064 | #endif | |||
3065 | #endif | |||
3066 | #else | |||
3067 | return PyString_FromStringAndSize(carray, (Py_ssize_t)(size)); | |||
3068 | #endif | |||
3069 | } | |||
3070 | } else { | |||
3071 | return SWIG_Py_Void(); | |||
3072 | } | |||
3073 | } | |||
3074 | ||||
3075 | ||||
3076 | SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline PyObject * | |||
3077 | SWIG_FromCharPtr(const char *cptr) | |||
3078 | { | |||
3079 | return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); | |||
3080 | } | |||
3081 | ||||
3082 | ||||
3083 | SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline PyObject* | |||
3084 | SWIG_From_int (int value) | |||
3085 | { | |||
3086 | return PyInt_FromLong((long) value); | |||
3087 | } | |||
3088 | ||||
3089 | ||||
3090 | #include <limits.h> | |||
3091 | #if !defined(SWIG_NO_LLONG_MAX) | |||
3092 | # if !defined(LLONG_MAX9223372036854775807LL) && defined(__GNUC__4) && defined (__LONG_LONG_MAX__9223372036854775807LL) | |||
3093 | # define LLONG_MAX9223372036854775807LL __LONG_LONG_MAX__9223372036854775807LL | |||
3094 | # define LLONG_MIN(-9223372036854775807LL -1LL) (-LLONG_MAX9223372036854775807LL - 1LL) | |||
3095 | # define ULLONG_MAX(9223372036854775807LL*2ULL+1ULL) (LLONG_MAX9223372036854775807LL * 2ULL + 1ULL) | |||
3096 | # endif | |||
3097 | #endif | |||
3098 | ||||
3099 | ||||
3100 | SWIGINTERNstatic __attribute__ ((__unused__)) int | |||
3101 | SWIG_AsVal_double (PyObject *obj, double *val) | |||
3102 | { | |||
3103 | int res = SWIG_TypeError-5; | |||
3104 | if (PyFloat_Check(obj)((((PyObject*)(obj))->ob_type) == (&PyFloat_Type) || PyType_IsSubtype ((((PyObject*)(obj))->ob_type), (&PyFloat_Type)))) { | |||
3105 | if (val) *val = PyFloat_AsDouble(obj); | |||
3106 | return SWIG_OK(0); | |||
3107 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x03000000 | |||
3108 | } else if (PyInt_Check(obj)((((obj)->ob_type)->tp_flags & ((1L<<23))) != 0)) { | |||
3109 | if (val) *val = (double) PyInt_AsLong(obj); | |||
3110 | return SWIG_OK(0); | |||
3111 | #endif | |||
3112 | } else if (PyLong_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<< 24))) != 0)) { | |||
3113 | double v = PyLong_AsDouble(obj); | |||
3114 | if (!PyErr_Occurred()) { | |||
3115 | if (val) *val = v; | |||
3116 | return SWIG_OK(0); | |||
3117 | } else { | |||
3118 | PyErr_Clear(); | |||
3119 | } | |||
3120 | } | |||
3121 | #ifdef SWIG_PYTHON_CAST_MODE | |||
3122 | { | |||
3123 | int dispatch = 0; | |||
3124 | double d = PyFloat_AsDouble(obj); | |||
3125 | if (!PyErr_Occurred()) { | |||
3126 | if (val) *val = d; | |||
3127 | return SWIG_AddCast(SWIG_OK)((0)); | |||
3128 | } else { | |||
3129 | PyErr_Clear(); | |||
3130 | } | |||
3131 | if (!dispatch) { | |||
3132 | long v = PyLong_AsLong(obj); | |||
3133 | if (!PyErr_Occurred()) { | |||
3134 | if (val) *val = v; | |||
3135 | return SWIG_AddCast(SWIG_AddCast(SWIG_OK))(((0))); | |||
3136 | } else { | |||
3137 | PyErr_Clear(); | |||
3138 | } | |||
3139 | } | |||
3140 | } | |||
3141 | #endif | |||
3142 | return res; | |||
3143 | } | |||
3144 | ||||
3145 | ||||
3146 | #include <float.h> | |||
3147 | ||||
3148 | ||||
3149 | #include <math.h> | |||
3150 | ||||
3151 | ||||
3152 | SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline int | |||
3153 | SWIG_CanCastAsInteger(double *d, double min, double max) { | |||
3154 | double x = *d; | |||
3155 | if ((min <= x && x <= max)) { | |||
3156 | double fx = floor(x); | |||
3157 | double cx = ceil(x); | |||
3158 | double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ | |||
3159 | if ((errno(*__errno_location ()) == EDOM33) || (errno(*__errno_location ()) == ERANGE34)) { | |||
3160 | errno(*__errno_location ()) = 0; | |||
3161 | } else { | |||
3162 | double summ, reps, diff; | |||
3163 | if (rd < x) { | |||
3164 | diff = x - rd; | |||
3165 | } else if (rd > x) { | |||
3166 | diff = rd - x; | |||
3167 | } else { | |||
3168 | return 1; | |||
3169 | } | |||
3170 | summ = rd + x; | |||
3171 | reps = diff/summ; | |||
3172 | if (reps < 8*DBL_EPSILON2.2204460492503131e-16) { | |||
3173 | *d = rd; | |||
3174 | return 1; | |||
3175 | } | |||
3176 | } | |||
3177 | } | |||
3178 | return 0; | |||
3179 | } | |||
3180 | ||||
3181 | ||||
3182 | SWIGINTERNstatic __attribute__ ((__unused__)) int | |||
3183 | SWIG_AsVal_long (PyObject *obj, long* val) | |||
3184 | { | |||
3185 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x03000000 | |||
3186 | if (PyInt_Check(obj)((((obj)->ob_type)->tp_flags & ((1L<<23))) != 0)) { | |||
3187 | if (val) *val = PyInt_AsLong(obj); | |||
3188 | return SWIG_OK(0); | |||
3189 | } else | |||
3190 | #endif | |||
3191 | if (PyLong_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<< 24))) != 0)) { | |||
3192 | long v = PyLong_AsLong(obj); | |||
3193 | if (!PyErr_Occurred()) { | |||
3194 | if (val) *val = v; | |||
3195 | return SWIG_OK(0); | |||
3196 | } else { | |||
3197 | PyErr_Clear(); | |||
3198 | return SWIG_OverflowError-7; | |||
3199 | } | |||
3200 | } | |||
3201 | #ifdef SWIG_PYTHON_CAST_MODE | |||
3202 | { | |||
3203 | int dispatch = 0; | |||
3204 | long v = PyInt_AsLong(obj); | |||
3205 | if (!PyErr_Occurred()) { | |||
3206 | if (val) *val = v; | |||
3207 | return SWIG_AddCast(SWIG_OK)((0)); | |||
3208 | } else { | |||
3209 | PyErr_Clear(); | |||
3210 | } | |||
3211 | if (!dispatch) { | |||
3212 | double d; | |||
3213 | int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d))(SWIG_AsVal_double (obj,&d)); | |||
3214 | if (SWIG_IsOK(res)(res >= 0) && SWIG_CanCastAsInteger(&d, LONG_MIN(-9223372036854775807L -1L), LONG_MAX9223372036854775807L)) { | |||
3215 | if (val) *val = (long)(d); | |||
3216 | return res; | |||
3217 | } | |||
3218 | } | |||
3219 | } | |||
3220 | #endif | |||
3221 | return SWIG_TypeError-5; | |||
3222 | } | |||
3223 | ||||
3224 | ||||
3225 | SWIGINTERNstatic __attribute__ ((__unused__)) int | |||
3226 | SWIG_AsVal_int (PyObject * obj, int *val) | |||
3227 | { | |||
3228 | long v; | |||
3229 | int res = SWIG_AsVal_long (obj, &v); | |||
3230 | if (SWIG_IsOK(res)(res >= 0)) { | |||
3231 | if ((v < INT_MIN(-2147483647 -1) || v > INT_MAX2147483647)) { | |||
3232 | return SWIG_OverflowError-7; | |||
3233 | } else { | |||
3234 | if (val) *val = (int)(v); | |||
3235 | } | |||
3236 | } | |||
3237 | return res; | |||
3238 | } | |||
3239 | ||||
3240 | ||||
3241 | SWIGINTERNstatic __attribute__ ((__unused__)) int | |||
3242 | SWIG_AsVal_bool (PyObject *obj, bool_Bool *val) | |||
3243 | { | |||
3244 | int r; | |||
3245 | if (!PyBool_Check(obj)((((PyObject*)(obj))->ob_type) == &PyBool_Type)) | |||
3246 | return SWIG_ERROR(-1); | |||
3247 | r = PyObject_IsTrue(obj); | |||
3248 | if (r == -1) | |||
3249 | return SWIG_ERROR(-1); | |||
3250 | if (val) *val = r ? true1 : false0; | |||
3251 | return SWIG_OK(0); | |||
3252 | } | |||
3253 | ||||
3254 | ||||
3255 | SWIGINTERNINLINEstatic __attribute__ ((__unused__)) inline PyObject* | |||
3256 | SWIG_From_bool (bool_Bool value) | |||
3257 | { | |||
3258 | return PyBool_FromLong(value ? 1 : 0); | |||
3259 | } | |||
3260 | ||||
3261 | ||||
3262 | SWIGINTERNstatic __attribute__ ((__unused__)) int | |||
3263 | SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) | |||
3264 | { | |||
3265 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0))>=0x03000000 | |||
3266 | #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) | |||
3267 | if (PyBytes_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<< 27))) != 0)) | |||
3268 | #else | |||
3269 | if (PyUnicode_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<< 28))) != 0)) | |||
3270 | #endif | |||
3271 | #else | |||
3272 | if (PyString_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<< 27))) != 0)) | |||
3273 | #endif | |||
3274 | { | |||
3275 | char *cstr; Py_ssize_t len; | |||
3276 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0))>=0x03000000 | |||
3277 | #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) | |||
3278 | if (!alloc && cptr) { | |||
3279 | /* We can't allow converting without allocation, since the internal | |||
3280 | representation of string in Python 3 is UCS-2/UCS-4 but we require | |||
3281 | a UTF-8 representation. | |||
3282 | TODO(bhy) More detailed explanation */ | |||
3283 | return SWIG_RuntimeError-3; | |||
3284 | } | |||
3285 | obj = PyUnicode_AsUTF8StringPyUnicodeUCS4_AsUTF8String(obj); | |||
3286 | if(alloc) *alloc = SWIG_NEWOBJ((0) | ((1 << 8) << 1)); | |||
3287 | #endif | |||
3288 | PyBytes_AsStringAndSizePyString_AsStringAndSize(obj, &cstr, &len); | |||
3289 | #else | |||
3290 | PyString_AsStringAndSize(obj, &cstr, &len); | |||
3291 | #endif | |||
3292 | if (cptr) { | |||
3293 | if (alloc) { | |||
3294 | /* | |||
3295 | In python the user should not be able to modify the inner | |||
3296 | string representation. To warranty that, if you define | |||
3297 | SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string | |||
3298 | buffer is always returned. | |||
3299 | ||||
3300 | The default behavior is just to return the pointer value, | |||
3301 | so, be careful. | |||
3302 | */ | |||
3303 | #if defined(SWIG_PYTHON_SAFE_CSTRINGS) | |||
3304 | if (*alloc != SWIG_OLDOBJ((0))) | |||
3305 | #else | |||
3306 | if (*alloc == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) | |||
3307 | #endif | |||
3308 | { | |||
3309 | *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); | |||
3310 | *alloc = SWIG_NEWOBJ((0) | ((1 << 8) << 1)); | |||
3311 | } else { | |||
3312 | *cptr = cstr; | |||
3313 | *alloc = SWIG_OLDOBJ((0)); | |||
3314 | } | |||
3315 | } else { | |||
3316 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0))>=0x03000000 | |||
3317 | #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) | |||
3318 | *cptr = PyBytes_AsStringPyString_AsString(obj); | |||
3319 | #else | |||
3320 | assert(0)((0) ? (void) (0) : __assert_fail ("0", "ddc_swig_wrap.c", 3320 , __PRETTY_FUNCTION__)); /* Should never reach here with Unicode strings in Python 3 */ | |||
3321 | #endif | |||
3322 | #else | |||
3323 | *cptr = SWIG_Python_str_AsChar(obj); | |||
3324 | #endif | |||
3325 | } | |||
3326 | } | |||
3327 | if (psize) *psize = len + 1; | |||
3328 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0))>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) | |||
3329 | Py_XDECREF(obj)do { if ((obj) == ((void*)0)) ; else do { if ( --((PyObject*) (obj))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(obj)))); } while (0); } while (0); | |||
3330 | #endif | |||
3331 | return SWIG_OK(0); | |||
3332 | } else { | |||
3333 | #if defined(SWIG_PYTHON_2_UNICODE) | |||
3334 | #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) | |||
3335 | #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once" | |||
3336 | #endif | |||
3337 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0))<0x03000000 | |||
3338 | if (PyUnicode_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<< 28))) != 0)) { | |||
3339 | char *cstr; Py_ssize_t len; | |||
3340 | if (!alloc && cptr) { | |||
3341 | return SWIG_RuntimeError-3; | |||
3342 | } | |||
3343 | obj = PyUnicode_AsUTF8StringPyUnicodeUCS4_AsUTF8String(obj); | |||
3344 | if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) { | |||
3345 | if (cptr) { | |||
3346 | if (alloc) *alloc = SWIG_NEWOBJ((0) | ((1 << 8) << 1)); | |||
3347 | *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); | |||
3348 | } | |||
3349 | if (psize) *psize = len + 1; | |||
3350 | ||||
3351 | Py_XDECREF(obj)do { if ((obj) == ((void*)0)) ; else do { if ( --((PyObject*) (obj))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(obj)))); } while (0); } while (0); | |||
3352 | return SWIG_OK(0); | |||
3353 | } else { | |||
3354 | Py_XDECREF(obj)do { if ((obj) == ((void*)0)) ; else do { if ( --((PyObject*) (obj))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(obj)))); } while (0); } while (0); | |||
3355 | } | |||
3356 | } | |||
3357 | #endif | |||
3358 | #endif | |||
3359 | ||||
3360 | swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); | |||
3361 | if (pchar_descriptor) { | |||
3362 | void* vptr = 0; | |||
3363 | if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0)SWIG_Python_ConvertPtrAndOwn(obj, &vptr, pchar_descriptor , 0, 0) == SWIG_OK(0)) { | |||
3364 | if (cptr) *cptr = (char *) vptr; | |||
3365 | if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; | |||
3366 | if (alloc) *alloc = SWIG_OLDOBJ((0)); | |||
3367 | return SWIG_OK(0); | |||
3368 | } | |||
3369 | } | |||
3370 | } | |||
3371 | return SWIG_TypeError-5; | |||
3372 | } | |||
3373 | ||||
3374 | ||||
3375 | ||||
3376 | ||||
3377 | #ifdef __cplusplus | |||
3378 | extern "C" { | |||
3379 | #endif | |||
3380 | ||||
3381 | ||||
3382 | ||||
3383 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_ddcutil_version_string(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3384 | PyObject *resultobj = 0; | |||
3385 | char *result = 0 ; | |||
3386 | ||||
3387 | if (!PyArg_ParseTuple(args,(char *)":ddcs_ddcutil_version_string")) SWIG_failgoto fail; | |||
3388 | { | |||
3389 | clear_exception(); // redundant | |||
3390 | result = (char *)ddcs_ddcutil_version_string(); | |||
3391 | // char * emsg = check_exception(); | |||
3392 | // if (emsg) { | |||
3393 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3394 | // return NULL; | |||
3395 | // } | |||
3396 | bool_Bool exception_thrown = check_exception2(); | |||
3397 | if (exception_thrown) { | |||
3398 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3399 | return NULL((void*)0); | |||
3400 | } | |||
3401 | } | |||
3402 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
3403 | return resultobj; | |||
3404 | fail: | |||
3405 | return NULL((void*)0); | |||
3406 | } | |||
3407 | ||||
3408 | ||||
3409 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_get_build_options(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3410 | PyObject *resultobj = 0; | |||
3411 | FlagsByte result; | |||
3412 | ||||
3413 | if (!PyArg_ParseTuple(args,(char *)":ddcs_get_build_options")) SWIG_failgoto fail; | |||
3414 | { | |||
3415 | clear_exception(); // redundant | |||
3416 | result = ddcs_get_build_options(); | |||
3417 | // char * emsg = check_exception(); | |||
3418 | // if (emsg) { | |||
3419 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3420 | // return NULL; | |||
3421 | // } | |||
3422 | bool_Bool exception_thrown = check_exception2(); | |||
3423 | if (exception_thrown) { | |||
3424 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3425 | return NULL((void*)0); | |||
3426 | } | |||
3427 | } | |||
3428 | { | |||
3429 | printf("(typemap:FlagsByte) Starting. Value=0x%02x\n", result); | |||
3430 | PyObject * pyset = PySet_New(NULL((void*)0)); | |||
3431 | for (int ndx = 0; ndx < 8; ndx++) { | |||
3432 | printf("(typemap:FlagsByte) testing bit %d, hexval 0x%02x\n", ndx, (1<<ndx) ); | |||
3433 | if (result & (1<<ndx)) { | |||
3434 | PyObject * iobj = PyInt_FromLong( 1<<ndx); | |||
3435 | int rc = PySet_Add(pyset, iobj); | |||
3436 | printf("(typemap:FlagsByte) PySet_Add returned %d\n", rc); | |||
3437 | } | |||
3438 | } | |||
3439 | resultobj = pyset; | |||
3440 | } | |||
3441 | return resultobj; | |||
3442 | fail: | |||
3443 | return NULL((void*)0); | |||
3444 | } | |||
3445 | ||||
3446 | ||||
3447 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_status_code_name(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3448 | PyObject *resultobj = 0; | |||
3449 | DDCA_Status arg1 ; | |||
3450 | int val1 ; | |||
3451 | int ecode1 = 0 ; | |||
3452 | PyObject * obj0 = 0 ; | |||
3453 | char *result = 0 ; | |||
3454 | ||||
3455 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_status_code_name",&obj0)) SWIG_failgoto fail; | |||
3456 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3457 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3458 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_status_code_name" "', argument " "1"" of type '" "DDCA_Status""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_status_code_name" "', argument " "1"" of type '" "DDCA_Status""'"); goto fail; } while(0); | |||
3459 | } | |||
3460 | arg1 = (DDCA_Status)(val1); | |||
3461 | { | |||
3462 | clear_exception(); // redundant | |||
3463 | result = (char *)ddca_rc_name(arg1); | |||
3464 | // char * emsg = check_exception(); | |||
3465 | // if (emsg) { | |||
3466 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3467 | // return NULL; | |||
3468 | // } | |||
3469 | bool_Bool exception_thrown = check_exception2(); | |||
3470 | if (exception_thrown) { | |||
3471 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3472 | return NULL((void*)0); | |||
3473 | } | |||
3474 | } | |||
3475 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
3476 | return resultobj; | |||
3477 | fail: | |||
3478 | return NULL((void*)0); | |||
3479 | } | |||
3480 | ||||
3481 | ||||
3482 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_status_code_desc(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3483 | PyObject *resultobj = 0; | |||
3484 | DDCA_Status arg1 ; | |||
3485 | int val1 ; | |||
3486 | int ecode1 = 0 ; | |||
3487 | PyObject * obj0 = 0 ; | |||
3488 | char *result = 0 ; | |||
3489 | ||||
3490 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_status_code_desc",&obj0)) SWIG_failgoto fail; | |||
3491 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3492 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3493 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_status_code_desc" "', argument " "1"" of type '" "DDCA_Status""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_status_code_desc" "', argument " "1"" of type '" "DDCA_Status""'"); goto fail; } while(0); | |||
3494 | } | |||
3495 | arg1 = (DDCA_Status)(val1); | |||
3496 | { | |||
3497 | clear_exception(); // redundant | |||
3498 | result = (char *)ddca_rc_desc(arg1); | |||
3499 | // char * emsg = check_exception(); | |||
3500 | // if (emsg) { | |||
3501 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3502 | // return NULL; | |||
3503 | // } | |||
3504 | bool_Bool exception_thrown = check_exception2(); | |||
3505 | if (exception_thrown) { | |||
3506 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3507 | return NULL((void*)0); | |||
3508 | } | |||
3509 | } | |||
3510 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
3511 | return resultobj; | |||
3512 | fail: | |||
3513 | return NULL((void*)0); | |||
3514 | } | |||
3515 | ||||
3516 | ||||
3517 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_get_max_tries(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3518 | PyObject *resultobj = 0; | |||
3519 | DDCA_Retry_Type arg1 ; | |||
3520 | int val1 ; | |||
3521 | int ecode1 = 0 ; | |||
3522 | PyObject * obj0 = 0 ; | |||
3523 | int result; | |||
3524 | ||||
3525 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_get_max_tries",&obj0)) SWIG_failgoto fail; | |||
3526 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3527 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3528 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_get_max_tries" "', argument " "1"" of type '" "DDCA_Retry_Type""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_get_max_tries" "', argument " "1"" of type '" "DDCA_Retry_Type""'"); goto fail; } while(0); | |||
3529 | } | |||
3530 | arg1 = (DDCA_Retry_Type)(val1); | |||
3531 | { | |||
3532 | clear_exception(); // redundant | |||
3533 | result = (int)ddca_get_max_tries(arg1); | |||
3534 | // char * emsg = check_exception(); | |||
3535 | // if (emsg) { | |||
3536 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3537 | // return NULL; | |||
3538 | // } | |||
3539 | bool_Bool exception_thrown = check_exception2(); | |||
3540 | if (exception_thrown) { | |||
3541 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3542 | return NULL((void*)0); | |||
3543 | } | |||
3544 | } | |||
3545 | resultobj = SWIG_From_int((int)(result)); | |||
3546 | return resultobj; | |||
3547 | fail: | |||
3548 | return NULL((void*)0); | |||
3549 | } | |||
3550 | ||||
3551 | ||||
3552 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_set_max_tries(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3553 | PyObject *resultobj = 0; | |||
3554 | DDCA_Retry_Type arg1 ; | |||
3555 | int arg2 ; | |||
3556 | int val1 ; | |||
3557 | int ecode1 = 0 ; | |||
3558 | int val2 ; | |||
3559 | int ecode2 = 0 ; | |||
3560 | PyObject * obj0 = 0 ; | |||
3561 | PyObject * obj1 = 0 ; | |||
3562 | DDCA_Status result; | |||
3563 | ||||
3564 | if (!PyArg_ParseTuple(args,(char *)"OO:ddcs_set_max_tries",&obj0,&obj1)) SWIG_failgoto fail; | |||
3565 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3566 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3567 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_set_max_tries" "', argument " "1"" of type '" "DDCA_Retry_Type""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_set_max_tries" "', argument " "1"" of type '" "DDCA_Retry_Type""'"); goto fail; } while(0); | |||
3568 | } | |||
3569 | arg1 = (DDCA_Retry_Type)(val1); | |||
3570 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
3571 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
3572 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ddcs_set_max_tries" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "ddcs_set_max_tries" "', argument " "2"" of type '" "int""'"); goto fail; } while(0); | |||
3573 | } | |||
3574 | arg2 = (int)(val2); | |||
3575 | { | |||
3576 | clear_exception(); // redundant | |||
3577 | result = (DDCA_Status)ddca_set_max_tries(arg1,arg2); | |||
3578 | // char * emsg = check_exception(); | |||
3579 | // if (emsg) { | |||
3580 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3581 | // return NULL; | |||
3582 | // } | |||
3583 | bool_Bool exception_thrown = check_exception2(); | |||
3584 | if (exception_thrown) { | |||
3585 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3586 | return NULL((void*)0); | |||
3587 | } | |||
3588 | } | |||
3589 | resultobj = SWIG_From_int((int)(result)); | |||
3590 | return resultobj; | |||
3591 | fail: | |||
3592 | return NULL((void*)0); | |||
3593 | } | |||
3594 | ||||
3595 | ||||
3596 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_get_output_level(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3597 | PyObject *resultobj = 0; | |||
3598 | DDCA_Output_Level result; | |||
3599 | ||||
3600 | if (!PyArg_ParseTuple(args,(char *)":ddcs_get_output_level")) SWIG_failgoto fail; | |||
3601 | { | |||
3602 | clear_exception(); // redundant | |||
3603 | result = (DDCA_Output_Level)ddca_get_output_level(); | |||
3604 | // char * emsg = check_exception(); | |||
3605 | // if (emsg) { | |||
3606 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3607 | // return NULL; | |||
3608 | // } | |||
3609 | bool_Bool exception_thrown = check_exception2(); | |||
3610 | if (exception_thrown) { | |||
3611 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3612 | return NULL((void*)0); | |||
3613 | } | |||
3614 | } | |||
3615 | resultobj = SWIG_From_int((int)(result)); | |||
3616 | return resultobj; | |||
3617 | fail: | |||
3618 | return NULL((void*)0); | |||
3619 | } | |||
3620 | ||||
3621 | ||||
3622 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_set_output_level(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3623 | PyObject *resultobj = 0; | |||
3624 | DDCA_Output_Level arg1 ; | |||
3625 | int val1 ; | |||
3626 | int ecode1 = 0 ; | |||
3627 | PyObject * obj0 = 0 ; | |||
3628 | ||||
3629 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_set_output_level",&obj0)) SWIG_failgoto fail; | |||
3630 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3631 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3632 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_set_output_level" "', argument " "1"" of type '" "DDCA_Output_Level""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_set_output_level" "', argument " "1"" of type '" "DDCA_Output_Level""'"); goto fail; } while(0); | |||
3633 | } | |||
3634 | arg1 = (DDCA_Output_Level)(val1); | |||
3635 | { | |||
3636 | clear_exception(); // redundant | |||
3637 | ddca_set_output_level(arg1); | |||
3638 | // char * emsg = check_exception(); | |||
3639 | // if (emsg) { | |||
3640 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3641 | // return NULL; | |||
3642 | // } | |||
3643 | bool_Bool exception_thrown = check_exception2(); | |||
3644 | if (exception_thrown) { | |||
3645 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3646 | return NULL((void*)0); | |||
3647 | } | |||
3648 | } | |||
3649 | resultobj = SWIG_Py_Void(); | |||
3650 | return resultobj; | |||
3651 | fail: | |||
3652 | return NULL((void*)0); | |||
3653 | } | |||
3654 | ||||
3655 | ||||
3656 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_output_level_name(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3657 | PyObject *resultobj = 0; | |||
3658 | DDCA_Output_Level arg1 ; | |||
3659 | int val1 ; | |||
3660 | int ecode1 = 0 ; | |||
3661 | PyObject * obj0 = 0 ; | |||
3662 | char *result = 0 ; | |||
3663 | ||||
3664 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_output_level_name",&obj0)) SWIG_failgoto fail; | |||
3665 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3666 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3667 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_output_level_name" "', argument " "1"" of type '" "DDCA_Output_Level""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_output_level_name" "', argument " "1"" of type '" "DDCA_Output_Level""'"); goto fail; } while(0); | |||
3668 | } | |||
3669 | arg1 = (DDCA_Output_Level)(val1); | |||
3670 | { | |||
3671 | clear_exception(); // redundant | |||
3672 | result = (char *)ddca_output_level_name(arg1); | |||
3673 | // char * emsg = check_exception(); | |||
3674 | // if (emsg) { | |||
3675 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3676 | // return NULL; | |||
3677 | // } | |||
3678 | bool_Bool exception_thrown = check_exception2(); | |||
3679 | if (exception_thrown) { | |||
3680 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3681 | return NULL((void*)0); | |||
3682 | } | |||
3683 | } | |||
3684 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
3685 | return resultobj; | |||
3686 | fail: | |||
3687 | return NULL((void*)0); | |||
3688 | } | |||
3689 | ||||
3690 | ||||
3691 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_enable_report_ddc_errors(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3692 | PyObject *resultobj = 0; | |||
3693 | bool_Bool arg1 ; | |||
3694 | bool_Bool val1 ; | |||
3695 | int ecode1 = 0 ; | |||
3696 | PyObject * obj0 = 0 ; | |||
3697 | ||||
3698 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_enable_report_ddc_errors",&obj0)) SWIG_failgoto fail; | |||
3699 | ecode1 = SWIG_AsVal_bool(obj0, &val1); | |||
3700 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3701 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_enable_report_ddc_errors" "', argument " "1"" of type '" "bool""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_enable_report_ddc_errors" "', argument " "1"" of type '" "bool""'"); goto fail; } while (0); | |||
3702 | } | |||
3703 | arg1 = (bool_Bool)(val1); | |||
3704 | { | |||
3705 | clear_exception(); // redundant | |||
3706 | ddca_enable_report_ddc_errors(arg1); | |||
3707 | // char * emsg = check_exception(); | |||
3708 | // if (emsg) { | |||
3709 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3710 | // return NULL; | |||
3711 | // } | |||
3712 | bool_Bool exception_thrown = check_exception2(); | |||
3713 | if (exception_thrown) { | |||
3714 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3715 | return NULL((void*)0); | |||
3716 | } | |||
3717 | } | |||
3718 | resultobj = SWIG_Py_Void(); | |||
3719 | return resultobj; | |||
3720 | fail: | |||
3721 | return NULL((void*)0); | |||
3722 | } | |||
3723 | ||||
3724 | ||||
3725 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_is_report_ddc_errors_enabled(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3726 | PyObject *resultobj = 0; | |||
3727 | bool_Bool result; | |||
3728 | ||||
3729 | if (!PyArg_ParseTuple(args,(char *)":ddcs_is_report_ddc_errors_enabled")) SWIG_failgoto fail; | |||
3730 | { | |||
3731 | clear_exception(); // redundant | |||
3732 | result = (bool_Bool)ddca_is_report_ddc_errors_enabled(); | |||
3733 | // char * emsg = check_exception(); | |||
3734 | // if (emsg) { | |||
3735 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3736 | // return NULL; | |||
3737 | // } | |||
3738 | bool_Bool exception_thrown = check_exception2(); | |||
3739 | if (exception_thrown) { | |||
3740 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3741 | return NULL((void*)0); | |||
3742 | } | |||
3743 | } | |||
3744 | resultobj = SWIG_From_bool((bool_Bool)(result)); | |||
3745 | return resultobj; | |||
3746 | fail: | |||
3747 | return NULL((void*)0); | |||
3748 | } | |||
3749 | ||||
3750 | ||||
3751 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_set_fout(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3752 | PyObject *resultobj = 0; | |||
3753 | FILE *arg1 = (FILE *) 0 ; | |||
3754 | PyObject * obj0 = 0 ; | |||
3755 | ||||
3756 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_set_fout",&obj0)) SWIG_failgoto fail; | |||
3757 | { | |||
3758 | FILE * result = NULL((void*)0); | |||
3759 | printf("(%s) input = %p\n", __func__, obj0); | |||
3760 | int is_pyfile = PyFile_Check(obj0)((((PyObject*)(obj0))->ob_type) == (&PyFile_Type) || PyType_IsSubtype ((((PyObject*)(obj0))->ob_type), (&PyFile_Type))); | |||
3761 | printf("(%s) is_pyfile=%d\n", __func__, is_pyfile); | |||
3762 | if ( PyFile_Check(obj0)((((PyObject*)(obj0))->ob_type) == (&PyFile_Type) || PyType_IsSubtype ((((PyObject*)(obj0))->ob_type), (&PyFile_Type))) ) { | |||
3763 | result = PyFile_AsFile(obj0); | |||
3764 | save_current_python_fout( (PyFileObject *) obj0); | |||
3765 | } | |||
3766 | else if (obj0 == Py_None(&_Py_NoneStruct)) { | |||
3767 | result = NULL((void*)0); | |||
3768 | } | |||
3769 | else { | |||
3770 | PyErr_SetString(PyExc_ValueError, "Not a Python file object"); | |||
3771 | return NULL((void*)0); | |||
3772 | } | |||
3773 | printf("(%s) Converted value: %p\n", __func__, result); | |||
3774 | arg1 = result; | |||
3775 | } | |||
3776 | { | |||
3777 | clear_exception(); // redundant | |||
3778 | ddcs_set_fout(arg1); | |||
3779 | // char * emsg = check_exception(); | |||
3780 | // if (emsg) { | |||
3781 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3782 | // return NULL; | |||
3783 | // } | |||
3784 | bool_Bool exception_thrown = check_exception2(); | |||
3785 | if (exception_thrown) { | |||
3786 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3787 | return NULL((void*)0); | |||
3788 | } | |||
3789 | } | |||
3790 | resultobj = SWIG_Py_Void(); | |||
3791 | return resultobj; | |||
3792 | fail: | |||
3793 | return NULL((void*)0); | |||
3794 | } | |||
3795 | ||||
3796 | ||||
3797 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_create_dispno_display_identifier(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3798 | PyObject *resultobj = 0; | |||
3799 | int arg1 ; | |||
3800 | int val1 ; | |||
3801 | int ecode1 = 0 ; | |||
3802 | PyObject * obj0 = 0 ; | |||
3803 | DDCS_Display_Identifier result; | |||
3804 | ||||
3805 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_create_dispno_display_identifier",&obj0)) SWIG_failgoto fail; | |||
3806 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3807 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3808 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_create_dispno_display_identifier" "', argument " "1"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_create_dispno_display_identifier" "', argument " "1"" of type '" "int""'"); goto fail; } while (0); | |||
3809 | } | |||
3810 | arg1 = (int)(val1); | |||
3811 | { | |||
3812 | clear_exception(); // redundant | |||
3813 | result = (DDCS_Display_Identifier)ddcs_create_dispno_display_identifier(arg1); | |||
3814 | // char * emsg = check_exception(); | |||
3815 | // if (emsg) { | |||
3816 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3817 | // return NULL; | |||
3818 | // } | |||
3819 | bool_Bool exception_thrown = check_exception2(); | |||
3820 | if (exception_thrown) { | |||
3821 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3822 | return NULL((void*)0); | |||
3823 | } | |||
3824 | } | |||
3825 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[9], 0 | 0); | |||
3826 | return resultobj; | |||
3827 | fail: | |||
3828 | return NULL((void*)0); | |||
3829 | } | |||
3830 | ||||
3831 | ||||
3832 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_create_adlno_display_identifier(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3833 | PyObject *resultobj = 0; | |||
3834 | int arg1 ; | |||
3835 | int arg2 ; | |||
3836 | int val1 ; | |||
3837 | int ecode1 = 0 ; | |||
3838 | int val2 ; | |||
3839 | int ecode2 = 0 ; | |||
3840 | PyObject * obj0 = 0 ; | |||
3841 | PyObject * obj1 = 0 ; | |||
3842 | DDCS_Display_Identifier result; | |||
3843 | ||||
3844 | if (!PyArg_ParseTuple(args,(char *)"OO:ddcs_create_adlno_display_identifier",&obj0,&obj1)) SWIG_failgoto fail; | |||
3845 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3846 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3847 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_create_adlno_display_identifier" "', argument " "1"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_create_adlno_display_identifier" "', argument " "1"" of type '" "int""'"); goto fail; } while (0); | |||
3848 | } | |||
3849 | arg1 = (int)(val1); | |||
3850 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
3851 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
3852 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ddcs_create_adlno_display_identifier" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "ddcs_create_adlno_display_identifier" "', argument " "2"" of type '" "int""'"); goto fail; } while (0); | |||
3853 | } | |||
3854 | arg2 = (int)(val2); | |||
3855 | { | |||
3856 | clear_exception(); // redundant | |||
3857 | result = (DDCS_Display_Identifier)ddcs_create_adlno_display_identifier(arg1,arg2); | |||
3858 | // char * emsg = check_exception(); | |||
3859 | // if (emsg) { | |||
3860 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3861 | // return NULL; | |||
3862 | // } | |||
3863 | bool_Bool exception_thrown = check_exception2(); | |||
3864 | if (exception_thrown) { | |||
3865 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3866 | return NULL((void*)0); | |||
3867 | } | |||
3868 | } | |||
3869 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[9], 0 | 0); | |||
3870 | return resultobj; | |||
3871 | fail: | |||
3872 | return NULL((void*)0); | |||
3873 | } | |||
3874 | ||||
3875 | ||||
3876 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_create_busno_display_identifier(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3877 | PyObject *resultobj = 0; | |||
3878 | int arg1 ; | |||
3879 | int val1 ; | |||
3880 | int ecode1 = 0 ; | |||
3881 | PyObject * obj0 = 0 ; | |||
3882 | DDCS_Display_Identifier result; | |||
3883 | ||||
3884 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_create_busno_display_identifier",&obj0)) SWIG_failgoto fail; | |||
3885 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
3886 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
3887 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_create_busno_display_identifier" "', argument " "1"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_create_busno_display_identifier" "', argument " "1"" of type '" "int""'"); goto fail; } while (0); | |||
3888 | } | |||
3889 | arg1 = (int)(val1); | |||
3890 | { | |||
3891 | clear_exception(); // redundant | |||
3892 | result = (DDCS_Display_Identifier)ddcs_create_busno_display_identifier(arg1); | |||
3893 | // char * emsg = check_exception(); | |||
3894 | // if (emsg) { | |||
3895 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3896 | // return NULL; | |||
3897 | // } | |||
3898 | bool_Bool exception_thrown = check_exception2(); | |||
3899 | if (exception_thrown) { | |||
3900 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3901 | return NULL((void*)0); | |||
3902 | } | |||
3903 | } | |||
3904 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[9], 0 | 0); | |||
3905 | return resultobj; | |||
3906 | fail: | |||
3907 | return NULL((void*)0); | |||
3908 | } | |||
3909 | ||||
3910 | ||||
3911 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_create_mfg_model_sn_display_identifier(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3912 | PyObject *resultobj = 0; | |||
3913 | char *arg1 = (char *) 0 ; | |||
3914 | char *arg2 = (char *) 0 ; | |||
3915 | char *arg3 = (char *) 0 ; | |||
3916 | int res1 ; | |||
3917 | char *buf1 = 0 ; | |||
3918 | int alloc1 = 0 ; | |||
3919 | int res2 ; | |||
3920 | char *buf2 = 0 ; | |||
3921 | int alloc2 = 0 ; | |||
3922 | int res3 ; | |||
3923 | char *buf3 = 0 ; | |||
3924 | int alloc3 = 0 ; | |||
3925 | PyObject * obj0 = 0 ; | |||
3926 | PyObject * obj1 = 0 ; | |||
3927 | PyObject * obj2 = 0 ; | |||
3928 | DDCS_Display_Identifier result; | |||
3929 | ||||
3930 | if (!PyArg_ParseTuple(args,(char *)"OOO:ddcs_create_mfg_model_sn_display_identifier",&obj0,&obj1,&obj2)) SWIG_failgoto fail; | |||
3931 | res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL((void*)0), &alloc1); | |||
3932 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
3933 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_create_mfg_model_sn_display_identifier" "', argument " "1"" of type '" "char const *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_create_mfg_model_sn_display_identifier" "', argument " "1"" of type '" "char const *""'"); goto fail ; } while(0); | |||
3934 | } | |||
3935 | arg1 = (char *)(buf1); | |||
3936 | res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL((void*)0), &alloc2); | |||
3937 | if (!SWIG_IsOK(res2)(res2 >= 0)) { | |||
3938 | SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ddcs_create_mfg_model_sn_display_identifier" "', argument " "2"" of type '" "char const *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res2 != ( -1)) ? res2 : -5)), "in method '" "ddcs_create_mfg_model_sn_display_identifier" "', argument " "2"" of type '" "char const *""'"); goto fail ; } while(0); | |||
3939 | } | |||
3940 | arg2 = (char *)(buf2); | |||
3941 | res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL((void*)0), &alloc3); | |||
3942 | if (!SWIG_IsOK(res3)(res3 >= 0)) { | |||
3943 | SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ddcs_create_mfg_model_sn_display_identifier" "', argument " "3"" of type '" "char const *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res3 != ( -1)) ? res3 : -5)), "in method '" "ddcs_create_mfg_model_sn_display_identifier" "', argument " "3"" of type '" "char const *""'"); goto fail ; } while(0); | |||
3944 | } | |||
3945 | arg3 = (char *)(buf3); | |||
3946 | { | |||
3947 | clear_exception(); // redundant | |||
3948 | result = (DDCS_Display_Identifier)ddcs_create_mfg_model_sn_display_identifier((char const *)arg1,(char const *)arg2,(char const *)arg3); | |||
3949 | // char * emsg = check_exception(); | |||
3950 | // if (emsg) { | |||
3951 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
3952 | // return NULL; | |||
3953 | // } | |||
3954 | bool_Bool exception_thrown = check_exception2(); | |||
3955 | if (exception_thrown) { | |||
3956 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
3957 | return NULL((void*)0); | |||
3958 | } | |||
3959 | } | |||
3960 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[9], 0 | 0); | |||
3961 | if (alloc1 == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) free((char*)buf1); | |||
3962 | if (alloc2 == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) free((char*)buf2); | |||
3963 | if (alloc3 == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) free((char*)buf3); | |||
3964 | return resultobj; | |||
3965 | fail: | |||
3966 | if (alloc1 == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) free((char*)buf1); | |||
3967 | if (alloc2 == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) free((char*)buf2); | |||
3968 | if (alloc3 == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) free((char*)buf3); | |||
3969 | return NULL((void*)0); | |||
3970 | } | |||
3971 | ||||
3972 | ||||
3973 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_create_edid_display_identifier(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
3974 | PyObject *resultobj = 0; | |||
3975 | uint8_t *arg1 = (uint8_t *) 0 ; | |||
3976 | int arg2 ; | |||
3977 | void *argp1 = 0 ; | |||
3978 | int res1 = 0 ; | |||
3979 | int val2 ; | |||
3980 | int ecode2 = 0 ; | |||
3981 | PyObject * obj0 = 0 ; | |||
3982 | PyObject * obj1 = 0 ; | |||
3983 | DDCS_Display_Identifier result; | |||
3984 | ||||
3985 | if (!PyArg_ParseTuple(args,(char *)"OO:ddcs_create_edid_display_identifier",&obj0,&obj1)) SWIG_failgoto fail; | |||
3986 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_uint8_t, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[8], 0 | 0, 0); | |||
3987 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
3988 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_create_edid_display_identifier" "', argument " "1"" of type '" "uint8_t const *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_create_edid_display_identifier" "', argument " "1"" of type '" "uint8_t const *""'"); goto fail ; } while(0); | |||
3989 | } | |||
3990 | arg1 = (uint8_t *)(argp1); | |||
3991 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
3992 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
3993 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ddcs_create_edid_display_identifier" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "ddcs_create_edid_display_identifier" "', argument " "2"" of type '" "int""'"); goto fail; } while (0); | |||
3994 | } | |||
3995 | arg2 = (int)(val2); | |||
3996 | { | |||
3997 | clear_exception(); // redundant | |||
3998 | result = (DDCS_Display_Identifier)ddcs_create_edid_display_identifier((uint8_t const *)arg1,arg2); | |||
3999 | // char * emsg = check_exception(); | |||
4000 | // if (emsg) { | |||
4001 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4002 | // return NULL; | |||
4003 | // } | |||
4004 | bool_Bool exception_thrown = check_exception2(); | |||
4005 | if (exception_thrown) { | |||
4006 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4007 | return NULL((void*)0); | |||
4008 | } | |||
4009 | } | |||
4010 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[9], 0 | 0); | |||
4011 | return resultobj; | |||
4012 | fail: | |||
4013 | return NULL((void*)0); | |||
4014 | } | |||
4015 | ||||
4016 | ||||
4017 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_create_usb_display_identifier(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4018 | PyObject *resultobj = 0; | |||
4019 | int arg1 ; | |||
4020 | int arg2 ; | |||
4021 | int val1 ; | |||
4022 | int ecode1 = 0 ; | |||
4023 | int val2 ; | |||
4024 | int ecode2 = 0 ; | |||
4025 | PyObject * obj0 = 0 ; | |||
4026 | PyObject * obj1 = 0 ; | |||
4027 | DDCS_Display_Identifier result; | |||
4028 | ||||
4029 | if (!PyArg_ParseTuple(args,(char *)"OO:ddcs_create_usb_display_identifier",&obj0,&obj1)) SWIG_failgoto fail; | |||
4030 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
4031 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
4032 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_create_usb_display_identifier" "', argument " "1"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_create_usb_display_identifier" "', argument " "1"" of type '" "int""'"); goto fail; } while (0); | |||
4033 | } | |||
4034 | arg1 = (int)(val1); | |||
4035 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
4036 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
4037 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ddcs_create_usb_display_identifier" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "ddcs_create_usb_display_identifier" "', argument " "2"" of type '" "int""'"); goto fail; } while (0); | |||
4038 | } | |||
4039 | arg2 = (int)(val2); | |||
4040 | { | |||
4041 | clear_exception(); // redundant | |||
4042 | result = (DDCS_Display_Identifier)ddcs_create_usb_display_identifier(arg1,arg2); | |||
4043 | // char * emsg = check_exception(); | |||
4044 | // if (emsg) { | |||
4045 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4046 | // return NULL; | |||
4047 | // } | |||
4048 | bool_Bool exception_thrown = check_exception2(); | |||
4049 | if (exception_thrown) { | |||
4050 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4051 | return NULL((void*)0); | |||
4052 | } | |||
4053 | } | |||
4054 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[9], 0 | 0); | |||
4055 | return resultobj; | |||
4056 | fail: | |||
4057 | return NULL((void*)0); | |||
4058 | } | |||
4059 | ||||
4060 | ||||
4061 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_free_display_identifier(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4062 | PyObject *resultobj = 0; | |||
4063 | DDCS_Display_Identifier arg1 = (DDCS_Display_Identifier) 0 ; | |||
4064 | int res1 ; | |||
4065 | PyObject * obj0 = 0 ; | |||
4066 | ||||
4067 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_free_display_identifier",&obj0)) SWIG_failgoto fail; | |||
4068 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4069 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4070 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_free_display_identifier" "', argument " "1"" of type '" "DDCS_Display_Identifier""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_free_display_identifier" "', argument " "1"" of type '" "DDCS_Display_Identifier""'") ; goto fail; } while(0); | |||
4071 | } | |||
4072 | { | |||
4073 | clear_exception(); // redundant | |||
4074 | ddcs_free_display_identifier(arg1); | |||
4075 | // char * emsg = check_exception(); | |||
4076 | // if (emsg) { | |||
4077 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4078 | // return NULL; | |||
4079 | // } | |||
4080 | bool_Bool exception_thrown = check_exception2(); | |||
4081 | if (exception_thrown) { | |||
4082 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4083 | return NULL((void*)0); | |||
4084 | } | |||
4085 | } | |||
4086 | resultobj = SWIG_Py_Void(); | |||
4087 | return resultobj; | |||
4088 | fail: | |||
4089 | return NULL((void*)0); | |||
4090 | } | |||
4091 | ||||
4092 | ||||
4093 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_repr_display_identifier(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4094 | PyObject *resultobj = 0; | |||
4095 | DDCS_Display_Identifier arg1 = (DDCS_Display_Identifier) 0 ; | |||
4096 | int res1 ; | |||
4097 | PyObject * obj0 = 0 ; | |||
4098 | char *result = 0 ; | |||
4099 | ||||
4100 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_repr_display_identifier",&obj0)) SWIG_failgoto fail; | |||
4101 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4102 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4103 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_repr_display_identifier" "', argument " "1"" of type '" "DDCS_Display_Identifier""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_repr_display_identifier" "', argument " "1"" of type '" "DDCS_Display_Identifier""'") ; goto fail; } while(0); | |||
4104 | } | |||
4105 | { | |||
4106 | clear_exception(); // redundant | |||
4107 | result = (char *)ddcs_repr_display_identifier(arg1); | |||
4108 | // char * emsg = check_exception(); | |||
4109 | // if (emsg) { | |||
4110 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4111 | // return NULL; | |||
4112 | // } | |||
4113 | bool_Bool exception_thrown = check_exception2(); | |||
4114 | if (exception_thrown) { | |||
4115 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4116 | return NULL((void*)0); | |||
4117 | } | |||
4118 | } | |||
4119 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
4120 | return resultobj; | |||
4121 | fail: | |||
4122 | return NULL((void*)0); | |||
4123 | } | |||
4124 | ||||
4125 | ||||
4126 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_get_display_ref(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4127 | PyObject *resultobj = 0; | |||
4128 | DDCS_Display_Identifier arg1 = (DDCS_Display_Identifier) 0 ; | |||
4129 | int res1 ; | |||
4130 | PyObject * obj0 = 0 ; | |||
4131 | DDCS_Display_Ref result; | |||
4132 | ||||
4133 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_get_display_ref",&obj0)) SWIG_failgoto fail; | |||
4134 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4135 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4136 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_get_display_ref" "', argument " "1"" of type '" "DDCS_Display_Identifier""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_get_display_ref" "', argument " "1"" of type '" "DDCS_Display_Identifier""'"); goto fail; } while (0); | |||
4137 | } | |||
4138 | { | |||
4139 | clear_exception(); // redundant | |||
4140 | result = (DDCS_Display_Ref)ddcs_get_display_ref(arg1); | |||
4141 | // char * emsg = check_exception(); | |||
4142 | // if (emsg) { | |||
4143 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4144 | // return NULL; | |||
4145 | // } | |||
4146 | bool_Bool exception_thrown = check_exception2(); | |||
4147 | if (exception_thrown) { | |||
4148 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4149 | return NULL((void*)0); | |||
4150 | } | |||
4151 | } | |||
4152 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[9], 0 | 0); | |||
4153 | return resultobj; | |||
4154 | fail: | |||
4155 | return NULL((void*)0); | |||
4156 | } | |||
4157 | ||||
4158 | ||||
4159 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_free_display_ref(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4160 | PyObject *resultobj = 0; | |||
4161 | DDCS_Display_Ref arg1 = (DDCS_Display_Ref) 0 ; | |||
4162 | int res1 ; | |||
4163 | PyObject * obj0 = 0 ; | |||
4164 | ||||
4165 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_free_display_ref",&obj0)) SWIG_failgoto fail; | |||
4166 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4167 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4168 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_free_display_ref" "', argument " "1"" of type '" "DDCS_Display_Ref""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_free_display_ref" "', argument " "1"" of type '" "DDCS_Display_Ref""'"); goto fail; } while(0 ); | |||
4169 | } | |||
4170 | { | |||
4171 | clear_exception(); // redundant | |||
4172 | ddcs_free_display_ref(arg1); | |||
4173 | // char * emsg = check_exception(); | |||
4174 | // if (emsg) { | |||
4175 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4176 | // return NULL; | |||
4177 | // } | |||
4178 | bool_Bool exception_thrown = check_exception2(); | |||
4179 | if (exception_thrown) { | |||
4180 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4181 | return NULL((void*)0); | |||
4182 | } | |||
4183 | } | |||
4184 | resultobj = SWIG_Py_Void(); | |||
4185 | return resultobj; | |||
4186 | fail: | |||
4187 | return NULL((void*)0); | |||
4188 | } | |||
4189 | ||||
4190 | ||||
4191 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_repr_display_ref(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4192 | PyObject *resultobj = 0; | |||
4193 | DDCS_Display_Ref arg1 = (DDCS_Display_Ref) 0 ; | |||
4194 | int res1 ; | |||
4195 | PyObject * obj0 = 0 ; | |||
4196 | char *result = 0 ; | |||
4197 | ||||
4198 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_repr_display_ref",&obj0)) SWIG_failgoto fail; | |||
4199 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4200 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4201 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_repr_display_ref" "', argument " "1"" of type '" "DDCS_Display_Ref""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_repr_display_ref" "', argument " "1"" of type '" "DDCS_Display_Ref""'"); goto fail; } while(0 ); | |||
4202 | } | |||
4203 | { | |||
4204 | clear_exception(); // redundant | |||
4205 | result = (char *)ddcs_repr_display_ref(arg1); | |||
4206 | // char * emsg = check_exception(); | |||
4207 | // if (emsg) { | |||
4208 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4209 | // return NULL; | |||
4210 | // } | |||
4211 | bool_Bool exception_thrown = check_exception2(); | |||
4212 | if (exception_thrown) { | |||
4213 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4214 | return NULL((void*)0); | |||
4215 | } | |||
4216 | } | |||
4217 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
4218 | return resultobj; | |||
4219 | fail: | |||
4220 | return NULL((void*)0); | |||
4221 | } | |||
4222 | ||||
4223 | ||||
4224 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_report_display_ref(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4225 | PyObject *resultobj = 0; | |||
4226 | DDCS_Display_Ref arg1 = (DDCS_Display_Ref) 0 ; | |||
4227 | int arg2 ; | |||
4228 | int res1 ; | |||
4229 | int val2 ; | |||
4230 | int ecode2 = 0 ; | |||
4231 | PyObject * obj0 = 0 ; | |||
4232 | PyObject * obj1 = 0 ; | |||
4233 | ||||
4234 | if (!PyArg_ParseTuple(args,(char *)"OO:ddcs_report_display_ref",&obj0,&obj1)) SWIG_failgoto fail; | |||
4235 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4236 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4237 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_report_display_ref" "', argument " "1"" of type '" "DDCS_Display_Ref""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_report_display_ref" "', argument " "1"" of type '" "DDCS_Display_Ref""'"); goto fail; } while(0 ); | |||
4238 | } | |||
4239 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
4240 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
4241 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ddcs_report_display_ref" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "ddcs_report_display_ref" "', argument " "2"" of type '" "int""'"); goto fail; } while (0); | |||
4242 | } | |||
4243 | arg2 = (int)(val2); | |||
4244 | { | |||
4245 | clear_exception(); // redundant | |||
4246 | ddcs_report_display_ref(arg1,arg2); | |||
4247 | // char * emsg = check_exception(); | |||
4248 | // if (emsg) { | |||
4249 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4250 | // return NULL; | |||
4251 | // } | |||
4252 | bool_Bool exception_thrown = check_exception2(); | |||
4253 | if (exception_thrown) { | |||
4254 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4255 | return NULL((void*)0); | |||
4256 | } | |||
4257 | } | |||
4258 | resultobj = SWIG_Py_Void(); | |||
4259 | return resultobj; | |||
4260 | fail: | |||
4261 | return NULL((void*)0); | |||
4262 | } | |||
4263 | ||||
4264 | ||||
4265 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_open_display(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4266 | PyObject *resultobj = 0; | |||
4267 | DDCS_Display_Ref arg1 = (DDCS_Display_Ref) 0 ; | |||
4268 | int res1 ; | |||
4269 | PyObject * obj0 = 0 ; | |||
4270 | DDCS_Display_Handle result; | |||
4271 | ||||
4272 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_open_display",&obj0)) SWIG_failgoto fail; | |||
4273 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4274 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4275 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_open_display" "', argument " "1"" of type '" "DDCS_Display_Ref""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_open_display" "', argument " "1"" of type '" "DDCS_Display_Ref""'"); goto fail; } while(0 ); | |||
4276 | } | |||
4277 | { | |||
4278 | clear_exception(); // redundant | |||
4279 | result = (DDCS_Display_Handle)ddcs_open_display(arg1); | |||
4280 | // char * emsg = check_exception(); | |||
4281 | // if (emsg) { | |||
4282 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4283 | // return NULL; | |||
4284 | // } | |||
4285 | bool_Bool exception_thrown = check_exception2(); | |||
4286 | if (exception_thrown) { | |||
4287 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4288 | return NULL((void*)0); | |||
4289 | } | |||
4290 | } | |||
4291 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[9], 0 | 0); | |||
4292 | return resultobj; | |||
4293 | fail: | |||
4294 | return NULL((void*)0); | |||
4295 | } | |||
4296 | ||||
4297 | ||||
4298 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_close_display(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4299 | PyObject *resultobj = 0; | |||
4300 | DDCS_Display_Handle arg1 = (DDCS_Display_Handle) 0 ; | |||
4301 | int res1 ; | |||
4302 | PyObject * obj0 = 0 ; | |||
4303 | ||||
4304 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_close_display",&obj0)) SWIG_failgoto fail; | |||
4305 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4306 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4307 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_close_display" "', argument " "1"" of type '" "DDCS_Display_Handle""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_close_display" "', argument " "1"" of type '" "DDCS_Display_Handle""'"); goto fail; } while (0); | |||
4308 | } | |||
4309 | { | |||
4310 | clear_exception(); // redundant | |||
4311 | ddcs_close_display(arg1); | |||
4312 | // char * emsg = check_exception(); | |||
4313 | // if (emsg) { | |||
4314 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4315 | // return NULL; | |||
4316 | // } | |||
4317 | bool_Bool exception_thrown = check_exception2(); | |||
4318 | if (exception_thrown) { | |||
4319 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4320 | return NULL((void*)0); | |||
4321 | } | |||
4322 | } | |||
4323 | resultobj = SWIG_Py_Void(); | |||
4324 | return resultobj; | |||
4325 | fail: | |||
4326 | return NULL((void*)0); | |||
4327 | } | |||
4328 | ||||
4329 | ||||
4330 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_repr_display_handle(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4331 | PyObject *resultobj = 0; | |||
4332 | DDCS_Display_Handle arg1 = (DDCS_Display_Handle) 0 ; | |||
4333 | int res1 ; | |||
4334 | PyObject * obj0 = 0 ; | |||
4335 | char *result = 0 ; | |||
4336 | ||||
4337 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_repr_display_handle",&obj0)) SWIG_failgoto fail; | |||
4338 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4339 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4340 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_repr_display_handle" "', argument " "1"" of type '" "DDCS_Display_Handle""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_repr_display_handle" "', argument " "1"" of type '" "DDCS_Display_Handle""'"); goto fail; } while (0); | |||
4341 | } | |||
4342 | { | |||
4343 | clear_exception(); // redundant | |||
4344 | result = (char *)ddcs_repr_display_handle(arg1); | |||
4345 | // char * emsg = check_exception(); | |||
4346 | // if (emsg) { | |||
4347 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4348 | // return NULL; | |||
4349 | // } | |||
4350 | bool_Bool exception_thrown = check_exception2(); | |||
4351 | if (exception_thrown) { | |||
4352 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4353 | return NULL((void*)0); | |||
4354 | } | |||
4355 | } | |||
4356 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
4357 | return resultobj; | |||
4358 | fail: | |||
4359 | return NULL((void*)0); | |||
4360 | } | |||
4361 | ||||
4362 | ||||
4363 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_report_active_displays(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4364 | PyObject *resultobj = 0; | |||
4365 | int arg1 ; | |||
4366 | int val1 ; | |||
4367 | int ecode1 = 0 ; | |||
4368 | PyObject * obj0 = 0 ; | |||
4369 | int result; | |||
4370 | ||||
4371 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_report_active_displays",&obj0)) SWIG_failgoto fail; | |||
4372 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
4373 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
4374 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_report_active_displays" "', argument " "1"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_report_active_displays" "', argument " "1"" of type '" "int""'"); goto fail; } while (0); | |||
4375 | } | |||
4376 | arg1 = (int)(val1); | |||
4377 | { | |||
4378 | clear_exception(); // redundant | |||
4379 | result = (int)ddcs_report_active_displays(arg1); | |||
4380 | // char * emsg = check_exception(); | |||
4381 | // if (emsg) { | |||
4382 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4383 | // return NULL; | |||
4384 | // } | |||
4385 | bool_Bool exception_thrown = check_exception2(); | |||
4386 | if (exception_thrown) { | |||
4387 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4388 | return NULL((void*)0); | |||
4389 | } | |||
4390 | } | |||
4391 | resultobj = SWIG_From_int((int)(result)); | |||
4392 | return resultobj; | |||
4393 | fail: | |||
4394 | return NULL((void*)0); | |||
4395 | } | |||
4396 | ||||
4397 | ||||
4398 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_MCCS_Version_Spec_major_set(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4399 | PyObject *resultobj = 0; | |||
4400 | DDCS_MCCS_Version_Spec *arg1 = (DDCS_MCCS_Version_Spec *) 0 ; | |||
4401 | int arg2 ; | |||
4402 | void *argp1 = 0 ; | |||
4403 | int res1 = 0 ; | |||
4404 | int val2 ; | |||
4405 | int ecode2 = 0 ; | |||
4406 | PyObject * obj0 = 0 ; | |||
4407 | PyObject * obj1 = 0 ; | |||
4408 | ||||
4409 | if (!PyArg_ParseTuple(args,(char *)"OO:DDCS_MCCS_Version_Spec_major_set",&obj0,&obj1)) SWIG_failgoto fail; | |||
4410 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_MCCS_Version_Spec, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[3], 0 | 0, 0); | |||
4411 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4412 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_MCCS_Version_Spec_major_set" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_MCCS_Version_Spec_major_set" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'" ); goto fail; } while(0); | |||
4413 | } | |||
4414 | arg1 = (DDCS_MCCS_Version_Spec *)(argp1); | |||
4415 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
4416 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
4417 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DDCS_MCCS_Version_Spec_major_set" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "DDCS_MCCS_Version_Spec_major_set" "', argument " "2"" of type '" "int""'"); goto fail; } while (0); | |||
4418 | } | |||
4419 | arg2 = (int)(val2); | |||
4420 | if (arg1) (arg1)->major = arg2; | |||
4421 | resultobj = SWIG_Py_Void(); | |||
4422 | return resultobj; | |||
4423 | fail: | |||
4424 | return NULL((void*)0); | |||
4425 | } | |||
4426 | ||||
4427 | ||||
4428 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_MCCS_Version_Spec_major_get(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4429 | PyObject *resultobj = 0; | |||
4430 | DDCS_MCCS_Version_Spec *arg1 = (DDCS_MCCS_Version_Spec *) 0 ; | |||
4431 | void *argp1 = 0 ; | |||
4432 | int res1 = 0 ; | |||
4433 | PyObject * obj0 = 0 ; | |||
4434 | int result; | |||
4435 | ||||
4436 | if (!PyArg_ParseTuple(args,(char *)"O:DDCS_MCCS_Version_Spec_major_get",&obj0)) SWIG_failgoto fail; | |||
4437 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_MCCS_Version_Spec, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[3], 0 | 0, 0); | |||
4438 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4439 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_MCCS_Version_Spec_major_get" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_MCCS_Version_Spec_major_get" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'" ); goto fail; } while(0); | |||
4440 | } | |||
4441 | arg1 = (DDCS_MCCS_Version_Spec *)(argp1); | |||
4442 | result = (int) ((arg1)->major); | |||
4443 | resultobj = SWIG_From_int((int)(result)); | |||
4444 | return resultobj; | |||
4445 | fail: | |||
4446 | return NULL((void*)0); | |||
4447 | } | |||
4448 | ||||
4449 | ||||
4450 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_MCCS_Version_Spec_minor_set(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4451 | PyObject *resultobj = 0; | |||
4452 | DDCS_MCCS_Version_Spec *arg1 = (DDCS_MCCS_Version_Spec *) 0 ; | |||
4453 | int arg2 ; | |||
4454 | void *argp1 = 0 ; | |||
4455 | int res1 = 0 ; | |||
4456 | int val2 ; | |||
4457 | int ecode2 = 0 ; | |||
4458 | PyObject * obj0 = 0 ; | |||
4459 | PyObject * obj1 = 0 ; | |||
4460 | ||||
4461 | if (!PyArg_ParseTuple(args,(char *)"OO:DDCS_MCCS_Version_Spec_minor_set",&obj0,&obj1)) SWIG_failgoto fail; | |||
4462 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_MCCS_Version_Spec, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[3], 0 | 0, 0); | |||
4463 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4464 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_MCCS_Version_Spec_minor_set" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_MCCS_Version_Spec_minor_set" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'" ); goto fail; } while(0); | |||
4465 | } | |||
4466 | arg1 = (DDCS_MCCS_Version_Spec *)(argp1); | |||
4467 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
4468 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
4469 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DDCS_MCCS_Version_Spec_minor_set" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "DDCS_MCCS_Version_Spec_minor_set" "', argument " "2"" of type '" "int""'"); goto fail; } while (0); | |||
4470 | } | |||
4471 | arg2 = (int)(val2); | |||
4472 | if (arg1) (arg1)->minor = arg2; | |||
4473 | resultobj = SWIG_Py_Void(); | |||
4474 | return resultobj; | |||
4475 | fail: | |||
4476 | return NULL((void*)0); | |||
4477 | } | |||
4478 | ||||
4479 | ||||
4480 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_MCCS_Version_Spec_minor_get(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4481 | PyObject *resultobj = 0; | |||
4482 | DDCS_MCCS_Version_Spec *arg1 = (DDCS_MCCS_Version_Spec *) 0 ; | |||
4483 | void *argp1 = 0 ; | |||
4484 | int res1 = 0 ; | |||
4485 | PyObject * obj0 = 0 ; | |||
4486 | int result; | |||
4487 | ||||
4488 | if (!PyArg_ParseTuple(args,(char *)"O:DDCS_MCCS_Version_Spec_minor_get",&obj0)) SWIG_failgoto fail; | |||
4489 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_MCCS_Version_Spec, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[3], 0 | 0, 0); | |||
4490 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4491 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_MCCS_Version_Spec_minor_get" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_MCCS_Version_Spec_minor_get" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'" ); goto fail; } while(0); | |||
4492 | } | |||
4493 | arg1 = (DDCS_MCCS_Version_Spec *)(argp1); | |||
4494 | result = (int) ((arg1)->minor); | |||
4495 | resultobj = SWIG_From_int((int)(result)); | |||
4496 | return resultobj; | |||
4497 | fail: | |||
4498 | return NULL((void*)0); | |||
4499 | } | |||
4500 | ||||
4501 | ||||
4502 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_new_DDCS_MCCS_Version_Spec(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4503 | PyObject *resultobj = 0; | |||
4504 | DDCS_MCCS_Version_Spec *result = 0 ; | |||
4505 | ||||
4506 | if (!PyArg_ParseTuple(args,(char *)":new_DDCS_MCCS_Version_Spec")) SWIG_failgoto fail; | |||
| ||||
4507 | { | |||
4508 | clear_exception(); // redundant | |||
4509 | result = (DDCS_MCCS_Version_Spec *)calloc(1, sizeof(DDCS_MCCS_Version_Spec)); | |||
4510 | // char * emsg = check_exception(); | |||
4511 | // if (emsg) { | |||
4512 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4513 | // return NULL; | |||
4514 | // } | |||
4515 | bool_Bool exception_thrown = check_exception2(); | |||
4516 | if (exception_thrown) { | |||
4517 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
| ||||
4518 | return NULL((void*)0); | |||
4519 | } | |||
4520 | } | |||
4521 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DDCS_MCCS_Version_Spec, SWIG_POINTER_NEW | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[3], ((0x1 << 1) | 0x1) | 0); | |||
4522 | return resultobj; | |||
4523 | fail: | |||
4524 | return NULL((void*)0); | |||
4525 | } | |||
4526 | ||||
4527 | ||||
4528 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_delete_DDCS_MCCS_Version_Spec(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4529 | PyObject *resultobj = 0; | |||
4530 | DDCS_MCCS_Version_Spec *arg1 = (DDCS_MCCS_Version_Spec *) 0 ; | |||
4531 | void *argp1 = 0 ; | |||
4532 | int res1 = 0 ; | |||
4533 | PyObject * obj0 = 0 ; | |||
4534 | ||||
4535 | if (!PyArg_ParseTuple(args,(char *)"O:delete_DDCS_MCCS_Version_Spec",&obj0)) SWIG_failgoto fail; | |||
4536 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_MCCS_Version_Spec, SWIG_POINTER_DISOWN | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[3], 0x1 | 0, 0); | |||
4537 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4538 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DDCS_MCCS_Version_Spec" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "delete_DDCS_MCCS_Version_Spec" "', argument " "1"" of type '" "DDCS_MCCS_Version_Spec *""'" ); goto fail; } while(0); | |||
4539 | } | |||
4540 | arg1 = (DDCS_MCCS_Version_Spec *)(argp1); | |||
4541 | { | |||
4542 | clear_exception(); // redundant | |||
4543 | free((char *) arg1); | |||
4544 | // char * emsg = check_exception(); | |||
4545 | // if (emsg) { | |||
4546 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4547 | // return NULL; | |||
4548 | // } | |||
4549 | bool_Bool exception_thrown = check_exception2(); | |||
4550 | if (exception_thrown) { | |||
4551 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4552 | return NULL((void*)0); | |||
4553 | } | |||
4554 | } | |||
4555 | resultobj = SWIG_Py_Void(); | |||
4556 | return resultobj; | |||
4557 | fail: | |||
4558 | return NULL((void*)0); | |||
4559 | } | |||
4560 | ||||
4561 | ||||
4562 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *DDCS_MCCS_Version_Spec_swigregister(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4563 | PyObject *obj; | |||
4564 | if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL((void*)0); | |||
4565 | SWIG_TypeNewClientData(SWIGTYPE_p_DDCS_MCCS_Version_Specswig_types[3], SWIG_NewClientData(obj)SwigPyClientData_New(obj)); | |||
4566 | return SWIG_Py_Void(); | |||
4567 | } | |||
4568 | ||||
4569 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_get_feature_name(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4570 | PyObject *resultobj = 0; | |||
4571 | DDCS_VCP_Feature_Code arg1 ; | |||
4572 | int val1 ; | |||
4573 | int ecode1 = 0 ; | |||
4574 | PyObject * obj0 = 0 ; | |||
4575 | char *result = 0 ; | |||
4576 | ||||
4577 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_get_feature_name",&obj0)) SWIG_failgoto fail; | |||
4578 | ecode1 = SWIG_AsVal_int(obj0, &val1); | |||
4579 | if (!SWIG_IsOK(ecode1)(ecode1 >= 0)) { | |||
4580 | SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ddcs_get_feature_name" "', argument " "1"" of type '" "DDCS_VCP_Feature_Code""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode1 != (-1)) ? ecode1 : -5)), "in method '" "ddcs_get_feature_name" "', argument " "1"" of type '" "DDCS_VCP_Feature_Code""'"); goto fail; } while(0); | |||
4581 | } | |||
4582 | arg1 = (DDCS_VCP_Feature_Code)(val1); | |||
4583 | { | |||
4584 | clear_exception(); // redundant | |||
4585 | result = (char *)ddcs_get_feature_name(arg1); | |||
4586 | // char * emsg = check_exception(); | |||
4587 | // if (emsg) { | |||
4588 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4589 | // return NULL; | |||
4590 | // } | |||
4591 | bool_Bool exception_thrown = check_exception2(); | |||
4592 | if (exception_thrown) { | |||
4593 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4594 | return NULL((void*)0); | |||
4595 | } | |||
4596 | } | |||
4597 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
4598 | return resultobj; | |||
4599 | fail: | |||
4600 | return NULL((void*)0); | |||
4601 | } | |||
4602 | ||||
4603 | ||||
4604 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_get_capabilities_string(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4605 | PyObject *resultobj = 0; | |||
4606 | DDCS_Display_Handle arg1 = (DDCS_Display_Handle) 0 ; | |||
4607 | int res1 ; | |||
4608 | PyObject * obj0 = 0 ; | |||
4609 | char *result = 0 ; | |||
4610 | ||||
4611 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_get_capabilities_string",&obj0)) SWIG_failgoto fail; | |||
4612 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
4613 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4614 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_get_capabilities_string" "', argument " "1"" of type '" "DDCS_Display_Handle""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_get_capabilities_string" "', argument " "1"" of type '" "DDCS_Display_Handle""'"); goto fail; } while(0); | |||
4615 | } | |||
4616 | { | |||
4617 | clear_exception(); // redundant | |||
4618 | result = (char *)ddcs_get_capabilities_string(arg1); | |||
4619 | // char * emsg = check_exception(); | |||
4620 | // if (emsg) { | |||
4621 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4622 | // return NULL; | |||
4623 | // } | |||
4624 | bool_Bool exception_thrown = check_exception2(); | |||
4625 | if (exception_thrown) { | |||
4626 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4627 | return NULL((void*)0); | |||
4628 | } | |||
4629 | } | |||
4630 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
4631 | return resultobj; | |||
4632 | fail: | |||
4633 | return NULL((void*)0); | |||
4634 | } | |||
4635 | ||||
4636 | ||||
4637 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_mh_set(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4638 | PyObject *resultobj = 0; | |||
4639 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4640 | uint8_t arg2 ; | |||
4641 | void *argp1 = 0 ; | |||
4642 | int res1 = 0 ; | |||
4643 | void *argp2 ; | |||
4644 | int res2 = 0 ; | |||
4645 | PyObject * obj0 = 0 ; | |||
4646 | PyObject * obj1 = 0 ; | |||
4647 | ||||
4648 | if (!PyArg_ParseTuple(args,(char *)"OO:DDCS_Non_Table_Value_Response_mh_set",&obj0,&obj1)) SWIG_failgoto fail; | |||
4649 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4650 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4651 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_mh_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_mh_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4652 | } | |||
4653 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4654 | { | |||
4655 | res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint8_t, 0 )SWIG_Python_ConvertPtrAndOwn(obj1, &argp2, swig_types[8], 0, 0); | |||
4656 | if (!SWIG_IsOK(res2)(res2 >= 0)) { | |||
4657 | SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DDCS_Non_Table_Value_Response_mh_set" "', argument " "2"" of type '" "uint8_t""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res2 != ( -1)) ? res2 : -5)), "in method '" "DDCS_Non_Table_Value_Response_mh_set" "', argument " "2"" of type '" "uint8_t""'"); goto fail; } while (0); | |||
4658 | } | |||
4659 | if (!argp2) { | |||
4660 | SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DDCS_Non_Table_Value_Response_mh_set" "', argument " "2"" of type '" "uint8_t""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(-9), "invalid null reference " "in method '" "DDCS_Non_Table_Value_Response_mh_set" "', argument " "2"" of type '" "uint8_t""'"); goto fail; } while(0); | |||
4661 | } else { | |||
4662 | arg2 = *((uint8_t *)(argp2)); | |||
4663 | } | |||
4664 | } | |||
4665 | if (arg1) (arg1)->mh = arg2; | |||
4666 | resultobj = SWIG_Py_Void(); | |||
4667 | return resultobj; | |||
4668 | fail: | |||
4669 | return NULL((void*)0); | |||
4670 | } | |||
4671 | ||||
4672 | ||||
4673 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_mh_get(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4674 | PyObject *resultobj = 0; | |||
4675 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4676 | void *argp1 = 0 ; | |||
4677 | int res1 = 0 ; | |||
4678 | PyObject * obj0 = 0 ; | |||
4679 | uint8_t result; | |||
4680 | ||||
4681 | if (!PyArg_ParseTuple(args,(char *)"O:DDCS_Non_Table_Value_Response_mh_get",&obj0)) SWIG_failgoto fail; | |||
4682 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4683 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4684 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_mh_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_mh_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4685 | } | |||
4686 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4687 | result = ((arg1)->mh); | |||
4688 | resultobj = SWIG_NewPointerObj((uint8_t *)memcpy((uint8_t *)calloc(1,sizeof(uint8_t)),&result,sizeof(uint8_t)), SWIGTYPE_p_uint8_t, SWIG_POINTER_OWN | 0 )SWIG_Python_NewPointerObj(((void*)0), (uint8_t *)memcpy((uint8_t *)calloc(1,sizeof(uint8_t)),&result,sizeof(uint8_t)), swig_types [8], 0x1 | 0); | |||
4689 | return resultobj; | |||
4690 | fail: | |||
4691 | return NULL((void*)0); | |||
4692 | } | |||
4693 | ||||
4694 | ||||
4695 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_ml_set(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4696 | PyObject *resultobj = 0; | |||
4697 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4698 | uint8_t arg2 ; | |||
4699 | void *argp1 = 0 ; | |||
4700 | int res1 = 0 ; | |||
4701 | void *argp2 ; | |||
4702 | int res2 = 0 ; | |||
4703 | PyObject * obj0 = 0 ; | |||
4704 | PyObject * obj1 = 0 ; | |||
4705 | ||||
4706 | if (!PyArg_ParseTuple(args,(char *)"OO:DDCS_Non_Table_Value_Response_ml_set",&obj0,&obj1)) SWIG_failgoto fail; | |||
4707 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4708 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4709 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_ml_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_ml_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4710 | } | |||
4711 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4712 | { | |||
4713 | res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint8_t, 0 )SWIG_Python_ConvertPtrAndOwn(obj1, &argp2, swig_types[8], 0, 0); | |||
4714 | if (!SWIG_IsOK(res2)(res2 >= 0)) { | |||
4715 | SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DDCS_Non_Table_Value_Response_ml_set" "', argument " "2"" of type '" "uint8_t""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res2 != ( -1)) ? res2 : -5)), "in method '" "DDCS_Non_Table_Value_Response_ml_set" "', argument " "2"" of type '" "uint8_t""'"); goto fail; } while (0); | |||
4716 | } | |||
4717 | if (!argp2) { | |||
4718 | SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DDCS_Non_Table_Value_Response_ml_set" "', argument " "2"" of type '" "uint8_t""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(-9), "invalid null reference " "in method '" "DDCS_Non_Table_Value_Response_ml_set" "', argument " "2"" of type '" "uint8_t""'"); goto fail; } while(0); | |||
4719 | } else { | |||
4720 | arg2 = *((uint8_t *)(argp2)); | |||
4721 | } | |||
4722 | } | |||
4723 | if (arg1) (arg1)->ml = arg2; | |||
4724 | resultobj = SWIG_Py_Void(); | |||
4725 | return resultobj; | |||
4726 | fail: | |||
4727 | return NULL((void*)0); | |||
4728 | } | |||
4729 | ||||
4730 | ||||
4731 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_ml_get(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4732 | PyObject *resultobj = 0; | |||
4733 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4734 | void *argp1 = 0 ; | |||
4735 | int res1 = 0 ; | |||
4736 | PyObject * obj0 = 0 ; | |||
4737 | uint8_t result; | |||
4738 | ||||
4739 | if (!PyArg_ParseTuple(args,(char *)"O:DDCS_Non_Table_Value_Response_ml_get",&obj0)) SWIG_failgoto fail; | |||
4740 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4741 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4742 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_ml_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_ml_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4743 | } | |||
4744 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4745 | result = ((arg1)->ml); | |||
4746 | resultobj = SWIG_NewPointerObj((uint8_t *)memcpy((uint8_t *)calloc(1,sizeof(uint8_t)),&result,sizeof(uint8_t)), SWIGTYPE_p_uint8_t, SWIG_POINTER_OWN | 0 )SWIG_Python_NewPointerObj(((void*)0), (uint8_t *)memcpy((uint8_t *)calloc(1,sizeof(uint8_t)),&result,sizeof(uint8_t)), swig_types [8], 0x1 | 0); | |||
4747 | return resultobj; | |||
4748 | fail: | |||
4749 | return NULL((void*)0); | |||
4750 | } | |||
4751 | ||||
4752 | ||||
4753 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_sh_set(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4754 | PyObject *resultobj = 0; | |||
4755 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4756 | uint8_t arg2 ; | |||
4757 | void *argp1 = 0 ; | |||
4758 | int res1 = 0 ; | |||
4759 | void *argp2 ; | |||
4760 | int res2 = 0 ; | |||
4761 | PyObject * obj0 = 0 ; | |||
4762 | PyObject * obj1 = 0 ; | |||
4763 | ||||
4764 | if (!PyArg_ParseTuple(args,(char *)"OO:DDCS_Non_Table_Value_Response_sh_set",&obj0,&obj1)) SWIG_failgoto fail; | |||
4765 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4766 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4767 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_sh_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_sh_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4768 | } | |||
4769 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4770 | { | |||
4771 | res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint8_t, 0 )SWIG_Python_ConvertPtrAndOwn(obj1, &argp2, swig_types[8], 0, 0); | |||
4772 | if (!SWIG_IsOK(res2)(res2 >= 0)) { | |||
4773 | SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DDCS_Non_Table_Value_Response_sh_set" "', argument " "2"" of type '" "uint8_t""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res2 != ( -1)) ? res2 : -5)), "in method '" "DDCS_Non_Table_Value_Response_sh_set" "', argument " "2"" of type '" "uint8_t""'"); goto fail; } while (0); | |||
4774 | } | |||
4775 | if (!argp2) { | |||
4776 | SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DDCS_Non_Table_Value_Response_sh_set" "', argument " "2"" of type '" "uint8_t""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(-9), "invalid null reference " "in method '" "DDCS_Non_Table_Value_Response_sh_set" "', argument " "2"" of type '" "uint8_t""'"); goto fail; } while(0); | |||
4777 | } else { | |||
4778 | arg2 = *((uint8_t *)(argp2)); | |||
4779 | } | |||
4780 | } | |||
4781 | if (arg1) (arg1)->sh = arg2; | |||
4782 | resultobj = SWIG_Py_Void(); | |||
4783 | return resultobj; | |||
4784 | fail: | |||
4785 | return NULL((void*)0); | |||
4786 | } | |||
4787 | ||||
4788 | ||||
4789 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_sh_get(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4790 | PyObject *resultobj = 0; | |||
4791 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4792 | void *argp1 = 0 ; | |||
4793 | int res1 = 0 ; | |||
4794 | PyObject * obj0 = 0 ; | |||
4795 | uint8_t result; | |||
4796 | ||||
4797 | if (!PyArg_ParseTuple(args,(char *)"O:DDCS_Non_Table_Value_Response_sh_get",&obj0)) SWIG_failgoto fail; | |||
4798 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4799 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4800 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_sh_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_sh_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4801 | } | |||
4802 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4803 | result = ((arg1)->sh); | |||
4804 | resultobj = SWIG_NewPointerObj((uint8_t *)memcpy((uint8_t *)calloc(1,sizeof(uint8_t)),&result,sizeof(uint8_t)), SWIGTYPE_p_uint8_t, SWIG_POINTER_OWN | 0 )SWIG_Python_NewPointerObj(((void*)0), (uint8_t *)memcpy((uint8_t *)calloc(1,sizeof(uint8_t)),&result,sizeof(uint8_t)), swig_types [8], 0x1 | 0); | |||
4805 | return resultobj; | |||
4806 | fail: | |||
4807 | return NULL((void*)0); | |||
4808 | } | |||
4809 | ||||
4810 | ||||
4811 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_sl_set(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4812 | PyObject *resultobj = 0; | |||
4813 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4814 | uint8_t arg2 ; | |||
4815 | void *argp1 = 0 ; | |||
4816 | int res1 = 0 ; | |||
4817 | void *argp2 ; | |||
4818 | int res2 = 0 ; | |||
4819 | PyObject * obj0 = 0 ; | |||
4820 | PyObject * obj1 = 0 ; | |||
4821 | ||||
4822 | if (!PyArg_ParseTuple(args,(char *)"OO:DDCS_Non_Table_Value_Response_sl_set",&obj0,&obj1)) SWIG_failgoto fail; | |||
4823 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4824 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4825 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_sl_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_sl_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4826 | } | |||
4827 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4828 | { | |||
4829 | res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint8_t, 0 )SWIG_Python_ConvertPtrAndOwn(obj1, &argp2, swig_types[8], 0, 0); | |||
4830 | if (!SWIG_IsOK(res2)(res2 >= 0)) { | |||
4831 | SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DDCS_Non_Table_Value_Response_sl_set" "', argument " "2"" of type '" "uint8_t""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res2 != ( -1)) ? res2 : -5)), "in method '" "DDCS_Non_Table_Value_Response_sl_set" "', argument " "2"" of type '" "uint8_t""'"); goto fail; } while (0); | |||
4832 | } | |||
4833 | if (!argp2) { | |||
4834 | SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DDCS_Non_Table_Value_Response_sl_set" "', argument " "2"" of type '" "uint8_t""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(-9), "invalid null reference " "in method '" "DDCS_Non_Table_Value_Response_sl_set" "', argument " "2"" of type '" "uint8_t""'"); goto fail; } while(0); | |||
4835 | } else { | |||
4836 | arg2 = *((uint8_t *)(argp2)); | |||
4837 | } | |||
4838 | } | |||
4839 | if (arg1) (arg1)->sl = arg2; | |||
4840 | resultobj = SWIG_Py_Void(); | |||
4841 | return resultobj; | |||
4842 | fail: | |||
4843 | return NULL((void*)0); | |||
4844 | } | |||
4845 | ||||
4846 | ||||
4847 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_sl_get(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4848 | PyObject *resultobj = 0; | |||
4849 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4850 | void *argp1 = 0 ; | |||
4851 | int res1 = 0 ; | |||
4852 | PyObject * obj0 = 0 ; | |||
4853 | uint8_t result; | |||
4854 | ||||
4855 | if (!PyArg_ParseTuple(args,(char *)"O:DDCS_Non_Table_Value_Response_sl_get",&obj0)) SWIG_failgoto fail; | |||
4856 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4857 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4858 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_sl_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_sl_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4859 | } | |||
4860 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4861 | result = ((arg1)->sl); | |||
4862 | resultobj = SWIG_NewPointerObj((uint8_t *)memcpy((uint8_t *)calloc(1,sizeof(uint8_t)),&result,sizeof(uint8_t)), SWIGTYPE_p_uint8_t, SWIG_POINTER_OWN | 0 )SWIG_Python_NewPointerObj(((void*)0), (uint8_t *)memcpy((uint8_t *)calloc(1,sizeof(uint8_t)),&result,sizeof(uint8_t)), swig_types [8], 0x1 | 0); | |||
4863 | return resultobj; | |||
4864 | fail: | |||
4865 | return NULL((void*)0); | |||
4866 | } | |||
4867 | ||||
4868 | ||||
4869 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_max_value_set(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4870 | PyObject *resultobj = 0; | |||
4871 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4872 | int arg2 ; | |||
4873 | void *argp1 = 0 ; | |||
4874 | int res1 = 0 ; | |||
4875 | int val2 ; | |||
4876 | int ecode2 = 0 ; | |||
4877 | PyObject * obj0 = 0 ; | |||
4878 | PyObject * obj1 = 0 ; | |||
4879 | ||||
4880 | if (!PyArg_ParseTuple(args,(char *)"OO:DDCS_Non_Table_Value_Response_max_value_set",&obj0,&obj1)) SWIG_failgoto fail; | |||
4881 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4882 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4883 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_max_value_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_max_value_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4884 | } | |||
4885 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4886 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
4887 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
4888 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DDCS_Non_Table_Value_Response_max_value_set" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "DDCS_Non_Table_Value_Response_max_value_set" "', argument " "2"" of type '" "int""'"); goto fail; } while (0); | |||
4889 | } | |||
4890 | arg2 = (int)(val2); | |||
4891 | if (arg1) (arg1)->max_value = arg2; | |||
4892 | resultobj = SWIG_Py_Void(); | |||
4893 | return resultobj; | |||
4894 | fail: | |||
4895 | return NULL((void*)0); | |||
4896 | } | |||
4897 | ||||
4898 | ||||
4899 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_max_value_get(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4900 | PyObject *resultobj = 0; | |||
4901 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4902 | void *argp1 = 0 ; | |||
4903 | int res1 = 0 ; | |||
4904 | PyObject * obj0 = 0 ; | |||
4905 | int result; | |||
4906 | ||||
4907 | if (!PyArg_ParseTuple(args,(char *)"O:DDCS_Non_Table_Value_Response_max_value_get",&obj0)) SWIG_failgoto fail; | |||
4908 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4909 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4910 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_max_value_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_max_value_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4911 | } | |||
4912 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4913 | result = (int) ((arg1)->max_value); | |||
4914 | resultobj = SWIG_From_int((int)(result)); | |||
4915 | return resultobj; | |||
4916 | fail: | |||
4917 | return NULL((void*)0); | |||
4918 | } | |||
4919 | ||||
4920 | ||||
4921 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_cur_value_set(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4922 | PyObject *resultobj = 0; | |||
4923 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4924 | int arg2 ; | |||
4925 | void *argp1 = 0 ; | |||
4926 | int res1 = 0 ; | |||
4927 | int val2 ; | |||
4928 | int ecode2 = 0 ; | |||
4929 | PyObject * obj0 = 0 ; | |||
4930 | PyObject * obj1 = 0 ; | |||
4931 | ||||
4932 | if (!PyArg_ParseTuple(args,(char *)"OO:DDCS_Non_Table_Value_Response_cur_value_set",&obj0,&obj1)) SWIG_failgoto fail; | |||
4933 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4934 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4935 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_cur_value_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_cur_value_set" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4936 | } | |||
4937 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4938 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
4939 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
4940 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DDCS_Non_Table_Value_Response_cur_value_set" "', argument " "2"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "DDCS_Non_Table_Value_Response_cur_value_set" "', argument " "2"" of type '" "int""'"); goto fail; } while (0); | |||
4941 | } | |||
4942 | arg2 = (int)(val2); | |||
4943 | if (arg1) (arg1)->cur_value = arg2; | |||
4944 | resultobj = SWIG_Py_Void(); | |||
4945 | return resultobj; | |||
4946 | fail: | |||
4947 | return NULL((void*)0); | |||
4948 | } | |||
4949 | ||||
4950 | ||||
4951 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_DDCS_Non_Table_Value_Response_cur_value_get(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4952 | PyObject *resultobj = 0; | |||
4953 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
4954 | void *argp1 = 0 ; | |||
4955 | int res1 = 0 ; | |||
4956 | PyObject * obj0 = 0 ; | |||
4957 | int result; | |||
4958 | ||||
4959 | if (!PyArg_ParseTuple(args,(char *)"O:DDCS_Non_Table_Value_Response_cur_value_get",&obj0)) SWIG_failgoto fail; | |||
4960 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, 0 | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0 | 0, 0); | |||
4961 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
4962 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DDCS_Non_Table_Value_Response_cur_value_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "DDCS_Non_Table_Value_Response_cur_value_get" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
4963 | } | |||
4964 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
4965 | result = (int) ((arg1)->cur_value); | |||
4966 | resultobj = SWIG_From_int((int)(result)); | |||
4967 | return resultobj; | |||
4968 | fail: | |||
4969 | return NULL((void*)0); | |||
4970 | } | |||
4971 | ||||
4972 | ||||
4973 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_new_DDCS_Non_Table_Value_Response(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
4974 | PyObject *resultobj = 0; | |||
4975 | DDCS_Non_Table_Value_Response *result = 0 ; | |||
4976 | ||||
4977 | if (!PyArg_ParseTuple(args,(char *)":new_DDCS_Non_Table_Value_Response")) SWIG_failgoto fail; | |||
4978 | { | |||
4979 | clear_exception(); // redundant | |||
4980 | result = (DDCS_Non_Table_Value_Response *)calloc(1, sizeof(DDCS_Non_Table_Value_Response)); | |||
4981 | // char * emsg = check_exception(); | |||
4982 | // if (emsg) { | |||
4983 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
4984 | // return NULL; | |||
4985 | // } | |||
4986 | bool_Bool exception_thrown = check_exception2(); | |||
4987 | if (exception_thrown) { | |||
4988 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
4989 | return NULL((void*)0); | |||
4990 | } | |||
4991 | } | |||
4992 | resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DDCS_Non_Table_Value_Response, SWIG_POINTER_NEW | 0 )SWIG_Python_NewPointerObj(((void*)0), (void *)((const void *) (result)), swig_types[4], ((0x1 << 1) | 0x1) | 0); | |||
4993 | return resultobj; | |||
4994 | fail: | |||
4995 | return NULL((void*)0); | |||
4996 | } | |||
4997 | ||||
4998 | ||||
4999 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_delete_DDCS_Non_Table_Value_Response(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
5000 | PyObject *resultobj = 0; | |||
5001 | DDCS_Non_Table_Value_Response *arg1 = (DDCS_Non_Table_Value_Response *) 0 ; | |||
5002 | void *argp1 = 0 ; | |||
5003 | int res1 = 0 ; | |||
5004 | PyObject * obj0 = 0 ; | |||
5005 | ||||
5006 | if (!PyArg_ParseTuple(args,(char *)"O:delete_DDCS_Non_Table_Value_Response",&obj0)) SWIG_failgoto fail; | |||
5007 | res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DDCS_Non_Table_Value_Response, SWIG_POINTER_DISOWN | 0 )SWIG_Python_ConvertPtrAndOwn(obj0, &argp1, swig_types[4], 0x1 | 0, 0); | |||
5008 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
5009 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DDCS_Non_Table_Value_Response" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "delete_DDCS_Non_Table_Value_Response" "', argument " "1"" of type '" "DDCS_Non_Table_Value_Response *" "'"); goto fail; } while(0); | |||
5010 | } | |||
5011 | arg1 = (DDCS_Non_Table_Value_Response *)(argp1); | |||
5012 | { | |||
5013 | clear_exception(); // redundant | |||
5014 | free((char *) arg1); | |||
5015 | // char * emsg = check_exception(); | |||
5016 | // if (emsg) { | |||
5017 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
5018 | // return NULL; | |||
5019 | // } | |||
5020 | bool_Bool exception_thrown = check_exception2(); | |||
5021 | if (exception_thrown) { | |||
5022 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
5023 | return NULL((void*)0); | |||
5024 | } | |||
5025 | } | |||
5026 | resultobj = SWIG_Py_Void(); | |||
5027 | return resultobj; | |||
5028 | fail: | |||
5029 | return NULL((void*)0); | |||
5030 | } | |||
5031 | ||||
5032 | ||||
5033 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *DDCS_Non_Table_Value_Response_swigregister(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
5034 | PyObject *obj; | |||
5035 | if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL((void*)0); | |||
5036 | SWIG_TypeNewClientData(SWIGTYPE_p_DDCS_Non_Table_Value_Responseswig_types[4], SWIG_NewClientData(obj)SwigPyClientData_New(obj)); | |||
5037 | return SWIG_Py_Void(); | |||
5038 | } | |||
5039 | ||||
5040 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_get_nontable_vcp_value(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
5041 | PyObject *resultobj = 0; | |||
5042 | DDCS_Display_Handle arg1 = (DDCS_Display_Handle) 0 ; | |||
5043 | DDCS_VCP_Feature_Code arg2 ; | |||
5044 | int res1 ; | |||
5045 | int val2 ; | |||
5046 | int ecode2 = 0 ; | |||
5047 | PyObject * obj0 = 0 ; | |||
5048 | PyObject * obj1 = 0 ; | |||
5049 | DDCS_Non_Table_Value_Response result; | |||
5050 | ||||
5051 | if (!PyArg_ParseTuple(args,(char *)"OO:ddcs_get_nontable_vcp_value",&obj0,&obj1)) SWIG_failgoto fail; | |||
5052 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
5053 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
5054 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_get_nontable_vcp_value" "', argument " "1"" of type '" "DDCS_Display_Handle""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_get_nontable_vcp_value" "', argument " "1"" of type '" "DDCS_Display_Handle""'"); goto fail; } while(0); | |||
5055 | } | |||
5056 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
5057 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
5058 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ddcs_get_nontable_vcp_value" "', argument " "2"" of type '" "DDCS_VCP_Feature_Code""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "ddcs_get_nontable_vcp_value" "', argument " "2"" of type '" "DDCS_VCP_Feature_Code""'"); goto fail; } while(0); | |||
5059 | } | |||
5060 | arg2 = (DDCS_VCP_Feature_Code)(val2); | |||
5061 | { | |||
5062 | clear_exception(); // redundant | |||
5063 | result = ddcs_get_nontable_vcp_value(arg1,arg2); | |||
5064 | // char * emsg = check_exception(); | |||
5065 | // if (emsg) { | |||
5066 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
5067 | // return NULL; | |||
5068 | // } | |||
5069 | bool_Bool exception_thrown = check_exception2(); | |||
5070 | if (exception_thrown) { | |||
5071 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
5072 | return NULL((void*)0); | |||
5073 | } | |||
5074 | } | |||
5075 | resultobj = SWIG_NewPointerObj((DDCS_Non_Table_Value_Response *)memcpy((DDCS_Non_Table_Value_Response *)calloc(1,sizeof(DDCS_Non_Table_Value_Response)),&result,sizeof(DDCS_Non_Table_Value_Response)), SWIGTYPE_p_DDCS_Non_Table_Value_Response, SWIG_POINTER_OWN | 0 )SWIG_Python_NewPointerObj(((void*)0), (DDCS_Non_Table_Value_Response *)memcpy((DDCS_Non_Table_Value_Response *)calloc(1,sizeof(DDCS_Non_Table_Value_Response )),&result,sizeof(DDCS_Non_Table_Value_Response)), swig_types [4], 0x1 | 0); | |||
5076 | return resultobj; | |||
5077 | fail: | |||
5078 | return NULL((void*)0); | |||
5079 | } | |||
5080 | ||||
5081 | ||||
5082 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_set_nontable_vcp_value(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
5083 | PyObject *resultobj = 0; | |||
5084 | DDCS_Display_Handle arg1 = (DDCS_Display_Handle) 0 ; | |||
5085 | DDCS_VCP_Feature_Code arg2 ; | |||
5086 | int arg3 ; | |||
5087 | int res1 ; | |||
5088 | int val2 ; | |||
5089 | int ecode2 = 0 ; | |||
5090 | int val3 ; | |||
5091 | int ecode3 = 0 ; | |||
5092 | PyObject * obj0 = 0 ; | |||
5093 | PyObject * obj1 = 0 ; | |||
5094 | PyObject * obj2 = 0 ; | |||
5095 | ||||
5096 | if (!PyArg_ParseTuple(args,(char *)"OOO:ddcs_set_nontable_vcp_value",&obj0,&obj1,&obj2)) SWIG_failgoto fail; | |||
5097 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
5098 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
5099 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_set_nontable_vcp_value" "', argument " "1"" of type '" "DDCS_Display_Handle""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_set_nontable_vcp_value" "', argument " "1"" of type '" "DDCS_Display_Handle""'"); goto fail; } while(0); | |||
5100 | } | |||
5101 | ecode2 = SWIG_AsVal_int(obj1, &val2); | |||
5102 | if (!SWIG_IsOK(ecode2)(ecode2 >= 0)) { | |||
5103 | SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ddcs_set_nontable_vcp_value" "', argument " "2"" of type '" "DDCS_VCP_Feature_Code""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode2 != (-1)) ? ecode2 : -5)), "in method '" "ddcs_set_nontable_vcp_value" "', argument " "2"" of type '" "DDCS_VCP_Feature_Code""'"); goto fail; } while(0); | |||
5104 | } | |||
5105 | arg2 = (DDCS_VCP_Feature_Code)(val2); | |||
5106 | ecode3 = SWIG_AsVal_int(obj2, &val3); | |||
5107 | if (!SWIG_IsOK(ecode3)(ecode3 >= 0)) { | |||
5108 | SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ddcs_set_nontable_vcp_value" "', argument " "3"" of type '" "int""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((ecode3 != (-1)) ? ecode3 : -5)), "in method '" "ddcs_set_nontable_vcp_value" "', argument " "3"" of type '" "int""'"); goto fail; } while (0); | |||
5109 | } | |||
5110 | arg3 = (int)(val3); | |||
5111 | { | |||
5112 | clear_exception(); // redundant | |||
5113 | ddcs_set_nontable_vcp_value(arg1,arg2,arg3); | |||
5114 | // char * emsg = check_exception(); | |||
5115 | // if (emsg) { | |||
5116 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
5117 | // return NULL; | |||
5118 | // } | |||
5119 | bool_Bool exception_thrown = check_exception2(); | |||
5120 | if (exception_thrown) { | |||
5121 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
5122 | return NULL((void*)0); | |||
5123 | } | |||
5124 | } | |||
5125 | resultobj = SWIG_Py_Void(); | |||
5126 | return resultobj; | |||
5127 | fail: | |||
5128 | return NULL((void*)0); | |||
5129 | } | |||
5130 | ||||
5131 | ||||
5132 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_get_profile_related_values(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
5133 | PyObject *resultobj = 0; | |||
5134 | DDCS_Display_Handle arg1 = (DDCS_Display_Handle) 0 ; | |||
5135 | int res1 ; | |||
5136 | PyObject * obj0 = 0 ; | |||
5137 | char *result = 0 ; | |||
5138 | ||||
5139 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_get_profile_related_values",&obj0)) SWIG_failgoto fail; | |||
5140 | res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0)SWIG_Python_ConvertPtrAndOwn(obj0, ((void)(void *)((const void *)(*&arg1)),(void**)(&arg1)), 0, 0, 0); | |||
5141 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
5142 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_get_profile_related_values" "', argument " "1"" of type '" "DDCS_Display_Handle""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_get_profile_related_values" "', argument " "1"" of type '" "DDCS_Display_Handle""'"); goto fail; } while(0); | |||
5143 | } | |||
5144 | { | |||
5145 | clear_exception(); // redundant | |||
5146 | result = (char *)ddcs_get_profile_related_values(arg1); | |||
5147 | // char * emsg = check_exception(); | |||
5148 | // if (emsg) { | |||
5149 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
5150 | // return NULL; | |||
5151 | // } | |||
5152 | bool_Bool exception_thrown = check_exception2(); | |||
5153 | if (exception_thrown) { | |||
5154 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
5155 | return NULL((void*)0); | |||
5156 | } | |||
5157 | } | |||
5158 | resultobj = SWIG_FromCharPtr((const char *)result); | |||
5159 | return resultobj; | |||
5160 | fail: | |||
5161 | return NULL((void*)0); | |||
5162 | } | |||
5163 | ||||
5164 | ||||
5165 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject *_wrap_ddcs_set_profile_related_values(PyObject *SWIGUNUSEDPARM(self)self __attribute__ ((__unused__)), PyObject *args) { | |||
5166 | PyObject *resultobj = 0; | |||
5167 | char *arg1 = (char *) 0 ; | |||
5168 | int res1 ; | |||
5169 | char *buf1 = 0 ; | |||
5170 | int alloc1 = 0 ; | |||
5171 | PyObject * obj0 = 0 ; | |||
5172 | ||||
5173 | if (!PyArg_ParseTuple(args,(char *)"O:ddcs_set_profile_related_values",&obj0)) SWIG_failgoto fail; | |||
5174 | res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL((void*)0), &alloc1); | |||
5175 | if (!SWIG_IsOK(res1)(res1 >= 0)) { | |||
5176 | SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ddcs_set_profile_related_values" "', argument " "1"" of type '" "char *""'")do { SWIG_Python_SetErrorMsg(SWIG_Python_ErrorType(((res1 != ( -1)) ? res1 : -5)), "in method '" "ddcs_set_profile_related_values" "', argument " "1"" of type '" "char *""'"); goto fail; } while (0); | |||
5177 | } | |||
5178 | arg1 = (char *)(buf1); | |||
5179 | { | |||
5180 | clear_exception(); // redundant | |||
5181 | ddcs_set_profile_related_values(arg1); | |||
5182 | // char * emsg = check_exception(); | |||
5183 | // if (emsg) { | |||
5184 | // PyErr_SetString( PyExc_RuntimeError, emsg); | |||
5185 | // return NULL; | |||
5186 | // } | |||
5187 | bool_Bool exception_thrown = check_exception2(); | |||
5188 | if (exception_thrown) { | |||
5189 | puts("(ddc_swig.i:exception handler) throwing exception"); | |||
5190 | return NULL((void*)0); | |||
5191 | } | |||
5192 | } | |||
5193 | resultobj = SWIG_Py_Void(); | |||
5194 | if (alloc1 == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) free((char*)buf1); | |||
5195 | return resultobj; | |||
5196 | fail: | |||
5197 | if (alloc1 == SWIG_NEWOBJ((0) | ((1 << 8) << 1))) free((char*)buf1); | |||
5198 | return NULL((void*)0); | |||
5199 | } | |||
5200 | ||||
5201 | ||||
5202 | static PyMethodDef SwigMethods[] = { | |||
5203 | { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O0x0008, NULL((void*)0)}, | |||
5204 | { (char *)"ddcs_ddcutil_version_string", _wrap_ddcs_ddcutil_version_string, METH_VARARGS0x0001, NULL((void*)0)}, | |||
5205 | { (char *)"ddcs_get_build_options", _wrap_ddcs_get_build_options, METH_VARARGS0x0001, (char *)"ddcs_get_build_options() -> FlagsByte"}, | |||
5206 | { (char *)"ddcs_status_code_name", _wrap_ddcs_status_code_name, METH_VARARGS0x0001, (char *)"ddcs_status_code_name(status_code) -> char *"}, | |||
5207 | { (char *)"ddcs_status_code_desc", _wrap_ddcs_status_code_desc, METH_VARARGS0x0001, (char *)"ddcs_status_code_desc(status_code) -> char *"}, | |||
5208 | { (char *)"ddcs_get_max_tries", _wrap_ddcs_get_max_tries, METH_VARARGS0x0001, (char *)"ddcs_get_max_tries(retry_type) -> int"}, | |||
5209 | { (char *)"ddcs_set_max_tries", _wrap_ddcs_set_max_tries, METH_VARARGS0x0001, (char *)"ddcs_set_max_tries(retry_type, max_tries) -> DDCA_Status"}, | |||
5210 | { (char *)"ddcs_get_output_level", _wrap_ddcs_get_output_level, METH_VARARGS0x0001, (char *)"ddcs_get_output_level() -> DDCA_Output_Level"}, | |||
5211 | { (char *)"ddcs_set_output_level", _wrap_ddcs_set_output_level, METH_VARARGS0x0001, (char *)"ddcs_set_output_level(newval)"}, | |||
5212 | { (char *)"ddcs_output_level_name", _wrap_ddcs_output_level_name, METH_VARARGS0x0001, (char *)"ddcs_output_level_name(val) -> char *"}, | |||
5213 | { (char *)"ddcs_enable_report_ddc_errors", _wrap_ddcs_enable_report_ddc_errors, METH_VARARGS0x0001, (char *)"ddcs_enable_report_ddc_errors(onoff)"}, | |||
5214 | { (char *)"ddcs_is_report_ddc_errors_enabled", _wrap_ddcs_is_report_ddc_errors_enabled, METH_VARARGS0x0001, (char *)"ddcs_is_report_ddc_errors_enabled() -> bool"}, | |||
5215 | { (char *)"ddcs_set_fout", _wrap_ddcs_set_fout, METH_VARARGS0x0001, (char *)"\n" | |||
5216 | "ddcs_set_fout(fout)\n" | |||
5217 | "\n" | |||
5218 | "Additional doc for ddcs_set_fout()\n" | |||
5219 | ""}, | |||
5220 | { (char *)"ddcs_create_dispno_display_identifier", _wrap_ddcs_create_dispno_display_identifier, METH_VARARGS0x0001, (char *)"ddcs_create_dispno_display_identifier(dispno) -> DDCS_Display_Identifier"}, | |||
5221 | { (char *)"ddcs_create_adlno_display_identifier", _wrap_ddcs_create_adlno_display_identifier, METH_VARARGS0x0001, (char *)"ddcs_create_adlno_display_identifier(int iAdapterIndex, int iDisplayIndex) -> DDCS_Display_Identifier"}, | |||
5222 | { (char *)"ddcs_create_busno_display_identifier", _wrap_ddcs_create_busno_display_identifier, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5223 | { (char *)"ddcs_create_mfg_model_sn_display_identifier", _wrap_ddcs_create_mfg_model_sn_display_identifier, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5224 | { (char *)"ddcs_create_edid_display_identifier", _wrap_ddcs_create_edid_display_identifier, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5225 | { (char *)"ddcs_create_usb_display_identifier", _wrap_ddcs_create_usb_display_identifier, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5226 | { (char *)"ddcs_free_display_identifier", _wrap_ddcs_free_display_identifier, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5227 | { (char *)"ddcs_repr_display_identifier", _wrap_ddcs_repr_display_identifier, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5228 | { (char *)"ddcs_get_display_ref", _wrap_ddcs_get_display_ref, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5229 | { (char *)"ddcs_free_display_ref", _wrap_ddcs_free_display_ref, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5230 | { (char *)"ddcs_repr_display_ref", _wrap_ddcs_repr_display_ref, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5231 | { (char *)"ddcs_report_display_ref", _wrap_ddcs_report_display_ref, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5232 | { (char *)"ddcs_open_display", _wrap_ddcs_open_display, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5233 | { (char *)"ddcs_close_display", _wrap_ddcs_close_display, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5234 | { (char *)"ddcs_repr_display_handle", _wrap_ddcs_repr_display_handle, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5235 | { (char *)"ddcs_report_active_displays", _wrap_ddcs_report_active_displays, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5236 | { (char *)"DDCS_MCCS_Version_Spec_major_set", _wrap_DDCS_MCCS_Version_Spec_major_set, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5237 | { (char *)"DDCS_MCCS_Version_Spec_major_get", _wrap_DDCS_MCCS_Version_Spec_major_get, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5238 | { (char *)"DDCS_MCCS_Version_Spec_minor_set", _wrap_DDCS_MCCS_Version_Spec_minor_set, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5239 | { (char *)"DDCS_MCCS_Version_Spec_minor_get", _wrap_DDCS_MCCS_Version_Spec_minor_get, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5240 | { (char *)"new_DDCS_MCCS_Version_Spec", _wrap_new_DDCS_MCCS_Version_Spec, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5241 | { (char *)"delete_DDCS_MCCS_Version_Spec", _wrap_delete_DDCS_MCCS_Version_Spec, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5242 | { (char *)"DDCS_MCCS_Version_Spec_swigregister", DDCS_MCCS_Version_Spec_swigregister, METH_VARARGS0x0001, NULL((void*)0)}, | |||
5243 | { (char *)"ddcs_get_feature_name", _wrap_ddcs_get_feature_name, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5244 | { (char *)"ddcs_get_capabilities_string", _wrap_ddcs_get_capabilities_string, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5245 | { (char *)"DDCS_Non_Table_Value_Response_mh_set", _wrap_DDCS_Non_Table_Value_Response_mh_set, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5246 | { (char *)"DDCS_Non_Table_Value_Response_mh_get", _wrap_DDCS_Non_Table_Value_Response_mh_get, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5247 | { (char *)"DDCS_Non_Table_Value_Response_ml_set", _wrap_DDCS_Non_Table_Value_Response_ml_set, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5248 | { (char *)"DDCS_Non_Table_Value_Response_ml_get", _wrap_DDCS_Non_Table_Value_Response_ml_get, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5249 | { (char *)"DDCS_Non_Table_Value_Response_sh_set", _wrap_DDCS_Non_Table_Value_Response_sh_set, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5250 | { (char *)"DDCS_Non_Table_Value_Response_sh_get", _wrap_DDCS_Non_Table_Value_Response_sh_get, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5251 | { (char *)"DDCS_Non_Table_Value_Response_sl_set", _wrap_DDCS_Non_Table_Value_Response_sl_set, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5252 | { (char *)"DDCS_Non_Table_Value_Response_sl_get", _wrap_DDCS_Non_Table_Value_Response_sl_get, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5253 | { (char *)"DDCS_Non_Table_Value_Response_max_value_set", _wrap_DDCS_Non_Table_Value_Response_max_value_set, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5254 | { (char *)"DDCS_Non_Table_Value_Response_max_value_get", _wrap_DDCS_Non_Table_Value_Response_max_value_get, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5255 | { (char *)"DDCS_Non_Table_Value_Response_cur_value_set", _wrap_DDCS_Non_Table_Value_Response_cur_value_set, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5256 | { (char *)"DDCS_Non_Table_Value_Response_cur_value_get", _wrap_DDCS_Non_Table_Value_Response_cur_value_get, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5257 | { (char *)"new_DDCS_Non_Table_Value_Response", _wrap_new_DDCS_Non_Table_Value_Response, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5258 | { (char *)"delete_DDCS_Non_Table_Value_Response", _wrap_delete_DDCS_Non_Table_Value_Response, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5259 | { (char *)"DDCS_Non_Table_Value_Response_swigregister", DDCS_Non_Table_Value_Response_swigregister, METH_VARARGS0x0001, NULL((void*)0)}, | |||
5260 | { (char *)"ddcs_get_nontable_vcp_value", _wrap_ddcs_get_nontable_vcp_value, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5261 | { (char *)"ddcs_set_nontable_vcp_value", _wrap_ddcs_set_nontable_vcp_value, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5262 | { (char *)"ddcs_get_profile_related_values", _wrap_ddcs_get_profile_related_values, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5263 | { (char *)"ddcs_set_profile_related_values", _wrap_ddcs_set_profile_related_values, METH_VARARGS0x0001, (char *)"sample feature autodoc docstring"}, | |||
5264 | { NULL((void*)0), NULL((void*)0), 0, NULL((void*)0) } | |||
5265 | }; | |||
5266 | ||||
5267 | ||||
5268 | /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ | |||
5269 | ||||
5270 | static swig_type_info _swigt__p_DDCA_Output_Level = {"_p_DDCA_Output_Level", "enum DDCA_Output_Level *|DDCA_Output_Level *", 0, 0, (void*)0, 0}; | |||
5271 | static swig_type_info _swigt__p_DDCA_Retry_Type = {"_p_DDCA_Retry_Type", "enum DDCA_Retry_Type *|DDCA_Retry_Type *", 0, 0, (void*)0, 0}; | |||
5272 | static swig_type_info _swigt__p_DDCS_Build_Flags = {"_p_DDCS_Build_Flags", "enum DDCS_Build_Flags *|DDCS_Build_Flags *", 0, 0, (void*)0, 0}; | |||
5273 | static swig_type_info _swigt__p_DDCS_MCCS_Version_Spec = {"_p_DDCS_MCCS_Version_Spec", "DDCS_MCCS_Version_Spec *", 0, 0, (void*)0, 0}; | |||
5274 | static swig_type_info _swigt__p_DDCS_Non_Table_Value_Response = {"_p_DDCS_Non_Table_Value_Response", "DDCS_Non_Table_Value_Response *", 0, 0, (void*)0, 0}; | |||
5275 | static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0}; | |||
5276 | static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; | |||
5277 | static swig_type_info _swigt__p_int = {"_p_int", "int *|DDCA_Status *|DDCS_VCP_Feature_Code *", 0, 0, (void*)0, 0}; | |||
5278 | static swig_type_info _swigt__p_uint8_t = {"_p_uint8_t", "uint8_t *", 0, 0, (void*)0, 0}; | |||
5279 | static swig_type_info _swigt__p_void = {"_p_void", "DDCS_Display_Handle|DDCS_Display_Identifier|void *|DDCS_Display_Ref", 0, 0, (void*)0, 0}; | |||
5280 | ||||
5281 | static swig_type_info *swig_type_initial[] = { | |||
5282 | &_swigt__p_DDCA_Output_Level, | |||
5283 | &_swigt__p_DDCA_Retry_Type, | |||
5284 | &_swigt__p_DDCS_Build_Flags, | |||
5285 | &_swigt__p_DDCS_MCCS_Version_Spec, | |||
5286 | &_swigt__p_DDCS_Non_Table_Value_Response, | |||
5287 | &_swigt__p_FILE, | |||
5288 | &_swigt__p_char, | |||
5289 | &_swigt__p_int, | |||
5290 | &_swigt__p_uint8_t, | |||
5291 | &_swigt__p_void, | |||
5292 | }; | |||
5293 | ||||
5294 | static swig_cast_info _swigc__p_DDCA_Output_Level[] = { {&_swigt__p_DDCA_Output_Level, 0, 0, 0},{0, 0, 0, 0}}; | |||
5295 | static swig_cast_info _swigc__p_DDCA_Retry_Type[] = { {&_swigt__p_DDCA_Retry_Type, 0, 0, 0},{0, 0, 0, 0}}; | |||
5296 | static swig_cast_info _swigc__p_DDCS_Build_Flags[] = { {&_swigt__p_DDCS_Build_Flags, 0, 0, 0},{0, 0, 0, 0}}; | |||
5297 | static swig_cast_info _swigc__p_DDCS_MCCS_Version_Spec[] = { {&_swigt__p_DDCS_MCCS_Version_Spec, 0, 0, 0},{0, 0, 0, 0}}; | |||
5298 | static swig_cast_info _swigc__p_DDCS_Non_Table_Value_Response[] = { {&_swigt__p_DDCS_Non_Table_Value_Response, 0, 0, 0},{0, 0, 0, 0}}; | |||
5299 | static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}}; | |||
5300 | static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; | |||
5301 | static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; | |||
5302 | static swig_cast_info _swigc__p_uint8_t[] = { {&_swigt__p_uint8_t, 0, 0, 0},{0, 0, 0, 0}}; | |||
5303 | static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; | |||
5304 | ||||
5305 | static swig_cast_info *swig_cast_initial[] = { | |||
5306 | _swigc__p_DDCA_Output_Level, | |||
5307 | _swigc__p_DDCA_Retry_Type, | |||
5308 | _swigc__p_DDCS_Build_Flags, | |||
5309 | _swigc__p_DDCS_MCCS_Version_Spec, | |||
5310 | _swigc__p_DDCS_Non_Table_Value_Response, | |||
5311 | _swigc__p_FILE, | |||
5312 | _swigc__p_char, | |||
5313 | _swigc__p_int, | |||
5314 | _swigc__p_uint8_t, | |||
5315 | _swigc__p_void, | |||
5316 | }; | |||
5317 | ||||
5318 | ||||
5319 | /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ | |||
5320 | ||||
5321 | static swig_const_info swig_const_table[] = { | |||
5322 | {0, 0, 0, 0.0, 0, 0}}; | |||
5323 | ||||
5324 | #ifdef __cplusplus | |||
5325 | } | |||
5326 | #endif | |||
5327 | /* ----------------------------------------------------------------------------- | |||
5328 | * Type initialization: | |||
5329 | * This problem is tough by the requirement that no dynamic | |||
5330 | * memory is used. Also, since swig_type_info structures store pointers to | |||
5331 | * swig_cast_info structures and swig_cast_info structures store pointers back | |||
5332 | * to swig_type_info structures, we need some lookup code at initialization. | |||
5333 | * The idea is that swig generates all the structures that are needed. | |||
5334 | * The runtime then collects these partially filled structures. | |||
5335 | * The SWIG_InitializeModule function takes these initial arrays out of | |||
5336 | * swig_module, and does all the lookup, filling in the swig_module.types | |||
5337 | * array with the correct data and linking the correct swig_cast_info | |||
5338 | * structures together. | |||
5339 | * | |||
5340 | * The generated swig_type_info structures are assigned statically to an initial | |||
5341 | * array. We just loop through that array, and handle each type individually. | |||
5342 | * First we lookup if this type has been already loaded, and if so, use the | |||
5343 | * loaded structure instead of the generated one. Then we have to fill in the | |||
5344 | * cast linked list. The cast data is initially stored in something like a | |||
5345 | * two-dimensional array. Each row corresponds to a type (there are the same | |||
5346 | * number of rows as there are in the swig_type_initial array). Each entry in | |||
5347 | * a column is one of the swig_cast_info structures for that type. | |||
5348 | * The cast_initial array is actually an array of arrays, because each row has | |||
5349 | * a variable number of columns. So to actually build the cast linked list, | |||
5350 | * we find the array of casts associated with the type, and loop through it | |||
5351 | * adding the casts to the list. The one last trick we need to do is making | |||
5352 | * sure the type pointer in the swig_cast_info struct is correct. | |||
5353 | * | |||
5354 | * First off, we lookup the cast->type name to see if it is already loaded. | |||
5355 | * There are three cases to handle: | |||
5356 | * 1) If the cast->type has already been loaded AND the type we are adding | |||
5357 | * casting info to has not been loaded (it is in this module), THEN we | |||
5358 | * replace the cast->type pointer with the type pointer that has already | |||
5359 | * been loaded. | |||
5360 | * 2) If BOTH types (the one we are adding casting info to, and the | |||
5361 | * cast->type) are loaded, THEN the cast info has already been loaded by | |||
5362 | * the previous module so we just ignore it. | |||
5363 | * 3) Finally, if cast->type has not already been loaded, then we add that | |||
5364 | * swig_cast_info to the linked list (because the cast->type) pointer will | |||
5365 | * be correct. | |||
5366 | * ----------------------------------------------------------------------------- */ | |||
5367 | ||||
5368 | #ifdef __cplusplus | |||
5369 | extern "C" { | |||
5370 | #if 0 | |||
5371 | } /* c-mode */ | |||
5372 | #endif | |||
5373 | #endif | |||
5374 | ||||
5375 | #if 0 | |||
5376 | #define SWIGRUNTIME_DEBUG | |||
5377 | #endif | |||
5378 | ||||
5379 | ||||
5380 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
5381 | SWIG_InitializeModule(void *clientdata) { | |||
5382 | size_t i; | |||
5383 | swig_module_info *module_head, *iter; | |||
5384 | int init; | |||
5385 | ||||
5386 | /* check to see if the circular list has been setup, if not, set it up */ | |||
5387 | if (swig_module.next==0) { | |||
5388 | /* Initialize the swig_module */ | |||
5389 | swig_module.type_initial = swig_type_initial; | |||
5390 | swig_module.cast_initial = swig_cast_initial; | |||
5391 | swig_module.next = &swig_module; | |||
5392 | init = 1; | |||
5393 | } else { | |||
5394 | init = 0; | |||
5395 | } | |||
5396 | ||||
5397 | /* Try and load any already created modules */ | |||
5398 | module_head = SWIG_GetModule(clientdata)SWIG_Python_GetModule(clientdata); | |||
5399 | if (!module_head) { | |||
5400 | /* This is the first module loaded for this interpreter */ | |||
5401 | /* so set the swig module into the interpreter */ | |||
5402 | SWIG_SetModule(clientdata, &swig_module)SWIG_Python_SetModule(&swig_module); | |||
5403 | } else { | |||
5404 | /* the interpreter has loaded a SWIG module, but has it loaded this one? */ | |||
5405 | iter=module_head; | |||
5406 | do { | |||
5407 | if (iter==&swig_module) { | |||
5408 | /* Our module is already in the list, so there's nothing more to do. */ | |||
5409 | return; | |||
5410 | } | |||
5411 | iter=iter->next; | |||
5412 | } while (iter!= module_head); | |||
5413 | ||||
5414 | /* otherwise we must add our module into the list */ | |||
5415 | swig_module.next = module_head->next; | |||
5416 | module_head->next = &swig_module; | |||
5417 | } | |||
5418 | ||||
5419 | /* When multiple interpreters are used, a module could have already been initialized in | |||
5420 | a different interpreter, but not yet have a pointer in this interpreter. | |||
5421 | In this case, we do not want to continue adding types... everything should be | |||
5422 | set up already */ | |||
5423 | if (init == 0) return; | |||
5424 | ||||
5425 | /* Now work on filling in swig_module.types */ | |||
5426 | #ifdef SWIGRUNTIME_DEBUG | |||
5427 | printf("SWIG_InitializeModule: size %d\n", swig_module.size); | |||
5428 | #endif | |||
5429 | for (i = 0; i < swig_module.size; ++i) { | |||
5430 | swig_type_info *type = 0; | |||
5431 | swig_type_info *ret; | |||
5432 | swig_cast_info *cast; | |||
5433 | ||||
5434 | #ifdef SWIGRUNTIME_DEBUG | |||
5435 | printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); | |||
5436 | #endif | |||
5437 | ||||
5438 | /* if there is another module already loaded */ | |||
5439 | if (swig_module.next != &swig_module) { | |||
5440 | type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); | |||
5441 | } | |||
5442 | if (type) { | |||
5443 | /* Overwrite clientdata field */ | |||
5444 | #ifdef SWIGRUNTIME_DEBUG | |||
5445 | printf("SWIG_InitializeModule: found type %s\n", type->name); | |||
5446 | #endif | |||
5447 | if (swig_module.type_initial[i]->clientdata) { | |||
5448 | type->clientdata = swig_module.type_initial[i]->clientdata; | |||
5449 | #ifdef SWIGRUNTIME_DEBUG | |||
5450 | printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); | |||
5451 | #endif | |||
5452 | } | |||
5453 | } else { | |||
5454 | type = swig_module.type_initial[i]; | |||
5455 | } | |||
5456 | ||||
5457 | /* Insert casting types */ | |||
5458 | cast = swig_module.cast_initial[i]; | |||
5459 | while (cast->type) { | |||
5460 | /* Don't need to add information already in the list */ | |||
5461 | ret = 0; | |||
5462 | #ifdef SWIGRUNTIME_DEBUG | |||
5463 | printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); | |||
5464 | #endif | |||
5465 | if (swig_module.next != &swig_module) { | |||
5466 | ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); | |||
5467 | #ifdef SWIGRUNTIME_DEBUG | |||
5468 | if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); | |||
5469 | #endif | |||
5470 | } | |||
5471 | if (ret) { | |||
5472 | if (type == swig_module.type_initial[i]) { | |||
5473 | #ifdef SWIGRUNTIME_DEBUG | |||
5474 | printf("SWIG_InitializeModule: skip old type %s\n", ret->name); | |||
5475 | #endif | |||
5476 | cast->type = ret; | |||
5477 | ret = 0; | |||
5478 | } else { | |||
5479 | /* Check for casting already in the list */ | |||
5480 | swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); | |||
5481 | #ifdef SWIGRUNTIME_DEBUG | |||
5482 | if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); | |||
5483 | #endif | |||
5484 | if (!ocast) ret = 0; | |||
5485 | } | |||
5486 | } | |||
5487 | ||||
5488 | if (!ret) { | |||
5489 | #ifdef SWIGRUNTIME_DEBUG | |||
5490 | printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); | |||
5491 | #endif | |||
5492 | if (type->cast) { | |||
5493 | type->cast->prev = cast; | |||
5494 | cast->next = type->cast; | |||
5495 | } | |||
5496 | type->cast = cast; | |||
5497 | } | |||
5498 | cast++; | |||
5499 | } | |||
5500 | /* Set entry in modules->types array equal to the type */ | |||
5501 | swig_module.types[i] = type; | |||
5502 | } | |||
5503 | swig_module.types[i] = 0; | |||
5504 | ||||
5505 | #ifdef SWIGRUNTIME_DEBUG | |||
5506 | printf("**** SWIG_InitializeModule: Cast List ******\n"); | |||
5507 | for (i = 0; i < swig_module.size; ++i) { | |||
5508 | int j = 0; | |||
5509 | swig_cast_info *cast = swig_module.cast_initial[i]; | |||
5510 | printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); | |||
5511 | while (cast->type) { | |||
5512 | printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); | |||
5513 | cast++; | |||
5514 | ++j; | |||
5515 | } | |||
5516 | printf("---- Total casts: %d\n",j); | |||
5517 | } | |||
5518 | printf("**** SWIG_InitializeModule: Cast List ******\n"); | |||
5519 | #endif | |||
5520 | } | |||
5521 | ||||
5522 | /* This function will propagate the clientdata field of type to | |||
5523 | * any new swig_type_info structures that have been added into the list | |||
5524 | * of equivalent types. It is like calling | |||
5525 | * SWIG_TypeClientData(type, clientdata) a second time. | |||
5526 | */ | |||
5527 | SWIGRUNTIMEstatic __attribute__ ((__unused__)) void | |||
5528 | SWIG_PropagateClientData(void) { | |||
5529 | size_t i; | |||
5530 | swig_cast_info *equiv; | |||
5531 | static int init_run = 0; | |||
5532 | ||||
5533 | if (init_run) return; | |||
5534 | init_run = 1; | |||
5535 | ||||
5536 | for (i = 0; i < swig_module.size; i++) { | |||
5537 | if (swig_module.types[i]->clientdata) { | |||
5538 | equiv = swig_module.types[i]->cast; | |||
5539 | while (equiv) { | |||
5540 | if (!equiv->converter) { | |||
5541 | if (equiv->type && !equiv->type->clientdata) | |||
5542 | SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); | |||
5543 | } | |||
5544 | equiv = equiv->next; | |||
5545 | } | |||
5546 | } | |||
5547 | } | |||
5548 | } | |||
5549 | ||||
5550 | #ifdef __cplusplus | |||
5551 | #if 0 | |||
5552 | { | |||
5553 | /* c-mode */ | |||
5554 | #endif | |||
5555 | } | |||
5556 | #endif | |||
5557 | ||||
5558 | ||||
5559 | ||||
5560 | #ifdef __cplusplus | |||
5561 | extern "C" { | |||
5562 | #endif | |||
5563 | ||||
5564 | /* Python-specific SWIG API */ | |||
5565 | #define SWIG_newvarlink()SWIG_Python_newvarlink() SWIG_Python_newvarlink() | |||
5566 | #define SWIG_addvarlink(p, name, get_attr, set_attr)SWIG_Python_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) | |||
5567 | #define SWIG_InstallConstants(d, constants)SWIG_Python_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) | |||
5568 | ||||
5569 | /* ----------------------------------------------------------------------------- | |||
5570 | * global variable support code. | |||
5571 | * ----------------------------------------------------------------------------- */ | |||
5572 | ||||
5573 | typedef struct swig_globalvar { | |||
5574 | char *name; /* Name of global variable */ | |||
5575 | PyObject *(*get_attr)(void); /* Return the current value */ | |||
5576 | int (*set_attr)(PyObject *); /* Set the value */ | |||
5577 | struct swig_globalvar *next; | |||
5578 | } swig_globalvar; | |||
5579 | ||||
5580 | typedef struct swig_varlinkobject { | |||
5581 | PyObject_HEADPy_ssize_t ob_refcnt; struct _typeobject *ob_type; | |||
5582 | swig_globalvar *vars; | |||
5583 | } swig_varlinkobject; | |||
5584 | ||||
5585 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject * | |||
5586 | swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)v __attribute__ ((__unused__))) { | |||
5587 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
5588 | return PyUnicode_InternFromString("<Swig global variables>"); | |||
5589 | #else | |||
5590 | return PyString_FromString("<Swig global variables>"); | |||
5591 | #endif | |||
5592 | } | |||
5593 | ||||
5594 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject * | |||
5595 | swig_varlink_str(swig_varlinkobject *v) { | |||
5596 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
5597 | PyObject *str = PyUnicode_InternFromString("("); | |||
5598 | PyObject *tail; | |||
5599 | PyObject *joined; | |||
5600 | swig_globalvar *var; | |||
5601 | for (var = v->vars; var; var=var->next) { | |||
5602 | tail = PyUnicode_FromStringPyUnicodeUCS4_FromString(var->name); | |||
5603 | joined = PyUnicode_ConcatPyUnicodeUCS4_Concat(str, tail); | |||
5604 | Py_DecRef(str); | |||
5605 | Py_DecRef(tail); | |||
5606 | str = joined; | |||
5607 | if (var->next) { | |||
5608 | tail = PyUnicode_InternFromString(", "); | |||
5609 | joined = PyUnicode_ConcatPyUnicodeUCS4_Concat(str, tail); | |||
5610 | Py_DecRef(str); | |||
5611 | Py_DecRef(tail); | |||
5612 | str = joined; | |||
5613 | } | |||
5614 | } | |||
5615 | tail = PyUnicode_InternFromString(")"); | |||
5616 | joined = PyUnicode_ConcatPyUnicodeUCS4_Concat(str, tail); | |||
5617 | Py_DecRef(str); | |||
5618 | Py_DecRef(tail); | |||
5619 | str = joined; | |||
5620 | #else | |||
5621 | PyObject *str = PyString_FromString("("); | |||
5622 | swig_globalvar *var; | |||
5623 | for (var = v->vars; var; var=var->next) { | |||
5624 | PyString_ConcatAndDel(&str,PyString_FromString(var->name)); | |||
5625 | if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); | |||
5626 | } | |||
5627 | PyString_ConcatAndDel(&str,PyString_FromString(")")); | |||
5628 | #endif | |||
5629 | return str; | |||
5630 | } | |||
5631 | ||||
5632 | SWIGINTERNstatic __attribute__ ((__unused__)) int | |||
5633 | swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)flags __attribute__ ((__unused__))) { | |||
5634 | char *tmp; | |||
5635 | PyObject *str = swig_varlink_str(v); | |||
5636 | fprintf(fp,"Swig global variables "); | |||
5637 | fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); | |||
5638 | SWIG_Python_str_DelForPy3(tmp); | |||
5639 | Py_DECREF(str)do { if ( --((PyObject*)(str))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(str)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(str)))); } while (0); | |||
5640 | return 0; | |||
5641 | } | |||
5642 | ||||
5643 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
5644 | swig_varlink_dealloc(swig_varlinkobject *v) { | |||
5645 | swig_globalvar *var = v->vars; | |||
5646 | while (var) { | |||
5647 | swig_globalvar *n = var->next; | |||
5648 | free(var->name); | |||
5649 | free(var); | |||
5650 | var = n; | |||
5651 | } | |||
5652 | } | |||
5653 | ||||
5654 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject * | |||
5655 | swig_varlink_getattr(swig_varlinkobject *v, char *n) { | |||
5656 | PyObject *res = NULL((void*)0); | |||
5657 | swig_globalvar *var = v->vars; | |||
5658 | while (var) { | |||
5659 | if (strcmp(var->name,n)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (var->name) && __builtin_constant_p (n) && (__s1_len = strlen (var->name), __s2_len = strlen (n), (! ((size_t)(const void *)((var->name) + 1) - (size_t)(const void *)(var->name) == 1) || __s1_len >= 4) && (!((size_t )(const void *)((n) + 1) - (size_t)(const void *)(n) == 1) || __s2_len >= 4)) ? __builtin_strcmp (var->name, n) : (__builtin_constant_p (var->name) && ((size_t)(const void *)((var->name ) + 1) - (size_t)(const void *)(var->name) == 1) && (__s1_len = strlen (var->name), __s1_len < 4) ? (__builtin_constant_p (n) && ((size_t)(const void *)((n) + 1) - (size_t)(const void *)(n) == 1) ? __builtin_strcmp (var->name, n) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (n); int __result = (((const unsigned char *) (const char *) (var->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (var->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (var->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (var->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (n) && ((size_t)(const void *)((n) + 1) - (size_t)(const void *)(n) == 1) && (__s2_len = strlen (n), __s2_len < 4) ? (__builtin_constant_p (var->name) && (( size_t)(const void *)((var->name) + 1) - (size_t)(const void *)(var->name) == 1) ? __builtin_strcmp (var->name, n) : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (var->name); int __result = (((const unsigned char *) (const char *) (n))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (n))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (n))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (n))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (var->name, n)))); }) == 0) { | |||
5660 | res = (*var->get_attr)(); | |||
5661 | break; | |||
5662 | } | |||
5663 | var = var->next; | |||
5664 | } | |||
5665 | if (res == NULL((void*)0) && !PyErr_Occurred()) { | |||
5666 | PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); | |||
5667 | } | |||
5668 | return res; | |||
5669 | } | |||
5670 | ||||
5671 | SWIGINTERNstatic __attribute__ ((__unused__)) int | |||
5672 | swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { | |||
5673 | int res = 1; | |||
5674 | swig_globalvar *var = v->vars; | |||
5675 | while (var) { | |||
5676 | if (strcmp(var->name,n)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (var->name) && __builtin_constant_p (n) && (__s1_len = strlen (var->name), __s2_len = strlen (n), (! ((size_t)(const void *)((var->name) + 1) - (size_t)(const void *)(var->name) == 1) || __s1_len >= 4) && (!((size_t )(const void *)((n) + 1) - (size_t)(const void *)(n) == 1) || __s2_len >= 4)) ? __builtin_strcmp (var->name, n) : (__builtin_constant_p (var->name) && ((size_t)(const void *)((var->name ) + 1) - (size_t)(const void *)(var->name) == 1) && (__s1_len = strlen (var->name), __s1_len < 4) ? (__builtin_constant_p (n) && ((size_t)(const void *)((n) + 1) - (size_t)(const void *)(n) == 1) ? __builtin_strcmp (var->name, n) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (n); int __result = (((const unsigned char *) (const char *) (var->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (var->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (var->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (var->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (n) && ((size_t)(const void *)((n) + 1) - (size_t)(const void *)(n) == 1) && (__s2_len = strlen (n), __s2_len < 4) ? (__builtin_constant_p (var->name) && (( size_t)(const void *)((var->name) + 1) - (size_t)(const void *)(var->name) == 1) ? __builtin_strcmp (var->name, n) : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (var->name); int __result = (((const unsigned char *) (const char *) (n))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (n))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (n))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (n))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (var->name, n)))); }) == 0) { | |||
5677 | res = (*var->set_attr)(p); | |||
5678 | break; | |||
5679 | } | |||
5680 | var = var->next; | |||
5681 | } | |||
5682 | if (res == 1 && !PyErr_Occurred()) { | |||
5683 | PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); | |||
5684 | } | |||
5685 | return res; | |||
5686 | } | |||
5687 | ||||
5688 | SWIGINTERNstatic __attribute__ ((__unused__)) PyTypeObject* | |||
5689 | swig_varlink_type(void) { | |||
5690 | static char varlink__doc__[] = "Swig var link object"; | |||
5691 | static PyTypeObject varlink_type; | |||
5692 | static int type_init = 0; | |||
5693 | if (!type_init) { | |||
5694 | const PyTypeObject tmp = { | |||
5695 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
5696 | PyVarObject_HEAD_INIT(NULL, 0)1, ((void*)0), 0, | |||
5697 | #else | |||
5698 | PyObject_HEAD_INIT(NULL)1, ((void*)0), | |||
5699 | 0, /* ob_size */ | |||
5700 | #endif | |||
5701 | (char *)"swigvarlink", /* tp_name */ | |||
5702 | sizeof(swig_varlinkobject), /* tp_basicsize */ | |||
5703 | 0, /* tp_itemsize */ | |||
5704 | (destructor) swig_varlink_dealloc, /* tp_dealloc */ | |||
5705 | (printfunc) swig_varlink_print, /* tp_print */ | |||
5706 | (getattrfunc) swig_varlink_getattr, /* tp_getattr */ | |||
5707 | (setattrfunc) swig_varlink_setattr, /* tp_setattr */ | |||
5708 | 0, /* tp_compare */ | |||
5709 | (reprfunc) swig_varlink_repr, /* tp_repr */ | |||
5710 | 0, /* tp_as_number */ | |||
5711 | 0, /* tp_as_sequence */ | |||
5712 | 0, /* tp_as_mapping */ | |||
5713 | 0, /* tp_hash */ | |||
5714 | 0, /* tp_call */ | |||
5715 | (reprfunc) swig_varlink_str, /* tp_str */ | |||
5716 | 0, /* tp_getattro */ | |||
5717 | 0, /* tp_setattro */ | |||
5718 | 0, /* tp_as_buffer */ | |||
5719 | 0, /* tp_flags */ | |||
5720 | varlink__doc__, /* tp_doc */ | |||
5721 | 0, /* tp_traverse */ | |||
5722 | 0, /* tp_clear */ | |||
5723 | 0, /* tp_richcompare */ | |||
5724 | 0, /* tp_weaklistoffset */ | |||
5725 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02020000 | |||
5726 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ | |||
5727 | #endif | |||
5728 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02030000 | |||
5729 | 0, /* tp_del */ | |||
5730 | #endif | |||
5731 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02060000 | |||
5732 | 0, /* tp_version_tag */ | |||
5733 | #endif | |||
5734 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03040000 | |||
5735 | 0, /* tp_finalize */ | |||
5736 | #endif | |||
5737 | #ifdef COUNT_ALLOCS | |||
5738 | 0, /* tp_allocs */ | |||
5739 | 0, /* tp_frees */ | |||
5740 | 0, /* tp_maxalloc */ | |||
5741 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x02050000 | |||
5742 | 0, /* tp_prev */ | |||
5743 | #endif | |||
5744 | 0 /* tp_next */ | |||
5745 | #endif | |||
5746 | }; | |||
5747 | varlink_type = tmp; | |||
5748 | type_init = 1; | |||
5749 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) < 0x02020000 | |||
5750 | varlink_type.ob_type = &PyType_Type; | |||
5751 | #else | |||
5752 | if (PyType_Ready(&varlink_type) < 0) | |||
5753 | return NULL((void*)0); | |||
5754 | #endif | |||
5755 | } | |||
5756 | return &varlink_type; | |||
5757 | } | |||
5758 | ||||
5759 | /* Create a variable linking object for use later */ | |||
5760 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject * | |||
5761 | SWIG_Python_newvarlink(void) { | |||
5762 | swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type())( (swig_varlinkobject *) PyObject_Init( (PyObject *) PyObject_Malloc ( ( (swig_varlink_type())->tp_basicsize ) ), (swig_varlink_type ())) ); | |||
5763 | if (result) { | |||
5764 | result->vars = 0; | |||
5765 | } | |||
5766 | return ((PyObject*) result); | |||
5767 | } | |||
5768 | ||||
5769 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
5770 | SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { | |||
5771 | swig_varlinkobject *v = (swig_varlinkobject *) p; | |||
5772 | swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); | |||
5773 | if (gv) { | |||
5774 | size_t size = strlen(name)+1; | |||
5775 | gv->name = (char *)malloc(size); | |||
5776 | if (gv->name) { | |||
5777 | strncpy(gv->name,name,size)__builtin_strncpy (gv->name, name, size); | |||
5778 | gv->get_attr = get_attr; | |||
5779 | gv->set_attr = set_attr; | |||
5780 | gv->next = v->vars; | |||
5781 | } | |||
5782 | } | |||
5783 | v->vars = gv; | |||
5784 | } | |||
5785 | ||||
5786 | SWIGINTERNstatic __attribute__ ((__unused__)) PyObject * | |||
5787 | SWIG_globals(void) { | |||
5788 | static PyObject *_SWIG_globals = 0; | |||
5789 | if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink()SWIG_Python_newvarlink(); | |||
5790 | return _SWIG_globals; | |||
5791 | } | |||
5792 | ||||
5793 | /* ----------------------------------------------------------------------------- | |||
5794 | * constants/methods manipulation | |||
5795 | * ----------------------------------------------------------------------------- */ | |||
5796 | ||||
5797 | /* Install Constants */ | |||
5798 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
5799 | SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { | |||
5800 | PyObject *obj = 0; | |||
5801 | size_t i; | |||
5802 | for (i = 0; constants[i].type; ++i) { | |||
5803 | switch(constants[i].type) { | |||
5804 | case SWIG_PY_POINTER4: | |||
5805 | obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0)SWIG_Python_NewPointerObj(((void*)0), constants[i].pvalue, *( constants[i]).ptype, 0); | |||
5806 | break; | |||
5807 | case SWIG_PY_BINARY5: | |||
5808 | obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype))SWIG_Python_NewPackedObj(constants[i].pvalue, constants[i].lvalue , *(constants[i].ptype)); | |||
5809 | break; | |||
5810 | default: | |||
5811 | obj = 0; | |||
5812 | break; | |||
5813 | } | |||
5814 | if (obj) { | |||
5815 | PyDict_SetItemString(d, constants[i].name, obj); | |||
5816 | Py_DECREF(obj)do { if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( ( *(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc )((PyObject *)((PyObject *)(obj)))); } while (0); | |||
5817 | } | |||
5818 | } | |||
5819 | } | |||
5820 | ||||
5821 | /* -----------------------------------------------------------------------------*/ | |||
5822 | /* Fix SwigMethods to carry the callback ptrs when needed */ | |||
5823 | /* -----------------------------------------------------------------------------*/ | |||
5824 | ||||
5825 | SWIGINTERNstatic __attribute__ ((__unused__)) void | |||
5826 | SWIG_Python_FixMethods(PyMethodDef *methods, | |||
5827 | swig_const_info *const_table, | |||
5828 | swig_type_info **types, | |||
5829 | swig_type_info **types_initial) { | |||
5830 | size_t i; | |||
5831 | for (i = 0; methods[i].ml_name; ++i) { | |||
5832 | const char *c = methods[i].ml_doc; | |||
5833 | if (!c) continue; | |||
5834 | c = strstr(c, "swig_ptr: "); | |||
5835 | if (c) { | |||
5836 | int j; | |||
5837 | swig_const_info *ci = 0; | |||
5838 | const char *name = c + 10; | |||
5839 | for (j = 0; const_table[j].type; ++j) { | |||
5840 | if (strncmp(const_table[j].name, name,(__extension__ (__builtin_constant_p (strlen(const_table[j].name )) && ((__builtin_constant_p (const_table[j].name) && strlen (const_table[j].name) < ((size_t) (strlen(const_table [j].name)))) || (__builtin_constant_p (name) && strlen (name) < ((size_t) (strlen(const_table[j].name))))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (const_table [j].name) && __builtin_constant_p (name) && ( __s1_len = strlen (const_table[j].name), __s2_len = strlen (name ), (!((size_t)(const void *)((const_table[j].name) + 1) - (size_t )(const void *)(const_table[j].name) == 1) || __s1_len >= 4 ) && (!((size_t)(const void *)((name) + 1) - (size_t) (const void *)(name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (const_table[j].name, name) : (__builtin_constant_p (const_table [j].name) && ((size_t)(const void *)((const_table[j]. name) + 1) - (size_t)(const void *)(const_table[j].name) == 1 ) && (__s1_len = strlen (const_table[j].name), __s1_len < 4) ? (__builtin_constant_p (name) && ((size_t)( const void *)((name) + 1) - (size_t)(const void *)(name) == 1 ) ? __builtin_strcmp (const_table[j].name, name) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (name); int __result = (((const unsigned char *) (const char *) (const_table[j].name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (const_table[j].name))[1] - __s2[1]); if ( __s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (const_table[j].name))[2] - __s2 [2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (const_table[j].name ))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ( name) && ((size_t)(const void *)((name) + 1) - (size_t )(const void *)(name) == 1) && (__s2_len = strlen (name ), __s2_len < 4) ? (__builtin_constant_p (const_table[j].name ) && ((size_t)(const void *)((const_table[j].name) + 1 ) - (size_t)(const void *)(const_table[j].name) == 1) ? __builtin_strcmp (const_table[j].name, name) : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (const_table [j].name); int __result = (((const unsigned char *) (const char *) (name))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ( name))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ( name))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (name ))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (const_table [j].name, name)))); }) : strncmp (const_table[j].name, name, strlen (const_table[j].name)))) | |||
5841 | strlen(const_table[j].name))(__extension__ (__builtin_constant_p (strlen(const_table[j].name )) && ((__builtin_constant_p (const_table[j].name) && strlen (const_table[j].name) < ((size_t) (strlen(const_table [j].name)))) || (__builtin_constant_p (name) && strlen (name) < ((size_t) (strlen(const_table[j].name))))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (const_table [j].name) && __builtin_constant_p (name) && ( __s1_len = strlen (const_table[j].name), __s2_len = strlen (name ), (!((size_t)(const void *)((const_table[j].name) + 1) - (size_t )(const void *)(const_table[j].name) == 1) || __s1_len >= 4 ) && (!((size_t)(const void *)((name) + 1) - (size_t) (const void *)(name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (const_table[j].name, name) : (__builtin_constant_p (const_table [j].name) && ((size_t)(const void *)((const_table[j]. name) + 1) - (size_t)(const void *)(const_table[j].name) == 1 ) && (__s1_len = strlen (const_table[j].name), __s1_len < 4) ? (__builtin_constant_p (name) && ((size_t)( const void *)((name) + 1) - (size_t)(const void *)(name) == 1 ) ? __builtin_strcmp (const_table[j].name, name) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (name); int __result = (((const unsigned char *) (const char *) (const_table[j].name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (const_table[j].name))[1] - __s2[1]); if ( __s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (const_table[j].name))[2] - __s2 [2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (const_table[j].name ))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ( name) && ((size_t)(const void *)((name) + 1) - (size_t )(const void *)(name) == 1) && (__s2_len = strlen (name ), __s2_len < 4) ? (__builtin_constant_p (const_table[j].name ) && ((size_t)(const void *)((const_table[j].name) + 1 ) - (size_t)(const void *)(const_table[j].name) == 1) ? __builtin_strcmp (const_table[j].name, name) : -(__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (const_table [j].name); int __result = (((const unsigned char *) (const char *) (name))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ( name))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ( name))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (name ))[3] - __s2[3]); } } __result; }))) : __builtin_strcmp (const_table [j].name, name)))); }) : strncmp (const_table[j].name, name, strlen (const_table[j].name)))) == 0) { | |||
5842 | ci = &(const_table[j]); | |||
5843 | break; | |||
5844 | } | |||
5845 | } | |||
5846 | if (ci) { | |||
5847 | void *ptr = (ci->type == SWIG_PY_POINTER4) ? ci->pvalue : 0; | |||
5848 | if (ptr) { | |||
5849 | size_t shift = (ci->ptype) - types; | |||
5850 | swig_type_info *ty = types_initial[shift]; | |||
5851 | size_t ldoc = (c - methods[i].ml_doc); | |||
5852 | size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; | |||
5853 | char *ndoc = (char*)malloc(ldoc + lptr + 10); | |||
5854 | if (ndoc) { | |||
5855 | char *buff = ndoc; | |||
5856 | strncpy(buff, methods[i].ml_doc, ldoc)__builtin_strncpy (buff, methods[i].ml_doc, ldoc); | |||
5857 | buff += ldoc; | |||
5858 | strncpy(buff, "swig_ptr: ", 10)__builtin_strncpy (buff, "swig_ptr: ", 10); | |||
5859 | buff += 10; | |||
5860 | SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); | |||
5861 | methods[i].ml_doc = ndoc; | |||
5862 | } | |||
5863 | } | |||
5864 | } | |||
5865 | } | |||
5866 | } | |||
5867 | } | |||
5868 | ||||
5869 | #ifdef __cplusplus | |||
5870 | } | |||
5871 | #endif | |||
5872 | ||||
5873 | /* -----------------------------------------------------------------------------* | |||
5874 | * Partial Init method | |||
5875 | * -----------------------------------------------------------------------------*/ | |||
5876 | ||||
5877 | #ifdef __cplusplus | |||
5878 | extern "C" | |||
5879 | #endif | |||
5880 | ||||
5881 | SWIGEXPORT__attribute__ ((visibility("default"))) | |||
5882 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
5883 | PyObject* | |||
5884 | #else | |||
5885 | void | |||
5886 | #endif | |||
5887 | SWIG_initinit_ddc_swig(void) { | |||
5888 | PyObject *m, *d, *md; | |||
5889 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
5890 | static struct PyModuleDef SWIG_module = { | |||
5891 | # if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03020000 | |||
5892 | PyModuleDef_HEAD_INIT, | |||
5893 | # else | |||
5894 | { | |||
5895 | PyObject_HEAD_INIT(NULL)1, ((void*)0), | |||
5896 | NULL((void*)0), /* m_init */ | |||
5897 | 0, /* m_index */ | |||
5898 | NULL((void*)0), /* m_copy */ | |||
5899 | }, | |||
5900 | # endif | |||
5901 | (char *) SWIG_name"_ddc_swig", | |||
5902 | NULL((void*)0), | |||
5903 | -1, | |||
5904 | SwigMethods, | |||
5905 | NULL((void*)0), | |||
5906 | NULL((void*)0), | |||
5907 | NULL((void*)0), | |||
5908 | NULL((void*)0) | |||
5909 | }; | |||
5910 | #endif | |||
5911 | ||||
5912 | #if defined(SWIGPYTHON_BUILTIN) | |||
5913 | static SwigPyClientData SwigPyObject_clientdata = { | |||
5914 | 0, 0, 0, 0, 0, 0, 0 | |||
5915 | }; | |||
5916 | static PyGetSetDef this_getset_def = { | |||
5917 | (char *)"this", &SwigPyBuiltin_ThisClosure, NULL((void*)0), NULL((void*)0), NULL((void*)0) | |||
5918 | }; | |||
5919 | static SwigPyGetSet thisown_getset_closure = { | |||
5920 | (PyCFunction) SwigPyObject_own, | |||
5921 | (PyCFunction) SwigPyObject_own | |||
5922 | }; | |||
5923 | static PyGetSetDef thisown_getset_def = { | |||
5924 | (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL((void*)0), &thisown_getset_closure | |||
5925 | }; | |||
5926 | PyTypeObject *builtin_pytype; | |||
5927 | int builtin_base_count; | |||
5928 | swig_type_info *builtin_basetype; | |||
5929 | PyObject *tuple; | |||
5930 | PyGetSetDescrObject *static_getset; | |||
5931 | PyTypeObject *metatype; | |||
5932 | PyTypeObject *swigpyobject; | |||
5933 | SwigPyClientData *cd; | |||
5934 | PyObject *public_interface, *public_symbol; | |||
5935 | PyObject *this_descr; | |||
5936 | PyObject *thisown_descr; | |||
5937 | PyObject *self = 0; | |||
5938 | int i; | |||
5939 | ||||
5940 | (void)builtin_pytype; | |||
5941 | (void)builtin_base_count; | |||
5942 | (void)builtin_basetype; | |||
5943 | (void)tuple; | |||
5944 | (void)static_getset; | |||
5945 | (void)self; | |||
5946 | ||||
5947 | /* Metaclass is used to implement static member variables */ | |||
5948 | metatype = SwigPyObjectType(); | |||
5949 | assert(metatype)((metatype) ? (void) (0) : __assert_fail ("metatype", "ddc_swig_wrap.c" , 5949, __PRETTY_FUNCTION__)); | |||
5950 | #endif | |||
5951 | ||||
5952 | /* Fix SwigMethods to carry the callback ptrs when needed */ | |||
5953 | SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); | |||
5954 | ||||
5955 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
5956 | m = PyModule_Create(&SWIG_module); | |||
5957 | #else | |||
5958 | m = Py_InitModule((char *) SWIG_name, SwigMethods)Py_InitModule4_64((char *) "_ddc_swig", SwigMethods, (char *) ((void*)0), (PyObject *)((void*)0), 1013); | |||
5959 | #endif | |||
5960 | ||||
5961 | md = d = PyModule_GetDict(m); | |||
5962 | (void)md; | |||
5963 | ||||
5964 | SWIG_InitializeModule(0); | |||
5965 | ||||
5966 | #ifdef SWIGPYTHON_BUILTIN | |||
5967 | swigpyobject = SwigPyObject_TypeOnce(); | |||
5968 | ||||
5969 | SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject")SWIG_MangledTypeQueryModule(&swig_module, &swig_module , "_p_SwigPyObject"); | |||
5970 | assert(SwigPyObject_stype)((SwigPyObject_stype) ? (void) (0) : __assert_fail ("SwigPyObject_stype" , "ddc_swig_wrap.c", 5970, __PRETTY_FUNCTION__)); | |||
5971 | cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; | |||
5972 | if (!cd) { | |||
5973 | SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; | |||
5974 | SwigPyObject_clientdata.pytype = swigpyobject; | |||
5975 | } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { | |||
5976 | PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); | |||
5977 | # if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
5978 | return NULL((void*)0); | |||
5979 | # else | |||
5980 | return; | |||
5981 | # endif | |||
5982 | } | |||
5983 | ||||
5984 | /* All objects have a 'this' attribute */ | |||
5985 | this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); | |||
5986 | (void)this_descr; | |||
5987 | ||||
5988 | /* All objects have a 'thisown' attribute */ | |||
5989 | thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); | |||
5990 | (void)thisown_descr; | |||
5991 | ||||
5992 | public_interface = PyList_New(0); | |||
5993 | public_symbol = 0; | |||
5994 | (void)public_symbol; | |||
5995 | ||||
5996 | PyDict_SetItemString(md, "__all__", public_interface); | |||
5997 | Py_DECREF(public_interface)do { if ( --((PyObject*)(public_interface))->ob_refcnt != 0 ) ; else ( (*(((PyObject*)((PyObject *)(public_interface)))-> ob_type)->tp_dealloc)((PyObject *)((PyObject *)(public_interface )))); } while (0); | |||
5998 | for (i = 0; SwigMethods[i].ml_name != NULL((void*)0); ++i) | |||
5999 | SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); | |||
6000 | for (i = 0; swig_const_table[i].name != 0; ++i) | |||
6001 | SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); | |||
6002 | #endif | |||
6003 | ||||
6004 | SWIG_InstallConstants(d,swig_const_table)SWIG_Python_InstallConstants(d, swig_const_table); | |||
6005 | ||||
6006 | ||||
6007 | ddcs_init(); | |||
6008 | ||||
6009 | SWIG_Python_SetConstant(d, "DDCS_HAS_ADL",SWIG_From_int((int)(DDCA_HAS_ADL))); | |||
6010 | SWIG_Python_SetConstant(d, "DDCS_HAS_USB",SWIG_From_int((int)(DDCA_HAS_USB))); | |||
6011 | SWIG_Python_SetConstant(d, "DDCS_HAS_FAILSIM",SWIG_From_int((int)(DDCA_HAS_FAILSIM))); | |||
6012 | SWIG_Python_SetConstant(d, "DDCS_WRITE_ONLY_TRIES",SWIG_From_int((int)(DDCA_WRITE_ONLY_TRIES))); | |||
6013 | SWIG_Python_SetConstant(d, "DDCS_WRITE_READ_TRIES",SWIG_From_int((int)(DDCA_WRITE_READ_TRIES))); | |||
6014 | SWIG_Python_SetConstant(d, "DDCS_MULTI_PART_TRIES",SWIG_From_int((int)(DDCA_MULTI_PART_TRIES))); | |||
6015 | SWIG_Python_SetConstant(d, "DDCS_OL_TERSE",SWIG_From_int((int)(DDCA_OL_TERSE))); | |||
6016 | SWIG_Python_SetConstant(d, "DDCS_OL_NORMAL",SWIG_From_int((int)(DDCA_OL_NORMAL))); | |||
6017 | SWIG_Python_SetConstant(d, "DDCS_OL_VERBOSE",SWIG_From_int((int)(DDCA_OL_VERBOSE))); | |||
6018 | #if PY_VERSION_HEX((2 << 24) | (7 << 16) | (13 << 8) | (0xF << 4) | (0 << 0)) >= 0x03000000 | |||
6019 | return m; | |||
6020 | #else | |||
6021 | return; | |||
6022 | #endif | |||
6023 | } | |||
6024 |