Line data Source code
1 : /* ----------------------------------------------------------------------------
2 : * This file was automatically generated by SWIG (http://www.swig.org).
3 : * Version 3.0.10
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 : * This section contains generic SWIG labels for method/variable
13 : * declarations/attributes, and other compiler dependent labels.
14 : * ----------------------------------------------------------------------------- */
15 :
16 : /* template workaround for compilers that cannot correctly implement the C++ standard */
17 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
18 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
19 : # define SWIGTEMPLATEDISAMBIGUATOR template
20 : # elif defined(__HP_aCC)
21 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
22 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
23 : # define SWIGTEMPLATEDISAMBIGUATOR template
24 : # else
25 : # define SWIGTEMPLATEDISAMBIGUATOR
26 : # endif
27 : #endif
28 :
29 : /* inline attribute */
30 : #ifndef SWIGINLINE
31 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
32 : # define SWIGINLINE inline
33 : # else
34 : # define SWIGINLINE
35 : # endif
36 : #endif
37 :
38 : /* attribute recognised by some compilers to avoid 'unused' warnings */
39 : #ifndef SWIGUNUSED
40 : # if defined(__GNUC__)
41 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
42 : # define SWIGUNUSED __attribute__ ((__unused__))
43 : # else
44 : # define SWIGUNUSED
45 : # endif
46 : # elif defined(__ICC)
47 : # define SWIGUNUSED __attribute__ ((__unused__))
48 : # else
49 : # define SWIGUNUSED
50 : # endif
51 : #endif
52 :
53 : #ifndef SWIG_MSC_UNSUPPRESS_4505
54 : # if defined(_MSC_VER)
55 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
56 : # endif
57 : #endif
58 :
59 : #ifndef SWIGUNUSEDPARM
60 : # ifdef __cplusplus
61 : # define SWIGUNUSEDPARM(p)
62 : # else
63 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
64 : # endif
65 : #endif
66 :
67 : /* internal SWIG method */
68 : #ifndef SWIGINTERN
69 : # define SWIGINTERN static SWIGUNUSED
70 : #endif
71 :
72 : /* internal inline SWIG method */
73 : #ifndef SWIGINTERNINLINE
74 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
75 : #endif
76 :
77 : /* exporting methods */
78 : #if defined(__GNUC__)
79 : # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
80 : # ifndef GCC_HASCLASSVISIBILITY
81 : # define GCC_HASCLASSVISIBILITY
82 : # endif
83 : # endif
84 : #endif
85 :
86 : #ifndef SWIGEXPORT
87 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
88 : # if defined(STATIC_LINKED)
89 : # define SWIGEXPORT
90 : # else
91 : # define SWIGEXPORT __declspec(dllexport)
92 : # endif
93 : # else
94 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
95 : # define SWIGEXPORT __attribute__ ((visibility("default")))
96 : # else
97 : # define SWIGEXPORT
98 : # endif
99 : # endif
100 : #endif
101 :
102 : /* calling conventions for Windows */
103 : #ifndef SWIGSTDCALL
104 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
105 : # define SWIGSTDCALL __stdcall
106 : # else
107 : # define SWIGSTDCALL
108 : # endif
109 : #endif
110 :
111 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
112 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
113 : # define _CRT_SECURE_NO_DEPRECATE
114 : #endif
115 :
116 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
117 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
118 : # define _SCL_SECURE_NO_DEPRECATE
119 : #endif
120 :
121 : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
122 : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
123 : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
124 : #endif
125 :
126 : /* Intel's compiler complains if a variable which was never initialised is
127 : * cast to void, which is a common idiom which we use to indicate that we
128 : * are aware a variable isn't used. So we just silence that warning.
129 : * See: https://github.com/swig/swig/issues/192 for more discussion.
130 : */
131 : #ifdef __INTEL_COMPILER
132 : # pragma warning disable 592
133 : #endif
134 : /* Errors in SWIG */
135 : #define SWIG_UnknownError -1
136 : #define SWIG_IOError -2
137 : #define SWIG_RuntimeError -3
138 : #define SWIG_IndexError -4
139 : #define SWIG_TypeError -5
140 : #define SWIG_DivisionByZero -6
141 : #define SWIG_OverflowError -7
142 : #define SWIG_SyntaxError -8
143 : #define SWIG_ValueError -9
144 : #define SWIG_SystemError -10
145 : #define SWIG_AttributeError -11
146 : #define SWIG_MemoryError -12
147 : #define SWIG_NullReferenceError -13
148 :
149 :
150 : /* -----------------------------------------------------------------------------
151 : * swigrun.swg
152 : *
153 : * This file contains generic C API SWIG runtime support for pointer
154 : * type checking.
155 : * ----------------------------------------------------------------------------- */
156 :
157 : /* This should only be incremented when either the layout of swig_type_info changes,
158 : or for whatever reason, the runtime changes incompatibly */
159 : #define SWIG_RUNTIME_VERSION "4"
160 :
161 : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
162 : #ifdef SWIG_TYPE_TABLE
163 : # define SWIG_QUOTE_STRING(x) #x
164 : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
165 : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
166 : #else
167 : # define SWIG_TYPE_TABLE_NAME
168 : #endif
169 :
170 : /*
171 : You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
172 : creating a static or dynamic library from the SWIG runtime code.
173 : In 99.9% of the cases, SWIG just needs to declare them as 'static'.
174 :
175 : But only do this if strictly necessary, ie, if you have problems
176 : with your compiler or suchlike.
177 : */
178 :
179 : #ifndef SWIGRUNTIME
180 : # define SWIGRUNTIME SWIGINTERN
181 : #endif
182 :
183 : #ifndef SWIGRUNTIMEINLINE
184 : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
185 : #endif
186 :
187 : /* Generic buffer size */
188 : #ifndef SWIG_BUFFER_SIZE
189 : # define SWIG_BUFFER_SIZE 1024
190 : #endif
191 :
192 : /* Flags for pointer conversions */
193 : #define SWIG_POINTER_DISOWN 0x1
194 : #define SWIG_CAST_NEW_MEMORY 0x2
195 :
196 : /* Flags for new pointer objects */
197 : #define SWIG_POINTER_OWN 0x1
198 :
199 :
200 : /*
201 : Flags/methods for returning states.
202 :
203 : The SWIG conversion methods, as ConvertPtr, return an integer
204 : that tells if the conversion was successful or not. And if not,
205 : an error code can be returned (see swigerrors.swg for the codes).
206 :
207 : Use the following macros/flags to set or process the returning
208 : states.
209 :
210 : In old versions of SWIG, code such as the following was usually written:
211 :
212 : if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
213 : // success code
214 : } else {
215 : //fail code
216 : }
217 :
218 : Now you can be more explicit:
219 :
220 : int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
221 : if (SWIG_IsOK(res)) {
222 : // success code
223 : } else {
224 : // fail code
225 : }
226 :
227 : which is the same really, but now you can also do
228 :
229 : Type *ptr;
230 : int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
231 : if (SWIG_IsOK(res)) {
232 : // success code
233 : if (SWIG_IsNewObj(res) {
234 : ...
235 : delete *ptr;
236 : } else {
237 : ...
238 : }
239 : } else {
240 : // fail code
241 : }
242 :
243 : I.e., now SWIG_ConvertPtr can return new objects and you can
244 : identify the case and take care of the deallocation. Of course that
245 : also requires SWIG_ConvertPtr to return new result values, such as
246 :
247 : int SWIG_ConvertPtr(obj, ptr,...) {
248 : if (<obj is ok>) {
249 : if (<need new object>) {
250 : *ptr = <ptr to new allocated object>;
251 : return SWIG_NEWOBJ;
252 : } else {
253 : *ptr = <ptr to old object>;
254 : return SWIG_OLDOBJ;
255 : }
256 : } else {
257 : return SWIG_BADOBJ;
258 : }
259 : }
260 :
261 : Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
262 : more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
263 : SWIG errors code.
264 :
265 : Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
266 : allows to return the 'cast rank', for example, if you have this
267 :
268 : int food(double)
269 : int fooi(int);
270 :
271 : and you call
272 :
273 : food(1) // cast rank '1' (1 -> 1.0)
274 : fooi(1) // cast rank '0'
275 :
276 : just use the SWIG_AddCast()/SWIG_CheckState()
277 : */
278 :
279 : #define SWIG_OK (0)
280 : #define SWIG_ERROR (-1)
281 : #define SWIG_IsOK(r) (r >= 0)
282 : #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
283 :
284 : /* The CastRankLimit says how many bits are used for the cast rank */
285 : #define SWIG_CASTRANKLIMIT (1 << 8)
286 : /* The NewMask denotes the object was created (using new/malloc) */
287 : #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
288 : /* The TmpMask is for in/out typemaps that use temporal objects */
289 : #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
290 : /* Simple returning values */
291 : #define SWIG_BADOBJ (SWIG_ERROR)
292 : #define SWIG_OLDOBJ (SWIG_OK)
293 : #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
294 : #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
295 : /* Check, add and del mask methods */
296 : #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
297 : #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
298 : #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
299 : #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
300 : #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
301 : #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
302 :
303 : /* Cast-Rank Mode */
304 : #if defined(SWIG_CASTRANK_MODE)
305 : # ifndef SWIG_TypeRank
306 : # define SWIG_TypeRank unsigned long
307 : # endif
308 : # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
309 : # define SWIG_MAXCASTRANK (2)
310 : # endif
311 : # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
312 : # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
313 : SWIGINTERNINLINE int SWIG_AddCast(int r) {
314 : return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
315 : }
316 : SWIGINTERNINLINE int SWIG_CheckState(int r) {
317 : return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
318 : }
319 : #else /* no cast-rank mode */
320 : # define SWIG_AddCast(r) (r)
321 : # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
322 : #endif
323 :
324 :
325 : #include <string.h>
326 :
327 : #ifdef __cplusplus
328 : extern "C" {
329 : #endif
330 :
331 : typedef void *(*swig_converter_func)(void *, int *);
332 : typedef struct swig_type_info *(*swig_dycast_func)(void **);
333 :
334 : /* Structure to store information on one type */
335 : typedef struct swig_type_info {
336 : const char *name; /* mangled name of this type */
337 : const char *str; /* human readable name of this type */
338 : swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
339 : struct swig_cast_info *cast; /* linked list of types that can cast into this type */
340 : void *clientdata; /* language specific type data */
341 : int owndata; /* flag if the structure owns the clientdata */
342 : } swig_type_info;
343 :
344 : /* Structure to store a type and conversion function used for casting */
345 : typedef struct swig_cast_info {
346 : swig_type_info *type; /* pointer to type that is equivalent to this type */
347 : swig_converter_func converter; /* function to cast the void pointers */
348 : struct swig_cast_info *next; /* pointer to next cast in linked list */
349 : struct swig_cast_info *prev; /* pointer to the previous cast */
350 : } swig_cast_info;
351 :
352 : /* Structure used to store module information
353 : * Each module generates one structure like this, and the runtime collects
354 : * all of these structures and stores them in a circularly linked list.*/
355 : typedef struct swig_module_info {
356 : swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
357 : size_t size; /* Number of types in this module */
358 : struct swig_module_info *next; /* Pointer to next element in circularly linked list */
359 : swig_type_info **type_initial; /* Array of initially generated type structures */
360 : swig_cast_info **cast_initial; /* Array of initially generated casting structures */
361 : void *clientdata; /* Language specific module data */
362 : } swig_module_info;
363 :
364 : /*
365 : Compare two type names skipping the space characters, therefore
366 : "char*" == "char *" and "Class<int>" == "Class<int >", etc.
367 :
368 : Return 0 when the two name types are equivalent, as in
369 : strncmp, but skipping ' '.
370 : */
371 : SWIGRUNTIME int
372 361 : SWIG_TypeNameComp(const char *f1, const char *l1,
373 : const char *f2, const char *l2) {
374 1923 : for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
375 1151 : while ((*f1 == ' ') && (f1 != l1)) ++f1;
376 1168 : while ((*f2 == ' ') && (f2 != l2)) ++f2;
377 1120 : if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
378 : }
379 22 : return (int)((l1 - f1) - (l2 - f2));
380 : }
381 :
382 : /*
383 : Check type equivalence in a name list like <name1>|<name2>|...
384 : Return 0 if equal, -1 if nb < tb, 1 if nb > tb
385 : */
386 : SWIGRUNTIME int
387 163 : SWIG_TypeCmp(const char *nb, const char *tb) {
388 163 : int equiv = 1;
389 163 : const char* te = tb + strlen(tb);
390 163 : const char* ne = nb;
391 524 : while (equiv != 0 && *ne) {
392 10099 : for (nb = ne; *ne; ++ne) {
393 5067 : if (*ne == '|') break;
394 : }
395 361 : equiv = SWIG_TypeNameComp(nb, ne, tb, te);
396 361 : if (*ne) ++ne;
397 : }
398 163 : return equiv;
399 : }
400 :
401 : /*
402 : Check type equivalence in a name list like <name1>|<name2>|...
403 : Return 0 if not equal, 1 if equal
404 : */
405 : SWIGRUNTIME int
406 : SWIG_TypeEquiv(const char *nb, const char *tb) {
407 163 : return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
408 : }
409 :
410 : /*
411 : Check the typename
412 : */
413 : SWIGRUNTIME swig_cast_info *
414 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
415 : if (ty) {
416 : swig_cast_info *iter = ty->cast;
417 : while (iter) {
418 : if (strcmp(iter->type->name, c) == 0) {
419 : if (iter == ty->cast)
420 : return iter;
421 : /* Move iter to the top of the linked list */
422 : iter->prev->next = iter->next;
423 : if (iter->next)
424 : iter->next->prev = iter->prev;
425 : iter->next = ty->cast;
426 : iter->prev = 0;
427 : if (ty->cast) ty->cast->prev = iter;
428 : ty->cast = iter;
429 : return iter;
430 : }
431 : iter = iter->next;
432 : }
433 : }
434 : return 0;
435 : }
436 :
437 : /*
438 : Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
439 : */
440 : SWIGRUNTIME swig_cast_info *
441 : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
442 : if (ty) {
443 : swig_cast_info *iter = ty->cast;
444 : while (iter) {
445 : if (iter->type == from) {
446 : if (iter == ty->cast)
447 : return iter;
448 : /* Move iter to the top of the linked list */
449 : iter->prev->next = iter->next;
450 : if (iter->next)
451 : iter->next->prev = iter->prev;
452 : iter->next = ty->cast;
453 : iter->prev = 0;
454 : if (ty->cast) ty->cast->prev = iter;
455 : ty->cast = iter;
456 : return iter;
457 : }
458 : iter = iter->next;
459 : }
460 : }
461 : return 0;
462 : }
463 :
464 : /*
465 : Cast a pointer up an inheritance hierarchy
466 : */
467 : SWIGRUNTIMEINLINE void *
468 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
469 : return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
470 : }
471 :
472 : /*
473 : Dynamic pointer casting. Down an inheritance hierarchy
474 : */
475 : SWIGRUNTIME swig_type_info *
476 : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
477 : swig_type_info *lastty = ty;
478 : if (!ty || !ty->dcast) return ty;
479 : while (ty && (ty->dcast)) {
480 : ty = (*ty->dcast)(ptr);
481 : if (ty) lastty = ty;
482 : }
483 : return lastty;
484 : }
485 :
486 : /*
487 : Return the name associated with this type
488 : */
489 : SWIGRUNTIMEINLINE const char *
490 : SWIG_TypeName(const swig_type_info *ty) {
491 : return ty->name;
492 : }
493 :
494 : /*
495 : Return the pretty name associated with this type,
496 : that is an unmangled type name in a form presentable to the user.
497 : */
498 : SWIGRUNTIME const char *
499 : SWIG_TypePrettyName(const swig_type_info *type) {
500 : /* The "str" field contains the equivalent pretty names of the
501 : type, separated by vertical-bar characters. We choose
502 : to print the last name, as it is often (?) the most
503 : specific. */
504 : if (!type) return NULL;
505 : if (type->str != NULL) {
506 : const char *last_name = type->str;
507 : const char *s;
508 : for (s = type->str; *s; s++)
509 : if (*s == '|') last_name = s+1;
510 : return last_name;
511 : }
512 : else
513 : return type->name;
514 : }
515 :
516 : /*
517 : Set the clientdata field for a type
518 : */
519 : SWIGRUNTIME void
520 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
521 : swig_cast_info *cast = ti->cast;
522 : /* if (ti->clientdata == clientdata) return; */
523 : ti->clientdata = clientdata;
524 :
525 : while (cast) {
526 : if (!cast->converter) {
527 : swig_type_info *tc = cast->type;
528 : if (!tc->clientdata) {
529 : SWIG_TypeClientData(tc, clientdata);
530 : }
531 : }
532 : cast = cast->next;
533 : }
534 : }
535 : SWIGRUNTIME void
536 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
537 : SWIG_TypeClientData(ti, clientdata);
538 : ti->owndata = 1;
539 : }
540 :
541 : /*
542 : Search for a swig_type_info structure only by mangled name
543 : Search is a O(log #types)
544 :
545 : We start searching at module start, and finish searching when start == end.
546 : Note: if start == end at the beginning of the function, we go all the way around
547 : the circular list.
548 : */
549 : SWIGRUNTIME swig_type_info *
550 22 : SWIG_MangledTypeQueryModule(swig_module_info *start,
551 : swig_module_info *end,
552 : const char *name) {
553 22 : swig_module_info *iter = start;
554 : do {
555 22 : if (iter->size) {
556 22 : size_t l = 0;
557 22 : size_t r = iter->size - 1;
558 : do {
559 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
560 110 : size_t i = (l + r) >> 1;
561 110 : const char *iname = iter->types[i]->name;
562 110 : if (iname) {
563 110 : int compare = strcmp(name, iname);
564 110 : if (compare == 0) {
565 : return iter->types[i];
566 110 : } else if (compare < 0) {
567 0 : if (i) {
568 0 : r = i - 1;
569 : } else {
570 : break;
571 : }
572 110 : } else if (compare > 0) {
573 110 : l = i + 1;
574 : }
575 : } else {
576 : break; /* should never happen */
577 : }
578 110 : } while (l <= r);
579 : }
580 22 : iter = iter->next;
581 22 : } while (iter != end);
582 : return 0;
583 : }
584 :
585 : /*
586 : Search for a swig_type_info structure for either a mangled name or a human readable name.
587 : It first searches the mangled names of the types, which is a O(log #types)
588 : If a type is not found it then searches the human readable names, which is O(#types).
589 :
590 : We start searching at module start, and finish searching when start == end.
591 : Note: if start == end at the beginning of the function, we go all the way around
592 : the circular list.
593 : */
594 : SWIGRUNTIME swig_type_info *
595 22 : SWIG_TypeQueryModule(swig_module_info *start,
596 : swig_module_info *end,
597 : const char *name) {
598 : /* STEP 1: Search the name field using binary search */
599 22 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
600 22 : if (ret) {
601 : return ret;
602 : } else {
603 : /* STEP 2: If the type hasn't been found, do a complete search
604 : of the str field (the human readable name) */
605 : swig_module_info *iter = start;
606 : do {
607 22 : size_t i = 0;
608 304 : for (; i < iter->size; ++i) {
609 326 : if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
610 : return iter->types[i];
611 : }
612 0 : iter = iter->next;
613 0 : } while (iter != end);
614 : }
615 :
616 : /* neither found a match */
617 : return 0;
618 : }
619 :
620 : /*
621 : Pack binary data into a string
622 : */
623 : SWIGRUNTIME char *
624 : SWIG_PackData(char *c, void *ptr, size_t sz) {
625 : static const char hex[17] = "0123456789abcdef";
626 : const unsigned char *u = (unsigned char *) ptr;
627 : const unsigned char *eu = u + sz;
628 : for (; u != eu; ++u) {
629 : unsigned char uu = *u;
630 : *(c++) = hex[(uu & 0xf0) >> 4];
631 : *(c++) = hex[uu & 0xf];
632 : }
633 : return c;
634 : }
635 :
636 : /*
637 : Unpack binary data from a string
638 : */
639 : SWIGRUNTIME const char *
640 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
641 : unsigned char *u = (unsigned char *) ptr;
642 : const unsigned char *eu = u + sz;
643 : for (; u != eu; ++u) {
644 : char d = *(c++);
645 : unsigned char uu;
646 : if ((d >= '0') && (d <= '9'))
647 : uu = (unsigned char)((d - '0') << 4);
648 : else if ((d >= 'a') && (d <= 'f'))
649 : uu = (unsigned char)((d - ('a'-10)) << 4);
650 : else
651 : return (char *) 0;
652 : d = *(c++);
653 : if ((d >= '0') && (d <= '9'))
654 : uu |= (unsigned char)(d - '0');
655 : else if ((d >= 'a') && (d <= 'f'))
656 : uu |= (unsigned char)(d - ('a'-10));
657 : else
658 : return (char *) 0;
659 : *u = uu;
660 : }
661 : return c;
662 : }
663 :
664 : /*
665 : Pack 'void *' into a string buffer.
666 : */
667 : SWIGRUNTIME char *
668 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
669 : char *r = buff;
670 : if ((2*sizeof(void *) + 2) > bsz) return 0;
671 : *(r++) = '_';
672 : r = SWIG_PackData(r,&ptr,sizeof(void *));
673 : if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
674 : strcpy(r,name);
675 : return buff;
676 : }
677 :
678 : SWIGRUNTIME const char *
679 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
680 : if (*c != '_') {
681 : if (strcmp(c,"NULL") == 0) {
682 : *ptr = (void *) 0;
683 : return name;
684 : } else {
685 : return 0;
686 : }
687 : }
688 : return SWIG_UnpackData(++c,ptr,sizeof(void *));
689 : }
690 :
691 : SWIGRUNTIME char *
692 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
693 : char *r = buff;
694 : size_t lname = (name ? strlen(name) : 0);
695 : if ((2*sz + 2 + lname) > bsz) return 0;
696 : *(r++) = '_';
697 : r = SWIG_PackData(r,ptr,sz);
698 : if (lname) {
699 : strncpy(r,name,lname+1);
700 : } else {
701 : *r = 0;
702 : }
703 : return buff;
704 : }
705 :
706 : SWIGRUNTIME const char *
707 : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
708 : if (*c != '_') {
709 : if (strcmp(c,"NULL") == 0) {
710 : memset(ptr,0,sz);
711 : return name;
712 : } else {
713 : return 0;
714 : }
715 : }
716 : return SWIG_UnpackData(++c,ptr,sz);
717 : }
718 :
719 : #ifdef __cplusplus
720 : }
721 : #endif
722 : #define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA
723 : /* -----------------------------------------------------------------------------
724 : * luarun.swg
725 : *
726 : * This file contains the runtime support for Lua modules
727 : * and includes code for managing global variables and pointer
728 : * type checking.
729 : * ----------------------------------------------------------------------------- */
730 :
731 : #ifdef __cplusplus
732 : extern "C" {
733 : #endif
734 :
735 : #include "lua.h"
736 : #include "lauxlib.h"
737 : #include <stdlib.h> /* for malloc */
738 : #include <assert.h> /* for a few sanity tests */
739 :
740 : /* -----------------------------------------------------------------------------
741 : * Lua flavors
742 : * ----------------------------------------------------------------------------- */
743 :
744 : #define SWIG_LUA_FLAVOR_LUA 1
745 : #define SWIG_LUA_FLAVOR_ELUA 2
746 : #define SWIG_LUA_FLAVOR_ELUAC 3
747 :
748 : #if !defined(SWIG_LUA_TARGET)
749 : # error SWIG_LUA_TARGET not defined
750 : #endif
751 :
752 : #if defined(SWIG_LUA_ELUA_EMULATE)
753 :
754 : struct swig_elua_entry;
755 :
756 : typedef struct swig_elua_key {
757 : int type;
758 : union {
759 : const char* strkey;
760 : lua_Number numkey;
761 : } key;
762 : } swig_elua_key;
763 :
764 : typedef struct swig_elua_val {
765 : int type;
766 : union {
767 : lua_Number number;
768 : const struct swig_elua_entry *table;
769 : const char *string;
770 : lua_CFunction function;
771 : struct {
772 : char member;
773 : long lvalue;
774 : void *pvalue;
775 : swig_type_info **ptype;
776 : } userdata;
777 : } value;
778 : } swig_elua_val;
779 :
780 : typedef struct swig_elua_entry {
781 : swig_elua_key key;
782 : swig_elua_val value;
783 : } swig_elua_entry;
784 :
785 : #define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} }
786 : #define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} }
787 : #define LNILKEY {LUA_TNIL, {.strkey = 0} }
788 :
789 : #define LNUMVAL(x) {LUA_TNUMBER, {.number = x} }
790 : #define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} }
791 : #define LROVAL(x) {LUA_TTABLE, {.table = x} }
792 : #define LNILVAL {LUA_TNIL, {.string = 0} }
793 : #define LSTRVAL(x) {LUA_TSTRING, {.string = x} }
794 :
795 : #define LUA_REG_TYPE swig_elua_entry
796 :
797 : #define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable"
798 :
799 : #define lua_pushrotable(L,p)\
800 : lua_newtable(L);\
801 : assert(p);\
802 : SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p));
803 :
804 : #define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
805 : LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } }
806 :
807 : #define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\
808 : LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } }
809 : #endif
810 :
811 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
812 : # define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
813 : # define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
814 : # define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
815 : # define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
816 : /* Those two types of constants are not supported in elua */
817 :
818 : #ifndef SWIG_LUA_CONSTTAB_POINTER
819 : #warning eLua does not support pointers as constants. By default, nil will be used as value
820 : #define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL
821 : #endif
822 :
823 : #ifndef SWIG_LUA_CONSTTAB_BINARY
824 : #warning eLua does not support pointers to member as constants. By default, nil will be used as value
825 : #define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL
826 : #endif
827 : #else /* SWIG_LUA_FLAVOR_LUA */
828 : # define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
829 : # define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
830 : # define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
831 : # define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
832 : # define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
833 : SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D
834 : # define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\
835 : SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D
836 : #endif
837 :
838 : #ifndef SWIG_LUA_ELUA_EMULATE
839 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
840 : # define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
841 : # define LSTRVAL LRO_STRVAL
842 : #endif
843 : #endif /* SWIG_LUA_ELUA_EMULATE*/
844 :
845 : #ifndef SWIG_LUA_ELUA_EMULATE
846 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
847 :
848 : #ifndef MIN_OPT_LEVEL
849 : #define MIN_OPT_LEVEL 2
850 : #endif
851 :
852 : #include "lrodefs.h"
853 : #include "lrotable.h"
854 : #endif
855 : #endif /* SWIG_LUA_ELUA_EMULATE*/
856 : /* -----------------------------------------------------------------------------
857 : * compatibility defines
858 : * ----------------------------------------------------------------------------- */
859 :
860 : /* History of Lua C API length functions: In Lua 5.0 (and before?)
861 : there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen",
862 : but a compatibility define of "lua_strlen" was added. In Lua 5.2,
863 : this function was again renamed, to "lua_rawlen" (to emphasize that
864 : it doesn't call the "__len" metamethod), and the compatibility
865 : define of lua_strlen was removed. All SWIG uses have been updated
866 : to "lua_rawlen", and we add our own defines of that here for older
867 : versions of Lua. */
868 : #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
869 : # define lua_rawlen lua_strlen
870 : #elif LUA_VERSION_NUM == 501
871 : # define lua_rawlen lua_objlen
872 : #endif
873 :
874 :
875 : /* lua_pushglobaltable is the recommended "future-proof" way to get
876 : the global table for Lua 5.2 and later. Here we define
877 : lua_pushglobaltable ourselves for Lua versions before 5.2. */
878 : #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
879 : # define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
880 : #endif
881 :
882 : /* lua_absindex was introduced in Lua 5.2 */
883 : #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
884 : # define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1)
885 : #endif
886 :
887 : /* lua_rawsetp was introduced in Lua 5.2 */
888 : #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
889 : #define lua_rawsetp(L,index,ptr)\
890 : lua_pushlightuserdata(L,(void*)(ptr));\
891 : lua_insert(L,-2);\
892 : lua_rawset(L,index);
893 :
894 : #define lua_rawgetp(L,index,ptr)\
895 : lua_pushlightuserdata(L,(void*)(ptr));\
896 : lua_rawget(L,index);
897 :
898 : #endif
899 :
900 : /* --------------------------------------------------------------------------
901 : * Helper functions for error handling
902 : * -------------------------------------------------------------------------- */
903 :
904 : /* Push the string STR on the Lua stack, like lua_pushstring, but
905 : prefixed with the the location of the innermost Lua call-point
906 : (as formated by luaL_where). */
907 : SWIGRUNTIME void
908 : SWIG_Lua_pusherrstring (lua_State *L, const char *str)
909 : {
910 : luaL_where (L, 1);
911 : lua_pushstring (L, str);
912 : lua_concat (L, 2);
913 : }
914 :
915 : /* Push a formatted string generated from FMT and following args on
916 : the Lua stack, like lua_pushfstring, but prefixed with the the
917 : location of the innermost Lua call-point (as formated by luaL_where). */
918 : SWIGRUNTIME void
919 : SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...)
920 : {
921 : va_list argp;
922 : va_start(argp, fmt);
923 : luaL_where(L, 1);
924 : lua_pushvfstring(L, fmt, argp);
925 : va_end(argp);
926 : lua_concat(L, 2);
927 : }
928 :
929 :
930 : /* -----------------------------------------------------------------------------
931 : * global swig types
932 : * ----------------------------------------------------------------------------- */
933 : /* Constant table */
934 : #define SWIG_LUA_INT 1
935 : #define SWIG_LUA_FLOAT 2
936 : #define SWIG_LUA_STRING 3
937 : #define SWIG_LUA_POINTER 4
938 : #define SWIG_LUA_BINARY 5
939 : #define SWIG_LUA_CHAR 6
940 :
941 : /* Structure for variable linking table */
942 : typedef struct {
943 : const char *name;
944 : lua_CFunction get;
945 : lua_CFunction set;
946 : } swig_lua_var_info;
947 :
948 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
949 : typedef const LUA_REG_TYPE swig_lua_method;
950 : typedef const LUA_REG_TYPE swig_lua_const_info;
951 : #else /* Normal lua */
952 : typedef luaL_Reg swig_lua_method;
953 :
954 : /* Constant information structure */
955 : typedef struct {
956 : int type;
957 : char *name;
958 : long lvalue;
959 : double dvalue;
960 : void *pvalue;
961 : swig_type_info **ptype;
962 : } swig_lua_const_info;
963 :
964 : #endif
965 :
966 : typedef struct {
967 : const char *name;
968 : lua_CFunction getmethod;
969 : lua_CFunction setmethod;
970 : } swig_lua_attribute;
971 :
972 :
973 : struct swig_lua_class;
974 : /* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */
975 : typedef struct swig_lua_namespace {
976 : const char *name;
977 : swig_lua_method *ns_methods;
978 : swig_lua_attribute *ns_attributes;
979 : swig_lua_const_info *ns_constants;
980 : struct swig_lua_class **ns_classes;
981 : struct swig_lua_namespace **ns_namespaces;
982 : } swig_lua_namespace;
983 :
984 : typedef struct swig_lua_class {
985 : const char *name; /* Name that this class has in Lua */
986 : const char *fqname; /* Fully qualified name - Scope + class name */
987 : swig_type_info **type;
988 : lua_CFunction constructor;
989 : void (*destructor)(void *);
990 : swig_lua_method *methods;
991 : swig_lua_attribute *attributes;
992 : swig_lua_namespace *cls_static;
993 : swig_lua_method *metatable; /* 0 for -eluac */
994 : struct swig_lua_class **bases;
995 : const char **base_names;
996 : } swig_lua_class;
997 :
998 : /* this is the struct for wrapping all pointers in SwigLua
999 : */
1000 : typedef struct {
1001 : swig_type_info *type;
1002 : int own; /* 1 if owned & must be destroyed */
1003 : void *ptr;
1004 : } swig_lua_userdata;
1005 :
1006 : /* this is the struct for wrapping arbitrary packed binary data
1007 : (currently it is only used for member function pointers)
1008 : the data ordering is similar to swig_lua_userdata, but it is currently not possible
1009 : to tell the two structures apart within SWIG, other than by looking at the type
1010 : */
1011 : typedef struct {
1012 : swig_type_info *type;
1013 : int own; /* 1 if owned & must be destroyed */
1014 : char data[1]; /* arbitary amount of data */
1015 : } swig_lua_rawdata;
1016 :
1017 : /* Common SWIG API */
1018 : #define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
1019 : #define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
1020 : #define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
1021 : /* for C++ member pointers, ie, member methods */
1022 : #define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
1023 : #define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type)
1024 :
1025 : /* Runtime API */
1026 : #define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
1027 : #define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
1028 : #define SWIG_MODULE_CLIENTDATA_TYPE lua_State*
1029 :
1030 : /* Contract support */
1031 : #define SWIG_contract_assert(expr, msg) \
1032 : if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else
1033 :
1034 :
1035 : /* helper #defines */
1036 : #define SWIG_fail {goto fail;}
1037 : #define SWIG_fail_arg(func_name,argnum,type) \
1038 : {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
1039 : func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
1040 : goto fail;}
1041 : #define SWIG_fail_ptr(func_name,argnum,type) \
1042 : SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
1043 : #define SWIG_check_num_args(func_name,a,b) \
1044 : if (lua_gettop(L)<a || lua_gettop(L)>b) \
1045 : {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
1046 : goto fail;}
1047 :
1048 :
1049 : #define SWIG_Lua_get_table(L,n) \
1050 : (lua_pushstring(L, n), lua_rawget(L,-2))
1051 :
1052 : #define SWIG_Lua_add_function(L,n,f) \
1053 : (lua_pushstring(L, n), \
1054 : lua_pushcfunction(L, f), \
1055 : lua_rawset(L,-3))
1056 :
1057 : #define SWIG_Lua_add_boolean(L,n,b) \
1058 : (lua_pushstring(L, n), \
1059 : lua_pushboolean(L, b), \
1060 : lua_rawset(L,-3))
1061 :
1062 : /* special helper for allowing 'nil' for usertypes */
1063 : #define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))
1064 :
1065 : #ifdef __cplusplus
1066 : /* Special helper for member function pointers
1067 : it gets the address, casts it, then dereferences it */
1068 : /*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */
1069 : #endif
1070 :
1071 : /* storing/access of swig_module_info */
1072 : SWIGRUNTIME swig_module_info *
1073 22 : SWIG_Lua_GetModule(lua_State *L) {
1074 22 : swig_module_info *ret = 0;
1075 22 : lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1076 22 : lua_rawget(L,LUA_REGISTRYINDEX);
1077 22 : if (lua_islightuserdata(L,-1))
1078 22 : ret=(swig_module_info*)lua_touserdata(L,-1);
1079 22 : lua_pop(L,1); /* tidy */
1080 22 : return ret;
1081 : }
1082 :
1083 : SWIGRUNTIME void
1084 : SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) {
1085 : /* add this all into the Lua registry: */
1086 : lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1087 : lua_pushlightuserdata(L,(void*)module);
1088 : lua_rawset(L,LUA_REGISTRYINDEX);
1089 : }
1090 :
1091 : /* -----------------------------------------------------------------------------
1092 : * global variable support code: modules
1093 : * ----------------------------------------------------------------------------- */
1094 :
1095 : /* this function is called when trying to set an immutable.
1096 : default action is to print an error.
1097 : This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
1098 : SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
1099 : {
1100 : /* there should be 1 param passed in: the new value */
1101 : #ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
1102 : lua_pop(L,1); /* remove it */
1103 : luaL_error(L,"This variable is immutable");
1104 : #endif
1105 : return 0; /* should not return anything */
1106 : }
1107 :
1108 : #ifdef SWIG_LUA_ELUA_EMULATE
1109 :
1110 : SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own);
1111 : SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type);
1112 : static int swig_lua_elua_emulate_unique_key;
1113 :
1114 : /* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */
1115 : SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table)
1116 : {
1117 : int i, table_parsed, parsed_tables_array, target_table;
1118 : assert(lua_istable(L,-1));
1119 : target_table = lua_gettop(L);
1120 : /* Get the registry where we put all parsed tables to avoid loops */
1121 : lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
1122 : if(lua_isnil(L,-1)) {
1123 : lua_pop(L,1);
1124 : lua_newtable(L);
1125 : lua_pushvalue(L,-1);
1126 : lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key));
1127 : }
1128 : parsed_tables_array = lua_gettop(L);
1129 : lua_pushvalue(L,target_table);
1130 : lua_rawsetp(L, parsed_tables_array, table);
1131 : table_parsed = 0;
1132 : const int SWIGUNUSED pairs_start = lua_gettop(L);
1133 : for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++)
1134 : {
1135 : const swig_elua_entry *entry = table + i;
1136 : int is_metatable = 0;
1137 : switch(entry->key.type) {
1138 : case LUA_TSTRING:
1139 : lua_pushstring(L,entry->key.key.strkey);
1140 : if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0)
1141 : is_metatable = 1;
1142 : break;
1143 : case LUA_TNUMBER:
1144 : lua_pushnumber(L,entry->key.key.numkey);
1145 : break;
1146 : case LUA_TNIL:
1147 : lua_pushnil(L);
1148 : break;
1149 : default:
1150 : assert(0);
1151 : }
1152 : switch(entry->value.type) {
1153 : case LUA_TSTRING:
1154 : lua_pushstring(L,entry->value.value.string);
1155 : break;
1156 : case LUA_TNUMBER:
1157 : lua_pushnumber(L,entry->value.value.number);
1158 : break;
1159 : case LUA_TFUNCTION:
1160 : lua_pushcfunction(L,entry->value.value.function);
1161 : break;
1162 : case LUA_TTABLE:
1163 : lua_rawgetp(L,parsed_tables_array, entry->value.value.table);
1164 : table_parsed = !lua_isnil(L,-1);
1165 : if(!table_parsed) {
1166 : lua_pop(L,1); /*remove nil */
1167 : lua_newtable(L);
1168 : SWIG_Lua_elua_emulate_register(L,entry->value.value.table);
1169 : }
1170 : if(is_metatable) {
1171 : assert(lua_istable(L,-1));
1172 : lua_pushvalue(L,-1);
1173 : lua_setmetatable(L,target_table);
1174 : }
1175 :
1176 : break;
1177 : case LUA_TUSERDATA:
1178 : if(entry->value.value.userdata.member)
1179 : SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue,
1180 : entry->value.value.userdata.lvalue,
1181 : *(entry->value.value.userdata.ptype));
1182 : else
1183 : SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue,
1184 : *(entry->value.value.userdata.ptype),0);
1185 : break;
1186 : case LUA_TNIL:
1187 : lua_pushnil(L);
1188 : break;
1189 : default:
1190 : assert(0);
1191 : }
1192 : assert(lua_gettop(L) == pairs_start + 2);
1193 : lua_rawset(L,target_table);
1194 : }
1195 : lua_pop(L,1); /* Removing parsed tables storage */
1196 : assert(lua_gettop(L) == target_table);
1197 : }
1198 :
1199 : SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L)
1200 : {
1201 : lua_pushnil(L);
1202 : lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
1203 : }
1204 :
1205 : SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L);
1206 :
1207 : SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L)
1208 : {
1209 : SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1);
1210 : SWIG_Lua_get_class_registry(L);
1211 : lua_getfield(L,-1,"lua_getmetatable");
1212 : lua_remove(L,-2); /* remove the registry*/
1213 : assert(!lua_isnil(L,-1));
1214 : lua_pushvalue(L,1);
1215 : assert(lua_gettop(L) == 3); /* object | function | object again */
1216 : lua_call(L,1,1);
1217 : if(!lua_isnil(L,-1)) /*There is an ordinary metatable */
1218 : return 1;
1219 : /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/
1220 : assert(lua_gettop(L) == 2);
1221 : if(lua_istable(L,-2)) {
1222 : lua_pop(L,1); /*remove the nil*/
1223 : lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY);
1224 : }
1225 : assert(lua_gettop(L) == 2);
1226 : return 1;
1227 :
1228 : fail:
1229 : lua_error(L);
1230 : return 0;
1231 : }
1232 :
1233 : SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L)
1234 : {
1235 : SWIG_Lua_get_class_registry(L);
1236 : lua_pushglobaltable(L);
1237 : lua_pushstring(L,"lua_getmetatable");
1238 : lua_getfield(L,-2,"getmetatable");
1239 : assert(!lua_isnil(L,-1));
1240 : lua_rawset(L,-4);
1241 : lua_pushstring(L, "getmetatable");
1242 : lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable);
1243 : lua_rawset(L,-3);
1244 : lua_pop(L,2);
1245 :
1246 : }
1247 : /* END OF REMOVE */
1248 :
1249 : #endif
1250 : /* -----------------------------------------------------------------------------
1251 : * global variable support code: namespaces and modules (which are the same thing)
1252 : * ----------------------------------------------------------------------------- */
1253 :
1254 : SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
1255 : {
1256 : /* there should be 2 params passed in
1257 : (1) table (not the meta table)
1258 : (2) string name of the attribute
1259 : */
1260 : assert(lua_istable(L,-2)); /* just in case */
1261 : lua_getmetatable(L,-2);
1262 : assert(lua_istable(L,-1));
1263 : SWIG_Lua_get_table(L,".get"); /* find the .get table */
1264 : assert(lua_istable(L,-1));
1265 : /* look for the key in the .get table */
1266 : lua_pushvalue(L,2); /* key */
1267 : lua_rawget(L,-2);
1268 : lua_remove(L,-2); /* stack tidy, remove .get table */
1269 : if (lua_iscfunction(L,-1))
1270 : { /* found it so call the fn & return its value */
1271 : lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */
1272 : lua_remove(L,-2); /* stack tidy, remove metatable */
1273 : return 1;
1274 : }
1275 : lua_pop(L,1); /* remove whatever was there */
1276 : /* ok, so try the .fn table */
1277 : SWIG_Lua_get_table(L,".fn"); /* find the .get table */
1278 : assert(lua_istable(L,-1)); /* just in case */
1279 : lua_pushvalue(L,2); /* key */
1280 : lua_rawget(L,-2); /* look for the fn */
1281 : lua_remove(L,-2); /* stack tidy, remove .fn table */
1282 : if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */
1283 : { /* found it so return the fn & let lua call it */
1284 : lua_remove(L,-2); /* stack tidy, remove metatable */
1285 : return 1;
1286 : }
1287 : lua_pop(L,1); /* remove whatever was there */
1288 : return 0;
1289 : }
1290 :
1291 : SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
1292 : {
1293 : /* there should be 3 params passed in
1294 : (1) table (not the meta table)
1295 : (2) string name of the attribute
1296 : (3) any for the new value
1297 : */
1298 :
1299 : assert(lua_istable(L,1));
1300 : lua_getmetatable(L,1); /* get the meta table */
1301 : assert(lua_istable(L,-1));
1302 :
1303 : SWIG_Lua_get_table(L,".set"); /* find the .set table */
1304 : if (lua_istable(L,-1))
1305 : {
1306 : /* look for the key in the .set table */
1307 : lua_pushvalue(L,2); /* key */
1308 : lua_rawget(L,-2);
1309 : if (lua_iscfunction(L,-1))
1310 : { /* found it so call the fn & return its value */
1311 : lua_pushvalue(L,3); /* value */
1312 : lua_call(L,1,0);
1313 : return 0;
1314 : }
1315 : lua_pop(L,1); /* remove the value */
1316 : }
1317 : lua_pop(L,1); /* remove the value .set table */
1318 : lua_pop(L,1); /* remote metatable */
1319 : lua_rawset(L,-3);
1320 : return 0;
1321 : }
1322 :
1323 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
1324 : SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */
1325 : SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */
1326 : SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss);
1327 :
1328 : /* helper function - register namespace methods and attributes into namespace */
1329 : SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
1330 : {
1331 : int i;
1332 : /* There must be namespace table (not metatable) at the top of the stack */
1333 : assert(lua_istable(L,-1));
1334 : SWIG_Lua_InstallConstants(L, ns->ns_constants);
1335 :
1336 : /* add methods to the namespace/module table */
1337 : for(i=0;ns->ns_methods[i].name;i++){
1338 : SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func);
1339 : }
1340 : lua_getmetatable(L,-1);
1341 :
1342 : /* add fns */
1343 : for(i=0;ns->ns_attributes[i].name;i++){
1344 : SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod);
1345 : }
1346 :
1347 : /* clear stack - remove metatble */
1348 : lua_pop(L,1);
1349 : return 0;
1350 : }
1351 :
1352 : /* Register all classes in the namespace */
1353 : SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
1354 : {
1355 : swig_lua_class **classes;
1356 :
1357 : /* There must be a module/namespace table at the top of the stack */
1358 : assert(lua_istable(L,-1));
1359 :
1360 : classes = ns->ns_classes;
1361 :
1362 : if( classes != 0 ) {
1363 : while(*classes != 0) {
1364 : SWIG_Lua_class_register(L, *classes);
1365 : classes++;
1366 : }
1367 : }
1368 : }
1369 :
1370 : /* Helper function. Creates namespace table and adds it to module table
1371 : if 'reg' is true, then will register namespace table to parent one (must be on top of the stack
1372 : when function is called).
1373 : Function always returns newly registered table on top of the stack.
1374 : */
1375 : SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg)
1376 : {
1377 : swig_lua_namespace **sub_namespace;
1378 : /* 1 argument - table on the top of the stack */
1379 : const int SWIGUNUSED begin = lua_gettop(L);
1380 : assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */
1381 : lua_checkstack(L,5);
1382 : lua_newtable(L); /* namespace itself */
1383 : lua_newtable(L); /* metatable for namespace */
1384 :
1385 : /* add a table called ".get" */
1386 : lua_pushstring(L,".get");
1387 : lua_newtable(L);
1388 : lua_rawset(L,-3);
1389 : /* add a table called ".set" */
1390 : lua_pushstring(L,".set");
1391 : lua_newtable(L);
1392 : lua_rawset(L,-3);
1393 : /* add a table called ".fn" */
1394 : lua_pushstring(L,".fn");
1395 : lua_newtable(L);
1396 : lua_rawset(L,-3);
1397 :
1398 : /* add accessor fns for using the .get,.set&.fn */
1399 : SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get);
1400 : SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set);
1401 :
1402 : lua_setmetatable(L,-2); /* set metatable */
1403 :
1404 : /* Register all functions, variables etc */
1405 : SWIG_Lua_add_namespace_details(L,ns);
1406 : /* Register classes */
1407 : SWIG_Lua_add_namespace_classes(L,ns);
1408 :
1409 : sub_namespace = ns->ns_namespaces;
1410 : if( sub_namespace != 0) {
1411 : while(*sub_namespace != 0) {
1412 : SWIG_Lua_namespace_register(L, *sub_namespace, 1);
1413 : lua_pop(L,1); /* removing sub-namespace table */
1414 : sub_namespace++;
1415 : }
1416 : }
1417 :
1418 : if (reg) {
1419 : lua_pushstring(L,ns->name);
1420 : lua_pushvalue(L,-2);
1421 : lua_rawset(L,-4); /* add namespace to module table */
1422 : }
1423 : assert(lua_gettop(L) == begin+1);
1424 : }
1425 : #endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
1426 :
1427 : /* -----------------------------------------------------------------------------
1428 : * global variable support code: classes
1429 : * ----------------------------------------------------------------------------- */
1430 :
1431 : SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname);
1432 :
1433 : typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret);
1434 :
1435 : SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type,
1436 : int first_arg, swig_lua_base_iterator_func func, int *const ret)
1437 : {
1438 : /* first_arg - position of the object in stack. Everything that is above are arguments
1439 : * and is passed to every evocation of the func */
1440 : int last_arg = lua_gettop(L);/* position of last argument */
1441 : int original_metatable = last_arg + 1;
1442 : size_t bases_count;
1443 : int result = SWIG_ERROR;
1444 : int bases_table;
1445 : (void)swig_type;
1446 : lua_getmetatable(L,first_arg);
1447 :
1448 : /* initialise base search */
1449 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1450 : SWIG_Lua_get_table(L,".bases");
1451 : assert(lua_istable(L,-1));
1452 : bases_count = lua_rawlen(L,-1);
1453 : bases_table = lua_gettop(L);
1454 : #else
1455 : /* In elua .bases table doesn't exist. Use table from swig_lua_class */
1456 : (void)bases_table;
1457 : assert(swig_type!=0);
1458 : swig_module_info *module=SWIG_GetModule(L);
1459 : swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases;
1460 : const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names;
1461 : bases_count = 0;
1462 : for(;base_names[bases_count];
1463 : bases_count++);/* get length of bases */
1464 : #endif
1465 :
1466 : if(ret)
1467 : *ret = 0;
1468 : if(bases_count>0)
1469 : {
1470 : int to_remove;
1471 : size_t i;
1472 : int j;
1473 : int subcall_last_arg;
1474 : int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */
1475 : int valid = 1;
1476 : swig_type_info *base_swig_type = 0;
1477 : for(j=first_arg;j<=last_arg;j++)
1478 : lua_pushvalue(L,j);
1479 : subcall_last_arg = lua_gettop(L);
1480 :
1481 : /* Trick: temporarily replacing original metatable with metatable for base class and call getter */
1482 : for(i=0;i<bases_count;i++) {
1483 : /* Iteration through class bases */
1484 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1485 : lua_rawgeti(L,bases_table,i+1);
1486 : base_swig_type = 0;
1487 : if(lua_isnil(L,-1)) {
1488 : valid = 0;
1489 : lua_pop(L,1);
1490 : } else {
1491 : valid = 1;
1492 : }
1493 : #else /* In elua .bases table doesn't exist. Use table from swig_lua_class */
1494 : swig_lua_class *base_class = bases[i];
1495 : if(!base_class) {
1496 : valid = 0;
1497 : } else {
1498 : valid = 1;
1499 : SWIG_Lua_get_class_metatable(L,base_class->fqname);
1500 : base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]);
1501 : assert(base_swig_type != 0);
1502 : }
1503 : #endif
1504 :
1505 : if(!valid)
1506 : continue;
1507 : assert(lua_isuserdata(L, subcall_first_arg));
1508 : assert(lua_istable(L,-1));
1509 : lua_setmetatable(L,subcall_first_arg); /* Set new metatable */
1510 : assert(lua_gettop(L) == subcall_last_arg);
1511 : result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */
1512 : if(result != SWIG_ERROR) {
1513 : break;
1514 : }
1515 : }
1516 : /* Restore original metatable */
1517 : lua_pushvalue(L,original_metatable);
1518 : lua_setmetatable(L,first_arg);
1519 : /* Clear - remove everything between last_arg and subcall_last_arg including */
1520 : to_remove = subcall_last_arg - last_arg;
1521 : for(j=0;j<to_remove;j++)
1522 : lua_remove(L,last_arg+1);
1523 : } else {
1524 : /* Remove everything after last_arg */
1525 : lua_pop(L, lua_gettop(L) - last_arg);
1526 : }
1527 : if(ret) assert(lua_gettop(L) == last_arg + *ret);
1528 : return result;
1529 : }
1530 :
1531 : /* The class.get method helper, performs the lookup of class attributes.
1532 : * It returns an error code. Number of function return values is passed inside 'ret'.
1533 : * first_arg is not used in this function because function always has 2 arguments.
1534 : */
1535 : SWIGINTERN int SWIG_Lua_class_do_get_item(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
1536 : {
1537 : /* there should be 2 params passed in
1538 : (1) userdata (not the meta table)
1539 : (2) string name of the attribute
1540 : */
1541 : int bases_search_result;
1542 : int substack_start = lua_gettop(L)-2;
1543 : assert(first_arg == substack_start+1);
1544 : lua_checkstack(L,5);
1545 : assert(lua_isuserdata(L,-2)); /* just in case */
1546 : lua_getmetatable(L,-2); /* get the meta table */
1547 : assert(lua_istable(L,-1)); /* just in case */
1548 : /* NEW: looks for the __getitem() fn
1549 : this is a user provided get fn */
1550 : SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
1551 : if (lua_iscfunction(L,-1)) /* if its there */
1552 : { /* found it so call the fn & return its value */
1553 : lua_pushvalue(L,substack_start+1); /* the userdata */
1554 : lua_pushvalue(L,substack_start+2); /* the parameter */
1555 : lua_call(L,2,1); /* 2 value in (userdata),1 out (result) */
1556 : lua_remove(L,-2); /* stack tidy, remove metatable */
1557 : if(ret) *ret = 1;
1558 : return SWIG_OK;
1559 : }
1560 : lua_pop(L,1);
1561 : /* Remove the metatable */
1562 : lua_pop(L,1);
1563 : /* Search in base classes */
1564 : bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get_item,ret);
1565 : return bases_search_result; /* sorry not known */
1566 : }
1567 :
1568 :
1569 : /* The class.get method helper, performs the lookup of class attributes.
1570 : * It returns an error code. Number of function return values is passed inside 'ret'.
1571 : * first_arg is not used in this function because function always has 2 arguments.
1572 : */
1573 : SWIGINTERN int SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
1574 : {
1575 : /* there should be 2 params passed in
1576 : (1) userdata (not the meta table)
1577 : (2) string name of the attribute
1578 : */
1579 : int bases_search_result;
1580 : int substack_start = lua_gettop(L)-2;
1581 : assert(first_arg == substack_start+1);
1582 : lua_checkstack(L,5);
1583 : assert(lua_isuserdata(L,-2)); /* just in case */
1584 : lua_getmetatable(L,-2); /* get the meta table */
1585 : assert(lua_istable(L,-1)); /* just in case */
1586 : SWIG_Lua_get_table(L,".get"); /* find the .get table */
1587 : assert(lua_istable(L,-1)); /* just in case */
1588 : /* look for the key in the .get table */
1589 : lua_pushvalue(L,substack_start+2); /* key */
1590 : lua_rawget(L,-2);
1591 : lua_remove(L,-2); /* stack tidy, remove .get table */
1592 : if (lua_iscfunction(L,-1))
1593 : { /* found it so call the fn & return its value */
1594 : lua_pushvalue(L,substack_start+1); /* the userdata */
1595 : lua_call(L,1,1); /* 1 value in (userdata),1 out (result) */
1596 : lua_remove(L,-2); /* stack tidy, remove metatable */
1597 : if(ret)
1598 : *ret = 1;
1599 : return SWIG_OK;
1600 : }
1601 : lua_pop(L,1); /* remove whatever was there */
1602 : /* ok, so try the .fn table */
1603 : SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
1604 : assert(lua_istable(L,-1)); /* just in case */
1605 : lua_pushvalue(L,substack_start+2); /* key */
1606 : lua_rawget(L,-2); /* look for the fn */
1607 : lua_remove(L,-2); /* stack tidy, remove .fn table */
1608 : if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
1609 : { /* found it so return the fn & let lua call it */
1610 : lua_remove(L,-2); /* stack tidy, remove metatable */
1611 : if(ret)
1612 : *ret = 1;
1613 : return SWIG_OK;
1614 : }
1615 : lua_pop(L,1); /* remove whatever was there */
1616 : /* Remove the metatable */
1617 : lua_pop(L,1);
1618 : /* Search in base classes */
1619 : bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get,ret);
1620 : return bases_search_result; /* sorry not known */
1621 : }
1622 :
1623 : /* the class.get method, performs the lookup of class attributes
1624 : */
1625 : SWIGINTERN int SWIG_Lua_class_get(lua_State *L)
1626 : {
1627 : /* there should be 2 params passed in
1628 : (1) userdata (not the meta table)
1629 : (2) string name of the attribute
1630 : */
1631 : int result;
1632 : swig_lua_userdata *usr;
1633 : swig_type_info *type;
1634 : int ret = 0;
1635 : assert(lua_isuserdata(L,1));
1636 : usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1637 : type = usr->type;
1638 : result = SWIG_Lua_class_do_get(L,type,1,&ret);
1639 : if(result == SWIG_OK)
1640 : return ret;
1641 :
1642 : result = SWIG_Lua_class_do_get_item(L,type,1,&ret);
1643 : if(result == SWIG_OK)
1644 : return ret;
1645 :
1646 : return 0;
1647 : }
1648 :
1649 : /* helper for the class.set method, performs the lookup of class attributes
1650 : * It returns error code. Number of function return values is passed inside 'ret'
1651 : */
1652 : SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret)
1653 : {
1654 : /* there should be 3 params passed in
1655 : (1) table (not the meta table)
1656 : (2) string name of the attribute
1657 : (3) any for the new value
1658 : */
1659 :
1660 : int bases_search_result;
1661 : int substack_start = lua_gettop(L) - 3;
1662 : lua_checkstack(L,5);
1663 : assert(lua_isuserdata(L,substack_start+1)); /* just in case */
1664 : lua_getmetatable(L,substack_start+1); /* get the meta table */
1665 : assert(lua_istable(L,-1)); /* just in case */
1666 : if(ret)
1667 : *ret = 0; /* it is setter - number of return values is always 0 */
1668 :
1669 : SWIG_Lua_get_table(L,".set"); /* find the .set table */
1670 : if (lua_istable(L,-1))
1671 : {
1672 : /* look for the key in the .set table */
1673 : lua_pushvalue(L,substack_start+2); /* key */
1674 : lua_rawget(L,-2);
1675 : lua_remove(L,-2); /* tidy stack, remove .set table */
1676 : if (lua_iscfunction(L,-1))
1677 : { /* found it so call the fn & return its value */
1678 : lua_pushvalue(L,substack_start+1); /* userdata */
1679 : lua_pushvalue(L,substack_start+3); /* value */
1680 : lua_call(L,2,0);
1681 : lua_remove(L,substack_start+4); /*remove metatable*/
1682 : return SWIG_OK;
1683 : }
1684 : lua_pop(L,1); /* remove the value */
1685 : } else {
1686 : lua_pop(L,1); /* remove the answer for .set table request*/
1687 : }
1688 : /* NEW: looks for the __setitem() fn
1689 : this is a user provided set fn */
1690 : SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
1691 : if (lua_iscfunction(L,-1)) /* if its there */
1692 : { /* found it so call the fn & return its value */
1693 : lua_pushvalue(L,substack_start+1); /* the userdata */
1694 : lua_pushvalue(L,substack_start+2); /* the parameter */
1695 : lua_pushvalue(L,substack_start+3); /* the value */
1696 : lua_call(L,3,0); /* 3 values in ,0 out */
1697 : lua_remove(L,-2); /* stack tidy, remove metatable */
1698 : return SWIG_OK;
1699 : }
1700 : lua_pop(L,1); /* remove value */
1701 :
1702 : lua_pop(L,1); /* remove metatable */
1703 : /* Search among bases */
1704 : bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret);
1705 : if(ret)
1706 : assert(*ret == 0);
1707 : assert(lua_gettop(L) == substack_start + 3);
1708 : return bases_search_result;
1709 : }
1710 :
1711 : /* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly
1712 : * handles return values.
1713 : */
1714 : SWIGINTERN int SWIG_Lua_class_set(lua_State *L)
1715 : {
1716 : /* There should be 3 params passed in
1717 : (1) table (not the meta table)
1718 : (2) string name of the attribute
1719 : (3) any for the new value
1720 : */
1721 : int ret = 0;
1722 : int result;
1723 : swig_lua_userdata *usr;
1724 : swig_type_info *type;
1725 : assert(lua_isuserdata(L,1));
1726 : usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1727 : type = usr->type;
1728 : result = SWIG_Lua_class_do_set(L,type,1,&ret);
1729 : if(result != SWIG_OK) {
1730 : SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method.");
1731 : lua_error(L);
1732 : } else {
1733 : assert(ret==0);
1734 : }
1735 : return 0;
1736 : }
1737 :
1738 : /* the class.destruct method called by the interpreter */
1739 : SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L)
1740 : {
1741 : /* there should be 1 params passed in
1742 : (1) userdata (not the meta table) */
1743 : swig_lua_userdata *usr;
1744 : swig_lua_class *clss;
1745 : assert(lua_isuserdata(L,-1)); /* just in case */
1746 : usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
1747 : /* if must be destroyed & has a destructor */
1748 : if (usr->own) /* if must be destroyed */
1749 : {
1750 : clss=(swig_lua_class*)usr->type->clientdata; /* get the class */
1751 : if (clss && clss->destructor) /* there is a destroy fn */
1752 : {
1753 : clss->destructor(usr->ptr); /* bye bye */
1754 : }
1755 : }
1756 : return 0;
1757 : }
1758 :
1759 : /* the class.__tostring method called by the interpreter and print */
1760 : SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L)
1761 : {
1762 : /* there should be 1 param passed in
1763 : (1) userdata (not the metatable) */
1764 : const char *className;
1765 : void* userData;
1766 : assert(lua_isuserdata(L,1)); /* just in case */
1767 : userData = lua_touserdata(L,1); /* get the userdata address for later */
1768 : lua_getmetatable(L,1); /* get the meta table */
1769 : assert(lua_istable(L,-1)); /* just in case */
1770 :
1771 : lua_getfield(L, -1, ".type");
1772 : className = lua_tostring(L, -1);
1773 :
1774 : lua_pushfstring(L, "<%s userdata: %p>", className, userData);
1775 : return 1;
1776 : }
1777 :
1778 : /* to manually disown some userdata */
1779 : SWIGINTERN int SWIG_Lua_class_disown(lua_State *L)
1780 : {
1781 : /* there should be 1 params passed in
1782 : (1) userdata (not the meta table) */
1783 : swig_lua_userdata *usr;
1784 : assert(lua_isuserdata(L,-1)); /* just in case */
1785 : usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
1786 :
1787 : usr->own = 0; /* clear our ownership */
1788 : return 0;
1789 : }
1790 :
1791 : /* lua callable function to compare userdata's value
1792 : the issue is that two userdata may point to the same thing
1793 : but to lua, they are different objects */
1794 : SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L)
1795 : {
1796 : int result;
1797 : swig_lua_userdata *usr1,*usr2;
1798 : if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */
1799 : return 0; /* nil reply */
1800 : usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1801 : usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */
1802 : /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
1803 : result=(usr1->ptr==usr2->ptr);
1804 : lua_pushboolean(L,result);
1805 : return 1;
1806 : }
1807 :
1808 : /* populate table at the top of the stack with metamethods that ought to be inherited */
1809 0 : SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L)
1810 : {
1811 0 : SWIG_Lua_add_boolean(L, "__add", 1);
1812 0 : SWIG_Lua_add_boolean(L, "__sub", 1);
1813 0 : SWIG_Lua_add_boolean(L, "__mul", 1);
1814 0 : SWIG_Lua_add_boolean(L, "__div", 1);
1815 0 : SWIG_Lua_add_boolean(L, "__mod", 1);
1816 0 : SWIG_Lua_add_boolean(L, "__pow", 1);
1817 0 : SWIG_Lua_add_boolean(L, "__unm", 1);
1818 0 : SWIG_Lua_add_boolean(L, "__len", 1 );
1819 0 : SWIG_Lua_add_boolean(L, "__concat", 1 );
1820 0 : SWIG_Lua_add_boolean(L, "__eq", 1);
1821 0 : SWIG_Lua_add_boolean(L, "__lt", 1);
1822 0 : SWIG_Lua_add_boolean(L, "__le", 1);
1823 0 : SWIG_Lua_add_boolean(L, "__call", 1);
1824 0 : SWIG_Lua_add_boolean(L, "__tostring", 1);
1825 0 : SWIG_Lua_add_boolean(L, "__gc", 0);
1826 0 : }
1827 :
1828 : /* creates the swig registry */
1829 0 : SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L)
1830 : {
1831 : /* create main SWIG registry table */
1832 0 : lua_pushstring(L,"SWIG");
1833 0 : lua_newtable(L);
1834 : /* populate it with some predefined data */
1835 :
1836 : /* .library table. Placeholder */
1837 0 : lua_pushstring(L,".library");
1838 0 : lua_newtable(L);
1839 : {
1840 : /* list of metamethods that class inherits from its bases */
1841 0 : lua_pushstring(L,"inheritable_metamethods");
1842 0 : lua_newtable(L);
1843 : /* populate with list of metamethods */
1844 0 : SWIG_Lua_populate_inheritable_metamethods(L);
1845 0 : lua_rawset(L,-3);
1846 : }
1847 0 : lua_rawset(L,-3);
1848 :
1849 0 : lua_rawset(L,LUA_REGISTRYINDEX);
1850 0 : }
1851 :
1852 : /* gets the swig registry (or creates it) */
1853 18 : SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L)
1854 : {
1855 : /* add this all into the swig registry: */
1856 18 : lua_pushstring(L,"SWIG");
1857 18 : lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */
1858 18 : if (!lua_istable(L,-1)) /* not there */
1859 : { /* must be first time, so add it */
1860 0 : lua_pop(L,1); /* remove the result */
1861 0 : SWIG_Lua_create_class_registry(L);
1862 : /* then get it */
1863 0 : lua_pushstring(L,"SWIG");
1864 0 : lua_rawget(L,LUA_REGISTRYINDEX);
1865 : }
1866 18 : }
1867 :
1868 : SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L)
1869 : {
1870 : SWIG_Lua_get_class_registry(L);
1871 : lua_pushstring(L, ".library");
1872 : lua_rawget(L,-2);
1873 : assert( !lua_isnil(L,-1) );
1874 : lua_pushstring(L, "inheritable_metamethods");
1875 : lua_rawget(L,-2);
1876 :
1877 : /* Remove class registry and library table */
1878 : lua_remove(L,-2);
1879 : lua_remove(L,-2);
1880 : }
1881 :
1882 : /* Helper function to get the classes metatable from the register */
1883 18 : SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname)
1884 : {
1885 18 : SWIG_Lua_get_class_registry(L); /* get the registry */
1886 18 : lua_pushstring(L,cname); /* get the name */
1887 18 : lua_rawget(L,-2); /* get it */
1888 18 : lua_remove(L,-2); /* tidy up (remove registry) */
1889 18 : }
1890 :
1891 : /* Set up the base classes pointers.
1892 : Each class structure has a list of pointers to the base class structures.
1893 : This function fills them.
1894 : It cannot be done at compile time, as this will not work with hireachies
1895 : spread over more than one swig file.
1896 : Therefore it must be done at runtime, querying the SWIG type system.
1897 : */
1898 : SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss)
1899 : {
1900 : int i=0;
1901 : swig_module_info *module=SWIG_GetModule(L);
1902 : for(i=0;clss->base_names[i];i++)
1903 : {
1904 : if (clss->bases[i]==0) /* not found yet */
1905 : {
1906 : /* lookup and cache the base class */
1907 : swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
1908 : if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
1909 : }
1910 : }
1911 : }
1912 :
1913 : #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1914 : /* Merges two tables */
1915 : SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
1916 : {
1917 : /* iterating */
1918 : lua_pushnil(L);
1919 : while (lua_next(L,source) != 0) {
1920 : /* -1 - value, -2 - index */
1921 : /* have to copy to assign */
1922 : lua_pushvalue(L,-2); /* copy of index */
1923 : lua_pushvalue(L,-2); /* copy of value */
1924 : lua_rawset(L, target);
1925 : lua_pop(L,1);
1926 : /* only key is left */
1927 : }
1928 : }
1929 :
1930 : /* Merges two tables with given name. original - index of target metatable, base - index of source metatable */
1931 : SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
1932 : {
1933 : /* push original[name], then base[name] */
1934 : lua_pushstring(L,name);
1935 : lua_rawget(L,original);
1936 : int original_table = lua_gettop(L);
1937 : lua_pushstring(L,name);
1938 : lua_rawget(L,base);
1939 : int base_table = lua_gettop(L);
1940 : SWIG_Lua_merge_tables_by_index(L, original_table, base_table);
1941 : /* clearing stack */
1942 : lua_pop(L,2);
1943 : }
1944 :
1945 : /* Function takes all symbols from base and adds it to derived class. It's just a helper. */
1946 : SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
1947 : {
1948 : /* There is one parameter - original, i.e. 'derived' class metatable */
1949 : assert(lua_istable(L,-1));
1950 : int original = lua_gettop(L);
1951 : SWIG_Lua_get_class_metatable(L,base_cls->fqname);
1952 : int base = lua_gettop(L);
1953 : SWIG_Lua_merge_tables(L, ".fn", original, base );
1954 : SWIG_Lua_merge_tables(L, ".set", original, base );
1955 : SWIG_Lua_merge_tables(L, ".get", original, base );
1956 : lua_pop(L,1);
1957 : }
1958 :
1959 : /* Function squashes all symbols from 'clss' bases into itself */
1960 : SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
1961 : {
1962 : int i;
1963 : SWIG_Lua_get_class_metatable(L,clss->fqname);
1964 : for(i=0;clss->base_names[i];i++)
1965 : {
1966 : if (clss->bases[i]==0) /* Somehow it's not found. Skip it */
1967 : continue;
1968 : /* Thing is: all bases are already registered. Thus they have already executed
1969 : * this function. So we just need to squash them into us, because their bases
1970 : * are already squashed into them. No need for recursion here!
1971 : */
1972 : SWIG_Lua_class_squash_base(L, clss->bases[i]);
1973 : }
1974 : lua_pop(L,1); /*tidy stack*/
1975 : }
1976 : #endif
1977 :
1978 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
1979 : /* helper add a variable to a registered class */
1980 : SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn)
1981 : {
1982 : assert(lua_istable(L,-1)); /* just in case */
1983 : SWIG_Lua_get_table(L,".get"); /* find the .get table */
1984 : assert(lua_istable(L,-1)); /* just in case */
1985 : SWIG_Lua_add_function(L,name,getFn);
1986 : lua_pop(L,1); /* tidy stack (remove table) */
1987 : if (setFn)
1988 : {
1989 : SWIG_Lua_get_table(L,".set"); /* find the .set table */
1990 : assert(lua_istable(L,-1)); /* just in case */
1991 : SWIG_Lua_add_function(L,name,setFn);
1992 : lua_pop(L,1); /* tidy stack (remove table) */
1993 : }
1994 : }
1995 :
1996 : /* helper to recursively add class static details (static attributes, operations and constants) */
1997 : SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss)
1998 : {
1999 : int i = 0;
2000 : /* The class namespace table must be on the top of the stack */
2001 : assert(lua_istable(L,-1));
2002 : /* call all the base classes first: we can then override these later: */
2003 : for(i=0;clss->bases[i];i++)
2004 : {
2005 : SWIG_Lua_add_class_static_details(L,clss->bases[i]);
2006 : }
2007 :
2008 : SWIG_Lua_add_namespace_details(L, clss->cls_static);
2009 : }
2010 :
2011 : SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */
2012 :
2013 : /* helper to recursively add class details (attributes & operations) */
2014 : SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss)
2015 : {
2016 : int i;
2017 : size_t bases_count = 0;
2018 : /* Add bases to .bases table */
2019 : SWIG_Lua_get_table(L,".bases");
2020 : assert(lua_istable(L,-1)); /* just in case */
2021 : for(i=0;clss->bases[i];i++)
2022 : {
2023 : SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
2024 : /* Base class must be already registered */
2025 : assert(lua_istable(L,-1));
2026 : lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */
2027 : bases_count++;
2028 : }
2029 : assert(lua_rawlen(L,-1) == bases_count);
2030 : lua_pop(L,1); /* remove .bases table */
2031 : /* add attributes */
2032 : for(i=0;clss->attributes[i].name;i++){
2033 : SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
2034 : }
2035 : /* add methods to the metatable */
2036 : SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
2037 : assert(lua_istable(L,-1)); /* just in case */
2038 : for(i=0;clss->methods[i].name;i++){
2039 : SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func);
2040 : }
2041 : lua_pop(L,1); /* tidy stack (remove table) */
2042 : /* add operator overloads
2043 : This adds methods from metatable array to metatable. Can mess up garbage
2044 : collectind if someone defines __gc method
2045 : */
2046 : if(clss->metatable) {
2047 : for(i=0;clss->metatable[i].name;i++) {
2048 : SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func);
2049 : }
2050 : }
2051 :
2052 : #if !defined(SWIG_LUA_SQUASH_BASES)
2053 : /* Adding metamethods that are defined in base classes. If bases were squashed
2054 : * then it is obviously unnecessary
2055 : */
2056 : SWIG_Lua_add_class_user_metamethods(L, clss);
2057 : #endif
2058 : }
2059 :
2060 : /* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed
2061 : for the following issue: Lua runtime checks for metamethod existence with rawget function
2062 : ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method
2063 : search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly
2064 : in metatable and not in object).
2065 : Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants
2066 : are automatically given a special proxy __x that calls the real __x method.
2067 : Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime,
2068 : those changes must be reflected in all descendants.
2069 : */
2070 :
2071 : SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/
2072 :
2073 : /* The real function that resolves a metamethod.
2074 : * Function searches given class and all it's bases(recursively) for first instance of something that is
2075 : * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation
2076 : * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the
2077 : * answer.
2078 : * Returns 1 if found, 0 otherwise.
2079 : * clss is class which metatable we will search for method
2080 : * metamethod_name_idx is index in L where metamethod name (as string) lies
2081 : * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check
2082 : * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from
2083 : * SWIG_Lua_resolve_metamethod
2084 : * */
2085 : SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx,
2086 : int skip_check)
2087 : {
2088 : /* This function is called recursively */
2089 : int result = 0;
2090 : int i = 0;
2091 :
2092 : if (!skip_check) {
2093 : SWIG_Lua_get_class_metatable(L, clss->fqname);
2094 : lua_pushvalue(L, metamethod_name_idx);
2095 : lua_rawget(L,-2);
2096 : /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then
2097 : * this isn't the function we are looking for :)
2098 : * lua_tocfunction will return NULL if not cfunction
2099 : */
2100 : if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) {
2101 : lua_remove(L,-2); /* removing class metatable */
2102 : return 1;
2103 : }
2104 : lua_pop(L,2); /* remove class metatable and query result */
2105 : }
2106 :
2107 : /* Forwarding calls to bases */
2108 : for(i=0;clss->bases[i];i++)
2109 : {
2110 : result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0);
2111 : if (result)
2112 : break;
2113 : }
2114 :
2115 : return result;
2116 : }
2117 :
2118 : /* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method
2119 : * and calls it */
2120 : SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L)
2121 : {
2122 : int numargs;
2123 : int metamethod_name_idx;
2124 : const swig_lua_class* clss;
2125 : int result;
2126 :
2127 : lua_checkstack(L,5);
2128 : numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */
2129 :
2130 : /* Get upvalues from closure */
2131 : lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/
2132 : metamethod_name_idx = lua_gettop(L);
2133 :
2134 : lua_pushvalue(L, lua_upvalueindex(2));
2135 : clss = (const swig_lua_class*)(lua_touserdata(L,-1));
2136 : lua_pop(L,1); /* remove lightuserdata with clss from stack */
2137 :
2138 : /* Actual work */
2139 : result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1);
2140 : if (!result) {
2141 : SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation.");
2142 : lua_error(L);
2143 : return 0;
2144 : }
2145 :
2146 : lua_remove(L,-2); /* remove metamethod key */
2147 : lua_insert(L,1); /* move function to correct position */
2148 : lua_call(L, numargs, LUA_MULTRET);
2149 : return lua_gettop(L); /* return all results */
2150 : }
2151 :
2152 :
2153 : /* If given metamethod must be present in given class, then creates appropriate proxy
2154 : * Returns 1 if successfully added, 0 if not added because no base class has it, -1
2155 : * if method is defined in the class metatable itself
2156 : */
2157 : SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index)
2158 : {
2159 : int key_index;
2160 : int success = 0;
2161 : int i = 0;
2162 :
2163 : /* metamethod name - on the top of the stack */
2164 : assert(lua_isstring(L,-1));
2165 :
2166 : key_index = lua_gettop(L);
2167 :
2168 : /* Check whether method is already defined in metatable */
2169 : lua_pushvalue(L,key_index); /* copy of the key */
2170 : lua_gettable(L,metatable_index);
2171 : if( !lua_isnil(L,-1) ) {
2172 : lua_pop(L,1);
2173 : return -1;
2174 : }
2175 : lua_pop(L,1);
2176 :
2177 : /* Iterating over immediate bases */
2178 : for(i=0;clss->bases[i];i++)
2179 : {
2180 : const swig_lua_class *base = clss->bases[i];
2181 : SWIG_Lua_get_class_metatable(L, base->fqname);
2182 : lua_pushvalue(L, key_index);
2183 : lua_rawget(L, -2);
2184 : if( !lua_isnil(L,-1) ) {
2185 : lua_pushvalue(L, key_index);
2186 :
2187 : /* Add proxy function */
2188 : lua_pushvalue(L, key_index); /* first closure value is function name */
2189 : lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */
2190 : lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2);
2191 :
2192 : lua_rawset(L, metatable_index);
2193 : success = 1;
2194 : }
2195 : lua_pop(L,1); /* remove function or nil */
2196 : lua_pop(L,1); /* remove base class metatable */
2197 :
2198 : if( success )
2199 : break;
2200 : }
2201 :
2202 : return success;
2203 : }
2204 :
2205 : SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss)
2206 : {
2207 : int metatable_index;
2208 : int metamethods_info_index;
2209 : int tostring_undefined;
2210 : int eq_undefined = 0;
2211 :
2212 : SWIG_Lua_get_class_metatable(L, clss->fqname);
2213 : metatable_index = lua_gettop(L);
2214 : SWIG_Lua_get_inheritable_metamethods(L);
2215 : assert(lua_istable(L,-1));
2216 : metamethods_info_index = lua_gettop(L);
2217 : lua_pushnil(L); /* first key */
2218 : while(lua_next(L, metamethods_info_index) != 0 ) {
2219 : /* key at index -2, value at index -1 */
2220 : const int is_inheritable = lua_toboolean(L,-2);
2221 : lua_pop(L,1); /* remove value - we don't need it anymore */
2222 :
2223 : if(is_inheritable) { /* if metamethod is inheritable */
2224 : SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index);
2225 : }
2226 : }
2227 :
2228 : lua_pop(L,1); /* remove inheritable metatmethods table */
2229 :
2230 : /* Special handling for __tostring method */
2231 : lua_pushstring(L, "__tostring");
2232 : lua_pushvalue(L,-1);
2233 : lua_rawget(L,metatable_index);
2234 : tostring_undefined = lua_isnil(L,-1);
2235 : lua_pop(L,1);
2236 : if( tostring_undefined ) {
2237 : lua_pushcfunction(L, SWIG_Lua_class_tostring);
2238 : lua_rawset(L, metatable_index);
2239 : } else {
2240 : lua_pop(L,1); /* remove copy of the key */
2241 : }
2242 :
2243 : /* Special handling for __eq method */
2244 : lua_pushstring(L, "__eq");
2245 : lua_pushvalue(L,-1);
2246 : lua_rawget(L,metatable_index);
2247 : eq_undefined = lua_isnil(L,-1);
2248 : lua_pop(L,1);
2249 : if( eq_undefined ) {
2250 : lua_pushcfunction(L, SWIG_Lua_class_equal);
2251 : lua_rawset(L, metatable_index);
2252 : } else {
2253 : lua_pop(L,1); /* remove copy of the key */
2254 : }
2255 : /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[]
2256 : * a __getitem/__setitem method should be defined
2257 : */
2258 : lua_pop(L,1); /* pop class metatable */
2259 : }
2260 :
2261 : /* Register class static methods,attributes etc as well as constructor proxy */
2262 : SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss)
2263 : {
2264 : const int SWIGUNUSED begin = lua_gettop(L);
2265 : lua_checkstack(L,5); /* just in case */
2266 : assert(lua_istable(L,-1)); /* just in case */
2267 : assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */
2268 :
2269 : SWIG_Lua_namespace_register(L,clss->cls_static, 1);
2270 :
2271 : assert(lua_istable(L,-1)); /* just in case */
2272 :
2273 : /* add its constructor to module with the name of the class
2274 : so you can do MyClass(...) as well as new_MyClass(...)
2275 : BUT only if a constructor is defined
2276 : (this overcomes the problem of pure virtual classes without constructors)*/
2277 : if (clss->constructor)
2278 : {
2279 : lua_getmetatable(L,-1);
2280 : assert(lua_istable(L,-1)); /* just in case */
2281 : SWIG_Lua_add_function(L,"__call", clss->constructor);
2282 : lua_pop(L,1);
2283 : }
2284 :
2285 : assert(lua_istable(L,-1)); /* just in case */
2286 : SWIG_Lua_add_class_static_details(L, clss);
2287 :
2288 : /* clear stack */
2289 : lua_pop(L,1);
2290 : assert( lua_gettop(L) == begin );
2291 : }
2292 :
2293 : /* Performs the instance (non-static) class registration process. Metatable for class is created
2294 : * and added to the class registry.
2295 : */
2296 : SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss)
2297 : {
2298 : const int SWIGUNUSED begin = lua_gettop(L);
2299 : int i;
2300 : /* if name already there (class is already registered) then do nothing */
2301 : SWIG_Lua_get_class_registry(L); /* get the registry */
2302 : lua_pushstring(L,clss->fqname); /* get the name */
2303 : lua_rawget(L,-2);
2304 : if(!lua_isnil(L,-1)) {
2305 : lua_pop(L,2);
2306 : assert(lua_gettop(L)==begin);
2307 : return;
2308 : }
2309 : lua_pop(L,2); /* tidy stack */
2310 : /* Recursively initialize all bases */
2311 : for(i=0;clss->bases[i];i++)
2312 : {
2313 : SWIG_Lua_class_register_instance(L,clss->bases[i]);
2314 : }
2315 : /* Again, get registry and push name */
2316 : SWIG_Lua_get_class_registry(L); /* get the registry */
2317 : lua_pushstring(L,clss->fqname); /* get the name */
2318 : lua_newtable(L); /* create the metatable */
2319 : #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
2320 : /* If squashing is requested, then merges all bases metatable into this one.
2321 : * It would get us all special methods: __getitem, __add etc.
2322 : * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away
2323 : */
2324 : {
2325 : int new_metatable_index = lua_absindex(L,-1);
2326 : for(i=0;clss->bases[i];i++)
2327 : {
2328 : int base_metatable;
2329 : SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
2330 : base_metatable = lua_absindex(L,-1);
2331 : SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable);
2332 : lua_pop(L,1);
2333 : }
2334 : }
2335 : /* And now we will overwrite all incorrectly set data */
2336 : #endif
2337 : /* add string of class name called ".type" */
2338 : lua_pushstring(L,".type");
2339 : lua_pushstring(L,clss->fqname);
2340 : lua_rawset(L,-3);
2341 : /* add a table called bases */
2342 : lua_pushstring(L,".bases");
2343 : lua_newtable(L);
2344 : lua_rawset(L,-3);
2345 : /* add a table called ".get" */
2346 : lua_pushstring(L,".get");
2347 : lua_newtable(L);
2348 : lua_rawset(L,-3);
2349 : /* add a table called ".set" */
2350 : lua_pushstring(L,".set");
2351 : lua_newtable(L);
2352 : lua_rawset(L,-3);
2353 : /* add a table called ".fn" */
2354 : lua_pushstring(L,".fn");
2355 : lua_newtable(L);
2356 : /* add manual disown method */
2357 : SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown);
2358 : lua_rawset(L,-3);
2359 : /* add accessor fns for using the .get,.set&.fn */
2360 : SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get);
2361 : SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
2362 : SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct);
2363 : /* add it */
2364 : lua_rawset(L,-3); /* metatable into registry */
2365 : lua_pop(L,1); /* tidy stack (remove registry) */
2366 : assert(lua_gettop(L) == begin);
2367 :
2368 : #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
2369 : /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */
2370 : SWIG_Lua_class_squash_bases(L,clss);
2371 : #endif
2372 : SWIG_Lua_get_class_metatable(L,clss->fqname);
2373 : SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */
2374 : lua_pop(L,1); /* tidy stack (remove class metatable) */
2375 : assert( lua_gettop(L) == begin );
2376 : }
2377 :
2378 : SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss)
2379 : {
2380 : int SWIGUNUSED begin;
2381 : assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */
2382 : SWIG_Lua_class_register_instance(L,clss);
2383 : SWIG_Lua_class_register_static(L,clss);
2384 :
2385 : /* Add links from static part to instance part and vice versa */
2386 : /* [SWIG registry] [Module]
2387 : * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part]
2388 : * ".get" ----> ... | | getmetatable()----|
2389 : * ".set" ----> ... | | |
2390 : * ".static" --------------)----------------/ [static part metatable]
2391 : * | ".get" --> ...
2392 : * | ".set" --> ....
2393 : * |=============================== ".instance"
2394 : */
2395 : begin = lua_gettop(L);
2396 : lua_pushstring(L,clss->cls_static->name);
2397 : lua_rawget(L,-2); /* get class static table */
2398 : assert(lua_istable(L,-1));
2399 : lua_getmetatable(L,-1);
2400 : assert(lua_istable(L,-1)); /* get class static metatable */
2401 : lua_pushstring(L,".instance"); /* prepare key */
2402 :
2403 : SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */
2404 : assert(lua_istable(L,-1));
2405 : lua_pushstring(L,".static"); /* prepare key */
2406 : lua_pushvalue(L, -4); /* push static class TABLE */
2407 : assert(lua_istable(L,-1));
2408 : lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */
2409 : lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */
2410 : lua_pop(L,2);
2411 : assert(lua_gettop(L) == begin);
2412 : }
2413 : #endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
2414 :
2415 : #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
2416 : SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss)
2417 : {
2418 : const int SWIGUNUSED begin = lua_gettop(L);
2419 : int i;
2420 : /* if name already there (class is already registered) then do nothing */
2421 : SWIG_Lua_get_class_registry(L); /* get the registry */
2422 : lua_pushstring(L,clss->fqname); /* get the name */
2423 : lua_rawget(L,-2);
2424 : if(!lua_isnil(L,-1)) {
2425 : lua_pop(L,2);
2426 : assert(lua_gettop(L)==begin);
2427 : return;
2428 : }
2429 : lua_pop(L,2); /* tidy stack */
2430 : /* Recursively initialize all bases */
2431 : for(i=0;clss->bases[i];i++)
2432 : {
2433 : SWIG_Lua_elua_class_register_instance(L,clss->bases[i]);
2434 : }
2435 : /* Again, get registry and push name */
2436 : SWIG_Lua_get_class_registry(L); /* get the registry */
2437 : lua_pushstring(L,clss->fqname); /* get the name */
2438 : assert(clss->metatable);
2439 : lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */
2440 : lua_rawset(L,-3);
2441 : lua_pop(L,1);
2442 : assert(lua_gettop(L) == begin);
2443 : }
2444 : #endif /* elua && eluac */
2445 :
2446 : /* -----------------------------------------------------------------------------
2447 : * Class/structure conversion fns
2448 : * ----------------------------------------------------------------------------- */
2449 :
2450 : /* helper to add metatable to new lua object */
2451 18 : SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type)
2452 : {
2453 18 : if (type->clientdata) /* there is clientdata: so add the metatable */
2454 : {
2455 18 : SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname);
2456 18 : if (lua_istable(L,-1))
2457 : {
2458 18 : lua_setmetatable(L,-2);
2459 : }
2460 : else
2461 : {
2462 0 : lua_pop(L,1);
2463 : }
2464 : }
2465 18 : }
2466 :
2467 : /* pushes a new object into the lua stack */
2468 18 : SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own)
2469 : {
2470 : swig_lua_userdata *usr;
2471 18 : if (!ptr){
2472 0 : lua_pushnil(L);
2473 0 : return;
2474 : }
2475 18 : usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */
2476 18 : usr->ptr=ptr; /* set the ptr */
2477 18 : usr->type=type;
2478 18 : usr->own=own;
2479 : #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
2480 18 : SWIG_Lua_AddMetatable(L,type); /* add metatable */
2481 : #endif
2482 : }
2483 :
2484 : /* takes a object from the lua stack & converts it into an object of the correct type
2485 : (if possible) */
2486 : SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
2487 : {
2488 : swig_lua_userdata *usr;
2489 : swig_cast_info *cast;
2490 : if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */
2491 : usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */
2492 : if (usr)
2493 : {
2494 : if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
2495 : {
2496 : usr->own=0;
2497 : }
2498 : if (!type) /* special cast void*, no casting fn */
2499 : {
2500 : *ptr=usr->ptr;
2501 : return SWIG_OK; /* ok */
2502 : }
2503 : cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
2504 : if (cast)
2505 : {
2506 : int newmemory = 0;
2507 : *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
2508 : assert(!newmemory); /* newmemory handling not yet implemented */
2509 : return SWIG_OK; /* ok */
2510 : }
2511 : }
2512 : return SWIG_ERROR; /* error */
2513 : }
2514 :
2515 : SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,
2516 : int argnum,const char *func_name){
2517 : void *result;
2518 : if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
2519 : luaL_error (L,"Error in %s, expected a %s at argument number %d\n",
2520 : func_name,(type && type->str)?type->str:"void*",argnum);
2521 : }
2522 : return result;
2523 : }
2524 :
2525 : /* pushes a packed userdata. user for member fn pointers only */
2526 : SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type)
2527 : {
2528 : swig_lua_rawdata *raw;
2529 : assert(ptr); /* not acceptable to pass in a NULL value */
2530 : raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */
2531 : raw->type=type;
2532 : raw->own=0;
2533 : memcpy(raw->data,ptr,size); /* copy the data */
2534 : SWIG_Lua_AddMetatable(L,type); /* add metatable */
2535 : }
2536 :
2537 : /* converts a packed userdata. user for member fn pointers only */
2538 : SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type)
2539 : {
2540 : swig_lua_rawdata *raw;
2541 : raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */
2542 : if (!raw) return SWIG_ERROR; /* error */
2543 : if (type==0 || type==raw->type) /* void* or identical type */
2544 : {
2545 : memcpy(ptr,raw->data,size); /* copy it */
2546 : return SWIG_OK; /* ok */
2547 : }
2548 : return SWIG_ERROR; /* error */
2549 : }
2550 :
2551 : /* a function to get the typestring of a piece of data */
2552 : SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
2553 : {
2554 : swig_lua_userdata *usr;
2555 : if (lua_isuserdata(L,tp))
2556 : {
2557 : usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */
2558 : if (usr && usr->type && usr->type->str)
2559 : return usr->type->str;
2560 : return "userdata (unknown type)";
2561 : }
2562 : return lua_typename(L,lua_type(L,tp));
2563 : }
2564 :
2565 : /* lua callable function to get the userdata's type */
2566 : SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
2567 : {
2568 : lua_pushstring(L,SWIG_Lua_typename(L,1));
2569 : return 1;
2570 : }
2571 :
2572 : /* -----------------------------------------------------------------------------
2573 : * global variable support code: class/struct typemap functions
2574 : * ----------------------------------------------------------------------------- */
2575 :
2576 : #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
2577 : /* Install Constants */
2578 : SWIGINTERN void
2579 : SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) {
2580 : int i;
2581 : for (i = 0; constants[i].type; i++) {
2582 : switch(constants[i].type) {
2583 : case SWIG_LUA_INT:
2584 : lua_pushstring(L,constants[i].name);
2585 : lua_pushinteger(L,(lua_Number)constants[i].lvalue);
2586 : lua_rawset(L,-3);
2587 : break;
2588 : case SWIG_LUA_FLOAT:
2589 : lua_pushstring(L,constants[i].name);
2590 : lua_pushnumber(L,(lua_Number)constants[i].dvalue);
2591 : lua_rawset(L,-3);
2592 : break;
2593 : case SWIG_LUA_CHAR:
2594 : lua_pushstring(L,constants[i].name);
2595 : {
2596 : char c = constants[i].lvalue;
2597 : lua_pushlstring(L,&c,1);
2598 : }
2599 : lua_rawset(L,-3);
2600 : break;
2601 : case SWIG_LUA_STRING:
2602 : lua_pushstring(L,constants[i].name);
2603 : lua_pushstring(L,(char *) constants[i].pvalue);
2604 : lua_rawset(L,-3);
2605 : break;
2606 : case SWIG_LUA_POINTER:
2607 : lua_pushstring(L,constants[i].name);
2608 : SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
2609 : lua_rawset(L,-3);
2610 : break;
2611 : case SWIG_LUA_BINARY:
2612 : lua_pushstring(L,constants[i].name);
2613 : SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
2614 : lua_rawset(L,-3);
2615 : break;
2616 : default:
2617 : break;
2618 : }
2619 : }
2620 : }
2621 : #endif
2622 :
2623 : /* -----------------------------------------------------------------------------
2624 : * executing lua code from within the wrapper
2625 : * ----------------------------------------------------------------------------- */
2626 :
2627 : #ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
2628 : #define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
2629 : #endif
2630 : /* Executes a C string in Lua which is a really simple way of calling lua from C
2631 : Unfortunately lua keeps changing its APIs, so we need a conditional compile
2632 : In lua 5.0.X it's lua_dostring()
2633 : In lua 5.1.X it's luaL_dostring()
2634 : */
2635 : SWIGINTERN int
2636 : SWIG_Lua_dostring(lua_State *L, const char *str) {
2637 : int ok,top;
2638 : if (str==0 || str[0]==0) return 0; /* nothing to do */
2639 : top=lua_gettop(L); /* save stack */
2640 : #if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
2641 : ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */
2642 : #else
2643 : ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */
2644 : #endif
2645 : if (ok!=0) {
2646 : SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
2647 : }
2648 : lua_settop(L,top); /* restore the stack */
2649 : return ok;
2650 : }
2651 :
2652 : #ifdef __cplusplus
2653 : }
2654 : #endif
2655 :
2656 : /* ------------------------------ end luarun.swg ------------------------------ */
2657 : /* -----------------------------------------------------------------------------*
2658 : Standard SWIG API for use inside user code.
2659 :
2660 : Don't include this file directly, run the command
2661 : swig -python -external-runtime
2662 : Also, read the Modules chapter of the SWIG Manual.
2663 :
2664 : * -----------------------------------------------------------------------------*/
2665 :
2666 : #ifdef SWIG_MODULE_CLIENTDATA_TYPE
2667 :
2668 : SWIGRUNTIMEINLINE swig_type_info *
2669 : SWIG_TypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
2670 22 : swig_module_info *module = SWIG_GetModule(clientdata);
2671 22 : return SWIG_TypeQueryModule(module, module, name);
2672 : }
2673 :
2674 : SWIGRUNTIMEINLINE swig_type_info *
2675 : SWIG_MangledTypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
2676 : swig_module_info *module = SWIG_GetModule(clientdata);
2677 : return SWIG_MangledTypeQueryModule(module, module, name);
2678 : }
2679 :
2680 : #else
2681 :
2682 : SWIGRUNTIMEINLINE swig_type_info *
2683 : SWIG_TypeQuery(const char *name) {
2684 : swig_module_info *module = SWIG_GetModule(NULL);
2685 : return SWIG_TypeQueryModule(module, module, name);
2686 : }
2687 :
2688 : SWIGRUNTIMEINLINE swig_type_info *
2689 : SWIG_MangledTypeQuery(const char *name) {
2690 : swig_module_info *module = SWIG_GetModule(NULL);
2691 : return SWIG_MangledTypeQueryModule(module, module, name);
2692 : }
2693 :
2694 : #endif
|