PLplot: plplotluacLUA_wrap.c Source File

PLplot 5.15.0

plplotluacLUA_wrap.c
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 3.0.12
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12 #ifndef SWIGLUA
13 #define SWIGLUA
14 #endif
15
16 #define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA
17 #define SWIG_LUA_MODULE_GLOBAL
18
19 /* -----------------------------------------------------------------------------
20 * This section contains generic SWIG labels for method/variable
21 * declarations/attributes, and other compiler dependent labels.
22 * ----------------------------------------------------------------------------- */
23
24 /* template workaround for compilers that cannot correctly implement the C++ standard */
25 #ifndef SWIGTEMPLATEDISAMBIGUATOR
26 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
27 # define SWIGTEMPLATEDISAMBIGUATOR template
28 # elif defined(__HP_aCC)
29 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
30 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
31 # define SWIGTEMPLATEDISAMBIGUATOR template
32 # else
33 # define SWIGTEMPLATEDISAMBIGUATOR
34 # endif
35 #endif
36
37 /* inline attribute */
38 #ifndef SWIGINLINE
39 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
40 # define SWIGINLINE inline
41 # else
42 # define SWIGINLINE
43 # endif
44 #endif
45
46 /* attribute recognised by some compilers to avoid 'unused' warnings */
47 #ifndef SWIGUNUSED
48 # if defined(__GNUC__)
49 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
50 # define SWIGUNUSED __attribute__ ((__unused__))
51 # else
52 # define SWIGUNUSED
53 # endif
54 # elif defined(__ICC)
55 # define SWIGUNUSED __attribute__ ((__unused__))
56 # else
57 # define SWIGUNUSED
58 # endif
59 #endif
60
61 #ifndef SWIG_MSC_UNSUPPRESS_4505
62 # if defined(_MSC_VER)
63 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
64 # endif
65 #endif
66
67 #ifndef SWIGUNUSEDPARM
68 # ifdef __cplusplus
69 # define SWIGUNUSEDPARM(p)
70 # else
71 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
72 # endif
73 #endif
74
75 /* internal SWIG method */
76 #ifndef SWIGINTERN
77 # define SWIGINTERN static SWIGUNUSED
78 #endif
79
80 /* internal inline SWIG method */
81 #ifndef SWIGINTERNINLINE
82 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
83 #endif
84
85 /* exporting methods */
86 #if defined(__GNUC__)
87 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
88 # ifndef GCC_HASCLASSVISIBILITY
89 # define GCC_HASCLASSVISIBILITY
90 # endif
91 # endif
92 #endif
93
94 #ifndef SWIGEXPORT
95 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
96 # if defined(STATIC_LINKED)
97 # define SWIGEXPORT
98 # else
99 # define SWIGEXPORT __declspec(dllexport)
100 # endif
101 # else
102 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
103 # define SWIGEXPORT __attribute__ ((visibility("default")))
104 # else
105 # define SWIGEXPORT
106 # endif
107 # endif
108 #endif
109
110 /* calling conventions for Windows */
111 #ifndef SWIGSTDCALL
112 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113 # define SWIGSTDCALL __stdcall
114 # else
115 # define SWIGSTDCALL
116 # endif
117 #endif
118
119 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
120 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
121 # define _CRT_SECURE_NO_DEPRECATE
122 #endif
123
124 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
125 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
126 # define _SCL_SECURE_NO_DEPRECATE
127 #endif
128
129 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
130 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
131 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
132 #endif
133
134 /* Intel's compiler complains if a variable which was never initialised is
135 * cast to void, which is a common idiom which we use to indicate that we
136 * are aware a variable isn't used. So we just silence that warning.
137 * See: https://github.com/swig/swig/issues/192 for more discussion.
138 */
139 #ifdef __INTEL_COMPILER
140 # pragma warning disable 592
141 #endif
142
143 /* -----------------------------------------------------------------------------
144 * swigrun.swg
145 *
146 * This file contains generic C API SWIG runtime support for pointer
147 * type checking.
148 * ----------------------------------------------------------------------------- */
149
150 /* This should only be incremented when either the layout of swig_type_info changes,
151 or for whatever reason, the runtime changes incompatibly */
152 #define SWIG_RUNTIME_VERSION "4"
153
154 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
155 #ifdef SWIG_TYPE_TABLE
156 # define SWIG_QUOTE_STRING(x) #x
157 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
158 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
159 #else
160 # define SWIG_TYPE_TABLE_NAME
161 #endif
162
163 /*
164 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
165 creating a static or dynamic library from the SWIG runtime code.
166 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
167
168 But only do this if strictly necessary, ie, if you have problems
169 with your compiler or suchlike.
170 */
171
172 #ifndef SWIGRUNTIME
173 # define SWIGRUNTIME SWIGINTERN
174 #endif
175
176 #ifndef SWIGRUNTIMEINLINE
177 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
178 #endif
179
180 /* Generic buffer size */
181 #ifndef SWIG_BUFFER_SIZE
182 # define SWIG_BUFFER_SIZE 1024
183 #endif
184
185 /* Flags for pointer conversions */
186 #define SWIG_POINTER_DISOWN 0x1
187 #define SWIG_CAST_NEW_MEMORY 0x2
188
189 /* Flags for new pointer objects */
190 #define SWIG_POINTER_OWN 0x1
191
192
193 /*
194 Flags/methods for returning states.
195
196 The SWIG conversion methods, as ConvertPtr, return an integer
197 that tells if the conversion was successful or not. And if not,
198 an error code can be returned (see swigerrors.swg for the codes).
199
200 Use the following macros/flags to set or process the returning
201 states.
202
203 In old versions of SWIG, code such as the following was usually written:
204
205 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
206 // success code
207 } else {
208 //fail code
209 }
210
211 Now you can be more explicit:
212
213 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
214 if (SWIG_IsOK(res)) {
215 // success code
216 } else {
217 // fail code
218 }
219
220 which is the same really, but now you can also do
221
222 Type *ptr;
223 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
224 if (SWIG_IsOK(res)) {
225 // success code
226 if (SWIG_IsNewObj(res) {
227 ...
228 delete *ptr;
229 } else {
230 ...
231 }
232 } else {
233 // fail code
234 }
235
236 I.e., now SWIG_ConvertPtr can return new objects and you can
237 identify the case and take care of the deallocation. Of course that
238 also requires SWIG_ConvertPtr to return new result values, such as
239
240 int SWIG_ConvertPtr(obj, ptr,...) {
241 if (<obj is ok>) {
242 if (<need new object>) {
243 *ptr = <ptr to new allocated object>;
244 return SWIG_NEWOBJ;
245 } else {
246 *ptr = <ptr to old object>;
247 return SWIG_OLDOBJ;
248 }
249 } else {
250 return SWIG_BADOBJ;
251 }
252 }
253
254 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
255 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
256 SWIG errors code.
257
258 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
259 allows to return the 'cast rank', for example, if you have this
260
261 int food(double)
262 int fooi(int);
263
264 and you call
265
266 food(1) // cast rank '1' (1 -> 1.0)
267 fooi(1) // cast rank '0'
268
269 just use the SWIG_AddCast()/SWIG_CheckState()
270 */
271
272 #define SWIG_OK (0)
273 #define SWIG_ERROR (-1)
274 #define SWIG_IsOK(r) (r >= 0)
275 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
276
277 /* The CastRankLimit says how many bits are used for the cast rank */
278 #define SWIG_CASTRANKLIMIT (1 << 8)
279 /* The NewMask denotes the object was created (using new/malloc) */
280 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
281 /* The TmpMask is for in/out typemaps that use temporal objects */
282 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
283 /* Simple returning values */
284 #define SWIG_BADOBJ (SWIG_ERROR)
285 #define SWIG_OLDOBJ (SWIG_OK)
286 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
287 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
288 /* Check, add and del mask methods */
289 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
290 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
291 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
292 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
293 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
294 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
295
296 /* Cast-Rank Mode */
297 #if defined(SWIG_CASTRANK_MODE)
298 # ifndef SWIG_TypeRank
299 # define SWIG_TypeRank unsigned long
300 # endif
301 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
302 # define SWIG_MAXCASTRANK (2)
303 # endif
304 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
305 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
306 SWIGINTERNINLINE int SWIG_AddCast(int r) {
307 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
308 }
309 SWIGINTERNINLINE int SWIG_CheckState(int r) {
310 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
311 }
312 #else /* no cast-rank mode */
313 # define SWIG_AddCast(r) (r)
314 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
315 #endif
316
317
318 #include <string.h>
319
320 #ifdef __cplusplus
321 extern "C" {
322 #endif
323
324 typedef void *(*swig_converter_func)(void *, int *);
325 typedef struct swig_type_info *(*swig_dycast_func)(void **);
326
327 /* Structure to store information on one type */
328 typedef struct swig_type_info {
329 const char *name; /* mangled name of this type */
330 const char *str; /* human readable name of this type */
331 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
332 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
333 void *clientdata; /* language specific type data */
334 int owndata; /* flag if the structure owns the clientdata */
335 } swig_type_info;
336
337 /* Structure to store a type and conversion function used for casting */
338 typedef struct swig_cast_info {
339 swig_type_info *type; /* pointer to type that is equivalent to this type */
340 swig_converter_func converter; /* function to cast the void pointers */
341 struct swig_cast_info *next; /* pointer to next cast in linked list */
342 struct swig_cast_info *prev; /* pointer to the previous cast */
343 } swig_cast_info;
344
345 /* Structure used to store module information
346 * Each module generates one structure like this, and the runtime collects
347 * all of these structures and stores them in a circularly linked list.*/
348 typedef struct swig_module_info {
349 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
350 size_t size; /* Number of types in this module */
351 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
352 swig_type_info **type_initial; /* Array of initially generated type structures */
353 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
354 void *clientdata; /* Language specific module data */
355 } swig_module_info;
356
357 /*
358 Compare two type names skipping the space characters, therefore
359 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
360
361 Return 0 when the two name types are equivalent, as in
362 strncmp, but skipping ' '.
363 */
364 SWIGRUNTIME int
365 SWIG_TypeNameComp(const char *f1, const char *l1,
366 const char *f2, const char *l2) {
367 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
368 while ((*f1 == ' ') && (f1 != l1)) ++f1;
369 while ((*f2 == ' ') && (f2 != l2)) ++f2;
370 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
371 }
372 return (int)((l1 - f1) - (l2 - f2));
373 }
374
375 /*
376 Check type equivalence in a name list like <name1>|<name2>|...
377 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
378 */
379 SWIGRUNTIME int
380 SWIG_TypeCmp(const char *nb, const char *tb) {
381 int equiv = 1;
382 const char* te = tb + strlen(tb);
383 const char* ne = nb;
384 while (equiv != 0 && *ne) {
385 for (nb = ne; *ne; ++ne) {
386 if (*ne == '|') break;
387 }
388 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
389 if (*ne) ++ne;
390 }
391 return equiv;
392 }
393
394 /*
395 Check type equivalence in a name list like <name1>|<name2>|...
396 Return 0 if not equal, 1 if equal
397 */
398 SWIGRUNTIME int
399 SWIG_TypeEquiv(const char *nb, const char *tb) {
400 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
401 }
402
403 /*
404 Check the typename
405 */
406 SWIGRUNTIME swig_cast_info *
407 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
408 if (ty) {
409 swig_cast_info *iter = ty->cast;
410 while (iter) {
411 if (strcmp(iter->type->name, c) == 0) {
412 if (iter == ty->cast)
413 return iter;
414 /* Move iter to the top of the linked list */
415 iter->prev->next = iter->next;
416 if (iter->next)
417 iter->next->prev = iter->prev;
418 iter->next = ty->cast;
419 iter->prev = 0;
420 if (ty->cast) ty->cast->prev = iter;
421 ty->cast = iter;
422 return iter;
423 }
424 iter = iter->next;
425 }
426 }
427 return 0;
428 }
429
430 /*
431 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
432 */
433 SWIGRUNTIME swig_cast_info *
434 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
435 if (ty) {
436 swig_cast_info *iter = ty->cast;
437 while (iter) {
438 if (iter->type == from) {
439 if (iter == ty->cast)
440 return iter;
441 /* Move iter to the top of the linked list */
442 iter->prev->next = iter->next;
443 if (iter->next)
444 iter->next->prev = iter->prev;
445 iter->next = ty->cast;
446 iter->prev = 0;
447 if (ty->cast) ty->cast->prev = iter;
448 ty->cast = iter;
449 return iter;
450 }
451 iter = iter->next;
452 }
453 }
454 return 0;
455 }
456
457 /*
458 Cast a pointer up an inheritance hierarchy
459 */
460 SWIGRUNTIMEINLINE void *
461 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
462 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
463 }
464
465 /*
466 Dynamic pointer casting. Down an inheritance hierarchy
467 */
468 SWIGRUNTIME swig_type_info *
469 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
470 swig_type_info *lastty = ty;
471 if (!ty || !ty->dcast) return ty;
472 while (ty && (ty->dcast)) {
473 ty = (*ty->dcast)(ptr);
474 if (ty) lastty = ty;
475 }
476 return lastty;
477 }
478
479 /*
480 Return the name associated with this type
481 */
482 SWIGRUNTIMEINLINE const char *
483 SWIG_TypeName(const swig_type_info *ty) {
484 return ty->name;
485 }
486
487 /*
488 Return the pretty name associated with this type,
489 that is an unmangled type name in a form presentable to the user.
490 */
491 SWIGRUNTIME const char *
492 SWIG_TypePrettyName(const swig_type_info *type) {
493 /* The "str" field contains the equivalent pretty names of the
494 type, separated by vertical-bar characters. We choose
495 to print the last name, as it is often (?) the most
496 specific. */
497 if (!type) return NULL;
498 if (type->str != NULL) {
499 const char *last_name = type->str;
500 const char *s;
501 for (s = type->str; *s; s++)
502 if (*s == '|') last_name = s+1;
503 return last_name;
504 }
505 else
506 return type->name;
507 }
508
509 /*
510 Set the clientdata field for a type
511 */
512 SWIGRUNTIME void
513 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
514 swig_cast_info *cast = ti->cast;
515 /* if (ti->clientdata == clientdata) return; */
516 ti->clientdata = clientdata;
517
518 while (cast) {
519 if (!cast->converter) {
520 swig_type_info *tc = cast->type;
521 if (!tc->clientdata) {
522 SWIG_TypeClientData(tc, clientdata);
523 }
524 }
525 cast = cast->next;
526 }
527 }
528 SWIGRUNTIME void
529 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
530 SWIG_TypeClientData(ti, clientdata);
531 ti->owndata = 1;
532 }
533
534 /*
535 Search for a swig_type_info structure only by mangled name
536 Search is a O(log #types)
537
538 We start searching at module start, and finish searching when start == end.
539 Note: if start == end at the beginning of the function, we go all the way around
540 the circular list.
541 */
542 SWIGRUNTIME swig_type_info *
543 SWIG_MangledTypeQueryModule(swig_module_info *start,
544 swig_module_info *end,
545 const char *name) {
546 swig_module_info *iter = start;
547 do {
548 if (iter->size) {
549 size_t l = 0;
550 size_t r = iter->size - 1;
551 do {
552 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
553 size_t i = (l + r) >> 1;
554 const char *iname = iter->types[i]->name;
555 if (iname) {
556 int compare = strcmp(name, iname);
557 if (compare == 0) {
558 return iter->types[i];
559 } else if (compare < 0) {
560 if (i) {
561 r = i - 1;
562 } else {
563 break;
564 }
565 } else if (compare > 0) {
566 l = i + 1;
567 }
568 } else {
569 break; /* should never happen */
570 }
571 } while (l <= r);
572 }
573 iter = iter->next;
574 } while (iter != end);
575 return 0;
576 }
577
578 /*
579 Search for a swig_type_info structure for either a mangled name or a human readable name.
580 It first searches the mangled names of the types, which is a O(log #types)
581 If a type is not found it then searches the human readable names, which is O(#types).
582
583 We start searching at module start, and finish searching when start == end.
584 Note: if start == end at the beginning of the function, we go all the way around
585 the circular list.
586 */
587 SWIGRUNTIME swig_type_info *
588 SWIG_TypeQueryModule(swig_module_info *start,
589 swig_module_info *end,
590 const char *name) {
591 /* STEP 1: Search the name field using binary search */
592 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
593 if (ret) {
594 return ret;
595 } else {
596 /* STEP 2: If the type hasn't been found, do a complete search
597 of the str field (the human readable name) */
598 swig_module_info *iter = start;
599 do {
600 size_t i = 0;
601 for (; i < iter->size; ++i) {
602 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
603 return iter->types[i];
604 }
605 iter = iter->next;
606 } while (iter != end);
607 }
608
609 /* neither found a match */
610 return 0;
611 }
612
613 /*
614 Pack binary data into a string
615 */
616 SWIGRUNTIME char *
617 SWIG_PackData(char *c, void *ptr, size_t sz) {
618 static const char hex[17] = "0123456789abcdef";
619 const unsigned char *u = (unsigned char *) ptr;
620 const unsigned char *eu = u + sz;
621 for (; u != eu; ++u) {
622 unsigned char uu = *u;
623 *(c++) = hex[(uu & 0xf0) >> 4];
624 *(c++) = hex[uu & 0xf];
625 }
626 return c;
627 }
628
629 /*
630 Unpack binary data from a string
631 */
632 SWIGRUNTIME const char *
633 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
634 unsigned char *u = (unsigned char *) ptr;
635 const unsigned char *eu = u + sz;
636 for (; u != eu; ++u) {
637 char d = *(c++);
638 unsigned char uu;
639 if ((d >= '0') && (d <= '9'))
640 uu = (unsigned char)((d - '0') << 4);
641 else if ((d >= 'a') && (d <= 'f'))
642 uu = (unsigned char)((d - ('a'-10)) << 4);
643 else
644 return (char *) 0;
645 d = *(c++);
646 if ((d >= '0') && (d <= '9'))
647 uu |= (unsigned char)(d - '0');
648 else if ((d >= 'a') && (d <= 'f'))
649 uu |= (unsigned char)(d - ('a'-10));
650 else
651 return (char *) 0;
652 *u = uu;
653 }
654 return c;
655 }
656
657 /*
658 Pack 'void *' into a string buffer.
659 */
660 SWIGRUNTIME char *
661 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
662 char *r = buff;
663 if ((2*sizeof(void *) + 2) > bsz) return 0;
664 *(r++) = '_';
665 r = SWIG_PackData(r,&ptr,sizeof(void *));
666 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
667 strcpy(r,name);
668 return buff;
669 }
670
671 SWIGRUNTIME const char *
672 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
673 if (*c != '_') {
674 if (strcmp(c,"NULL") == 0) {
675 *ptr = (void *) 0;
676 return name;
677 } else {
678 return 0;
679 }
680 }
681 return SWIG_UnpackData(++c,ptr,sizeof(void *));
682 }
683
684 SWIGRUNTIME char *
685 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
686 char *r = buff;
687 size_t lname = (name ? strlen(name) : 0);
688 if ((2*sz + 2 + lname) > bsz) return 0;
689 *(r++) = '_';
690 r = SWIG_PackData(r,ptr,sz);
691 if (lname) {
692 strncpy(r,name,lname+1);
693 } else {
694 *r = 0;
695 }
696 return buff;
697 }
698
699 SWIGRUNTIME const char *
700 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
701 if (*c != '_') {
702 if (strcmp(c,"NULL") == 0) {
703 memset(ptr,0,sz);
704 return name;
705 } else {
706 return 0;
707 }
708 }
709 return SWIG_UnpackData(++c,ptr,sz);
710 }
711
712 #ifdef __cplusplus
713 }
714 #endif
715
716 /* -----------------------------------------------------------------------------
717 * luarun.swg
718 *
719 * This file contains the runtime support for Lua modules
720 * and includes code for managing global variables and pointer
721 * type checking.
722 * ----------------------------------------------------------------------------- */
723
724 #ifdef __cplusplus
725 extern "C" {
726 #endif
727
728 #include "lua.h"
729 #include "lauxlib.h"
730 #include <stdlib.h> /* for malloc */
731 #include <assert.h> /* for a few sanity tests */
732
733 /* -----------------------------------------------------------------------------
734 * Lua flavors
735 * ----------------------------------------------------------------------------- */
736
737 #define SWIG_LUA_FLAVOR_LUA 1
738 #define SWIG_LUA_FLAVOR_ELUA 2
739 #define SWIG_LUA_FLAVOR_ELUAC 3
740
741 #if !defined(SWIG_LUA_TARGET)
742 # error SWIG_LUA_TARGET not defined
743 #endif
744
745 #if defined(SWIG_LUA_ELUA_EMULATE)
746
747 struct swig_elua_entry;
748
749 typedef struct swig_elua_key {
750 int type;
751 union {
752 const char* strkey;
753 lua_Number numkey;
754 } key;
755 } swig_elua_key;
756
757 typedef struct swig_elua_val {
758 int type;
759 union {
760 lua_Number number;
761 const struct swig_elua_entry *table;
762 const char *string;
763 lua_CFunction function;
764 struct {
765 char member;
766 long lvalue;
767 void *pvalue;
768 swig_type_info **ptype;
769 } userdata;
770 } value;
771 } swig_elua_val;
772
773 typedef struct swig_elua_entry {
774 swig_elua_key key;
775 swig_elua_val value;
776 } swig_elua_entry;
777
778 #define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} }
779 #define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} }
780 #define LNILKEY {LUA_TNIL, {.strkey = 0} }
781
782 #define LNUMVAL(x) {LUA_TNUMBER, {.number = x} }
783 #define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} }
784 #define LROVAL(x) {LUA_TTABLE, {.table = x} }
785 #define LNILVAL {LUA_TNIL, {.string = 0} }
786 #define LSTRVAL(x) {LUA_TSTRING, {.string = x} }
787
788 #define LUA_REG_TYPE swig_elua_entry
789
790 #define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable"
791
792 #define lua_pushrotable(L,p)\
793 lua_newtable(L);\
794 assert(p);\
795 SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p));
796
797 #define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
798 LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } }
799
800 #define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\
801 LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } }
802 #endif
803
804 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
805 # define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
806 # define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
807 # define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
808 # define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
809 /* Those two types of constants are not supported in elua */
810
811 #ifndef SWIG_LUA_CONSTTAB_POINTER
812 #warning eLua does not support pointers as constants. By default, nil will be used as value
813 #define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL
814 #endif
815
816 #ifndef SWIG_LUA_CONSTTAB_BINARY
817 #warning eLua does not support pointers to member as constants. By default, nil will be used as value
818 #define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL
819 #endif
820 #else /* SWIG_LUA_FLAVOR_LUA */
821 # define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
822 # define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
823 # define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
824 # define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
825 # define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
826 SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D
827 # define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\
828 SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D
829 #endif
830
831 #ifndef SWIG_LUA_ELUA_EMULATE
832 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
833 # define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
834 # define LSTRVAL LRO_STRVAL
835 #endif
836 #endif /* SWIG_LUA_ELUA_EMULATE*/
837
838 #ifndef SWIG_LUA_ELUA_EMULATE
839 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
840
841 #ifndef MIN_OPT_LEVEL
842 #define MIN_OPT_LEVEL 2
843 #endif
844
845 #include "lrodefs.h"
846 #include "lrotable.h"
847 #endif
848 #endif /* SWIG_LUA_ELUA_EMULATE*/
849 /* -----------------------------------------------------------------------------
850 * compatibility defines
851 * ----------------------------------------------------------------------------- */
852
853 /* History of Lua C API length functions: In Lua 5.0 (and before?)
854 there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen",
855 but a compatibility define of "lua_strlen" was added. In Lua 5.2,
856 this function was again renamed, to "lua_rawlen" (to emphasize that
857 it doesn't call the "__len" metamethod), and the compatibility
858 define of lua_strlen was removed. All SWIG uses have been updated
859 to "lua_rawlen", and we add our own defines of that here for older
860 versions of Lua. */
861 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
862 # define lua_rawlen lua_strlen
863 #elif LUA_VERSION_NUM == 501
864 # define lua_rawlen lua_objlen
865 #endif
866
867
868 /* lua_pushglobaltable is the recommended "future-proof" way to get
869 the global table for Lua 5.2 and later. Here we define
870 lua_pushglobaltable ourselves for Lua versions before 5.2. */
871 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
872 # define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
873 #endif
874
875 /* lua_absindex was introduced in Lua 5.2 */
876 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
877 # define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1)
878 #endif
879
880 /* lua_rawsetp was introduced in Lua 5.2 */
881 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
882 #define lua_rawsetp(L,index,ptr)\
883 lua_pushlightuserdata(L,(void*)(ptr));\
884 lua_insert(L,-2);\
885 lua_rawset(L,index);
886
887 #define lua_rawgetp(L,index,ptr)\
888 lua_pushlightuserdata(L,(void*)(ptr));\
889 lua_rawget(L,index);
890
891 #endif
892
893 /* --------------------------------------------------------------------------
894 * Helper functions for error handling
895 * -------------------------------------------------------------------------- */
896
897 /* Push the string STR on the Lua stack, like lua_pushstring, but
898 prefixed with the the location of the innermost Lua call-point
899 (as formated by luaL_where). */
900 SWIGRUNTIME void
901 SWIG_Lua_pusherrstring (lua_State *L, const char *str)
902 {
903 luaL_where (L, 1);
904 lua_pushstring (L, str);
905 lua_concat (L, 2);
906 }
907
908 /* Push a formatted string generated from FMT and following args on
909 the Lua stack, like lua_pushfstring, but prefixed with the the
910 location of the innermost Lua call-point (as formated by luaL_where). */
911 SWIGRUNTIME void
912 SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...)
913 {
914 va_list argp;
915 va_start(argp, fmt);
916 luaL_where(L, 1);
917 lua_pushvfstring(L, fmt, argp);
918 va_end(argp);
919 lua_concat(L, 2);
920 }
921
922
923 /* -----------------------------------------------------------------------------
924 * global swig types
925 * ----------------------------------------------------------------------------- */
926 /* Constant table */
927 #define SWIG_LUA_INT 1
928 #define SWIG_LUA_FLOAT 2
929 #define SWIG_LUA_STRING 3
930 #define SWIG_LUA_POINTER 4
931 #define SWIG_LUA_BINARY 5
932 #define SWIG_LUA_CHAR 6
933
934 /* Structure for variable linking table */
935 typedef struct {
936 const char *name;
937 lua_CFunction get;
938 lua_CFunction set;
939 } swig_lua_var_info;
940
941 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
942 typedef const LUA_REG_TYPE swig_lua_method;
943 typedef const LUA_REG_TYPE swig_lua_const_info;
944 #else /* Normal lua */
945 typedef luaL_Reg swig_lua_method;
946
947 /* Constant information structure */
948 typedef struct {
949 int type;
950 char *name;
951 long lvalue;
952 double dvalue;
953 void *pvalue;
954 swig_type_info **ptype;
955 } swig_lua_const_info;
956
957 #endif
958
959 typedef struct {
960 const char *name;
961 lua_CFunction getmethod;
962 lua_CFunction setmethod;
963 } swig_lua_attribute;
964
965
966 struct swig_lua_class;
967 /* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */
968 typedef struct swig_lua_namespace {
969 const char *name;
970 swig_lua_method *ns_methods;
971 swig_lua_attribute *ns_attributes;
972 swig_lua_const_info *ns_constants;
973 struct swig_lua_class **ns_classes;
974 struct swig_lua_namespace **ns_namespaces;
975 } swig_lua_namespace;
976
977 typedef struct swig_lua_class {
978 const char *name; /* Name that this class has in Lua */
979 const char *fqname; /* Fully qualified name - Scope + class name */
980 swig_type_info **type;
981 lua_CFunction constructor;
982 void (*destructor)(void *);
983 swig_lua_method *methods;
984 swig_lua_attribute *attributes;
985 swig_lua_namespace *cls_static;
986 swig_lua_method *metatable; /* 0 for -eluac */
987 struct swig_lua_class **bases;
988 const char **base_names;
989 } swig_lua_class;
990
991 /* this is the struct for wrapping all pointers in SwigLua
992 */
993 typedef struct {
994 swig_type_info *type;
995 int own; /* 1 if owned & must be destroyed */
996 void *ptr;
997 } swig_lua_userdata;
998
999 /* this is the struct for wrapping arbitrary packed binary data
1000 (currently it is only used for member function pointers)
1001 the data ordering is similar to swig_lua_userdata, but it is currently not possible
1002 to tell the two structures apart within SWIG, other than by looking at the type
1003 */
1004 typedef struct {
1005 swig_type_info *type;
1006 int own; /* 1 if owned & must be destroyed */
1007 char data[1]; /* arbitary amount of data */
1008 } swig_lua_rawdata;
1009
1010 /* Common SWIG API */
1011 #define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
1012 #define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
1013 #define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
1014 /* for C++ member pointers, ie, member methods */
1015 #define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
1016 #define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type)
1017
1018 /* Runtime API */
1019 #define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
1020 #define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
1021 #define SWIG_MODULE_CLIENTDATA_TYPE lua_State*
1022
1023 /* Contract support */
1024 #define SWIG_contract_assert(expr, msg) \
1025 if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else
1026
1027
1028 /* helper #defines */
1029 #define SWIG_fail {goto fail;}
1030 #define SWIG_fail_arg(func_name,argnum,type) \
1031 {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
1032 func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
1033 goto fail;}
1034 #define SWIG_fail_ptr(func_name,argnum,type) \
1035 SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
1036 #define SWIG_check_num_args(func_name,a,b) \
1037 if (lua_gettop(L)<a || lua_gettop(L)>b) \
1038 {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
1039 goto fail;}
1040
1041
1042 #define SWIG_Lua_get_table(L,n) \
1043 (lua_pushstring(L, n), lua_rawget(L,-2))
1044
1045 #define SWIG_Lua_add_function(L,n,f) \
1046 (lua_pushstring(L, n), \
1047 lua_pushcfunction(L, f), \
1048 lua_rawset(L,-3))
1049
1050 #define SWIG_Lua_add_boolean(L,n,b) \
1051 (lua_pushstring(L, n), \
1052 lua_pushboolean(L, b), \
1053 lua_rawset(L,-3))
1054
1055 /* special helper for allowing 'nil' for usertypes */
1056 #define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))
1057
1058 #ifdef __cplusplus
1059 /* Special helper for member function pointers
1060 it gets the address, casts it, then dereferences it */
1061 /*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */
1062 #endif
1063
1064 /* storing/access of swig_module_info */
1065 SWIGRUNTIME swig_module_info *
1066 SWIG_Lua_GetModule(lua_State *L) {
1067 swig_module_info *ret = 0;
1068 lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1069 lua_rawget(L,LUA_REGISTRYINDEX);
1070 if (lua_islightuserdata(L,-1))
1071 ret=(swig_module_info*)lua_touserdata(L,-1);
1072 lua_pop(L,1); /* tidy */
1073 return ret;
1074 }
1075
1076 SWIGRUNTIME void
1077 SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) {
1078 /* add this all into the Lua registry: */
1079 lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1080 lua_pushlightuserdata(L,(void*)module);
1081 lua_rawset(L,LUA_REGISTRYINDEX);
1082 }
1083
1084 /* -----------------------------------------------------------------------------
1085 * global variable support code: modules
1086 * ----------------------------------------------------------------------------- */
1087
1088 /* this function is called when trying to set an immutable.
1089 default action is to print an error.
1090 This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
1091 SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
1092 {
1093 /* there should be 1 param passed in: the new value */
1094 #ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
1095 lua_pop(L,1); /* remove it */
1096 luaL_error(L,"This variable is immutable");
1097 #endif
1098 return 0; /* should not return anything */
1099 }
1100
1101 #ifdef SWIG_LUA_ELUA_EMULATE
1102
1103 SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own);
1104 SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type);
1105 static int swig_lua_elua_emulate_unique_key;
1106
1107 /* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */
1108 SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table)
1109 {
1110 int i, table_parsed, parsed_tables_array, target_table;
1111 assert(lua_istable(L,-1));
1112 target_table = lua_gettop(L);
1113 /* Get the registry where we put all parsed tables to avoid loops */
1114 lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
1115 if(lua_isnil(L,-1)) {
1116 lua_pop(L,1);
1117 lua_newtable(L);
1118 lua_pushvalue(L,-1);
1119 lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key));
1120 }
1121 parsed_tables_array = lua_gettop(L);
1122 lua_pushvalue(L,target_table);
1123 lua_rawsetp(L, parsed_tables_array, table);
1124 table_parsed = 0;
1125 const int SWIGUNUSED pairs_start = lua_gettop(L);
1126 for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++)
1127 {
1128 const swig_elua_entry *entry = table + i;
1129 int is_metatable = 0;
1130 switch(entry->key.type) {
1131 case LUA_TSTRING:
1132 lua_pushstring(L,entry->key.key.strkey);
1133 if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0)
1134 is_metatable = 1;
1135 break;
1136 case LUA_TNUMBER:
1137 lua_pushnumber(L,entry->key.key.numkey);
1138 break;
1139 case LUA_TNIL:
1140 lua_pushnil(L);
1141 break;
1142 default:
1143 assert(0);
1144 }
1145 switch(entry->value.type) {
1146 case LUA_TSTRING:
1147 lua_pushstring(L,entry->value.value.string);
1148 break;
1149 case LUA_TNUMBER:
1150 lua_pushnumber(L,entry->value.value.number);
1151 break;
1152 case LUA_TFUNCTION:
1153 lua_pushcfunction(L,entry->value.value.function);
1154 break;
1155 case LUA_TTABLE:
1156 lua_rawgetp(L,parsed_tables_array, entry->value.value.table);
1157 table_parsed = !lua_isnil(L,-1);
1158 if(!table_parsed) {
1159 lua_pop(L,1); /*remove nil */
1160 lua_newtable(L);
1161 SWIG_Lua_elua_emulate_register(L,entry->value.value.table);
1162 }
1163 if(is_metatable) {
1164 assert(lua_istable(L,-1));
1165 lua_pushvalue(L,-1);
1166 lua_setmetatable(L,target_table);
1167 }
1168
1169 break;
1170 case LUA_TUSERDATA:
1171 if(entry->value.value.userdata.member)
1172 SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue,
1173 entry->value.value.userdata.lvalue,
1174 *(entry->value.value.userdata.ptype));
1175 else
1176 SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue,
1177 *(entry->value.value.userdata.ptype),0);
1178 break;
1179 case LUA_TNIL:
1180 lua_pushnil(L);
1181 break;
1182 default:
1183 assert(0);
1184 }
1185 assert(lua_gettop(L) == pairs_start + 2);
1186 lua_rawset(L,target_table);
1187 }
1188 lua_pop(L,1); /* Removing parsed tables storage */
1189 assert(lua_gettop(L) == target_table);
1190 }
1191
1192 SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L)
1193 {
1194 lua_pushnil(L);
1195 lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
1196 }
1197
1198 SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L);
1199
1200 SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L)
1201 {
1202 SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1);
1203 SWIG_Lua_get_class_registry(L);
1204 lua_getfield(L,-1,"lua_getmetatable");
1205 lua_remove(L,-2); /* remove the registry*/
1206 assert(!lua_isnil(L,-1));
1207 lua_pushvalue(L,1);
1208 assert(lua_gettop(L) == 3); /* object | function | object again */
1209 lua_call(L,1,1);
1210 if(!lua_isnil(L,-1)) /*There is an ordinary metatable */
1211 return 1;
1212 /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/
1213 assert(lua_gettop(L) == 2);
1214 if(lua_istable(L,-2)) {
1215 lua_pop(L,1); /*remove the nil*/
1216 lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY);
1217 }
1218 assert(lua_gettop(L) == 2);
1219 return 1;
1220
1221 fail:
1222 lua_error(L);
1223 return 0;
1224 }
1225
1226 SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L)
1227 {
1228 SWIG_Lua_get_class_registry(L);
1229 lua_pushglobaltable(L);
1230 lua_pushstring(L,"lua_getmetatable");
1231 lua_getfield(L,-2,"getmetatable");
1232 assert(!lua_isnil(L,-1));
1233 lua_rawset(L,-4);
1234 lua_pushstring(L, "getmetatable");
1235 lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable);
1236 lua_rawset(L,-3);
1237 lua_pop(L,2);
1238
1239 }
1240 /* END OF REMOVE */
1241
1242 #endif
1243 /* -----------------------------------------------------------------------------
1244 * global variable support code: namespaces and modules (which are the same thing)
1245 * ----------------------------------------------------------------------------- */
1246
1247 SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
1248 {
1249 /* there should be 2 params passed in
1250 (1) table (not the meta table)
1251 (2) string name of the attribute
1252 */
1253 assert(lua_istable(L,-2)); /* just in case */
1254 lua_getmetatable(L,-2);
1255 assert(lua_istable(L,-1));
1256 SWIG_Lua_get_table(L,".get"); /* find the .get table */
1257 assert(lua_istable(L,-1));
1258 /* look for the key in the .get table */
1259 lua_pushvalue(L,2); /* key */
1260 lua_rawget(L,-2);
1261 lua_remove(L,-2); /* stack tidy, remove .get table */
1262 if (lua_iscfunction(L,-1))
1263 { /* found it so call the fn & return its value */
1264 lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */
1265 lua_remove(L,-2); /* stack tidy, remove metatable */
1266 return 1;
1267 }
1268 lua_pop(L,1); /* remove whatever was there */
1269 /* ok, so try the .fn table */
1270 SWIG_Lua_get_table(L,".fn"); /* find the .get table */
1271 assert(lua_istable(L,-1)); /* just in case */
1272 lua_pushvalue(L,2); /* key */
1273 lua_rawget(L,-2); /* look for the fn */
1274 lua_remove(L,-2); /* stack tidy, remove .fn table */
1275 if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */
1276 { /* found it so return the fn & let lua call it */
1277 lua_remove(L,-2); /* stack tidy, remove metatable */
1278 return 1;
1279 }
1280 lua_pop(L,1); /* remove whatever was there */
1281 return 0;
1282 }
1283
1284 SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
1285 {
1286 /* there should be 3 params passed in
1287 (1) table (not the meta table)
1288 (2) string name of the attribute
1289 (3) any for the new value
1290 */
1291
1292 assert(lua_istable(L,1));
1293 lua_getmetatable(L,1); /* get the meta table */
1294 assert(lua_istable(L,-1));
1295
1296 SWIG_Lua_get_table(L,".set"); /* find the .set table */
1297 if (lua_istable(L,-1))
1298 {
1299 /* look for the key in the .set table */
1300 lua_pushvalue(L,2); /* key */
1301 lua_rawget(L,-2);
1302 if (lua_iscfunction(L,-1))
1303 { /* found it so call the fn & return its value */
1304 lua_pushvalue(L,3); /* value */
1305 lua_call(L,1,0);
1306 return 0;
1307 }
1308 lua_pop(L,1); /* remove the value */
1309 }
1310 lua_pop(L,1); /* remove the value .set table */
1311 lua_pop(L,1); /* remote metatable */
1312 lua_rawset(L,-3);
1313 return 0;
1314 }
1315
1316 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
1317 SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */
1318 SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */
1319 SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss);
1320
1321 /* helper function - register namespace methods and attributes into namespace */
1322 SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
1323 {
1324 int i;
1325 /* There must be namespace table (not metatable) at the top of the stack */
1326 assert(lua_istable(L,-1));
1327 SWIG_Lua_InstallConstants(L, ns->ns_constants);
1328
1329 /* add methods to the namespace/module table */
1330 for(i=0;ns->ns_methods[i].name;i++){
1331 SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func);
1332 }
1333 lua_getmetatable(L,-1);
1334
1335 /* add fns */
1336 for(i=0;ns->ns_attributes[i].name;i++){
1337 SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod);
1338 }
1339
1340 /* clear stack - remove metatble */
1341 lua_pop(L,1);
1342 return 0;
1343 }
1344
1345 /* Register all classes in the namespace */
1346 SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
1347 {
1348 swig_lua_class **classes;
1349
1350 /* There must be a module/namespace table at the top of the stack */
1351 assert(lua_istable(L,-1));
1352
1353 classes = ns->ns_classes;
1354
1355 if( classes != 0 ) {
1356 while(*classes != 0) {
1357 SWIG_Lua_class_register(L, *classes);
1358 classes++;
1359 }
1360 }
1361 }
1362
1363 /* Helper function. Creates namespace table and adds it to module table
1364 if 'reg' is true, then will register namespace table to parent one (must be on top of the stack
1365 when function is called).
1366 Function always returns newly registered table on top of the stack.
1367 */
1368 SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg)
1369 {
1370 swig_lua_namespace **sub_namespace;
1371 /* 1 argument - table on the top of the stack */
1372 const int SWIGUNUSED begin = lua_gettop(L);
1373 assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */
1374 lua_checkstack(L,5);
1375 lua_newtable(L); /* namespace itself */
1376 lua_newtable(L); /* metatable for namespace */
1377
1378 /* add a table called ".get" */
1379 lua_pushstring(L,".get");
1380 lua_newtable(L);
1381 lua_rawset(L,-3);
1382 /* add a table called ".set" */
1383 lua_pushstring(L,".set");
1384 lua_newtable(L);
1385 lua_rawset(L,-3);
1386 /* add a table called ".fn" */
1387 lua_pushstring(L,".fn");
1388 lua_newtable(L);
1389 lua_rawset(L,-3);
1390
1391 /* add accessor fns for using the .get,.set&.fn */
1392 SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get);
1393 SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set);
1394
1395 lua_setmetatable(L,-2); /* set metatable */
1396
1397 /* Register all functions, variables etc */
1398 SWIG_Lua_add_namespace_details(L,ns);
1399 /* Register classes */
1400 SWIG_Lua_add_namespace_classes(L,ns);
1401
1402 sub_namespace = ns->ns_namespaces;
1403 if( sub_namespace != 0) {
1404 while(*sub_namespace != 0) {
1405 SWIG_Lua_namespace_register(L, *sub_namespace, 1);
1406 lua_pop(L,1); /* removing sub-namespace table */
1407 sub_namespace++;
1408 }
1409 }
1410
1411 if (reg) {
1412 lua_pushstring(L,ns->name);
1413 lua_pushvalue(L,-2);
1414 lua_rawset(L,-4); /* add namespace to module table */
1415 }
1416 assert(lua_gettop(L) == begin+1);
1417 }
1418 #endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
1419
1420 /* -----------------------------------------------------------------------------
1421 * global variable support code: classes
1422 * ----------------------------------------------------------------------------- */
1423
1424 SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname);
1425
1426 typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret);
1427
1428 SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type,
1429 int first_arg, swig_lua_base_iterator_func func, int *const ret)
1430 {
1431 /* first_arg - position of the object in stack. Everything that is above are arguments
1432 * and is passed to every evocation of the func */
1433 int last_arg = lua_gettop(L);/* position of last argument */
1434 int original_metatable = last_arg + 1;
1435 size_t bases_count;
1436 int result = SWIG_ERROR;
1437 int bases_table;
1438 (void)swig_type;
1439 lua_getmetatable(L,first_arg);
1440
1441 /* initialise base search */
1442 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1443 SWIG_Lua_get_table(L,".bases");
1444 assert(lua_istable(L,-1));
1445 bases_count = lua_rawlen(L,-1);
1446 bases_table = lua_gettop(L);
1447 #else
1448 /* In elua .bases table doesn't exist. Use table from swig_lua_class */
1449 (void)bases_table;
1450 assert(swig_type!=0);
1451 swig_module_info *module=SWIG_GetModule(L);
1452 swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases;
1453 const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names;
1454 bases_count = 0;
1455 for(;base_names[bases_count];
1456 bases_count++);/* get length of bases */
1457 #endif
1458
1459 if(ret)
1460 *ret = 0;
1461 if(bases_count>0)
1462 {
1463 int to_remove;
1464 size_t i;
1465 int j;
1466 int subcall_last_arg;
1467 int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */
1468 int valid = 1;
1469 swig_type_info *base_swig_type = 0;
1470 for(j=first_arg;j<=last_arg;j++)
1471 lua_pushvalue(L,j);
1472 subcall_last_arg = lua_gettop(L);
1473
1474 /* Trick: temporarily replacing original metatable with metatable for base class and call getter */
1475 for(i=0;i<bases_count;i++) {
1476 /* Iteration through class bases */
1477 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1478 lua_rawgeti(L,bases_table,i+1);
1479 base_swig_type = 0;
1480 if(lua_isnil(L,-1)) {
1481 valid = 0;
1482 lua_pop(L,1);
1483 } else {
1484 valid = 1;
1485 }
1486 #else /* In elua .bases table doesn't exist. Use table from swig_lua_class */
1487 swig_lua_class *base_class = bases[i];
1488 if(!base_class) {
1489 valid = 0;
1490 } else {
1491 valid = 1;
1492 SWIG_Lua_get_class_metatable(L,base_class->fqname);
1493 base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]);
1494 assert(base_swig_type != 0);
1495 }
1496 #endif
1497
1498 if(!valid)
1499 continue;
1500 assert(lua_isuserdata(L, subcall_first_arg));
1501 assert(lua_istable(L,-1));
1502 lua_setmetatable(L,subcall_first_arg); /* Set new metatable */
1503 assert(lua_gettop(L) == subcall_last_arg);
1504 result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */
1505 if(result != SWIG_ERROR) {
1506 break;
1507 }
1508 }
1509 /* Restore original metatable */
1510 lua_pushvalue(L,original_metatable);
1511 lua_setmetatable(L,first_arg);
1512 /* Clear - remove everything between last_arg and subcall_last_arg including */
1513 to_remove = subcall_last_arg - last_arg;
1514 for(j=0;j<to_remove;j++)
1515 lua_remove(L,last_arg+1);
1516 } else {
1517 /* Remove everything after last_arg */
1518 lua_pop(L, lua_gettop(L) - last_arg);
1519 }
1520 if(ret) assert(lua_gettop(L) == last_arg + *ret);
1521 return result;
1522 }
1523
1524 /* The class.get method helper, performs the lookup of class attributes.
1525 * It returns an error code. Number of function return values is passed inside 'ret'.
1526 * first_arg is not used in this function because function always has 2 arguments.
1527 */
1528 SWIGINTERN int SWIG_Lua_class_do_get_item(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
1529 {
1530 /* there should be 2 params passed in
1531 (1) userdata (not the meta table)
1532 (2) string name of the attribute
1533 */
1534 int bases_search_result;
1535 int substack_start = lua_gettop(L)-2;
1536 assert(first_arg == substack_start+1);
1537 lua_checkstack(L,5);
1538 assert(lua_isuserdata(L,-2)); /* just in case */
1539 lua_getmetatable(L,-2); /* get the meta table */
1540 assert(lua_istable(L,-1)); /* just in case */
1541 /* NEW: looks for the __getitem() fn
1542 this is a user provided get fn */
1543 SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
1544 if (lua_iscfunction(L,-1)) /* if its there */
1545 { /* found it so call the fn & return its value */
1546 lua_pushvalue(L,substack_start+1); /* the userdata */
1547 lua_pushvalue(L,substack_start+2); /* the parameter */
1548 lua_call(L,2,1); /* 2 value in (userdata),1 out (result) */
1549 lua_remove(L,-2); /* stack tidy, remove metatable */
1550 if(ret) *ret = 1;
1551 return SWIG_OK;
1552 }
1553 lua_pop(L,1);
1554 /* Remove the metatable */
1555 lua_pop(L,1);
1556 /* Search in base classes */
1557 bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get_item,ret);
1558 return bases_search_result; /* sorry not known */
1559 }
1560
1561
1562 /* The class.get method helper, performs the lookup of class attributes.
1563 * It returns an error code. Number of function return values is passed inside 'ret'.
1564 * first_arg is not used in this function because function always has 2 arguments.
1565 */
1566 SWIGINTERN int SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
1567 {
1568 /* there should be 2 params passed in
1569 (1) userdata (not the meta table)
1570 (2) string name of the attribute
1571 */
1572 int bases_search_result;
1573 int substack_start = lua_gettop(L)-2;
1574 assert(first_arg == substack_start+1);
1575 lua_checkstack(L,5);
1576 assert(lua_isuserdata(L,-2)); /* just in case */
1577 lua_getmetatable(L,-2); /* get the meta table */
1578 assert(lua_istable(L,-1)); /* just in case */
1579 SWIG_Lua_get_table(L,".get"); /* find the .get table */
1580 assert(lua_istable(L,-1)); /* just in case */
1581 /* look for the key in the .get table */
1582 lua_pushvalue(L,substack_start+2); /* key */
1583 lua_rawget(L,-2);
1584 lua_remove(L,-2); /* stack tidy, remove .get table */
1585 if (lua_iscfunction(L,-1))
1586 { /* found it so call the fn & return its value */
1587 lua_pushvalue(L,substack_start+1); /* the userdata */
1588 lua_call(L,1,1); /* 1 value in (userdata),1 out (result) */
1589 lua_remove(L,-2); /* stack tidy, remove metatable */
1590 if(ret)
1591 *ret = 1;
1592 return SWIG_OK;
1593 }
1594 lua_pop(L,1); /* remove whatever was there */
1595 /* ok, so try the .fn table */
1596 SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
1597 assert(lua_istable(L,-1)); /* just in case */
1598 lua_pushvalue(L,substack_start+2); /* key */
1599 lua_rawget(L,-2); /* look for the fn */
1600 lua_remove(L,-2); /* stack tidy, remove .fn table */
1601 if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
1602 { /* found it so return the fn & let lua call it */
1603 lua_remove(L,-2); /* stack tidy, remove metatable */
1604 if(ret)
1605 *ret = 1;
1606 return SWIG_OK;
1607 }
1608 lua_pop(L,1); /* remove whatever was there */
1609 /* Remove the metatable */
1610 lua_pop(L,1);
1611 /* Search in base classes */
1612 bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get,ret);
1613 return bases_search_result; /* sorry not known */
1614 }
1615
1616 /* the class.get method, performs the lookup of class attributes
1617 */
1618 SWIGINTERN int SWIG_Lua_class_get(lua_State *L)
1619 {
1620 /* there should be 2 params passed in
1621 (1) userdata (not the meta table)
1622 (2) string name of the attribute
1623 */
1624 int result;
1625 swig_lua_userdata *usr;
1626 swig_type_info *type;
1627 int ret = 0;
1628 assert(lua_isuserdata(L,1));
1629 usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1630 type = usr->type;
1631 result = SWIG_Lua_class_do_get(L,type,1,&ret);
1632 if(result == SWIG_OK)
1633 return ret;
1634
1635 result = SWIG_Lua_class_do_get_item(L,type,1,&ret);
1636 if(result == SWIG_OK)
1637 return ret;
1638
1639 return 0;
1640 }
1641
1642 /* helper for the class.set method, performs the lookup of class attributes
1643 * It returns error code. Number of function return values is passed inside 'ret'
1644 */
1645 SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret)
1646 {
1647 /* there should be 3 params passed in
1648 (1) table (not the meta table)
1649 (2) string name of the attribute
1650 (3) any for the new value
1651 */
1652
1653 int bases_search_result;
1654 int substack_start = lua_gettop(L) - 3;
1655 lua_checkstack(L,5);
1656 assert(lua_isuserdata(L,substack_start+1)); /* just in case */
1657 lua_getmetatable(L,substack_start+1); /* get the meta table */
1658 assert(lua_istable(L,-1)); /* just in case */
1659 if(ret)
1660 *ret = 0; /* it is setter - number of return values is always 0 */
1661
1662 SWIG_Lua_get_table(L,".set"); /* find the .set table */
1663 if (lua_istable(L,-1))
1664 {
1665 /* look for the key in the .set table */
1666 lua_pushvalue(L,substack_start+2); /* key */
1667 lua_rawget(L,-2);
1668 lua_remove(L,-2); /* tidy stack, remove .set table */
1669 if (lua_iscfunction(L,-1))
1670 { /* found it so call the fn & return its value */
1671 lua_pushvalue(L,substack_start+1); /* userdata */
1672 lua_pushvalue(L,substack_start+3); /* value */
1673 lua_call(L,2,0);
1674 lua_remove(L,substack_start+4); /*remove metatable*/
1675 return SWIG_OK;
1676 }
1677 lua_pop(L,1); /* remove the value */
1678 } else {
1679 lua_pop(L,1); /* remove the answer for .set table request*/
1680 }
1681 /* NEW: looks for the __setitem() fn
1682 this is a user provided set fn */
1683 SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
1684 if (lua_iscfunction(L,-1)) /* if its there */
1685 { /* found it so call the fn & return its value */
1686 lua_pushvalue(L,substack_start+1); /* the userdata */
1687 lua_pushvalue(L,substack_start+2); /* the parameter */
1688 lua_pushvalue(L,substack_start+3); /* the value */
1689 lua_call(L,3,0); /* 3 values in ,0 out */
1690 lua_remove(L,-2); /* stack tidy, remove metatable */
1691 return SWIG_OK;
1692 }
1693 lua_pop(L,1); /* remove value */
1694
1695 lua_pop(L,1); /* remove metatable */
1696 /* Search among bases */
1697 bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret);
1698 if(ret)
1699 assert(*ret == 0);
1700 assert(lua_gettop(L) == substack_start + 3);
1701 return bases_search_result;
1702 }
1703
1704 /* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly
1705 * handles return values.
1706 */
1707 SWIGINTERN int SWIG_Lua_class_set(lua_State *L)
1708 {
1709 /* There should be 3 params passed in
1710 (1) table (not the meta table)
1711 (2) string name of the attribute
1712 (3) any for the new value
1713 */
1714 int ret = 0;
1715 int result;
1716 swig_lua_userdata *usr;
1717 swig_type_info *type;
1718 assert(lua_isuserdata(L,1));
1719 usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1720 type = usr->type;
1721 result = SWIG_Lua_class_do_set(L,type,1,&ret);
1722 if(result != SWIG_OK) {
1723 SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method.");
1724 lua_error(L);
1725 } else {
1726 assert(ret==0);
1727 }
1728 return 0;
1729 }
1730
1731 /* the class.destruct method called by the interpreter */
1732 SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L)
1733 {
1734 /* there should be 1 params passed in
1735 (1) userdata (not the meta table) */
1736 swig_lua_userdata *usr;
1737 swig_lua_class *clss;
1738 assert(lua_isuserdata(L,-1)); /* just in case */
1739 usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
1740 /* if must be destroyed & has a destructor */
1741 if (usr->own) /* if must be destroyed */
1742 {
1743 clss=(swig_lua_class*)usr->type->clientdata; /* get the class */
1744 if (clss && clss->destructor) /* there is a destroy fn */
1745 {
1746 clss->destructor(usr->ptr); /* bye bye */
1747 }
1748 }
1749 return 0;
1750 }
1751
1752 /* the class.__tostring method called by the interpreter and print */
1753 SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L)
1754 {
1755 /* there should be 1 param passed in
1756 (1) userdata (not the metatable) */
1757 const char *className;
1758 void* userData;
1759 assert(lua_isuserdata(L,1)); /* just in case */
1760 userData = lua_touserdata(L,1); /* get the userdata address for later */
1761 lua_getmetatable(L,1); /* get the meta table */
1762 assert(lua_istable(L,-1)); /* just in case */
1763
1764 lua_getfield(L, -1, ".type");
1765 className = lua_tostring(L, -1);
1766
1767 lua_pushfstring(L, "<%s userdata: %p>", className, userData);
1768 return 1;
1769 }
1770
1771 /* to manually disown some userdata */
1772 SWIGINTERN int SWIG_Lua_class_disown(lua_State *L)
1773 {
1774 /* there should be 1 params passed in
1775 (1) userdata (not the meta table) */
1776 swig_lua_userdata *usr;
1777 assert(lua_isuserdata(L,-1)); /* just in case */
1778 usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
1779
1780 usr->own = 0; /* clear our ownership */
1781 return 0;
1782 }
1783
1784 /* lua callable function to compare userdata's value
1785 the issue is that two userdata may point to the same thing
1786 but to lua, they are different objects */
1787 SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L)
1788 {
1789 int result;
1790 swig_lua_userdata *usr1,*usr2;
1791 if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */
1792 return 0; /* nil reply */
1793 usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1794 usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */
1795 /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
1796 result=(usr1->ptr==usr2->ptr);
1797 lua_pushboolean(L,result);
1798 return 1;
1799 }
1800
1801 /* populate table at the top of the stack with metamethods that ought to be inherited */
1802 SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L)
1803 {
1804 SWIG_Lua_add_boolean(L, "__add", 1);
1805 SWIG_Lua_add_boolean(L, "__sub", 1);
1806 SWIG_Lua_add_boolean(L, "__mul", 1);
1807 SWIG_Lua_add_boolean(L, "__div", 1);
1808 SWIG_Lua_add_boolean(L, "__mod", 1);
1809 SWIG_Lua_add_boolean(L, "__pow", 1);
1810 SWIG_Lua_add_boolean(L, "__unm", 1);
1811 SWIG_Lua_add_boolean(L, "__len", 1 );
1812 SWIG_Lua_add_boolean(L, "__concat", 1 );
1813 SWIG_Lua_add_boolean(L, "__eq", 1);
1814 SWIG_Lua_add_boolean(L, "__lt", 1);
1815 SWIG_Lua_add_boolean(L, "__le", 1);
1816 SWIG_Lua_add_boolean(L, "__call", 1);
1817 SWIG_Lua_add_boolean(L, "__tostring", 1);
1818 SWIG_Lua_add_boolean(L, "__gc", 0);
1819 }
1820
1821 /* creates the swig registry */
1822 SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L)
1823 {
1824 /* create main SWIG registry table */
1825 lua_pushstring(L,"SWIG");
1826 lua_newtable(L);
1827 /* populate it with some predefined data */
1828
1829 /* .library table. Placeholder */
1830 lua_pushstring(L,".library");
1831 lua_newtable(L);
1832 {
1833 /* list of metamethods that class inherits from its bases */
1834 lua_pushstring(L,"inheritable_metamethods");
1835 lua_newtable(L);
1836 /* populate with list of metamethods */
1837 SWIG_Lua_populate_inheritable_metamethods(L);
1838 lua_rawset(L,-3);
1839 }
1840 lua_rawset(L,-3);
1841
1842 lua_rawset(L,LUA_REGISTRYINDEX);
1843 }
1844
1845 /* gets the swig registry (or creates it) */
1846 SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L)
1847 {
1848 /* add this all into the swig registry: */
1849 lua_pushstring(L,"SWIG");
1850 lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */
1851 if (!lua_istable(L,-1)) /* not there */
1852 { /* must be first time, so add it */
1853 lua_pop(L,1); /* remove the result */
1854 SWIG_Lua_create_class_registry(L);
1855 /* then get it */
1856 lua_pushstring(L,"SWIG");
1857 lua_rawget(L,LUA_REGISTRYINDEX);
1858 }
1859 }
1860
1861 SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L)
1862 {
1863 SWIG_Lua_get_class_registry(L);
1864 lua_pushstring(L, ".library");
1865 lua_rawget(L,-2);
1866 assert( !lua_isnil(L,-1) );
1867 lua_pushstring(L, "inheritable_metamethods");
1868 lua_rawget(L,-2);
1869
1870 /* Remove class registry and library table */
1871 lua_remove(L,-2);
1872 lua_remove(L,-2);
1873 }
1874
1875 /* Helper function to get the classes metatable from the register */
1876 SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname)
1877 {
1878 SWIG_Lua_get_class_registry(L); /* get the registry */
1879 lua_pushstring(L,cname); /* get the name */
1880 lua_rawget(L,-2); /* get it */
1881 lua_remove(L,-2); /* tidy up (remove registry) */
1882 }
1883
1884 /* Set up the base classes pointers.
1885 Each class structure has a list of pointers to the base class structures.
1886 This function fills them.
1887 It cannot be done at compile time, as this will not work with hireachies
1888 spread over more than one swig file.
1889 Therefore it must be done at runtime, querying the SWIG type system.
1890 */
1891 SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss)
1892 {
1893 int i=0;
1894 swig_module_info *module=SWIG_GetModule(L);
1895 for(i=0;clss->base_names[i];i++)
1896 {
1897 if (clss->bases[i]==0) /* not found yet */
1898 {
1899 /* lookup and cache the base class */
1900 swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
1901 if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
1902 }
1903 }
1904 }
1905
1906 #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1907 /* Merges two tables */
1908 SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
1909 {
1910 /* iterating */
1911 lua_pushnil(L);
1912 while (lua_next(L,source) != 0) {
1913 /* -1 - value, -2 - index */
1914 /* have to copy to assign */
1915 lua_pushvalue(L,-2); /* copy of index */
1916 lua_pushvalue(L,-2); /* copy of value */
1917 lua_rawset(L, target);
1918 lua_pop(L,1);
1919 /* only key is left */
1920 }
1921 }
1922
1923 /* Merges two tables with given name. original - index of target metatable, base - index of source metatable */
1924 SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
1925 {
1926 /* push original[name], then base[name] */
1927 lua_pushstring(L,name);
1928 lua_rawget(L,original);
1929 int original_table = lua_gettop(L);
1930 lua_pushstring(L,name);
1931 lua_rawget(L,base);
1932 int base_table = lua_gettop(L);
1933 SWIG_Lua_merge_tables_by_index(L, original_table, base_table);
1934 /* clearing stack */
1935 lua_pop(L,2);
1936 }
1937
1938 /* Function takes all symbols from base and adds it to derived class. It's just a helper. */
1939 SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
1940 {
1941 /* There is one parameter - original, i.e. 'derived' class metatable */
1942 assert(lua_istable(L,-1));
1943 int original = lua_gettop(L);
1944 SWIG_Lua_get_class_metatable(L,base_cls->fqname);
1945 int base = lua_gettop(L);
1946 SWIG_Lua_merge_tables(L, ".fn", original, base );
1947 SWIG_Lua_merge_tables(L, ".set", original, base );
1948 SWIG_Lua_merge_tables(L, ".get", original, base );
1949 lua_pop(L,1);
1950 }
1951
1952 /* Function squashes all symbols from 'clss' bases into itself */
1953 SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
1954 {
1955 int i;
1956 SWIG_Lua_get_class_metatable(L,clss->fqname);
1957 for(i=0;clss->base_names[i];i++)
1958 {
1959 if (clss->bases[i]==0) /* Somehow it's not found. Skip it */
1960 continue;
1961 /* Thing is: all bases are already registered. Thus they have already executed
1962 * this function. So we just need to squash them into us, because their bases
1963 * are already squashed into them. No need for recursion here!
1964 */
1965 SWIG_Lua_class_squash_base(L, clss->bases[i]);
1966 }
1967 lua_pop(L,1); /*tidy stack*/
1968 }
1969 #endif
1970
1971 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
1972 /* helper add a variable to a registered class */
1973 SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn)
1974 {
1975 assert(lua_istable(L,-1)); /* just in case */
1976 SWIG_Lua_get_table(L,".get"); /* find the .get table */
1977 assert(lua_istable(L,-1)); /* just in case */
1978 SWIG_Lua_add_function(L,name,getFn);
1979 lua_pop(L,1); /* tidy stack (remove table) */
1980 if (setFn)
1981 {
1982 SWIG_Lua_get_table(L,".set"); /* find the .set table */
1983 assert(lua_istable(L,-1)); /* just in case */
1984 SWIG_Lua_add_function(L,name,setFn);
1985 lua_pop(L,1); /* tidy stack (remove table) */
1986 }
1987 }
1988
1989 /* helper to recursively add class static details (static attributes, operations and constants) */
1990 SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss)
1991 {
1992 int i = 0;
1993 /* The class namespace table must be on the top of the stack */
1994 assert(lua_istable(L,-1));
1995 /* call all the base classes first: we can then override these later: */
1996 for(i=0;clss->bases[i];i++)
1997 {
1998 SWIG_Lua_add_class_static_details(L,clss->bases[i]);
1999 }
2000
2001 SWIG_Lua_add_namespace_details(L, clss->cls_static);
2002 }
2003
2004 SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */
2005
2006 /* helper to recursively add class details (attributes & operations) */
2007 SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss)
2008 {
2009 int i;
2010 size_t bases_count = 0;
2011 /* Add bases to .bases table */
2012 SWIG_Lua_get_table(L,".bases");
2013 assert(lua_istable(L,-1)); /* just in case */
2014 for(i=0;clss->bases[i];i++)
2015 {
2016 SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
2017 /* Base class must be already registered */
2018 assert(lua_istable(L,-1));
2019 lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */
2020 bases_count++;
2021 }
2022 assert(lua_rawlen(L,-1) == bases_count);
2023 lua_pop(L,1); /* remove .bases table */
2024 /* add attributes */
2025 for(i=0;clss->attributes[i].name;i++){
2026 SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
2027 }
2028 /* add methods to the metatable */
2029 SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
2030 assert(lua_istable(L,-1)); /* just in case */
2031 for(i=0;clss->methods[i].name;i++){
2032 SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func);
2033 }
2034 lua_pop(L,1); /* tidy stack (remove table) */
2035 /* add operator overloads
2036 This adds methods from metatable array to metatable. Can mess up garbage
2037 collectind if someone defines __gc method
2038 */
2039 if(clss->metatable) {
2040 for(i=0;clss->metatable[i].name;i++) {
2041 SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func);
2042 }
2043 }
2044
2045 #if !defined(SWIG_LUA_SQUASH_BASES)
2046 /* Adding metamethods that are defined in base classes. If bases were squashed
2047 * then it is obviously unnecessary
2048 */
2049 SWIG_Lua_add_class_user_metamethods(L, clss);
2050 #endif
2051 }
2052
2053 /* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed
2054 for the following issue: Lua runtime checks for metamethod existence with rawget function
2055 ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method
2056 search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly
2057 in metatable and not in object).
2058 Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants
2059 are automatically given a special proxy __x that calls the real __x method.
2060 Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime,
2061 those changes must be reflected in all descendants.
2062 */
2063
2064 SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/
2065
2066 /* The real function that resolves a metamethod.
2067 * Function searches given class and all it's bases(recursively) for first instance of something that is
2068 * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation
2069 * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the
2070 * answer.
2071 * Returns 1 if found, 0 otherwise.
2072 * clss is class which metatable we will search for method
2073 * metamethod_name_idx is index in L where metamethod name (as string) lies
2074 * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check
2075 * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from
2076 * SWIG_Lua_resolve_metamethod
2077 * */
2078 SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx,
2079 int skip_check)
2080 {
2081 /* This function is called recursively */
2082 int result = 0;
2083 int i = 0;
2084
2085 if (!skip_check) {
2086 SWIG_Lua_get_class_metatable(L, clss->fqname);
2087 lua_pushvalue(L, metamethod_name_idx);
2088 lua_rawget(L,-2);
2089 /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then
2090 * this isn't the function we are looking for :)
2091 * lua_tocfunction will return NULL if not cfunction
2092 */
2093 if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) {
2094 lua_remove(L,-2); /* removing class metatable */
2095 return 1;
2096 }
2097 lua_pop(L,2); /* remove class metatable and query result */
2098 }
2099
2100 /* Forwarding calls to bases */
2101 for(i=0;clss->bases[i];i++)
2102 {
2103 result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0);
2104 if (result)
2105 break;
2106 }
2107
2108 return result;
2109 }
2110
2111 /* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method
2112 * and calls it */
2113 SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L)
2114 {
2115 int numargs;
2116 int metamethod_name_idx;
2117 const swig_lua_class* clss;
2118 int result;
2119
2120 lua_checkstack(L,5);
2121 numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */
2122
2123 /* Get upvalues from closure */
2124 lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/
2125 metamethod_name_idx = lua_gettop(L);
2126
2127 lua_pushvalue(L, lua_upvalueindex(2));
2128 clss = (const swig_lua_class*)(lua_touserdata(L,-1));
2129 lua_pop(L,1); /* remove lightuserdata with clss from stack */
2130
2131 /* Actual work */
2132 result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1);
2133 if (!result) {
2134 SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation.");
2135 lua_error(L);
2136 return 0;
2137 }
2138
2139 lua_remove(L,-2); /* remove metamethod key */
2140 lua_insert(L,1); /* move function to correct position */
2141 lua_call(L, numargs, LUA_MULTRET);
2142 return lua_gettop(L); /* return all results */
2143 }
2144
2145
2146 /* If given metamethod must be present in given class, then creates appropriate proxy
2147 * Returns 1 if successfully added, 0 if not added because no base class has it, -1
2148 * if method is defined in the class metatable itself
2149 */
2150 SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index)
2151 {
2152 int key_index;
2153 int success = 0;
2154 int i = 0;
2155
2156 /* metamethod name - on the top of the stack */
2157 assert(lua_isstring(L,-1));
2158
2159 key_index = lua_gettop(L);
2160
2161 /* Check whether method is already defined in metatable */
2162 lua_pushvalue(L,key_index); /* copy of the key */
2163 lua_gettable(L,metatable_index);
2164 if( !lua_isnil(L,-1) ) {
2165 lua_pop(L,1);
2166 return -1;
2167 }
2168 lua_pop(L,1);
2169
2170 /* Iterating over immediate bases */
2171 for(i=0;clss->bases[i];i++)
2172 {
2173 const swig_lua_class *base = clss->bases[i];
2174 SWIG_Lua_get_class_metatable(L, base->fqname);
2175 lua_pushvalue(L, key_index);
2176 lua_rawget(L, -2);
2177 if( !lua_isnil(L,-1) ) {
2178 lua_pushvalue(L, key_index);
2179
2180 /* Add proxy function */
2181 lua_pushvalue(L, key_index); /* first closure value is function name */
2182 lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */
2183 lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2);
2184
2185 lua_rawset(L, metatable_index);
2186 success = 1;
2187 }
2188 lua_pop(L,1); /* remove function or nil */
2189 lua_pop(L,1); /* remove base class metatable */
2190
2191 if( success )
2192 break;
2193 }
2194
2195 return success;
2196 }
2197
2198 SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss)
2199 {
2200 int metatable_index;
2201 int metamethods_info_index;
2202 int tostring_undefined;
2203 int eq_undefined = 0;
2204
2205 SWIG_Lua_get_class_metatable(L, clss->fqname);
2206 metatable_index = lua_gettop(L);
2207 SWIG_Lua_get_inheritable_metamethods(L);
2208 assert(lua_istable(L,-1));
2209 metamethods_info_index = lua_gettop(L);
2210 lua_pushnil(L); /* first key */
2211 while(lua_next(L, metamethods_info_index) != 0 ) {
2212 /* key at index -2, value at index -1 */
2213 const int is_inheritable = lua_toboolean(L,-2);
2214 lua_pop(L,1); /* remove value - we don't need it anymore */
2215
2216 if(is_inheritable) { /* if metamethod is inheritable */
2217 SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index);
2218 }
2219 }
2220
2221 lua_pop(L,1); /* remove inheritable metatmethods table */
2222
2223 /* Special handling for __tostring method */
2224 lua_pushstring(L, "__tostring");
2225 lua_pushvalue(L,-1);
2226 lua_rawget(L,metatable_index);
2227 tostring_undefined = lua_isnil(L,-1);
2228 lua_pop(L,1);
2229 if( tostring_undefined ) {
2230 lua_pushcfunction(L, SWIG_Lua_class_tostring);
2231 lua_rawset(L, metatable_index);
2232 } else {
2233 lua_pop(L,1); /* remove copy of the key */
2234 }
2235
2236 /* Special handling for __eq method */
2237 lua_pushstring(L, "__eq");
2238 lua_pushvalue(L,-1);
2239 lua_rawget(L,metatable_index);
2240 eq_undefined = lua_isnil(L,-1);
2241 lua_pop(L,1);
2242 if( eq_undefined ) {
2243 lua_pushcfunction(L, SWIG_Lua_class_equal);
2244 lua_rawset(L, metatable_index);
2245 } else {
2246 lua_pop(L,1); /* remove copy of the key */
2247 }
2248 /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[]
2249 * a __getitem/__setitem method should be defined
2250 */
2251 lua_pop(L,1); /* pop class metatable */
2252 }
2253
2254 /* Register class static methods,attributes etc as well as constructor proxy */
2255 SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss)
2256 {
2257 const int SWIGUNUSED begin = lua_gettop(L);
2258 lua_checkstack(L,5); /* just in case */
2259 assert(lua_istable(L,-1)); /* just in case */
2260 assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */
2261
2262 SWIG_Lua_namespace_register(L,clss->cls_static, 1);
2263
2264 assert(lua_istable(L,-1)); /* just in case */
2265
2266 /* add its constructor to module with the name of the class
2267 so you can do MyClass(...) as well as new_MyClass(...)
2268 BUT only if a constructor is defined
2269 (this overcomes the problem of pure virtual classes without constructors)*/
2270 if (clss->constructor)
2271 {
2272 lua_getmetatable(L,-1);
2273 assert(lua_istable(L,-1)); /* just in case */
2274 SWIG_Lua_add_function(L,"__call", clss->constructor);
2275 lua_pop(L,1);
2276 }
2277
2278 assert(lua_istable(L,-1)); /* just in case */
2279 SWIG_Lua_add_class_static_details(L, clss);
2280
2281 /* clear stack */
2282 lua_pop(L,1);
2283 assert( lua_gettop(L) == begin );
2284 }
2285
2286 /* Performs the instance (non-static) class registration process. Metatable for class is created
2287 * and added to the class registry.
2288 */
2289 SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss)
2290 {
2291 const int SWIGUNUSED begin = lua_gettop(L);
2292 int i;
2293 /* if name already there (class is already registered) then do nothing */
2294 SWIG_Lua_get_class_registry(L); /* get the registry */
2295 lua_pushstring(L,clss->fqname); /* get the name */
2296 lua_rawget(L,-2);
2297 if(!lua_isnil(L,-1)) {
2298 lua_pop(L,2);
2299 assert(lua_gettop(L)==begin);
2300 return;
2301 }
2302 lua_pop(L,2); /* tidy stack */
2303 /* Recursively initialize all bases */
2304 for(i=0;clss->bases[i];i++)
2305 {
2306 SWIG_Lua_class_register_instance(L,clss->bases[i]);
2307 }
2308 /* Again, get registry and push name */
2309 SWIG_Lua_get_class_registry(L); /* get the registry */
2310 lua_pushstring(L,clss->fqname); /* get the name */
2311 lua_newtable(L); /* create the metatable */
2312 #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
2313 /* If squashing is requested, then merges all bases metatable into this one.
2314 * It would get us all special methods: __getitem, __add etc.
2315 * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away
2316 */
2317 {
2318 int new_metatable_index = lua_absindex(L,-1);
2319 for(i=0;clss->bases[i];i++)
2320 {
2321 int base_metatable;
2322 SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
2323 base_metatable = lua_absindex(L,-1);
2324 SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable);
2325 lua_pop(L,1);
2326 }
2327 }
2328 /* And now we will overwrite all incorrectly set data */
2329 #endif
2330 /* add string of class name called ".type" */
2331 lua_pushstring(L,".type");
2332 lua_pushstring(L,clss->fqname);
2333 lua_rawset(L,-3);
2334 /* add a table called bases */
2335 lua_pushstring(L,".bases");
2336 lua_newtable(L);
2337 lua_rawset(L,-3);
2338 /* add a table called ".get" */
2339 lua_pushstring(L,".get");
2340 lua_newtable(L);
2341 lua_rawset(L,-3);
2342 /* add a table called ".set" */
2343 lua_pushstring(L,".set");
2344 lua_newtable(L);
2345 lua_rawset(L,-3);
2346 /* add a table called ".fn" */
2347 lua_pushstring(L,".fn");
2348 lua_newtable(L);
2349 /* add manual disown method */
2350 SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown);
2351 lua_rawset(L,-3);
2352 /* add accessor fns for using the .get,.set&.fn */
2353 SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get);
2354 SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
2355 SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct);
2356 /* add it */
2357 lua_rawset(L,-3); /* metatable into registry */
2358 lua_pop(L,1); /* tidy stack (remove registry) */
2359 assert(lua_gettop(L) == begin);
2360
2361 #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
2362 /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */
2363 SWIG_Lua_class_squash_bases(L,clss);
2364 #endif
2365 SWIG_Lua_get_class_metatable(L,clss->fqname);
2366 SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */
2367 lua_pop(L,1); /* tidy stack (remove class metatable) */
2368 assert( lua_gettop(L) == begin );
2369 }
2370
2371 SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss)
2372 {
2373 int SWIGUNUSED begin;
2374 assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */
2375 SWIG_Lua_class_register_instance(L,clss);
2376 SWIG_Lua_class_register_static(L,clss);
2377
2378 /* Add links from static part to instance part and vice versa */
2379 /* [SWIG registry] [Module]
2380 * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part]
2381 * ".get" ----> ... | | getmetatable()----|
2382 * ".set" ----> ... | | |
2383 * ".static" --------------)----------------/ [static part metatable]
2384 * | ".get" --> ...
2385 * | ".set" --> ....
2386 * |=============================== ".instance"
2387 */
2388 begin = lua_gettop(L);
2389 lua_pushstring(L,clss->cls_static->name);
2390 lua_rawget(L,-2); /* get class static table */
2391 assert(lua_istable(L,-1));
2392 lua_getmetatable(L,-1);
2393 assert(lua_istable(L,-1)); /* get class static metatable */
2394 lua_pushstring(L,".instance"); /* prepare key */
2395
2396 SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */
2397 assert(lua_istable(L,-1));
2398 lua_pushstring(L,".static"); /* prepare key */
2399 lua_pushvalue(L, -4); /* push static class TABLE */
2400 assert(lua_istable(L,-1));
2401 lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */
2402 lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */
2403 lua_pop(L,2);
2404 assert(lua_gettop(L) == begin);
2405 }
2406 #endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
2407
2408 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
2409 SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss)
2410 {
2411 const int SWIGUNUSED begin = lua_gettop(L);
2412 int i;
2413 /* if name already there (class is already registered) then do nothing */
2414 SWIG_Lua_get_class_registry(L); /* get the registry */
2415 lua_pushstring(L,clss->fqname); /* get the name */
2416 lua_rawget(L,-2);
2417 if(!lua_isnil(L,-1)) {
2418 lua_pop(L,2);
2419 assert(lua_gettop(L)==begin);
2420 return;
2421 }
2422 lua_pop(L,2); /* tidy stack */
2423 /* Recursively initialize all bases */
2424 for(i=0;clss->bases[i];i++)
2425 {
2426 SWIG_Lua_elua_class_register_instance(L,clss->bases[i]);
2427 }
2428 /* Again, get registry and push name */
2429 SWIG_Lua_get_class_registry(L); /* get the registry */
2430 lua_pushstring(L,clss->fqname); /* get the name */
2431 assert(clss->metatable);
2432 lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */
2433 lua_rawset(L,-3);
2434 lua_pop(L,1);
2435 assert(lua_gettop(L) == begin);
2436 }
2437 #endif /* elua && eluac */
2438
2439 /* -----------------------------------------------------------------------------
2440 * Class/structure conversion fns
2441 * ----------------------------------------------------------------------------- */
2442
2443 /* helper to add metatable to new lua object */
2444 SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type)
2445 {
2446 if (type->clientdata) /* there is clientdata: so add the metatable */
2447 {
2448 SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname);
2449 if (lua_istable(L,-1))
2450 {
2451 lua_setmetatable(L,-2);
2452 }
2453 else
2454 {
2455 lua_pop(L,1);
2456 }
2457 }
2458 }
2459
2460 /* pushes a new object into the lua stack */
2461 SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own)
2462 {
2463 swig_lua_userdata *usr;
2464 if (!ptr){
2465 lua_pushnil(L);
2466 return;
2467 }
2468 usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */
2469 usr->ptr=ptr; /* set the ptr */
2470 usr->type=type;
2471 usr->own=own;
2472 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
2473 SWIG_Lua_AddMetatable(L,type); /* add metatable */
2474 #endif
2475 }
2476
2477 /* takes a object from the lua stack & converts it into an object of the correct type
2478 (if possible) */
2479 SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
2480 {
2481 swig_lua_userdata *usr;
2482 swig_cast_info *cast;
2483 if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */
2484 usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */
2485 if (usr)
2486 {
2487 if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
2488 {
2489 usr->own=0;
2490 }
2491 if (!type) /* special cast void*, no casting fn */
2492 {
2493 *ptr=usr->ptr;
2494 return SWIG_OK; /* ok */
2495 }
2496 cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
2497 if (cast)
2498 {
2499 int newmemory = 0;
2500 *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
2501 assert(!newmemory); /* newmemory handling not yet implemented */
2502 return SWIG_OK; /* ok */
2503 }
2504 }
2505 return SWIG_ERROR; /* error */
2506 }
2507
2508 SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,
2509 int argnum,const char *func_name){
2510 void *result;
2511 if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
2512 luaL_error (L,"Error in %s, expected a %s at argument number %d\n",
2513 func_name,(type && type->str)?type->str:"void*",argnum);
2514 }
2515 return result;
2516 }
2517
2518 /* pushes a packed userdata. user for member fn pointers only */
2519 SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type)
2520 {
2521 swig_lua_rawdata *raw;
2522 assert(ptr); /* not acceptable to pass in a NULL value */
2523 raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */
2524 raw->type=type;
2525 raw->own=0;
2526 memcpy(raw->data,ptr,size); /* copy the data */
2527 SWIG_Lua_AddMetatable(L,type); /* add metatable */
2528 }
2529
2530 /* converts a packed userdata. user for member fn pointers only */
2531 SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type)
2532 {
2533 swig_lua_rawdata *raw;
2534 raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */
2535 if (!raw) return SWIG_ERROR; /* error */
2536 if (type==0 || type==raw->type) /* void* or identical type */
2537 {
2538 memcpy(ptr,raw->data,size); /* copy it */
2539 return SWIG_OK; /* ok */
2540 }
2541 return SWIG_ERROR; /* error */
2542 }
2543
2544 /* a function to get the typestring of a piece of data */
2545 SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
2546 {
2547 swig_lua_userdata *usr;
2548 if (lua_isuserdata(L,tp))
2549 {
2550 usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */
2551 if (usr && usr->type && usr->type->str)
2552 return usr->type->str;
2553 return "userdata (unknown type)";
2554 }
2555 return lua_typename(L,lua_type(L,tp));
2556 }
2557
2558 /* lua callable function to get the userdata's type */
2559 SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
2560 {
2561 lua_pushstring(L,SWIG_Lua_typename(L,1));
2562 return 1;
2563 }
2564
2565 /* -----------------------------------------------------------------------------
2566 * global variable support code: class/struct typemap functions
2567 * ----------------------------------------------------------------------------- */
2568
2569 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
2570 /* Install Constants */
2571 SWIGINTERN void
2572 SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) {
2573 int i;
2574 for (i = 0; constants[i].type; i++) {
2575 switch(constants[i].type) {
2576 case SWIG_LUA_INT:
2577 lua_pushstring(L,constants[i].name);
2578 lua_pushinteger(L,(lua_Number)constants[i].lvalue);
2579 lua_rawset(L,-3);
2580 break;
2581 case SWIG_LUA_FLOAT:
2582 lua_pushstring(L,constants[i].name);
2583 lua_pushnumber(L,(lua_Number)constants[i].dvalue);
2584 lua_rawset(L,-3);
2585 break;
2586 case SWIG_LUA_CHAR:
2587 lua_pushstring(L,constants[i].name);
2588 {
2589 char c = constants[i].lvalue;
2590 lua_pushlstring(L,&c,1);
2591 }
2592 lua_rawset(L,-3);
2593 break;
2594 case SWIG_LUA_STRING:
2595 lua_pushstring(L,constants[i].name);
2596 lua_pushstring(L,(char *) constants[i].pvalue);
2597 lua_rawset(L,-3);
2598 break;
2599 case SWIG_LUA_POINTER:
2600 lua_pushstring(L,constants[i].name);
2601 SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
2602 lua_rawset(L,-3);
2603 break;
2604 case SWIG_LUA_BINARY:
2605 lua_pushstring(L,constants[i].name);
2606 SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
2607 lua_rawset(L,-3);
2608 break;
2609 default:
2610 break;
2611 }
2612 }
2613 }
2614 #endif
2615
2616 /* -----------------------------------------------------------------------------
2617 * executing lua code from within the wrapper
2618 * ----------------------------------------------------------------------------- */
2619
2620 #ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
2621 #define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
2622 #endif
2623 /* Executes a C string in Lua which is a really simple way of calling lua from C
2624 Unfortunately lua keeps changing its APIs, so we need a conditional compile
2625 In lua 5.0.X it's lua_dostring()
2626 In lua 5.1.X it's luaL_dostring()
2627 */
2628 SWIGINTERN int
2629 SWIG_Lua_dostring(lua_State *L, const char *str) {
2630 int ok,top;
2631 if (str==0 || str[0]==0) return 0; /* nothing to do */
2632 top=lua_gettop(L); /* save stack */
2633 #if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
2634 ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */
2635 #else
2636 ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */
2637 #endif
2638 if (ok!=0) {
2639 SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
2640 }
2641 lua_settop(L,top); /* restore the stack */
2642 return ok;
2643 }
2644
2645 #ifdef __cplusplus
2646 }
2647 #endif
2648
2649 /* ------------------------------ end luarun.swg ------------------------------ */
2650
2651
2652 /* -------- TYPES TABLE (BEGIN) -------- */
2653
2654 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2655 #define SWIGTYPE_p_char swig_types[1]
2656 #define SWIGTYPE_p_double swig_types[2]
2657 #define SWIGTYPE_p_f_double_double__int swig_types[3]
2658 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[4]
2659 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[5]
2660 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[6]
2661 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[7]
2662 #define SWIGTYPE_p_int swig_types[8]
2663 #define SWIGTYPE_p_p_char swig_types[9]
2664 #define SWIGTYPE_p_p_double swig_types[10]
2665 #define SWIGTYPE_p_unsigned_int swig_types[11]
2666 static swig_type_info *swig_types[13];
2667 static swig_module_info swig_module = {swig_types, 12, 0, 0, 0, 0};
2668 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2669 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2670
2671 /* -------- TYPES TABLE (END) -------- */
2672
2673 #define SWIG_name "plplotluac"
2674 #define SWIG_init luaopen_plplotluac
2675 #define SWIG_init_user luaopen_plplotluac_user
2676
2677 #define SWIG_LUACODE luaopen_plplotluac_luacode
2678
2679 #include "plplotP.h"
2680
2681
2682 #define LUA_ALLOC_ARRAY( TYPE, LEN ) (TYPE *) malloc( LEN * sizeof ( TYPE ) )
2683 #define LUA_FREE_ARRAY( PTR ) if ( PTR ) { free( PTR ); PTR = NULL;}
2684
2685 // super macro to declare array typemap helper fns
2686 SWIGINTERN int SWIG_itable_size( lua_State* L, int index );
2687 #define LUA_DECLARE_TYPEMAP_ARR_FN( NAME, TYPE ) \
2688 SWIGINTERN int LUA_read_ ## NAME ## _num_array( lua_State * L, int index, TYPE * array, int size ){ \
2689 int i; \
2690 for ( i = 0; i < size; i++ ) { \
2691 lua_rawgeti( L, index, i + 1 ); \
2692 if ( lua_isnumber( L, -1 ) ) { \
2693 array[i] = (TYPE) lua_tonumber( L, -1 ); \
2694 } else { \
2695 lua_pop( L, 1 ); \
2696 return 0; \
2697 } \
2698 lua_pop( L, 1 ); \
2699 } \
2700 return 1; \
2701 } \
2702 SWIGINTERN TYPE* LUA_get_ ## NAME ## _num_array_var( lua_State * L, int index, int* size ) \
2703 { \
2704 TYPE *array; \
2705 if ( !lua_istable( L, index ) ) { \
2706 lua_pushstring( L, "expected a table" ); \
2707 return 0; \
2708 } \
2709 *size = SWIG_itable_size( L, index ); \
2710 if ( *size < 1 ) { \
2711 array = LUA_ALLOC_ARRAY( TYPE, 1 ); \
2712 array[0] = (TYPE) 0; \
2713 return array; \
2714 } \
2715 array = LUA_ALLOC_ARRAY( TYPE, *size ); \
2716 if ( !LUA_read_ ## NAME ## _num_array( L, index, array, *size ) ) { \
2717 lua_pushstring( L, "table must contain numbers" ); \
2718 LUA_FREE_ARRAY( array ); \
2719 return 0; \
2720 } \
2721 return array; \
2722 }
2723
2724 LUA_DECLARE_TYPEMAP_ARR_FN( double, double );
2725 LUA_DECLARE_TYPEMAP_ARR_FN( int, int );
2726
2727
2728 static PLINT Alen = 0;
2729 static PLINT Xlen = 0, Ylen = 0;
2730
2731
2732 #ifdef __cplusplus /* generic alloc/dealloc fns*/
2733 #define SWIG_ALLOC_ARRAY(TYPE,LEN) new TYPE[LEN]
2734 #define SWIG_FREE_ARRAY(PTR) delete[] PTR
2735 #else
2736 #define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE))
2737 #define SWIG_FREE_ARRAY(PTR) free(PTR)
2738 #endif
2739 /* counting the size of arrays:*/
2740 SWIGINTERN int SWIG_itable_size(lua_State* L, int index)
2741 {
2742 int n=0;
2743 while(1){
2744 lua_rawgeti(L,index,n+1);
2745 if (lua_isnil(L,-1))break;
2746 ++n;
2747 lua_pop(L,1);
2748 }
2749 lua_pop(L,1);
2750 return n;
2751 }
2752
2753 SWIGINTERN int SWIG_table_size(lua_State* L, int index)
2754 {
2755 int n=0;
2756 lua_pushnil(L); /* first key*/
2757 while (lua_next(L, index) != 0) {
2758 ++n;
2759 lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/
2760 }
2761 return n;
2762 }
2763
2764 /* super macro to declare array typemap helper fns */
2765 #define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\
2766 SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\
2767 int i;\
2768 for (i = 0; i < size; i++) {\
2769 lua_rawgeti(L,index,i+1);\
2770 if (lua_isnumber(L,-1)){\
2771 array[i] = (TYPE)lua_tonumber(L,-1);\
2772 } else {\
2773 lua_pop(L,1);\
2774 return 0;\
2775 }\
2776 lua_pop(L,1);\
2777 }\
2778 return 1;\
2779 }\
2780 SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\
2781 TYPE *array;\
2782 if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\
2783 SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\
2784 return 0;\
2785 }\
2786 array=SWIG_ALLOC_ARRAY(TYPE,size);\
2787 if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\
2788 SWIG_Lua_pusherrstring(L,"table must contain numbers");\
2789 SWIG_FREE_ARRAY(array);\
2790 return 0;\
2791 }\
2792 return array;\
2793 }\
2794 SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\
2795 {\
2796 TYPE *array;\
2797 if (!lua_istable(L,index)) {\
2798 SWIG_Lua_pusherrstring(L,"expected a table");\
2799 return 0;\
2800 }\
2801 *size=SWIG_itable_size(L,index);\
2802 if (*size<1){\
2803 SWIG_Lua_pusherrstring(L,"table appears to be empty");\
2804 return 0;\
2805 }\
2806 array=SWIG_ALLOC_ARRAY(TYPE,*size);\
2807 if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\
2808 SWIG_Lua_pusherrstring(L,"table must contain numbers");\
2809 SWIG_FREE_ARRAY(array);\
2810 return 0;\
2811 }\
2812 return array;\
2813 }\
2814 SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\
2815 int i;\
2816 lua_newtable(L);\
2817 for (i = 0; i < size; i++){\
2818 lua_pushnumber(L,(lua_Number)array[i]);\
2819 lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \
2820 }\
2821 }
2822
2823 SWIG_DECLARE_TYPEMAP_ARR_FN(schar,signed char)
2824 SWIG_DECLARE_TYPEMAP_ARR_FN(uchar,unsigned char)
2825 SWIG_DECLARE_TYPEMAP_ARR_FN(int,int)
2826 SWIG_DECLARE_TYPEMAP_ARR_FN(uint,unsigned int)
2827 SWIG_DECLARE_TYPEMAP_ARR_FN(short,short)
2828 SWIG_DECLARE_TYPEMAP_ARR_FN(ushort,unsigned short)
2829 SWIG_DECLARE_TYPEMAP_ARR_FN(long,long)
2830 SWIG_DECLARE_TYPEMAP_ARR_FN(ulong,unsigned long)
2831 SWIG_DECLARE_TYPEMAP_ARR_FN(float,float)
2832 SWIG_DECLARE_TYPEMAP_ARR_FN(double,double)
2833
2834 SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){
2835 int i;
2836 for (i = 0; i < size; i++) {
2837 lua_rawgeti(L,index,i+1);
2838 if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){
2839 lua_pop(L,1);
2840 return 0;
2841 }
2842 lua_pop(L,1);
2843 }
2844 return 1;
2845 }
2846 SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){
2847 void **array;
2848 if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {
2849 SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);
2850 return 0;
2851 }
2852 array=SWIG_ALLOC_ARRAY(void*,size);
2853 if (!SWIG_read_ptr_array(L,index,array,size,type)){
2854 SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
2855 SWIG_FREE_ARRAY(array);
2856 return 0;
2857 }
2858 return array;
2859 }
2860 SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){
2861 void **array;
2862 if (!lua_istable(L,index)) {
2863 SWIG_Lua_pusherrstring(L,"expected a table");
2864 return 0;
2865 }
2866 *size=SWIG_itable_size(L,index);
2867 if (*size<1){
2868 SWIG_Lua_pusherrstring(L,"table appears to be empty");
2869 return 0;
2870 }
2871 array=SWIG_ALLOC_ARRAY(void*,*size);
2872 if (!SWIG_read_ptr_array(L,index,array,*size,type)){
2873 SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
2874 SWIG_FREE_ARRAY(array);
2875 return 0;
2876 }
2877 return array;
2878 }
2879 SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){
2880 int i;
2881 lua_newtable(L);
2882 for (i = 0; i < size; i++){
2883 SWIG_NewPointerObj(L,array[i],type,own);
2884 lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/
2885 }
2886 }
2887
2888
2889 PLFLT** read_double_Matrix( lua_State* L, int index, int* nx, int *ny );
2890
2891 PLFLT** read_double_Matrix( lua_State* L, int index, int* nx, int *ny )
2892 {
2893 int i, j;
2894 PLFLT** matrix;
2895
2896 *nx = 0;
2897 *ny = 0;
2898
2899 if ( !lua_istable( L, index ) )
2900 {
2901 lua_pushstring( L, "expected a table" );
2902 return NULL;
2903 }
2904 *nx = SWIG_itable_size( L, index );
2905 if ( *nx < 1 )
2906 {
2907 lua_pushstring( L, "table appears to be empty" );
2908 return NULL;
2909 }
2910 matrix = LUA_ALLOC_ARRAY( PLFLT *, *nx );
2911 for ( i = 0; i < *nx; i++ )
2912 matrix[i] = NULL;
2913
2914 lua_rawgeti( L, index, 1 );
2915 if ( !lua_istable( L, -1 ) )
2916 {
2917 lua_pop( L, 1 );
2918 lua_pushstring( L, "expected a table" );
2919 LUA_FREE_ARRAY( matrix );
2920 return NULL;
2921 }
2922 *ny = SWIG_itable_size( L, -1 );
2923 if ( *ny < 1 )
2924 {
2925 lua_pushstring( L, "table appears to be empty" );
2926 LUA_FREE_ARRAY( matrix );
2927 return NULL;
2928 }
2929 lua_pop( L, 1 );
2930
2931 for ( i = 0; i < *nx; i++ )
2932 {
2933 lua_rawgeti( L, index, i + 1 );
2934 if ( !lua_istable( L, -1 ) )
2935 {
2936 lua_pop( L, 1 );
2937 lua_pushstring( L, "expected a table" );
2938 for ( j = 0; j < *ny; j++ )
2939 LUA_FREE_ARRAY( matrix[j] );
2940 LUA_FREE_ARRAY( matrix );
2941 return NULL;
2942 }
2943 if ( *ny != SWIG_itable_size( L, -1 ) )
2944 {
2945 lua_pop( L, 1 );
2946 lua_pushstring( L, "inconsistent table sizes" );
2947 for ( j = 0; j < i; j++ )
2948 LUA_FREE_ARRAY( matrix[j] );
2949 LUA_FREE_ARRAY( matrix );
2950 return NULL;
2951 }
2952 matrix[i] = LUA_ALLOC_ARRAY( PLFLT, *ny );
2953 for ( j = 0; j < *ny; j++ )
2954 {
2955 lua_rawgeti( L, -1, j + 1 );
2956 if ( lua_isnumber( L, -1 ) )
2957 {
2958 matrix[i][j] = (PLFLT) lua_tonumber( L, -1 );
2959 }
2960 else
2961 {
2962 lua_pop( L, 1 );
2963 lua_pushstring( L, "table must contain numbers" );
2964 for ( j = 0; j < i + 1; j++ )
2965 LUA_FREE_ARRAY( matrix[j] );
2966 LUA_FREE_ARRAY( matrix );
2967 return NULL;
2968 }
2969 lua_pop( L, 1 );
2970 }
2971 lua_pop( L, 1 );
2972 }
2973
2974 return matrix;
2975 }
2976
2977
2978 void mapform( PLINT n, PLFLT* x, PLFLT* y );
2979
2980 static lua_State* myL = NULL;
2981 static char mapform_funcstr[255];
2982
2983 void mapform( PLINT n, PLFLT* x, PLFLT* y )
2984 {
2985 PLFLT *xtemp, *ytemp;
2986 int len, i;
2987
2988 // check Lua state
2989 if ( myL == NULL )
2990 {
2991 fprintf( stderr, "Lua state is not set!" );
2992 return;
2993 }
2994
2995 // push functions and arguments
2996 lua_getglobal( myL, mapform_funcstr ); // function to be called
2997 lua_pushnumber( myL, n ); // push 1st argument
2998 SWIG_write_double_num_array( myL, x, n ); // push 2nd argument
2999 SWIG_write_double_num_array( myL, y, n ); // push 3rd argument
3000
3001 // do the call (3 arguments, 2 result)
3002 if ( lua_pcall( myL, 3, 2, 0 ) != 0 )
3003 fprintf( stderr, "error running function `%s':%s",
3004 mapform_funcstr, lua_tostring( myL, -1 ) );
3005
3006 // retrieve results
3007 if ( !lua_istable( myL, -2 ) )
3008 {
3009 fprintf( stderr, "function `%s' must return a table as 1st result", mapform_funcstr );
3010 return;
3011 }
3012 if ( !lua_istable( myL, -1 ) )
3013 {
3014 fprintf( stderr, "function `%s' must return a table as 2nd result", mapform_funcstr );
3015 return;
3016 }
3017 xtemp = (PLFLT *) LUA_get_double_num_array_var( myL, -2, &len );
3018 if ( !xtemp || len != n )
3019 {
3020 fprintf( stderr, "function `%s' must return a table of length%d", mapform_funcstr, n );
3021 return;
3022 }
3023 for ( i = 0; i < n; i++ )
3024 x[i] = xtemp[i];
3025 LUA_FREE_ARRAY( xtemp );
3026
3027 ytemp = (PLFLT *) LUA_get_double_num_array_var( myL, -1, &len );
3028 if ( !ytemp || len != n )
3029 {
3030 fprintf( stderr, "function `%s' must return a table of length%d", mapform_funcstr, n );
3031 return;
3032 }
3033 for ( i = 0; i < n; i++ )
3034 y[i] = ytemp[i];
3035 LUA_FREE_ARRAY( ytemp );
3036
3037 lua_pop( myL, 2 ); // pop returned values
3038
3039 return;
3040 }
3041
3042
3043 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3044 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3045 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3046 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3047 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3048 typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
3049 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
3050
3051 // Function prototypes
3052 void mypltr( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void * pltr_data );
3053 void myct( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void * pltr_data );
3054 void mylabel( PLINT axis, PLFLT value, char* label, PLINT length, PLPointer data );
3055
3056 static char mypltr_funcstr[255];
3057
3058 // This is the callback that gets handed to the C code.
3059 // It, in turn, calls the Lua callback
3060 void mypltr( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void * PL_UNUSED( pltr_data ) )
3061 {
3062 *tx = 0;
3063 *ty = 0;
3064
3065 // check Lua state
3066 if ( myL == NULL )
3067 {
3068 fprintf( stderr, "Lua state is not set!" );
3069 return;
3070 }
3071
3072 // push functions and arguments
3073 lua_getglobal( myL, mypltr_funcstr ); // function to be called
3074 lua_pushnumber( myL, x ); // push 1st argument
3075 lua_pushnumber( myL, y ); // push 2nd argument
3076
3077 // do the call (2 arguments, 2 result)
3078 if ( lua_pcall( myL, 2, 2, 0 ) != 0 )
3079 fprintf( stderr, "error running function `%s':%s",
3080 mypltr_funcstr, lua_tostring( myL, -1 ) );
3081
3082 // retrieve results
3083 if ( !lua_isnumber( myL, -2 ) )
3084 {
3085 fprintf( stderr, "function `%s' must return a number as 1st result", mypltr_funcstr );
3086 return;
3087 }
3088 if ( !lua_isnumber( myL, -1 ) )
3089 {
3090 fprintf( stderr, "function `%s' must return a number as 2nd result", mypltr_funcstr );
3091 return;
3092 }
3093 *tx = lua_tonumber( myL, -2 );
3094 *ty = lua_tonumber( myL, -1 );
3095 lua_pop( myL, 2 ); // pop returned values
3096
3097 return;
3098 }
3099
3100 static char myct_funcstr[255];
3101
3102 // This is the callback that gets handed to the C code.
3103 // It, in turn, calls the Lua callback
3104 void myct( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void * PL_UNUSED( pltr_data ) )
3105 {
3106 *tx = 0;
3107 *ty = 0;
3108
3109 // check Lua state
3110 if ( myL == NULL )
3111 {
3112 fprintf( stderr, "Lua state is not set!" );
3113 return;
3114 }
3115
3116 // push functions and arguments
3117 lua_getglobal( myL, myct_funcstr ); // function to be called
3118 lua_pushnumber( myL, x ); // push 1st argument
3119 lua_pushnumber( myL, y ); // push 2nd argument
3120
3121 // do the call (2 arguments, 2 result)
3122 if ( lua_pcall( myL, 2, 2, 0 ) != 0 )
3123 fprintf( stderr, "error running function `%s':%s",
3124 myct_funcstr, lua_tostring( myL, -1 ) );
3125
3126 // retrieve results
3127 if ( !lua_isnumber( myL, -2 ) )
3128 {
3129 fprintf( stderr, "function `%s' must return a number as 1st result", myct_funcstr );
3130 return;
3131 }
3132 if ( !lua_isnumber( myL, -1 ) )
3133 {
3134 fprintf( stderr, "function `%s' must return a number as 2nd result", myct_funcstr );
3135 return;
3136 }
3137 *tx = lua_tonumber( myL, -2 );
3138 *ty = lua_tonumber( myL, -1 );
3139 lua_pop( myL, 2 ); // pop returned values
3140
3141 return;
3142 }
3143
3144 static char mylabel_funcstr[255];
3145
3146 void mylabel( PLINT axis, PLFLT value, char* label, PLINT length, PLPointer PL_UNUSED( data ) )
3147 {
3148 // check Lua state
3149 if ( myL == NULL )
3150 {
3151 fprintf( stderr, "Lua state is not set!" );
3152 return;
3153 }
3154
3155 // push functions and arguments
3156 lua_getglobal( myL, mylabel_funcstr ); // function to be called
3157 lua_pushnumber( myL, axis ); // push 1st argument
3158 lua_pushnumber( myL, value ); // push 1st argument
3159
3160 // do the call (2 arguments, 1 result)
3161 if ( lua_pcall( myL, 2, 1, 0 ) != 0 )
3162 fprintf( stderr, "error running function `%s':%s",
3163 mylabel_funcstr, lua_tostring( myL, -1 ) );
3164
3165 // retrieve results
3166 if ( !lua_isstring( myL, -1 ) )
3167 {
3168 fprintf( stderr, "function `%s' must return a string as result", mylabel_funcstr );
3169 return;
3170 }
3171 strncpy( label, lua_tostring( myL, -1 ), length );
3172
3173 lua_pop( myL, 1 ); // pop returned values
3174
3175 return;
3176 }
3177
3178
3179 SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
3180 int ret = lua_isstring(L, idx);
3181 if (!ret)
3182 ret = lua_isnil(L, idx);
3183 return ret;
3184 }
3185
3186 #ifdef __cplusplus
3187 extern "C" {
3188 #endif
3189 static int _wrap_PLGraphicsIn_type_set(lua_State* L) {
3190 int SWIG_arg = 0;
3191 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3192 int arg2 ;
3193
3194 SWIG_check_num_args("PLGraphicsIn::type",2,2)
3195 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::type",1,"PLGraphicsIn *");
3196 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::type",2,"int");
3197
3198 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3199 SWIG_fail_ptr("PLGraphicsIn_type_set",1,SWIGTYPE_p_PLGraphicsIn);
3200 }
3201
3202 arg2 = (int)lua_tonumber(L, 2);
3203 if (arg1) (arg1)->type = arg2;
3204
3205 return SWIG_arg;
3206
3207 if(0) SWIG_fail;
3208
3209 fail:
3210 lua_error(L);
3211 return SWIG_arg;
3212 }
3213
3214
3215 static int _wrap_PLGraphicsIn_type_get(lua_State* L) {
3216 int SWIG_arg = 0;
3217 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3218 int result;
3219
3220 SWIG_check_num_args("PLGraphicsIn::type",1,1)
3221 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::type",1,"PLGraphicsIn *");
3222
3223 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3224 SWIG_fail_ptr("PLGraphicsIn_type_get",1,SWIGTYPE_p_PLGraphicsIn);
3225 }
3226
3227 result = (int) ((arg1)->type);
3228 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3229 return SWIG_arg;
3230
3231 if(0) SWIG_fail;
3232
3233 fail:
3234 lua_error(L);
3235 return SWIG_arg;
3236 }
3237
3238
3239 static int _wrap_PLGraphicsIn_state_set(lua_State* L) {
3240 int SWIG_arg = 0;
3241 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3242 unsigned int arg2 ;
3243
3244 SWIG_check_num_args("PLGraphicsIn::state",2,2)
3245 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::state",1,"PLGraphicsIn *");
3246 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::state",2,"unsigned int");
3247
3248 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3249 SWIG_fail_ptr("PLGraphicsIn_state_set",1,SWIGTYPE_p_PLGraphicsIn);
3250 }
3251
3252 SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
3253 arg2 = (unsigned int)lua_tonumber(L, 2);
3254 if (arg1) (arg1)->state = arg2;
3255
3256 return SWIG_arg;
3257
3258 if(0) SWIG_fail;
3259
3260 fail:
3261 lua_error(L);
3262 return SWIG_arg;
3263 }
3264
3265
3266 static int _wrap_PLGraphicsIn_state_get(lua_State* L) {
3267 int SWIG_arg = 0;
3268 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3269 unsigned int result;
3270
3271 SWIG_check_num_args("PLGraphicsIn::state",1,1)
3272 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::state",1,"PLGraphicsIn *");
3273
3274 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3275 SWIG_fail_ptr("PLGraphicsIn_state_get",1,SWIGTYPE_p_PLGraphicsIn);
3276 }
3277
3278 result = (unsigned int) ((arg1)->state);
3279 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3280 return SWIG_arg;
3281
3282 if(0) SWIG_fail;
3283
3284 fail:
3285 lua_error(L);
3286 return SWIG_arg;
3287 }
3288
3289
3290 static int _wrap_PLGraphicsIn_keysym_set(lua_State* L) {
3291 int SWIG_arg = 0;
3292 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3293 unsigned int arg2 ;
3294
3295 SWIG_check_num_args("PLGraphicsIn::keysym",2,2)
3296 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::keysym",1,"PLGraphicsIn *");
3297 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::keysym",2,"unsigned int");
3298
3299 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3300 SWIG_fail_ptr("PLGraphicsIn_keysym_set",1,SWIGTYPE_p_PLGraphicsIn);
3301 }
3302
3303 SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
3304 arg2 = (unsigned int)lua_tonumber(L, 2);
3305 if (arg1) (arg1)->keysym = arg2;
3306
3307 return SWIG_arg;
3308
3309 if(0) SWIG_fail;
3310
3311 fail:
3312 lua_error(L);
3313 return SWIG_arg;
3314 }
3315
3316
3317 static int _wrap_PLGraphicsIn_keysym_get(lua_State* L) {
3318 int SWIG_arg = 0;
3319 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3320 unsigned int result;
3321
3322 SWIG_check_num_args("PLGraphicsIn::keysym",1,1)
3323 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::keysym",1,"PLGraphicsIn *");
3324
3325 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3326 SWIG_fail_ptr("PLGraphicsIn_keysym_get",1,SWIGTYPE_p_PLGraphicsIn);
3327 }
3328
3329 result = (unsigned int) ((arg1)->keysym);
3330 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3331 return SWIG_arg;
3332
3333 if(0) SWIG_fail;
3334
3335 fail:
3336 lua_error(L);
3337 return SWIG_arg;
3338 }
3339
3340
3341 static int _wrap_PLGraphicsIn_button_set(lua_State* L) {
3342 int SWIG_arg = 0;
3343 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3344 unsigned int arg2 ;
3345
3346 SWIG_check_num_args("PLGraphicsIn::button",2,2)
3347 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::button",1,"PLGraphicsIn *");
3348 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::button",2,"unsigned int");
3349
3350 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3351 SWIG_fail_ptr("PLGraphicsIn_button_set",1,SWIGTYPE_p_PLGraphicsIn);
3352 }
3353
3354 SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
3355 arg2 = (unsigned int)lua_tonumber(L, 2);
3356 if (arg1) (arg1)->button = arg2;
3357
3358 return SWIG_arg;
3359
3360 if(0) SWIG_fail;
3361
3362 fail:
3363 lua_error(L);
3364 return SWIG_arg;
3365 }
3366
3367
3368 static int _wrap_PLGraphicsIn_button_get(lua_State* L) {
3369 int SWIG_arg = 0;
3370 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3371 unsigned int result;
3372
3373 SWIG_check_num_args("PLGraphicsIn::button",1,1)
3374 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::button",1,"PLGraphicsIn *");
3375
3376 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3377 SWIG_fail_ptr("PLGraphicsIn_button_get",1,SWIGTYPE_p_PLGraphicsIn);
3378 }
3379
3380 result = (unsigned int) ((arg1)->button);
3381 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3382 return SWIG_arg;
3383
3384 if(0) SWIG_fail;
3385
3386 fail:
3387 lua_error(L);
3388 return SWIG_arg;
3389 }
3390
3391
3392 static int _wrap_PLGraphicsIn_subwindow_set(lua_State* L) {
3393 int SWIG_arg = 0;
3394 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3395 PLINT arg2 ;
3396
3397 SWIG_check_num_args("PLGraphicsIn::subwindow",2,2)
3398 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::subwindow",1,"PLGraphicsIn *");
3399 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::subwindow",2,"PLINT");
3400
3401 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3402 SWIG_fail_ptr("PLGraphicsIn_subwindow_set",1,SWIGTYPE_p_PLGraphicsIn);
3403 }
3404
3405 arg2 = (PLINT)lua_tonumber(L, 2);
3406 if (arg1) (arg1)->subwindow = arg2;
3407
3408 return SWIG_arg;
3409
3410 if(0) SWIG_fail;
3411
3412 fail:
3413 lua_error(L);
3414 return SWIG_arg;
3415 }
3416
3417
3418 static int _wrap_PLGraphicsIn_subwindow_get(lua_State* L) {
3419 int SWIG_arg = 0;
3420 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3421 PLINT result;
3422
3423 SWIG_check_num_args("PLGraphicsIn::subwindow",1,1)
3424 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::subwindow",1,"PLGraphicsIn *");
3425
3426 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3427 SWIG_fail_ptr("PLGraphicsIn_subwindow_get",1,SWIGTYPE_p_PLGraphicsIn);
3428 }
3429
3430 result = (PLINT) ((arg1)->subwindow);
3431 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3432 return SWIG_arg;
3433
3434 if(0) SWIG_fail;
3435
3436 fail:
3437 lua_error(L);
3438 return SWIG_arg;
3439 }
3440
3441
3442 static int _wrap_PLGraphicsIn_string_set(lua_State* L) {
3443 int SWIG_arg = 0;
3444 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3445 char *arg2 ;
3446
3447 SWIG_check_num_args("PLGraphicsIn::string",2,2)
3448 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::string",1,"PLGraphicsIn *");
3449 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("PLGraphicsIn::string",2,"char [16]");
3450
3451 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3452 SWIG_fail_ptr("PLGraphicsIn_string_set",1,SWIGTYPE_p_PLGraphicsIn);
3453 }
3454
3455 arg2 = (char *)lua_tostring(L, 2);
3456 {
3457 if(arg2) {
3458 strncpy((char*)arg1->string, (const char *)arg2, 16-1);
3459 arg1->string[16-1] = 0;
3460 } else {
3461 arg1->string[0] = 0;
3462 }
3463 }
3464
3465 return SWIG_arg;
3466
3467 if(0) SWIG_fail;
3468
3469 fail:
3470 lua_error(L);
3471 return SWIG_arg;
3472 }
3473
3474
3475 static int _wrap_PLGraphicsIn_string_get(lua_State* L) {
3476 int SWIG_arg = 0;
3477 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3478 char *result = 0 ;
3479
3480 SWIG_check_num_args("PLGraphicsIn::string",1,1)
3481 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::string",1,"PLGraphicsIn *");
3482
3483 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3484 SWIG_fail_ptr("PLGraphicsIn_string_get",1,SWIGTYPE_p_PLGraphicsIn);
3485 }
3486
3487 result = (char *)(char *) ((arg1)->string);
3488 lua_pushstring(L,(const char *)result); SWIG_arg++;
3489 return SWIG_arg;
3490
3491 if(0) SWIG_fail;
3492
3493 fail:
3494 lua_error(L);
3495 return SWIG_arg;
3496 }
3497
3498
3499 static int _wrap_PLGraphicsIn_pX_set(lua_State* L) {
3500 int SWIG_arg = 0;
3501 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3502 int arg2 ;
3503
3504 SWIG_check_num_args("PLGraphicsIn::pX",2,2)
3505 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::pX",1,"PLGraphicsIn *");
3506 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::pX",2,"int");
3507
3508 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3509 SWIG_fail_ptr("PLGraphicsIn_pX_set",1,SWIGTYPE_p_PLGraphicsIn);
3510 }
3511
3512 arg2 = (int)lua_tonumber(L, 2);
3513 if (arg1) (arg1)->pX = arg2;
3514
3515 return SWIG_arg;
3516
3517 if(0) SWIG_fail;
3518
3519 fail:
3520 lua_error(L);
3521 return SWIG_arg;
3522 }
3523
3524
3525 static int _wrap_PLGraphicsIn_pX_get(lua_State* L) {
3526 int SWIG_arg = 0;
3527 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3528 int result;
3529
3530 SWIG_check_num_args("PLGraphicsIn::pX",1,1)
3531 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::pX",1,"PLGraphicsIn *");
3532
3533 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3534 SWIG_fail_ptr("PLGraphicsIn_pX_get",1,SWIGTYPE_p_PLGraphicsIn);
3535 }
3536
3537 result = (int) ((arg1)->pX);
3538 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3539 return SWIG_arg;
3540
3541 if(0) SWIG_fail;
3542
3543 fail:
3544 lua_error(L);
3545 return SWIG_arg;
3546 }
3547
3548
3549 static int _wrap_PLGraphicsIn_pY_set(lua_State* L) {
3550 int SWIG_arg = 0;
3551 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3552 int arg2 ;
3553
3554 SWIG_check_num_args("PLGraphicsIn::pY",2,2)
3555 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::pY",1,"PLGraphicsIn *");
3556 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::pY",2,"int");
3557
3558 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3559 SWIG_fail_ptr("PLGraphicsIn_pY_set",1,SWIGTYPE_p_PLGraphicsIn);
3560 }
3561
3562 arg2 = (int)lua_tonumber(L, 2);
3563 if (arg1) (arg1)->pY = arg2;
3564
3565 return SWIG_arg;
3566
3567 if(0) SWIG_fail;
3568
3569 fail:
3570 lua_error(L);
3571 return SWIG_arg;
3572 }
3573
3574
3575 static int _wrap_PLGraphicsIn_pY_get(lua_State* L) {
3576 int SWIG_arg = 0;
3577 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3578 int result;
3579
3580 SWIG_check_num_args("PLGraphicsIn::pY",1,1)
3581 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::pY",1,"PLGraphicsIn *");
3582
3583 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3584 SWIG_fail_ptr("PLGraphicsIn_pY_get",1,SWIGTYPE_p_PLGraphicsIn);
3585 }
3586
3587 result = (int) ((arg1)->pY);
3588 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3589 return SWIG_arg;
3590
3591 if(0) SWIG_fail;
3592
3593 fail:
3594 lua_error(L);
3595 return SWIG_arg;
3596 }
3597
3598
3599 static int _wrap_PLGraphicsIn_dX_set(lua_State* L) {
3600 int SWIG_arg = 0;
3601 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3602 PLFLT arg2 ;
3603
3604 SWIG_check_num_args("PLGraphicsIn::dX",2,2)
3605 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::dX",1,"PLGraphicsIn *");
3606 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::dX",2,"PLFLT");
3607
3608 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3609 SWIG_fail_ptr("PLGraphicsIn_dX_set",1,SWIGTYPE_p_PLGraphicsIn);
3610 }
3611
3612 arg2 = (PLFLT)lua_tonumber(L, 2);
3613 if (arg1) (arg1)->dX = arg2;
3614
3615 return SWIG_arg;
3616
3617 if(0) SWIG_fail;
3618
3619 fail:
3620 lua_error(L);
3621 return SWIG_arg;
3622 }
3623
3624
3625 static int _wrap_PLGraphicsIn_dX_get(lua_State* L) {
3626 int SWIG_arg = 0;
3627 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3628 PLFLT result;
3629
3630 SWIG_check_num_args("PLGraphicsIn::dX",1,1)
3631 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::dX",1,"PLGraphicsIn *");
3632
3633 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3634 SWIG_fail_ptr("PLGraphicsIn_dX_get",1,SWIGTYPE_p_PLGraphicsIn);
3635 }
3636
3637 result = (PLFLT) ((arg1)->dX);
3638 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3639 return SWIG_arg;
3640
3641 if(0) SWIG_fail;
3642
3643 fail:
3644 lua_error(L);
3645 return SWIG_arg;
3646 }
3647
3648
3649 static int _wrap_PLGraphicsIn_dY_set(lua_State* L) {
3650 int SWIG_arg = 0;
3651 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3652 PLFLT arg2 ;
3653
3654 SWIG_check_num_args("PLGraphicsIn::dY",2,2)
3655 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::dY",1,"PLGraphicsIn *");
3656 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::dY",2,"PLFLT");
3657
3658 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3659 SWIG_fail_ptr("PLGraphicsIn_dY_set",1,SWIGTYPE_p_PLGraphicsIn);
3660 }
3661
3662 arg2 = (PLFLT)lua_tonumber(L, 2);
3663 if (arg1) (arg1)->dY = arg2;
3664
3665 return SWIG_arg;
3666
3667 if(0) SWIG_fail;
3668
3669 fail:
3670 lua_error(L);
3671 return SWIG_arg;
3672 }
3673
3674
3675 static int _wrap_PLGraphicsIn_dY_get(lua_State* L) {
3676 int SWIG_arg = 0;
3677 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3678 PLFLT result;
3679
3680 SWIG_check_num_args("PLGraphicsIn::dY",1,1)
3681 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::dY",1,"PLGraphicsIn *");
3682
3683 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3684 SWIG_fail_ptr("PLGraphicsIn_dY_get",1,SWIGTYPE_p_PLGraphicsIn);
3685 }
3686
3687 result = (PLFLT) ((arg1)->dY);
3688 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3689 return SWIG_arg;
3690
3691 if(0) SWIG_fail;
3692
3693 fail:
3694 lua_error(L);
3695 return SWIG_arg;
3696 }
3697
3698
3699 static int _wrap_PLGraphicsIn_wX_set(lua_State* L) {
3700 int SWIG_arg = 0;
3701 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3702 PLFLT arg2 ;
3703
3704 SWIG_check_num_args("PLGraphicsIn::wX",2,2)
3705 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::wX",1,"PLGraphicsIn *");
3706 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::wX",2,"PLFLT");
3707
3708 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3709 SWIG_fail_ptr("PLGraphicsIn_wX_set",1,SWIGTYPE_p_PLGraphicsIn);
3710 }
3711
3712 arg2 = (PLFLT)lua_tonumber(L, 2);
3713 if (arg1) (arg1)->wX = arg2;
3714
3715 return SWIG_arg;
3716
3717 if(0) SWIG_fail;
3718
3719 fail:
3720 lua_error(L);
3721 return SWIG_arg;
3722 }
3723
3724
3725 static int _wrap_PLGraphicsIn_wX_get(lua_State* L) {
3726 int SWIG_arg = 0;
3727 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3728 PLFLT result;
3729
3730 SWIG_check_num_args("PLGraphicsIn::wX",1,1)
3731 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::wX",1,"PLGraphicsIn *");
3732
3733 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3734 SWIG_fail_ptr("PLGraphicsIn_wX_get",1,SWIGTYPE_p_PLGraphicsIn);
3735 }
3736
3737 result = (PLFLT) ((arg1)->wX);
3738 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3739 return SWIG_arg;
3740
3741 if(0) SWIG_fail;
3742
3743 fail:
3744 lua_error(L);
3745 return SWIG_arg;
3746 }
3747
3748
3749 static int _wrap_PLGraphicsIn_wY_set(lua_State* L) {
3750 int SWIG_arg = 0;
3751 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3752 PLFLT arg2 ;
3753
3754 SWIG_check_num_args("PLGraphicsIn::wY",2,2)
3755 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::wY",1,"PLGraphicsIn *");
3756 if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::wY",2,"PLFLT");
3757
3758 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3759 SWIG_fail_ptr("PLGraphicsIn_wY_set",1,SWIGTYPE_p_PLGraphicsIn);
3760 }
3761
3762 arg2 = (PLFLT)lua_tonumber(L, 2);
3763 if (arg1) (arg1)->wY = arg2;
3764
3765 return SWIG_arg;
3766
3767 if(0) SWIG_fail;
3768
3769 fail:
3770 lua_error(L);
3771 return SWIG_arg;
3772 }
3773
3774
3775 static int _wrap_PLGraphicsIn_wY_get(lua_State* L) {
3776 int SWIG_arg = 0;
3777 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3778 PLFLT result;
3779
3780 SWIG_check_num_args("PLGraphicsIn::wY",1,1)
3781 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::wY",1,"PLGraphicsIn *");
3782
3783 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3784 SWIG_fail_ptr("PLGraphicsIn_wY_get",1,SWIGTYPE_p_PLGraphicsIn);
3785 }
3786
3787 result = (PLFLT) ((arg1)->wY);
3788 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3789 return SWIG_arg;
3790
3791 if(0) SWIG_fail;
3792
3793 fail:
3794 lua_error(L);
3795 return SWIG_arg;
3796 }
3797
3798
3799 static int _wrap_new_PLGraphicsIn(lua_State* L) {
3800 int SWIG_arg = 0;
3801 PLGraphicsIn *result = 0 ;
3802
3803 SWIG_check_num_args("PLGraphicsIn::PLGraphicsIn",0,0)
3804 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
3805 SWIG_NewPointerObj(L,result,SWIGTYPE_p_PLGraphicsIn,1); SWIG_arg++;
3806 return SWIG_arg;
3807
3808 if(0) SWIG_fail;
3809
3810 fail:
3811 lua_error(L);
3812 return SWIG_arg;
3813 }
3814
3815
3816 static void swig_delete_PLGraphicsIn(void *obj) {
3817 PLGraphicsIn *arg1 = (PLGraphicsIn *) obj;
3818 free((char *) arg1);
3819 }
3820 static int _proxy__wrap_new_PLGraphicsIn(lua_State *L) {
3821 assert(lua_istable(L,1));
3822 lua_pushcfunction(L,_wrap_new_PLGraphicsIn);
3823 assert(!lua_isnil(L,-1));
3824 lua_replace(L,1); /* replace our table with real constructor */
3825 lua_call(L,lua_gettop(L)-1,1);
3826 return 1;
3827 }
3828 static swig_lua_attribute swig_PLGraphicsIn_attributes[] = {
3829 { "type", _wrap_PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_set },
3830 { "state", _wrap_PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_set },
3831 { "keysym", _wrap_PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_set },
3832 { "button", _wrap_PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_set },
3833 { "subwindow", _wrap_PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_set },
3834 { "string", _wrap_PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_set },
3835 { "pX", _wrap_PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_set },
3836 { "pY", _wrap_PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_set },
3837 { "dX", _wrap_PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_set },
3838 { "dY", _wrap_PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_set },
3839 { "wX", _wrap_PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_set },
3840 { "wY", _wrap_PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_set },
3841 {0,0,0}
3842 };
3843 static swig_lua_method swig_PLGraphicsIn_methods[]= {
3844 {0,0}
3845 };
3846 static swig_lua_method swig_PLGraphicsIn_meta[] = {
3847 {0,0}
3848 };
3849
3850 static swig_lua_attribute swig_PLGraphicsIn_Sf_SwigStatic_attributes[] = {
3851 {0,0,0}
3852 };
3853 static swig_lua_const_info swig_PLGraphicsIn_Sf_SwigStatic_constants[]= {
3854 {0,0,0,0,0,0}
3855 };
3856 static swig_lua_method swig_PLGraphicsIn_Sf_SwigStatic_methods[]= {
3857 {0,0}
3858 };
3859 static swig_lua_class* swig_PLGraphicsIn_Sf_SwigStatic_classes[]= {
3860 0
3861 };
3862
3863 static swig_lua_namespace swig_PLGraphicsIn_Sf_SwigStatic = {
3864 "PLGraphicsIn",
3865 swig_PLGraphicsIn_Sf_SwigStatic_methods,
3866 swig_PLGraphicsIn_Sf_SwigStatic_attributes,
3867 swig_PLGraphicsIn_Sf_SwigStatic_constants,
3868 swig_PLGraphicsIn_Sf_SwigStatic_classes,
3869 0
3870 };
3871 static swig_lua_class *swig_PLGraphicsIn_bases[] = {0};
3872 static const char *swig_PLGraphicsIn_base_names[] = {0};
3873 static swig_lua_class _wrap_class_PLGraphicsIn = { "PLGraphicsIn", "PLGraphicsIn", &SWIGTYPE_p_PLGraphicsIn,_proxy__wrap_new_PLGraphicsIn, swig_delete_PLGraphicsIn, swig_PLGraphicsIn_methods, swig_PLGraphicsIn_attributes, &swig_PLGraphicsIn_Sf_SwigStatic, swig_PLGraphicsIn_meta, swig_PLGraphicsIn_bases, swig_PLGraphicsIn_base_names };
3874
3875 static int _wrap_setcontlabelformat(lua_State* L) {
3876 int SWIG_arg = 0;
3877 PLINT arg1 ;
3878 PLINT arg2 ;
3879
3880 SWIG_check_num_args("pl_setcontlabelformat",2,2)
3881 if(!lua_isnumber(L,1)) SWIG_fail_arg("pl_setcontlabelformat",1,"PLINT");
3882 if(!lua_isnumber(L,2)) SWIG_fail_arg("pl_setcontlabelformat",2,"PLINT");
3883 arg1 = (PLINT)lua_tonumber(L, 1);
3884 arg2 = (PLINT)lua_tonumber(L, 2);
3885 pl_setcontlabelformat(arg1,arg2);
3886
3887 return SWIG_arg;
3888
3889 if(0) SWIG_fail;
3890
3891 fail:
3892 lua_error(L);
3893 return SWIG_arg;
3894 }
3895
3896
3897 static int _wrap_setcontlabelparam(lua_State* L) {
3898 int SWIG_arg = 0;
3899 PLFLT arg1 ;
3900 PLFLT arg2 ;
3901 PLFLT arg3 ;
3902 PLINT arg4 ;
3903
3904 SWIG_check_num_args("pl_setcontlabelparam",4,4)
3905 if(!lua_isnumber(L,1)) SWIG_fail_arg("pl_setcontlabelparam",1,"PLFLT");
3906 if(!lua_isnumber(L,2)) SWIG_fail_arg("pl_setcontlabelparam",2,"PLFLT");
3907 if(!lua_isnumber(L,3)) SWIG_fail_arg("pl_setcontlabelparam",3,"PLFLT");
3908 if(!lua_isnumber(L,4)) SWIG_fail_arg("pl_setcontlabelparam",4,"PLINT");
3909 arg1 = (PLFLT)lua_tonumber(L, 1);
3910 arg2 = (PLFLT)lua_tonumber(L, 2);
3911 arg3 = (PLFLT)lua_tonumber(L, 3);
3912 arg4 = (PLINT)lua_tonumber(L, 4);
3913 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
3914
3915 return SWIG_arg;
3916
3917 if(0) SWIG_fail;
3918
3919 fail:
3920 lua_error(L);
3921 return SWIG_arg;
3922 }
3923
3924
3925 static int _wrap_adv(lua_State* L) {
3926 int SWIG_arg = 0;
3927 PLINT arg1 ;
3928
3929 SWIG_check_num_args("pladv",1,1)
3930 if(!lua_isnumber(L,1)) SWIG_fail_arg("pladv",1,"PLINT");
3931 arg1 = (PLINT)lua_tonumber(L, 1);
3932 pladv(arg1);
3933
3934 return SWIG_arg;
3935
3936 if(0) SWIG_fail;
3937
3938 fail:
3939 lua_error(L);
3940 return SWIG_arg;
3941 }
3942
3943
3944 static int _wrap_arc(lua_State* L) {
3945 int SWIG_arg = 0;
3946 PLFLT arg1 ;
3947 PLFLT arg2 ;
3948 PLFLT arg3 ;
3949 PLFLT arg4 ;
3950 PLFLT arg5 ;
3951 PLFLT arg6 ;
3952 PLFLT arg7 ;
3953 PLBOOL arg8 ;
3954
3955 SWIG_check_num_args("plarc",8,8)
3956 if(!lua_isnumber(L,1)) SWIG_fail_arg("plarc",1,"PLFLT");
3957 if(!lua_isnumber(L,2)) SWIG_fail_arg("plarc",2,"PLFLT");
3958 if(!lua_isnumber(L,3)) SWIG_fail_arg("plarc",3,"PLFLT");
3959 if(!lua_isnumber(L,4)) SWIG_fail_arg("plarc",4,"PLFLT");
3960 if(!lua_isnumber(L,5)) SWIG_fail_arg("plarc",5,"PLFLT");
3961 if(!lua_isnumber(L,6)) SWIG_fail_arg("plarc",6,"PLFLT");
3962 if(!lua_isnumber(L,7)) SWIG_fail_arg("plarc",7,"PLFLT");
3963 if(!lua_isnumber(L,8)) SWIG_fail_arg("plarc",8,"PLBOOL");
3964 arg1 = (PLFLT)lua_tonumber(L, 1);
3965 arg2 = (PLFLT)lua_tonumber(L, 2);
3966 arg3 = (PLFLT)lua_tonumber(L, 3);
3967 arg4 = (PLFLT)lua_tonumber(L, 4);
3968 arg5 = (PLFLT)lua_tonumber(L, 5);
3969 arg6 = (PLFLT)lua_tonumber(L, 6);
3970 arg7 = (PLFLT)lua_tonumber(L, 7);
3971 arg8 = (PLBOOL)lua_tonumber(L, 8);
3972 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3973
3974 return SWIG_arg;
3975
3976 if(0) SWIG_fail;
3977
3978 fail:
3979 lua_error(L);
3980 return SWIG_arg;
3981 }
3982
3983
3984 static int _wrap_axes(lua_State* L) {
3985 int SWIG_arg = 0;
3986 PLFLT arg1 ;
3987 PLFLT arg2 ;
3988 char *arg3 = (char *) 0 ;
3989 PLFLT arg4 ;
3990 PLINT arg5 ;
3991 char *arg6 = (char *) 0 ;
3992 PLFLT arg7 ;
3993 PLINT arg8 ;
3994
3995 SWIG_check_num_args("plaxes",8,8)
3996 if(!lua_isnumber(L,1)) SWIG_fail_arg("plaxes",1,"PLFLT");
3997 if(!lua_isnumber(L,2)) SWIG_fail_arg("plaxes",2,"PLFLT");
3998 if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("plaxes",3,"char const *");
3999 if(!lua_isnumber(L,4)) SWIG_fail_arg("plaxes",4,"PLFLT");
4000 if(!lua_isnumber(L,5)) SWIG_fail_arg("plaxes",5,"PLINT");
4001 if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("plaxes",6,"char const *");
4002 if(!lua_isnumber(L,7)) SWIG_fail_arg("plaxes",7,"PLFLT");
4003 if(!lua_isnumber(L,8)) SWIG_fail_arg("plaxes",8,"PLINT");
4004 arg1 = (PLFLT)lua_tonumber(L, 1);
4005 arg2 = (PLFLT)lua_tonumber(L, 2);
4006 arg3 = (char *)lua_tostring(L, 3);
4007 arg4 = (PLFLT)lua_tonumber(L, 4);
4008 arg5 = (PLINT)lua_tonumber(L, 5);
4009 arg6 = (char *)lua_tostring(L, 6);
4010 arg7 = (PLFLT)lua_tonumber(L, 7);
4011 arg8 = (PLINT)lua_tonumber(L, 8);
4012 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
4013
4014 return SWIG_arg;
4015
4016 if(0) SWIG_fail;
4017
4018 fail:
4019 lua_error(L);
4020 return SWIG_arg;
4021 }
4022
4023
4024 static int _wrap_bin(lua_State* L) {
4025 int SWIG_arg = 0;
4026 PLINT arg1 ;
4027 PLFLT *arg2 = (PLFLT *) 0 ;
4028 PLFLT *arg3 = (PLFLT *) 0 ;
4029 PLINT arg4 ;
4030 int temp3 ;
4031
4032 SWIG_check_num_args("plbin",3,3)
4033 if(!lua_isnumber(L,3)) SWIG_fail_arg("plbin",3,"PLINT");
4034 {
4035 int temp;
4036 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
4037 if ( !arg2 )
4038 SWIG_fail;
4039 arg1 = Alen = temp;
4040 }
4041 {
4042 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
4043 if ( !arg3 )
4044 SWIG_fail;
4045 if ( temp3 != Alen )
4046 {
4047 lua_pushfstring( L, "Tables must be of same length." );
4048 SWIG_fail;
4049 }
4050 }
4051 arg4 = (PLINT)lua_tonumber(L, 3);
4052 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
4053
4054 {
4055 LUA_FREE_ARRAY( arg2 );
4056 }
4057 {
4058 LUA_FREE_ARRAY( arg3 );
4059 }
4060 return SWIG_arg;
4061
4062 if(0) SWIG_fail;
4063
4064 fail:
4065 {
4066 LUA_FREE_ARRAY( arg2 );
4067 }
4068 {
4069 LUA_FREE_ARRAY( arg3 );
4070 }
4071 lua_error(L);
4072 return SWIG_arg;
4073 }
4074
4075
4076 static int _wrap_btime(lua_State* L) {
4077 int SWIG_arg = 0;
4078 PLINT *arg1 = (PLINT *) 0 ;
4079 PLINT *arg2 = (PLINT *) 0 ;
4080 PLINT *arg3 = (PLINT *) 0 ;
4081 PLINT *arg4 = (PLINT *) 0 ;
4082 PLINT *arg5 = (PLINT *) 0 ;
4083 PLFLT *arg6 = (PLFLT *) 0 ;
4084 PLFLT arg7 ;
4085 PLINT temp1 ;
4086 PLINT temp2 ;
4087 PLINT temp3 ;
4088 PLINT temp4 ;
4089 PLINT temp5 ;
4090 PLFLT temp6 ;
4091
4092 arg1 = &temp1;
4093 arg2 = &temp2;
4094 arg3 = &temp3;
4095 arg4 = &temp4;
4096 arg5 = &temp5;
4097 arg6 = &temp6;
4098 SWIG_check_num_args("plbtime",1,1)
4099 if(!lua_isnumber(L,1)) SWIG_fail_arg("plbtime",1,"PLFLT");
4100 arg7 = (PLFLT)lua_tonumber(L, 1);
4101 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4102
4103 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
4104 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
4105 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
4106 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
4107 lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
4108 lua_pushnumber(L, (lua_Number) *arg6); SWIG_arg++;
4109 return SWIG_arg;
4110
4111 if(0) SWIG_fail;
4112
4113 fail:
4114 lua_error(L);
4115 return SWIG_arg;
4116 }
4117
4118
4119 static int _wrap_bop(lua_State* L) {
4120 int SWIG_arg = 0;
4121
4122 SWIG_check_num_args("plbop",0,0)
4123 plbop();
4124
4125 return SWIG_arg;
4126
4127 if(0) SWIG_fail;
4128
4129 fail:
4130 lua_error(L);
4131 return SWIG_arg;
4132 }
4133
4134
4135 static int _wrap_box(lua_State* L) {
4136 int SWIG_arg = 0;
4137 char *arg1 = (char *) 0 ;
4138 PLFLT arg2 ;
4139 PLINT arg3 ;
4140 char *arg4 = (char *) 0 ;
4141 PLFLT arg5 ;
4142 PLINT arg6 ;
4143
4144 SWIG_check_num_args("plbox",6,6)
4145 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plbox",1,"char const *");
4146 if(!lua_isnumber(L,2)) SWIG_fail_arg("plbox",2,"PLFLT");
4147 if(!lua_isnumber(L,3)) SWIG_fail_arg("plbox",3,"PLINT");
4148 if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("plbox",4,"char const *");
4149 if(!lua_isnumber(L,5)) SWIG_fail_arg("plbox",5,"PLFLT");
4150 if(!lua_isnumber(L,6)) SWIG_fail_arg("plbox",6,"PLINT");
4151 arg1 = (char *)lua_tostring(L, 1);
4152 arg2 = (PLFLT)lua_tonumber(L, 2);
4153 arg3 = (PLINT)lua_tonumber(L, 3);
4154 arg4 = (char *)lua_tostring(L, 4);
4155 arg5 = (PLFLT)lua_tonumber(L, 5);
4156 arg6 = (PLINT)lua_tonumber(L, 6);
4157 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
4158
4159 return SWIG_arg;
4160
4161 if(0) SWIG_fail;
4162
4163 fail:
4164 lua_error(L);
4165 return SWIG_arg;
4166 }
4167
4168
4169 static int _wrap_box3(lua_State* L) {
4170 int SWIG_arg = 0;
4171 char *arg1 = (char *) 0 ;
4172 char *arg2 = (char *) 0 ;
4173 PLFLT arg3 ;
4174 PLINT arg4 ;
4175 char *arg5 = (char *) 0 ;
4176 char *arg6 = (char *) 0 ;
4177 PLFLT arg7 ;
4178 PLINT arg8 ;
4179 char *arg9 = (char *) 0 ;
4180 char *arg10 = (char *) 0 ;
4181 PLFLT arg11 ;
4182 PLINT arg12 ;
4183
4184 SWIG_check_num_args("plbox3",12,12)
4185 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plbox3",1,"char const *");
4186 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plbox3",2,"char const *");
4187 if(!lua_isnumber(L,3)) SWIG_fail_arg("plbox3",3,"PLFLT");
4188 if(!lua_isnumber(L,4)) SWIG_fail_arg("plbox3",4,"PLINT");
4189 if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("plbox3",5,"char const *");
4190 if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("plbox3",6,"char const *");
4191 if(!lua_isnumber(L,7)) SWIG_fail_arg("plbox3",7,"PLFLT");
4192 if(!lua_isnumber(L,8)) SWIG_fail_arg("plbox3",8,"PLINT");
4193 if(!SWIG_lua_isnilstring(L,9)) SWIG_fail_arg("plbox3",9,"char const *");
4194 if(!SWIG_lua_isnilstring(L,10)) SWIG_fail_arg("plbox3",10,"char const *");
4195 if(!lua_isnumber(L,11)) SWIG_fail_arg("plbox3",11,"PLFLT");
4196 if(!lua_isnumber(L,12)) SWIG_fail_arg("plbox3",12,"PLINT");
4197 arg1 = (char *)lua_tostring(L, 1);
4198 arg2 = (char *)lua_tostring(L, 2);
4199 arg3 = (PLFLT)lua_tonumber(L, 3);
4200 arg4 = (PLINT)lua_tonumber(L, 4);
4201 arg5 = (char *)lua_tostring(L, 5);
4202 arg6 = (char *)lua_tostring(L, 6);
4203 arg7 = (PLFLT)lua_tonumber(L, 7);
4204 arg8 = (PLINT)lua_tonumber(L, 8);
4205 arg9 = (char *)lua_tostring(L, 9);
4206 arg10 = (char *)lua_tostring(L, 10);
4207 arg11 = (PLFLT)lua_tonumber(L, 11);
4208 arg12 = (PLINT)lua_tonumber(L, 12);
4209 plbox3((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,(char const *)arg9,(char const *)arg10,arg11,arg12);
4210
4211 return SWIG_arg;
4212
4213 if(0) SWIG_fail;
4214
4215 fail:
4216 lua_error(L);
4217 return SWIG_arg;
4218 }
4219
4220
4221 static int _wrap_calc_world(lua_State* L) {
4222 int SWIG_arg = 0;
4223 PLFLT arg1 ;
4224 PLFLT arg2 ;
4225 PLFLT *arg3 = (PLFLT *) 0 ;
4226 PLFLT *arg4 = (PLFLT *) 0 ;
4227 PLINT *arg5 = (PLINT *) 0 ;
4228 PLFLT temp3 ;
4229 PLFLT temp4 ;
4230 PLINT temp5 ;
4231
4232 arg3 = &temp3;
4233 arg4 = &temp4;
4234 arg5 = &temp5;
4235 SWIG_check_num_args("plcalc_world",2,2)
4236 if(!lua_isnumber(L,1)) SWIG_fail_arg("plcalc_world",1,"PLFLT");
4237 if(!lua_isnumber(L,2)) SWIG_fail_arg("plcalc_world",2,"PLFLT");
4238 arg1 = (PLFLT)lua_tonumber(L, 1);
4239 arg2 = (PLFLT)lua_tonumber(L, 2);
4240 plcalc_world(arg1,arg2,arg3,arg4,arg5);
4241
4242 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
4243 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
4244 lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
4245 return SWIG_arg;
4246
4247 if(0) SWIG_fail;
4248
4249 fail:
4250 lua_error(L);
4251 return SWIG_arg;
4252 }
4253
4254
4255 static int _wrap_clear(lua_State* L) {
4256 int SWIG_arg = 0;
4257
4258 SWIG_check_num_args("plclear",0,0)
4259 plclear();
4260
4261 return SWIG_arg;
4262
4263 if(0) SWIG_fail;
4264
4265 fail:
4266 lua_error(L);
4267 return SWIG_arg;
4268 }
4269
4270
4271 static int _wrap_col0(lua_State* L) {
4272 int SWIG_arg = 0;
4273 PLINT arg1 ;
4274
4275 SWIG_check_num_args("plcol0",1,1)
4276 if(!lua_isnumber(L,1)) SWIG_fail_arg("plcol0",1,"PLINT");
4277 arg1 = (PLINT)lua_tonumber(L, 1);
4278 plcol0(arg1);
4279
4280 return SWIG_arg;
4281
4282 if(0) SWIG_fail;
4283
4284 fail:
4285 lua_error(L);
4286 return SWIG_arg;
4287 }
4288
4289
4290 static int _wrap_col1(lua_State* L) {
4291 int SWIG_arg = 0;
4292 PLFLT arg1 ;
4293
4294 SWIG_check_num_args("plcol1",1,1)
4295 if(!lua_isnumber(L,1)) SWIG_fail_arg("plcol1",1,"PLFLT");
4296 arg1 = (PLFLT)lua_tonumber(L, 1);
4297 plcol1(arg1);
4298
4299 return SWIG_arg;
4300
4301 if(0) SWIG_fail;
4302
4303 fail:
4304 lua_error(L);
4305 return SWIG_arg;
4306 }
4307
4308
4309 static int _wrap_configtime(lua_State* L) {
4310 int SWIG_arg = 0;
4311 PLFLT arg1 ;
4312 PLFLT arg2 ;
4313 PLFLT arg3 ;
4314 PLINT arg4 ;
4315 PLBOOL arg5 ;
4316 PLINT arg6 ;
4317 PLINT arg7 ;
4318 PLINT arg8 ;
4319 PLINT arg9 ;
4320 PLINT arg10 ;
4321 PLFLT arg11 ;
4322
4323 SWIG_check_num_args("plconfigtime",11,11)
4324 if(!lua_isnumber(L,1)) SWIG_fail_arg("plconfigtime",1,"PLFLT");
4325 if(!lua_isnumber(L,2)) SWIG_fail_arg("plconfigtime",2,"PLFLT");
4326 if(!lua_isnumber(L,3)) SWIG_fail_arg("plconfigtime",3,"PLFLT");
4327 if(!lua_isnumber(L,4)) SWIG_fail_arg("plconfigtime",4,"PLINT");
4328 if(!lua_isnumber(L,5)) SWIG_fail_arg("plconfigtime",5,"PLBOOL");
4329 if(!lua_isnumber(L,6)) SWIG_fail_arg("plconfigtime",6,"PLINT");
4330 if(!lua_isnumber(L,7)) SWIG_fail_arg("plconfigtime",7,"PLINT");
4331 if(!lua_isnumber(L,8)) SWIG_fail_arg("plconfigtime",8,"PLINT");
4332 if(!lua_isnumber(L,9)) SWIG_fail_arg("plconfigtime",9,"PLINT");
4333 if(!lua_isnumber(L,10)) SWIG_fail_arg("plconfigtime",10,"PLINT");
4334 if(!lua_isnumber(L,11)) SWIG_fail_arg("plconfigtime",11,"PLFLT");
4335 arg1 = (PLFLT)lua_tonumber(L, 1);
4336 arg2 = (PLFLT)lua_tonumber(L, 2);
4337 arg3 = (PLFLT)lua_tonumber(L, 3);
4338 arg4 = (PLINT)lua_tonumber(L, 4);
4339 arg5 = (PLBOOL)lua_tonumber(L, 5);
4340 arg6 = (PLINT)lua_tonumber(L, 6);
4341 arg7 = (PLINT)lua_tonumber(L, 7);
4342 arg8 = (PLINT)lua_tonumber(L, 8);
4343 arg9 = (PLINT)lua_tonumber(L, 9);
4344 arg10 = (PLINT)lua_tonumber(L, 10);
4345 arg11 = (PLFLT)lua_tonumber(L, 11);
4346 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
4347
4348 return SWIG_arg;
4349
4350 if(0) SWIG_fail;
4351
4352 fail:
4353 lua_error(L);
4354 return SWIG_arg;
4355 }
4356
4357
4358 static int _wrap_cont(lua_State* L) {
4359 int SWIG_arg = 0;
4360 PLFLT **arg1 = (PLFLT **) 0 ;
4361 PLINT arg2 ;
4362 PLINT arg3 ;
4363 PLINT arg4 ;
4364 PLINT arg5 ;
4365 PLINT arg6 ;
4366 PLINT arg7 ;
4367 PLFLT *arg8 = (PLFLT *) 0 ;
4368 PLINT arg9 ;
4369 pltr_func arg10 = (pltr_func) 0 ;
4370 PLPointer arg11 = (PLPointer) 0 ;
4371 int ii1 ;
4372 PLcGrid cgrid111 ;
4373 PLcGrid2 cgrid211 ;
4374
4375 {
4376 cgrid111.xg = cgrid111.yg = cgrid111.zg = NULL;
4377 cgrid111.nx = cgrid111.ny = cgrid111.nz = 0;
4378 cgrid211.xg = cgrid211.yg = cgrid211.zg = NULL;
4379 cgrid211.nx = cgrid211.ny = 0;
4380 }
4381 {
4382 arg10 = NULL;
4383 }
4384 {
4385 arg11 = NULL;
4386 }
4387 SWIG_check_num_args("plcont",6,8)
4388 if(!lua_isnumber(L,2)) SWIG_fail_arg("plcont",2,"PLINT");
4389 if(!lua_isnumber(L,3)) SWIG_fail_arg("plcont",3,"PLINT");
4390 if(!lua_isnumber(L,4)) SWIG_fail_arg("plcont",4,"PLINT");
4391 if(!lua_isnumber(L,5)) SWIG_fail_arg("plcont",5,"PLINT");
4392 {
4393 int jj;
4394
4395 arg1 = read_double_Matrix( L, 1, &ii1, &jj );
4396 if ( !arg1 )
4397 SWIG_fail;
4398 Xlen = arg2 = ii1;
4399 Ylen = arg3 = jj;
4400 }
4401 arg4 = (PLINT)lua_tonumber(L, 2);
4402 arg5 = (PLINT)lua_tonumber(L, 3);
4403 arg6 = (PLINT)lua_tonumber(L, 4);
4404 arg7 = (PLINT)lua_tonumber(L, 5);
4405 {
4406 int temp;
4407 arg8 = (PLFLT *) LUA_get_double_num_array_var( L, 6, &temp );
4408 if ( !arg8 )
4409 SWIG_fail;
4410 arg9 = Alen = temp;
4411 }
4412 if(lua_gettop(L)>=7){
4413 {
4414 arg10 = NULL;
4415 mypltr_funcstr[0] = '\0';
4416
4417 if ( lua_isstring( L, 7 ) )
4418 {
4419 const char* funcstr = lua_tostring( L, 7 );
4420 if ( strcmp( "pltr0", funcstr ) == 0 )
4421 {
4422 arg10 = pltr0;
4423 }
4424 else if ( strcmp( "pltr1", funcstr ) == 0 )
4425 {
4426 arg10 = pltr1;
4427 }
4428 else if ( strcmp( "pltr2", funcstr ) == 0 )
4429 {
4430 arg10 = pltr2;
4431 }
4432 else
4433 {
4434 arg10 = mypltr;
4435 strncpy( mypltr_funcstr, funcstr, 255 );
4436 myL = L;
4437 }
4438 }
4439 else
4440 SWIG_fail_arg( "cont", 10, "pltr_func" );
4441 }
4442 }
4443 if(lua_gettop(L)>=8){
4444 {
4445 int nx, ny;
4446 int gridmode = 0;
4447
4448 lua_pushstring( L, "xg" );
4449 lua_gettable( L, 8 );
4450 if ( !lua_istable( L, -1 ) )
4451 {
4452 lua_pop( L, 1 ); // pop "xg"
4453 lua_pushstring( L, "expected a table xg" );
4454 SWIG_fail;
4455 }
4456 lua_rawgeti( L, -1, 1 );
4457 if ( lua_istable( L, -1 ) )
4458 gridmode = 2; // two dimensional array
4459 else if ( lua_isnumber( L, -1 ) )
4460 gridmode = 1; // one dimensional array
4461 else
4462 {
4463 lua_pop( L, 1 ); // pop "1"
4464 lua_pop( L, 1 ); // pop "xg"
4465 lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
4466 SWIG_fail;
4467 }
4468 lua_pop( L, 1 ); // pop test element
4469 if ( gridmode == 1 )
4470 {
4471 cgrid111.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
4472 if ( !cgrid111.xg )
4473 {
4474 lua_pop( L, 1 ); // pop "xg"
4475 SWIG_fail;
4476 }
4477 if ( nx != Xlen )
4478 {
4479 lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
4480 SWIG_fail;
4481 }
4482 cgrid111.nx = nx;
4483 }
4484 else
4485 {
4486 cgrid211.xg = read_double_Matrix( L, -1, &nx, &ny );
4487 if ( !cgrid211.xg )
4488 {
4489 lua_pop( L, 1 ); // pop "xg"
4490 SWIG_fail;
4491 }
4492 if ( ( nx != Xlen ) || ( ny != Ylen ) )
4493 {
4494 lua_pop( L, 1 ); // pop "xg"
4495 lua_pushfstring( L, "Vectors must match matrix." );
4496 SWIG_fail;
4497 }
4498 cgrid211.nx = nx;
4499 cgrid211.ny = ny;
4500 }
4501 lua_pop( L, 1 ); // pop "xg"
4502
4503 lua_pushstring( L, "yg" );
4504 lua_gettable( L, 8 );
4505 if ( !lua_istable( L, -1 ) )
4506 {
4507 lua_pop( L, 1 );
4508 lua_pushstring( L, "expected a table yg" );
4509 SWIG_fail;
4510 }
4511 lua_rawgeti( L, -1, 1 );
4512 if ( gridmode == 2 )
4513 {
4514 if ( !lua_istable( L, -1 ) )
4515 {
4516 lua_pop( L, 1 ); // pop "1"
4517 lua_pop( L, 1 ); // pop "yg"
4518 lua_pushstring( L, "expected a two dimensional array/table in yg" );
4519 SWIG_fail;
4520 }
4521 }
4522 else
4523 {
4524 if ( !lua_isnumber( L, -1 ) )
4525 {
4526 lua_pop( L, 1 ); // pop "1"
4527 lua_pop( L, 1 ); // pop "yg"
4528 lua_pushstring( L, "expected a one dimensional array/table in yg" );
4529 SWIG_fail;
4530 }
4531 }
4532 lua_pop( L, 1 ); // pop "1"
4533 if ( gridmode == 1 )
4534 {
4535 cgrid111.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
4536 if ( !cgrid111.yg )
4537 {
4538 lua_pop( L, 1 ); // pop "yg"
4539 SWIG_fail;
4540 }
4541 if ( ny != Ylen )
4542 {
4543 lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
4544 SWIG_fail;
4545 }
4546 cgrid111.ny = ny;
4547 }
4548 else
4549 {
4550 cgrid211.yg = read_double_Matrix( L, -1, &nx, &ny );
4551 if ( !cgrid211.yg )
4552 {
4553 lua_pop( L, 1 ); // pop "xg"
4554 SWIG_fail;
4555 }
4556 if ( ( nx != Xlen ) || ( ny != Ylen ) )
4557 {
4558 lua_pop( L, 1 ); // pop "xg"
4559 lua_pushfstring( L, "Vectors must match matrix." );
4560 SWIG_fail;
4561 }
4562 // cgrid211.nx/ny already set
4563 }
4564 lua_pop( L, 1 ); // pop "yg"
4565
4566 if ( gridmode == 1 )
4567 arg11 = &cgrid111;
4568 else if ( gridmode == 2 )
4569 arg11 = &cgrid211;
4570 }
4571 }
4572 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
4573
4574 {
4575 int i;
4576
4577 if ( arg1 )
4578 {
4579 for ( i = 0; i < ii1; i++ )
4580 LUA_FREE_ARRAY( arg1[i] );
4581 LUA_FREE_ARRAY( arg1 );
4582 }
4583 }
4584 {
4585 LUA_FREE_ARRAY( arg8 );
4586 }
4587 {
4588 mypltr_funcstr[0] = '\0';
4589 }
4590 {
4591 int i;
4592
4593 LUA_FREE_ARRAY( cgrid111.xg );
4594 LUA_FREE_ARRAY( cgrid111.yg );
4595
4596 if ( cgrid211.xg )
4597 {
4598 for ( i = 0; i < Xlen; i++ )
4599 LUA_FREE_ARRAY( cgrid211.xg[i] );
4600 LUA_FREE_ARRAY( cgrid211.xg );
4601 }
4602 if ( cgrid211.yg )
4603 {
4604 for ( i = 0; i < Xlen; i++ )
4605 LUA_FREE_ARRAY( cgrid211.yg[i] );
4606 LUA_FREE_ARRAY( cgrid211.yg );
4607 }
4608 }
4609 return SWIG_arg;
4610
4611 if(0) SWIG_fail;
4612
4613 fail:
4614 {
4615 int i;
4616
4617 if ( arg1 )
4618 {
4619 for ( i = 0; i < ii1; i++ )
4620 LUA_FREE_ARRAY( arg1[i] );
4621 LUA_FREE_ARRAY( arg1 );
4622 }
4623 }
4624 {
4625 LUA_FREE_ARRAY( arg8 );
4626 }
4627 {
4628 mypltr_funcstr[0] = '\0';
4629 }
4630 {
4631 int i;
4632
4633 LUA_FREE_ARRAY( cgrid111.xg );
4634 LUA_FREE_ARRAY( cgrid111.yg );
4635
4636 if ( cgrid211.xg )
4637 {
4638 for ( i = 0; i < Xlen; i++ )
4639 LUA_FREE_ARRAY( cgrid211.xg[i] );
4640 LUA_FREE_ARRAY( cgrid211.xg );
4641 }
4642 if ( cgrid211.yg )
4643 {
4644 for ( i = 0; i < Xlen; i++ )
4645 LUA_FREE_ARRAY( cgrid211.yg[i] );
4646 LUA_FREE_ARRAY( cgrid211.yg );
4647 }
4648 }
4649 lua_error(L);
4650 return SWIG_arg;
4651 }
4652
4653
4654 static int _wrap_ctime(lua_State* L) {
4655 int SWIG_arg = 0;
4656 PLINT arg1 ;
4657 PLINT arg2 ;
4658 PLINT arg3 ;
4659 PLINT arg4 ;
4660 PLINT arg5 ;
4661 PLFLT arg6 ;
4662 PLFLT *arg7 = (PLFLT *) 0 ;
4663 PLFLT temp7 ;
4664
4665 arg7 = &temp7;
4666 SWIG_check_num_args("plctime",6,6)
4667 if(!lua_isnumber(L,1)) SWIG_fail_arg("plctime",1,"PLINT");
4668 if(!lua_isnumber(L,2)) SWIG_fail_arg("plctime",2,"PLINT");
4669 if(!lua_isnumber(L,3)) SWIG_fail_arg("plctime",3,"PLINT");
4670 if(!lua_isnumber(L,4)) SWIG_fail_arg("plctime",4,"PLINT");
4671 if(!lua_isnumber(L,5)) SWIG_fail_arg("plctime",5,"PLINT");
4672 if(!lua_isnumber(L,6)) SWIG_fail_arg("plctime",6,"PLFLT");
4673 arg1 = (PLINT)lua_tonumber(L, 1);
4674 arg2 = (PLINT)lua_tonumber(L, 2);
4675 arg3 = (PLINT)lua_tonumber(L, 3);
4676 arg4 = (PLINT)lua_tonumber(L, 4);
4677 arg5 = (PLINT)lua_tonumber(L, 5);
4678 arg6 = (PLFLT)lua_tonumber(L, 6);
4679 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4680
4681 lua_pushnumber(L, (lua_Number) *arg7); SWIG_arg++;
4682 return SWIG_arg;
4683
4684 if(0) SWIG_fail;
4685
4686 fail:
4687 lua_error(L);
4688 return SWIG_arg;
4689 }
4690
4691
4692 static int _wrap_cpstrm(lua_State* L) {
4693 int SWIG_arg = 0;
4694 PLINT arg1 ;
4695 PLBOOL arg2 ;
4696
4697 SWIG_check_num_args("plcpstrm",2,2)
4698 if(!lua_isnumber(L,1)) SWIG_fail_arg("plcpstrm",1,"PLINT");
4699 if(!lua_isnumber(L,2)) SWIG_fail_arg("plcpstrm",2,"PLBOOL");
4700 arg1 = (PLINT)lua_tonumber(L, 1);
4701 arg2 = (PLBOOL)lua_tonumber(L, 2);
4702 plcpstrm(arg1,arg2);
4703
4704 return SWIG_arg;
4705
4706 if(0) SWIG_fail;
4707
4708 fail:
4709 lua_error(L);
4710 return SWIG_arg;
4711 }
4712
4713
4714 static int _wrap_plend(lua_State* L) {
4715 int SWIG_arg = 0;
4716
4717 SWIG_check_num_args("plend",0,0)
4718 plend();
4719
4720 return SWIG_arg;
4721
4722 if(0) SWIG_fail;
4723
4724 fail:
4725 lua_error(L);
4726 return SWIG_arg;
4727 }
4728
4729
4730 static int _wrap_plend1(lua_State* L) {
4731 int SWIG_arg = 0;
4732
4733 SWIG_check_num_args("plend1",0,0)
4734 plend1();
4735
4736 return SWIG_arg;
4737
4738 if(0) SWIG_fail;
4739
4740 fail:
4741 lua_error(L);
4742 return SWIG_arg;
4743 }
4744
4745
4746 static int _wrap_env(lua_State* L) {
4747 int SWIG_arg = 0;
4748 PLFLT arg1 ;
4749 PLFLT arg2 ;
4750 PLFLT arg3 ;
4751 PLFLT arg4 ;
4752 PLINT arg5 ;
4753 PLINT arg6 ;
4754
4755 SWIG_check_num_args("plenv",6,6)
4756 if(!lua_isnumber(L,1)) SWIG_fail_arg("plenv",1,"PLFLT");
4757 if(!lua_isnumber(L,2)) SWIG_fail_arg("plenv",2,"PLFLT");
4758 if(!lua_isnumber(L,3)) SWIG_fail_arg("plenv",3,"PLFLT");
4759 if(!lua_isnumber(L,4)) SWIG_fail_arg("plenv",4,"PLFLT");
4760 if(!lua_isnumber(L,5)) SWIG_fail_arg("plenv",5,"PLINT");
4761 if(!lua_isnumber(L,6)) SWIG_fail_arg("plenv",6,"PLINT");
4762 arg1 = (PLFLT)lua_tonumber(L, 1);
4763 arg2 = (PLFLT)lua_tonumber(L, 2);
4764 arg3 = (PLFLT)lua_tonumber(L, 3);
4765 arg4 = (PLFLT)lua_tonumber(L, 4);
4766 arg5 = (PLINT)lua_tonumber(L, 5);
4767 arg6 = (PLINT)lua_tonumber(L, 6);
4768 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
4769
4770 return SWIG_arg;
4771
4772 if(0) SWIG_fail;
4773
4774 fail:
4775 lua_error(L);
4776 return SWIG_arg;
4777 }
4778
4779
4780 static int _wrap_env0(lua_State* L) {
4781 int SWIG_arg = 0;
4782 PLFLT arg1 ;
4783 PLFLT arg2 ;
4784 PLFLT arg3 ;
4785 PLFLT arg4 ;
4786 PLINT arg5 ;
4787 PLINT arg6 ;
4788
4789 SWIG_check_num_args("plenv0",6,6)
4790 if(!lua_isnumber(L,1)) SWIG_fail_arg("plenv0",1,"PLFLT");
4791 if(!lua_isnumber(L,2)) SWIG_fail_arg("plenv0",2,"PLFLT");
4792 if(!lua_isnumber(L,3)) SWIG_fail_arg("plenv0",3,"PLFLT");
4793 if(!lua_isnumber(L,4)) SWIG_fail_arg("plenv0",4,"PLFLT");
4794 if(!lua_isnumber(L,5)) SWIG_fail_arg("plenv0",5,"PLINT");
4795 if(!lua_isnumber(L,6)) SWIG_fail_arg("plenv0",6,"PLINT");
4796 arg1 = (PLFLT)lua_tonumber(L, 1);
4797 arg2 = (PLFLT)lua_tonumber(L, 2);
4798 arg3 = (PLFLT)lua_tonumber(L, 3);
4799 arg4 = (PLFLT)lua_tonumber(L, 4);
4800 arg5 = (PLINT)lua_tonumber(L, 5);
4801 arg6 = (PLINT)lua_tonumber(L, 6);
4802 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
4803
4804 return SWIG_arg;
4805
4806 if(0) SWIG_fail;
4807
4808 fail:
4809 lua_error(L);
4810 return SWIG_arg;
4811 }
4812
4813
4814 static int _wrap_eop(lua_State* L) {
4815 int SWIG_arg = 0;
4816
4817 SWIG_check_num_args("pleop",0,0)
4818 pleop();
4819
4820 return SWIG_arg;
4821
4822 if(0) SWIG_fail;
4823
4824 fail:
4825 lua_error(L);
4826 return SWIG_arg;
4827 }
4828
4829
4830 static int _wrap_errx(lua_State* L) {
4831 int SWIG_arg = 0;
4832 PLINT arg1 ;
4833 PLFLT *arg2 = (PLFLT *) 0 ;
4834 PLFLT *arg3 = (PLFLT *) 0 ;
4835 PLFLT *arg4 = (PLFLT *) 0 ;
4836 int temp3 ;
4837 int temp4 ;
4838
4839 SWIG_check_num_args("plerrx",3,3)
4840 {
4841 int temp;
4842 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
4843 if ( !arg2 )
4844 SWIG_fail;
4845 arg1 = Alen = temp;
4846 }
4847 {
4848 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
4849 if ( !arg3 )
4850 SWIG_fail;
4851 if ( temp3 != Alen )
4852 {
4853 lua_pushfstring( L, "Tables must be of same length." );
4854 SWIG_fail;
4855 }
4856 }
4857 {
4858 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
4859 if ( !arg4 )
4860 SWIG_fail;
4861 if ( temp4 != Alen )
4862 {
4863 lua_pushfstring( L, "Tables must be of same length." );
4864 SWIG_fail;
4865 }
4866 }
4867 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
4868
4869 {
4870 LUA_FREE_ARRAY( arg2 );
4871 }
4872 {
4873 LUA_FREE_ARRAY( arg3 );
4874 }
4875 {
4876 LUA_FREE_ARRAY( arg4 );
4877 }
4878 return SWIG_arg;
4879
4880 if(0) SWIG_fail;
4881
4882 fail:
4883 {
4884 LUA_FREE_ARRAY( arg2 );
4885 }
4886 {
4887 LUA_FREE_ARRAY( arg3 );
4888 }
4889 {
4890 LUA_FREE_ARRAY( arg4 );
4891 }
4892 lua_error(L);
4893 return SWIG_arg;
4894 }
4895
4896
4897 static int _wrap_erry(lua_State* L) {
4898 int SWIG_arg = 0;
4899 PLINT arg1 ;
4900 PLFLT *arg2 = (PLFLT *) 0 ;
4901 PLFLT *arg3 = (PLFLT *) 0 ;
4902 PLFLT *arg4 = (PLFLT *) 0 ;
4903 int temp3 ;
4904 int temp4 ;
4905
4906 SWIG_check_num_args("plerry",3,3)
4907 {
4908 int temp;
4909 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
4910 if ( !arg2 )
4911 SWIG_fail;
4912 arg1 = Alen = temp;
4913 }
4914 {
4915 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
4916 if ( !arg3 )
4917 SWIG_fail;
4918 if ( temp3 != Alen )
4919 {
4920 lua_pushfstring( L, "Tables must be of same length." );
4921 SWIG_fail;
4922 }
4923 }
4924 {
4925 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
4926 if ( !arg4 )
4927 SWIG_fail;
4928 if ( temp4 != Alen )
4929 {
4930 lua_pushfstring( L, "Tables must be of same length." );
4931 SWIG_fail;
4932 }
4933 }
4934 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
4935
4936 {
4937 LUA_FREE_ARRAY( arg2 );
4938 }
4939 {
4940 LUA_FREE_ARRAY( arg3 );
4941 }
4942 {
4943 LUA_FREE_ARRAY( arg4 );
4944 }
4945 return SWIG_arg;
4946
4947 if(0) SWIG_fail;
4948
4949 fail:
4950 {
4951 LUA_FREE_ARRAY( arg2 );
4952 }
4953 {
4954 LUA_FREE_ARRAY( arg3 );
4955 }
4956 {
4957 LUA_FREE_ARRAY( arg4 );
4958 }
4959 lua_error(L);
4960 return SWIG_arg;
4961 }
4962
4963
4964 static int _wrap_famadv(lua_State* L) {
4965 int SWIG_arg = 0;
4966
4967 SWIG_check_num_args("plfamadv",0,0)
4968 plfamadv();
4969
4970 return SWIG_arg;
4971
4972 if(0) SWIG_fail;
4973
4974 fail:
4975 lua_error(L);
4976 return SWIG_arg;
4977 }
4978
4979
4980 static int _wrap_fill(lua_State* L) {
4981 int SWIG_arg = 0;
4982 PLINT arg1 ;
4983 PLFLT *arg2 = (PLFLT *) 0 ;
4984 PLFLT *arg3 = (PLFLT *) 0 ;
4985 int temp3 ;
4986
4987 SWIG_check_num_args("plfill",2,2)
4988 {
4989 int temp;
4990 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
4991 if ( !arg2 )
4992 SWIG_fail;
4993 arg1 = Alen = temp;
4994 }
4995 {
4996 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
4997 if ( !arg3 )
4998 SWIG_fail;
4999 if ( temp3 != Alen )
5000 {
5001 lua_pushfstring( L, "Tables must be of same length." );
5002 SWIG_fail;
5003 }
5004 }
5005 plfill(arg1,(double const *)arg2,(double const *)arg3);
5006
5007 {
5008 LUA_FREE_ARRAY( arg2 );
5009 }
5010 {
5011 LUA_FREE_ARRAY( arg3 );
5012 }
5013 return SWIG_arg;
5014
5015 if(0) SWIG_fail;
5016
5017 fail:
5018 {
5019 LUA_FREE_ARRAY( arg2 );
5020 }
5021 {
5022 LUA_FREE_ARRAY( arg3 );
5023 }
5024 lua_error(L);
5025 return SWIG_arg;
5026 }
5027
5028
5029 static int _wrap_fill3(lua_State* L) {
5030 int SWIG_arg = 0;
5031 PLINT arg1 ;
5032 PLFLT *arg2 = (PLFLT *) 0 ;
5033 PLFLT *arg3 = (PLFLT *) 0 ;
5034 PLFLT *arg4 = (PLFLT *) 0 ;
5035 int temp3 ;
5036 int temp4 ;
5037
5038 SWIG_check_num_args("plfill3",3,3)
5039 {
5040 int temp;
5041 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
5042 if ( !arg2 )
5043 SWIG_fail;
5044 arg1 = Alen = temp;
5045 }
5046 {
5047 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
5048 if ( !arg3 )
5049 SWIG_fail;
5050 if ( temp3 != Alen )
5051 {
5052 lua_pushfstring( L, "Tables must be of same length." );
5053 SWIG_fail;
5054 }
5055 }
5056 {
5057 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
5058 if ( !arg4 )
5059 SWIG_fail;
5060 if ( temp4 != Alen )
5061 {
5062 lua_pushfstring( L, "Tables must be of same length." );
5063 SWIG_fail;
5064 }
5065 }
5066 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5067
5068 {
5069 LUA_FREE_ARRAY( arg2 );
5070 }
5071 {
5072 LUA_FREE_ARRAY( arg3 );
5073 }
5074 {
5075 LUA_FREE_ARRAY( arg4 );
5076 }
5077 return SWIG_arg;
5078
5079 if(0) SWIG_fail;
5080
5081 fail:
5082 {
5083 LUA_FREE_ARRAY( arg2 );
5084 }
5085 {
5086 LUA_FREE_ARRAY( arg3 );
5087 }
5088 {
5089 LUA_FREE_ARRAY( arg4 );
5090 }
5091 lua_error(L);
5092 return SWIG_arg;
5093 }
5094
5095
5096 static int _wrap_gradient(lua_State* L) {
5097 int SWIG_arg = 0;
5098 PLINT arg1 ;
5099 PLFLT *arg2 = (PLFLT *) 0 ;
5100 PLFLT *arg3 = (PLFLT *) 0 ;
5101 PLFLT arg4 ;
5102 int temp3 ;
5103
5104 SWIG_check_num_args("plgradient",3,3)
5105 if(!lua_isnumber(L,3)) SWIG_fail_arg("plgradient",3,"PLFLT");
5106 {
5107 int temp;
5108 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
5109 if ( !arg2 )
5110 SWIG_fail;
5111 arg1 = Alen = temp;
5112 }
5113 {
5114 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
5115 if ( !arg3 )
5116 SWIG_fail;
5117 if ( temp3 != Alen )
5118 {
5119 lua_pushfstring( L, "Tables must be of same length." );
5120 SWIG_fail;
5121 }
5122 }
5123 arg4 = (PLFLT)lua_tonumber(L, 3);
5124 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
5125
5126 {
5127 LUA_FREE_ARRAY( arg2 );
5128 }
5129 {
5130 LUA_FREE_ARRAY( arg3 );
5131 }
5132 return SWIG_arg;
5133
5134 if(0) SWIG_fail;
5135
5136 fail:
5137 {
5138 LUA_FREE_ARRAY( arg2 );
5139 }
5140 {
5141 LUA_FREE_ARRAY( arg3 );
5142 }
5143 lua_error(L);
5144 return SWIG_arg;
5145 }
5146
5147
5148 static int _wrap_flush(lua_State* L) {
5149 int SWIG_arg = 0;
5150
5151 SWIG_check_num_args("plflush",0,0)
5152 plflush();
5153
5154 return SWIG_arg;
5155
5156 if(0) SWIG_fail;
5157
5158 fail:
5159 lua_error(L);
5160 return SWIG_arg;
5161 }
5162
5163
5164 static int _wrap_font(lua_State* L) {
5165 int SWIG_arg = 0;
5166 PLINT arg1 ;
5167
5168 SWIG_check_num_args("plfont",1,1)
5169 if(!lua_isnumber(L,1)) SWIG_fail_arg("plfont",1,"PLINT");
5170 arg1 = (PLINT)lua_tonumber(L, 1);
5171 plfont(arg1);
5172
5173 return SWIG_arg;
5174
5175 if(0) SWIG_fail;
5176
5177 fail:
5178 lua_error(L);
5179 return SWIG_arg;
5180 }
5181
5182
5183 static int _wrap_fontld(lua_State* L) {
5184 int SWIG_arg = 0;
5185 PLINT arg1 ;
5186
5187 SWIG_check_num_args("plfontld",1,1)
5188 if(!lua_isnumber(L,1)) SWIG_fail_arg("plfontld",1,"PLINT");
5189 arg1 = (PLINT)lua_tonumber(L, 1);
5190 plfontld(arg1);
5191
5192 return SWIG_arg;
5193
5194 if(0) SWIG_fail;
5195
5196 fail:
5197 lua_error(L);
5198 return SWIG_arg;
5199 }
5200
5201
5202 static int _wrap_gchr(lua_State* L) {
5203 int SWIG_arg = 0;
5204 PLFLT *arg1 = (PLFLT *) 0 ;
5205 PLFLT *arg2 = (PLFLT *) 0 ;
5206 PLFLT temp1 ;
5207 PLFLT temp2 ;
5208
5209 arg1 = &temp1;
5210 arg2 = &temp2;
5211 SWIG_check_num_args("plgchr",0,0)
5212 plgchr(arg1,arg2);
5213
5214 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5215 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5216 return SWIG_arg;
5217
5218 if(0) SWIG_fail;
5219
5220 fail:
5221 lua_error(L);
5222 return SWIG_arg;
5223 }
5224
5225
5226 static int _wrap_gcol0(lua_State* L) {
5227 int SWIG_arg = 0;
5228 PLINT arg1 ;
5229 PLINT *arg2 = (PLINT *) 0 ;
5230 PLINT *arg3 = (PLINT *) 0 ;
5231 PLINT *arg4 = (PLINT *) 0 ;
5232 PLINT temp2 ;
5233 PLINT temp3 ;
5234 PLINT temp4 ;
5235
5236 arg2 = &temp2;
5237 arg3 = &temp3;
5238 arg4 = &temp4;
5239 SWIG_check_num_args("plgcol0",1,1)
5240 if(!lua_isnumber(L,1)) SWIG_fail_arg("plgcol0",1,"PLINT");
5241 arg1 = (PLINT)lua_tonumber(L, 1);
5242 plgcol0(arg1,arg2,arg3,arg4);
5243
5244 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5245 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5246 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5247 return SWIG_arg;
5248
5249 if(0) SWIG_fail;
5250
5251 fail:
5252 lua_error(L);
5253 return SWIG_arg;
5254 }
5255
5256
5257 static int _wrap_gcol0a(lua_State* L) {
5258 int SWIG_arg = 0;
5259 PLINT arg1 ;
5260 PLINT *arg2 = (PLINT *) 0 ;
5261 PLINT *arg3 = (PLINT *) 0 ;
5262 PLINT *arg4 = (PLINT *) 0 ;
5263 PLFLT *arg5 = (PLFLT *) 0 ;
5264 PLINT temp2 ;
5265 PLINT temp3 ;
5266 PLINT temp4 ;
5267 PLFLT temp5 ;
5268
5269 arg2 = &temp2;
5270 arg3 = &temp3;
5271 arg4 = &temp4;
5272 arg5 = &temp5;
5273 SWIG_check_num_args("plgcol0a",1,1)
5274 if(!lua_isnumber(L,1)) SWIG_fail_arg("plgcol0a",1,"PLINT");
5275 arg1 = (PLINT)lua_tonumber(L, 1);
5276 plgcol0a(arg1,arg2,arg3,arg4,arg5);
5277
5278 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5279 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5280 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5281 lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
5282 return SWIG_arg;
5283
5284 if(0) SWIG_fail;
5285
5286 fail:
5287 lua_error(L);
5288 return SWIG_arg;
5289 }
5290
5291
5292 static int _wrap_gcolbg(lua_State* L) {
5293 int SWIG_arg = 0;
5294 PLINT *arg1 = (PLINT *) 0 ;
5295 PLINT *arg2 = (PLINT *) 0 ;
5296 PLINT *arg3 = (PLINT *) 0 ;
5297 PLINT temp1 ;
5298 PLINT temp2 ;
5299 PLINT temp3 ;
5300
5301 arg1 = &temp1;
5302 arg2 = &temp2;
5303 arg3 = &temp3;
5304 SWIG_check_num_args("plgcolbg",0,0)
5305 plgcolbg(arg1,arg2,arg3);
5306
5307 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5308 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5309 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5310 return SWIG_arg;
5311
5312 if(0) SWIG_fail;
5313
5314 fail:
5315 lua_error(L);
5316 return SWIG_arg;
5317 }
5318
5319
5320 static int _wrap_gcolbga(lua_State* L) {
5321 int SWIG_arg = 0;
5322 PLINT *arg1 = (PLINT *) 0 ;
5323 PLINT *arg2 = (PLINT *) 0 ;
5324 PLINT *arg3 = (PLINT *) 0 ;
5325 PLFLT *arg4 = (PLFLT *) 0 ;
5326 PLINT temp1 ;
5327 PLINT temp2 ;
5328 PLINT temp3 ;
5329 PLFLT temp4 ;
5330
5331 arg1 = &temp1;
5332 arg2 = &temp2;
5333 arg3 = &temp3;
5334 arg4 = &temp4;
5335 SWIG_check_num_args("plgcolbga",0,0)
5336 plgcolbga(arg1,arg2,arg3,arg4);
5337
5338 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5339 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5340 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5341 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5342 return SWIG_arg;
5343
5344 if(0) SWIG_fail;
5345
5346 fail:
5347 lua_error(L);
5348 return SWIG_arg;
5349 }
5350
5351
5352 static int _wrap_gcompression(lua_State* L) {
5353 int SWIG_arg = 0;
5354 PLINT *arg1 = (PLINT *) 0 ;
5355 PLINT temp1 ;
5356
5357 arg1 = &temp1;
5358 SWIG_check_num_args("plgcompression",0,0)
5359 plgcompression(arg1);
5360
5361 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5362 return SWIG_arg;
5363
5364 if(0) SWIG_fail;
5365
5366 fail:
5367 lua_error(L);
5368 return SWIG_arg;
5369 }
5370
5371
5372 static int _wrap_gdev(lua_State* L) {
5373 int SWIG_arg = 0;
5374 char *arg1 = (char *) 0 ;
5375 char buff1[1000] ;
5376
5377 {
5378 arg1 = buff1;
5379 }
5380 SWIG_check_num_args("plgdev",0,0)
5381 plgdev(arg1);
5382
5383 {
5384 lua_pushstring( L, arg1 );
5385 SWIG_arg++;
5386 }
5387 return SWIG_arg;
5388
5389 if(0) SWIG_fail;
5390
5391 fail:
5392 lua_error(L);
5393 return SWIG_arg;
5394 }
5395
5396
5397 static int _wrap_gdidev(lua_State* L) {
5398 int SWIG_arg = 0;
5399 PLFLT *arg1 = (PLFLT *) 0 ;
5400 PLFLT *arg2 = (PLFLT *) 0 ;
5401 PLFLT *arg3 = (PLFLT *) 0 ;
5402 PLFLT *arg4 = (PLFLT *) 0 ;
5403 PLFLT temp1 ;
5404 PLFLT temp2 ;
5405 PLFLT temp3 ;
5406 PLFLT temp4 ;
5407
5408 arg1 = &temp1;
5409 arg2 = &temp2;
5410 arg3 = &temp3;
5411 arg4 = &temp4;
5412 SWIG_check_num_args("plgdidev",0,0)
5413 plgdidev(arg1,arg2,arg3,arg4);
5414
5415 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5416 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5417 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5418 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5419 return SWIG_arg;
5420
5421 if(0) SWIG_fail;
5422
5423 fail:
5424 lua_error(L);
5425 return SWIG_arg;
5426 }
5427
5428
5429 static int _wrap_gdiori(lua_State* L) {
5430 int SWIG_arg = 0;
5431 PLFLT *arg1 = (PLFLT *) 0 ;
5432 PLFLT temp1 ;
5433
5434 arg1 = &temp1;
5435 SWIG_check_num_args("plgdiori",0,0)
5436 plgdiori(arg1);
5437
5438 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5439 return SWIG_arg;
5440
5441 if(0) SWIG_fail;
5442
5443 fail:
5444 lua_error(L);
5445 return SWIG_arg;
5446 }
5447
5448
5449 static int _wrap_gdiplt(lua_State* L) {
5450 int SWIG_arg = 0;
5451 PLFLT *arg1 = (PLFLT *) 0 ;
5452 PLFLT *arg2 = (PLFLT *) 0 ;
5453 PLFLT *arg3 = (PLFLT *) 0 ;
5454 PLFLT *arg4 = (PLFLT *) 0 ;
5455 PLFLT temp1 ;
5456 PLFLT temp2 ;
5457 PLFLT temp3 ;
5458 PLFLT temp4 ;
5459
5460 arg1 = &temp1;
5461 arg2 = &temp2;
5462 arg3 = &temp3;
5463 arg4 = &temp4;
5464 SWIG_check_num_args("plgdiplt",0,0)
5465 plgdiplt(arg1,arg2,arg3,arg4);
5466
5467 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5468 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5469 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5470 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5471 return SWIG_arg;
5472
5473 if(0) SWIG_fail;
5474
5475 fail:
5476 lua_error(L);
5477 return SWIG_arg;
5478 }
5479
5480
5481 static int _wrap_gfam(lua_State* L) {
5482 int SWIG_arg = 0;
5483 PLINT *arg1 = (PLINT *) 0 ;
5484 PLINT *arg2 = (PLINT *) 0 ;
5485 PLINT *arg3 = (PLINT *) 0 ;
5486 PLINT temp1 ;
5487 PLINT temp2 ;
5488 PLINT temp3 ;
5489
5490 arg1 = &temp1;
5491 arg2 = &temp2;
5492 arg3 = &temp3;
5493 SWIG_check_num_args("plgfam",0,0)
5494 plgfam(arg1,arg2,arg3);
5495
5496 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5497 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5498 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5499 return SWIG_arg;
5500
5501 if(0) SWIG_fail;
5502
5503 fail:
5504 lua_error(L);
5505 return SWIG_arg;
5506 }
5507
5508
5509 static int _wrap_gfci(lua_State* L) {
5510 int SWIG_arg = 0;
5511 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
5512 PLUNICODE temp1 ;
5513
5514 arg1 = &temp1;
5515 SWIG_check_num_args("plgfci",0,0)
5516 plgfci(arg1);
5517
5518 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5519 return SWIG_arg;
5520
5521 if(0) SWIG_fail;
5522
5523 fail:
5524 lua_error(L);
5525 return SWIG_arg;
5526 }
5527
5528
5529 static int _wrap_gfnam(lua_State* L) {
5530 int SWIG_arg = 0;
5531 char *arg1 = (char *) 0 ;
5532 char buff1[1000] ;
5533
5534 {
5535 arg1 = buff1;
5536 }
5537 SWIG_check_num_args("plgfnam",0,0)
5538 plgfnam(arg1);
5539
5540 {
5541 lua_pushstring( L, arg1 );
5542 SWIG_arg++;
5543 }
5544 return SWIG_arg;
5545
5546 if(0) SWIG_fail;
5547
5548 fail:
5549 lua_error(L);
5550 return SWIG_arg;
5551 }
5552
5553
5554 static int _wrap_gfont(lua_State* L) {
5555 int SWIG_arg = 0;
5556 PLINT *arg1 = (PLINT *) 0 ;
5557 PLINT *arg2 = (PLINT *) 0 ;
5558 PLINT *arg3 = (PLINT *) 0 ;
5559 PLINT temp1 ;
5560 PLINT temp2 ;
5561 PLINT temp3 ;
5562
5563 arg1 = &temp1;
5564 arg2 = &temp2;
5565 arg3 = &temp3;
5566 SWIG_check_num_args("plgfont",0,0)
5567 plgfont(arg1,arg2,arg3);
5568
5569 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5570 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5571 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5572 return SWIG_arg;
5573
5574 if(0) SWIG_fail;
5575
5576 fail:
5577 lua_error(L);
5578 return SWIG_arg;
5579 }
5580
5581
5582 static int _wrap_glevel(lua_State* L) {
5583 int SWIG_arg = 0;
5584 PLINT *arg1 = (PLINT *) 0 ;
5585 PLINT temp1 ;
5586
5587 arg1 = &temp1;
5588 SWIG_check_num_args("plglevel",0,0)
5589 plglevel(arg1);
5590
5591 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5592 return SWIG_arg;
5593
5594 if(0) SWIG_fail;
5595
5596 fail:
5597 lua_error(L);
5598 return SWIG_arg;
5599 }
5600
5601
5602 static int _wrap_gpage(lua_State* L) {
5603 int SWIG_arg = 0;
5604 PLFLT *arg1 = (PLFLT *) 0 ;
5605 PLFLT *arg2 = (PLFLT *) 0 ;
5606 PLINT *arg3 = (PLINT *) 0 ;
5607 PLINT *arg4 = (PLINT *) 0 ;
5608 PLINT *arg5 = (PLINT *) 0 ;
5609 PLINT *arg6 = (PLINT *) 0 ;
5610 PLFLT temp1 ;
5611 PLFLT temp2 ;
5612 PLINT temp3 ;
5613 PLINT temp4 ;
5614 PLINT temp5 ;
5615 PLINT temp6 ;
5616
5617 arg1 = &temp1;
5618 arg2 = &temp2;
5619 arg3 = &temp3;
5620 arg4 = &temp4;
5621 arg5 = &temp5;
5622 arg6 = &temp6;
5623 SWIG_check_num_args("plgpage",0,0)
5624 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
5625
5626 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5627 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5628 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5629 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5630 lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
5631 lua_pushnumber(L, (lua_Number) *arg6); SWIG_arg++;
5632 return SWIG_arg;
5633
5634 if(0) SWIG_fail;
5635
5636 fail:
5637 lua_error(L);
5638 return SWIG_arg;
5639 }
5640
5641
5642 static int _wrap_gra(lua_State* L) {
5643 int SWIG_arg = 0;
5644
5645 SWIG_check_num_args("plgra",0,0)
5646 plgra();
5647
5648 return SWIG_arg;
5649
5650 if(0) SWIG_fail;
5651
5652 fail:
5653 lua_error(L);
5654 return SWIG_arg;
5655 }
5656
5657
5658 static int _wrap_griddata(lua_State* L) {
5659 int SWIG_arg = 0;
5660 PLFLT *arg1 = (PLFLT *) 0 ;
5661 PLFLT *arg2 = (PLFLT *) 0 ;
5662 PLFLT *arg3 = (PLFLT *) 0 ;
5663 PLINT arg4 ;
5664 PLFLT *arg5 = (PLFLT *) 0 ;
5665 PLINT arg6 ;
5666 PLFLT *arg7 = (PLFLT *) 0 ;
5667 PLINT arg8 ;
5668 PLFLT **arg9 = (PLFLT **) 0 ;
5669 PLINT arg10 ;
5670 PLFLT arg11 ;
5671 int temp2 ;
5672
5673 SWIG_check_num_args("plgriddata",7,7)
5674 if(!lua_isnumber(L,6)) SWIG_fail_arg("plgriddata",6,"PLINT");
5675 if(!lua_isnumber(L,7)) SWIG_fail_arg("plgriddata",7,"PLFLT");
5676 {
5677 int temp;
5678 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
5679 if ( !arg1 )
5680 SWIG_fail;
5681 Alen = temp;
5682 }
5683 {
5684 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp2 );
5685 if ( !arg2 )
5686 SWIG_fail;
5687 if ( temp2 != Alen )
5688 {
5689 lua_pushfstring( L, "Tables must be of same length." );
5690 SWIG_fail;
5691 }
5692 }
5693 {
5694 int temp;
5695 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp );
5696 if ( !arg3 )
5697 SWIG_fail;
5698 if ( temp != Alen )
5699 {
5700 lua_pushfstring( L, "Tables must be of same length." );
5701 SWIG_fail;
5702 }
5703 arg4 = temp;
5704 }
5705 {
5706 int temp;
5707 arg5 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp );
5708 if ( !arg5 )
5709 SWIG_fail;
5710 arg6 = Xlen = temp;
5711 }
5712 {
5713 int temp, i;
5714
5715 arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
5716 if ( !arg7 )
5717 SWIG_fail;
5718 arg8 = Ylen = temp;
5719
5720 arg9 = LUA_ALLOC_ARRAY( PLFLT *, Xlen );
5721 if ( !arg9 )
5722 SWIG_fail;
5723 for ( i = 0; i < Xlen; i++ )
5724 arg9[i] = NULL;
5725
5726 for ( i = 0; i < Xlen; i++ )
5727 {
5728 arg9[i] = LUA_ALLOC_ARRAY( PLFLT, Ylen );
5729 if ( !arg9[i] )
5730 SWIG_fail;
5731 }
5732 }
5733 arg10 = (PLINT)lua_tonumber(L, 6);
5734 arg11 = (PLFLT)lua_tonumber(L, 7);
5735 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
5736
5737 {
5738 int i;
5739
5740 if ( arg9 )
5741 {
5742 lua_newtable( L );
5743 for ( i = 0; i < Xlen; i++ )
5744 {
5745 SWIG_write_double_num_array( L, arg9[i], Ylen );
5746 lua_rawseti( L, -2, i + 1 ); // -1 is the inner table, -2 is the outer table
5747 }
5748 SWIG_arg++;
5749 }
5750 }
5751 {
5752 LUA_FREE_ARRAY( arg1 );
5753 }
5754 {
5755 LUA_FREE_ARRAY( arg2 );
5756 }
5757 {
5758 LUA_FREE_ARRAY( arg3 );
5759 }
5760 {
5761 LUA_FREE_ARRAY( arg5 );
5762 }
5763 {
5764 int i;
5765
5766 LUA_FREE_ARRAY( arg7 );
5767
5768 if ( arg9 )
5769 {
5770 for ( i = 0; i < Xlen; i++ )
5771 LUA_FREE_ARRAY( arg9[i] );
5772 LUA_FREE_ARRAY( arg9 );
5773 }
5774 }
5775 return SWIG_arg;
5776
5777 if(0) SWIG_fail;
5778
5779 fail:
5780 {
5781 LUA_FREE_ARRAY( arg1 );
5782 }
5783 {
5784 LUA_FREE_ARRAY( arg2 );
5785 }
5786 {
5787 LUA_FREE_ARRAY( arg3 );
5788 }
5789 {
5790 LUA_FREE_ARRAY( arg5 );
5791 }
5792 {
5793 int i;
5794
5795 LUA_FREE_ARRAY( arg7 );
5796
5797 if ( arg9 )
5798 {
5799 for ( i = 0; i < Xlen; i++ )
5800 LUA_FREE_ARRAY( arg9[i] );
5801 LUA_FREE_ARRAY( arg9 );
5802 }
5803 }
5804 lua_error(L);
5805 return SWIG_arg;
5806 }
5807
5808
5809 static int _wrap_gspa(lua_State* L) {
5810 int SWIG_arg = 0;
5811 PLFLT *arg1 = (PLFLT *) 0 ;
5812 PLFLT *arg2 = (PLFLT *) 0 ;
5813 PLFLT *arg3 = (PLFLT *) 0 ;
5814 PLFLT *arg4 = (PLFLT *) 0 ;
5815 PLFLT temp1 ;
5816 PLFLT temp2 ;
5817 PLFLT temp3 ;
5818 PLFLT temp4 ;
5819
5820 arg1 = &temp1;
5821 arg2 = &temp2;
5822 arg3 = &temp3;
5823 arg4 = &temp4;
5824 SWIG_check_num_args("plgspa",0,0)
5825 plgspa(arg1,arg2,arg3,arg4);
5826
5827 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5828 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5829 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5830 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5831 return SWIG_arg;
5832
5833 if(0) SWIG_fail;
5834
5835 fail:
5836 lua_error(L);
5837 return SWIG_arg;
5838 }
5839
5840
5841 static int _wrap_gstrm(lua_State* L) {
5842 int SWIG_arg = 0;
5843 PLINT *arg1 = (PLINT *) 0 ;
5844 PLINT temp1 ;
5845
5846 arg1 = &temp1;
5847 SWIG_check_num_args("plgstrm",0,0)
5848 plgstrm(arg1);
5849
5850 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5851 return SWIG_arg;
5852
5853 if(0) SWIG_fail;
5854
5855 fail:
5856 lua_error(L);
5857 return SWIG_arg;
5858 }
5859
5860
5861 static int _wrap_gver(lua_State* L) {
5862 int SWIG_arg = 0;
5863 char *arg1 = (char *) 0 ;
5864 char buff1[1000] ;
5865
5866 {
5867 arg1 = buff1;
5868 }
5869 SWIG_check_num_args("plgver",0,0)
5870 plgver(arg1);
5871
5872 {
5873 lua_pushstring( L, arg1 );
5874 SWIG_arg++;
5875 }
5876 return SWIG_arg;
5877
5878 if(0) SWIG_fail;
5879
5880 fail:
5881 lua_error(L);
5882 return SWIG_arg;
5883 }
5884
5885
5886 static int _wrap_gvpd(lua_State* L) {
5887 int SWIG_arg = 0;
5888 PLFLT *arg1 = (PLFLT *) 0 ;
5889 PLFLT *arg2 = (PLFLT *) 0 ;
5890 PLFLT *arg3 = (PLFLT *) 0 ;
5891 PLFLT *arg4 = (PLFLT *) 0 ;
5892 PLFLT temp1 ;
5893 PLFLT temp2 ;
5894 PLFLT temp3 ;
5895 PLFLT temp4 ;
5896
5897 arg1 = &temp1;
5898 arg2 = &temp2;
5899 arg3 = &temp3;
5900 arg4 = &temp4;
5901 SWIG_check_num_args("plgvpd",0,0)
5902 plgvpd(arg1,arg2,arg3,arg4);
5903
5904 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5905 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5906 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5907 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5908 return SWIG_arg;
5909
5910 if(0) SWIG_fail;
5911
5912 fail:
5913 lua_error(L);
5914 return SWIG_arg;
5915 }
5916
5917
5918 static int _wrap_gvpw(lua_State* L) {
5919 int SWIG_arg = 0;
5920 PLFLT *arg1 = (PLFLT *) 0 ;
5921 PLFLT *arg2 = (PLFLT *) 0 ;
5922 PLFLT *arg3 = (PLFLT *) 0 ;
5923 PLFLT *arg4 = (PLFLT *) 0 ;
5924 PLFLT temp1 ;
5925 PLFLT temp2 ;
5926 PLFLT temp3 ;
5927 PLFLT temp4 ;
5928
5929 arg1 = &temp1;
5930 arg2 = &temp2;
5931 arg3 = &temp3;
5932 arg4 = &temp4;
5933 SWIG_check_num_args("plgvpw",0,0)
5934 plgvpw(arg1,arg2,arg3,arg4);
5935
5936 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5937 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5938 lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5939 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5940 return SWIG_arg;
5941
5942 if(0) SWIG_fail;
5943
5944 fail:
5945 lua_error(L);
5946 return SWIG_arg;
5947 }
5948
5949
5950 static int _wrap_gxax(lua_State* L) {
5951 int SWIG_arg = 0;
5952 PLINT *arg1 = (PLINT *) 0 ;
5953 PLINT *arg2 = (PLINT *) 0 ;
5954 PLINT temp1 ;
5955 PLINT temp2 ;
5956
5957 arg1 = &temp1;
5958 arg2 = &temp2;
5959 SWIG_check_num_args("plgxax",0,0)
5960 plgxax(arg1,arg2);
5961
5962 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5963 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5964 return SWIG_arg;
5965
5966 if(0) SWIG_fail;
5967
5968 fail:
5969 lua_error(L);
5970 return SWIG_arg;
5971 }
5972
5973
5974 static int _wrap_gyax(lua_State* L) {
5975 int SWIG_arg = 0;
5976 PLINT *arg1 = (PLINT *) 0 ;
5977 PLINT *arg2 = (PLINT *) 0 ;
5978 PLINT temp1 ;
5979 PLINT temp2 ;
5980
5981 arg1 = &temp1;
5982 arg2 = &temp2;
5983 SWIG_check_num_args("plgyax",0,0)
5984 plgyax(arg1,arg2);
5985
5986 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5987 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5988 return SWIG_arg;
5989
5990 if(0) SWIG_fail;
5991
5992 fail:
5993 lua_error(L);
5994 return SWIG_arg;
5995 }
5996
5997
5998 static int _wrap_gzax(lua_State* L) {
5999 int SWIG_arg = 0;
6000 PLINT *arg1 = (PLINT *) 0 ;
6001 PLINT *arg2 = (PLINT *) 0 ;
6002 PLINT temp1 ;
6003 PLINT temp2 ;
6004
6005 arg1 = &temp1;
6006 arg2 = &temp2;
6007 SWIG_check_num_args("plgzax",0,0)
6008 plgzax(arg1,arg2);
6009
6010 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
6011 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
6012 return SWIG_arg;
6013
6014 if(0) SWIG_fail;
6015
6016 fail:
6017 lua_error(L);
6018 return SWIG_arg;
6019 }
6020
6021
6022 static int _wrap_hist(lua_State* L) {
6023 int SWIG_arg = 0;
6024 PLINT arg1 ;
6025 PLFLT *arg2 = (PLFLT *) 0 ;
6026 PLFLT arg3 ;
6027 PLFLT arg4 ;
6028 PLINT arg5 ;
6029 PLINT arg6 ;
6030
6031 SWIG_check_num_args("plhist",5,5)
6032 if(!lua_isnumber(L,2)) SWIG_fail_arg("plhist",2,"PLFLT");
6033 if(!lua_isnumber(L,3)) SWIG_fail_arg("plhist",3,"PLFLT");
6034 if(!lua_isnumber(L,4)) SWIG_fail_arg("plhist",4,"PLINT");
6035 if(!lua_isnumber(L,5)) SWIG_fail_arg("plhist",5,"PLINT");
6036 {
6037 int temp;
6038 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
6039 if ( !arg2 )
6040 SWIG_fail;
6041 arg1 = Alen = temp;
6042 }
6043 arg3 = (PLFLT)lua_tonumber(L, 2);
6044 arg4 = (PLFLT)lua_tonumber(L, 3);
6045 arg5 = (PLINT)lua_tonumber(L, 4);
6046 arg6 = (PLINT)lua_tonumber(L, 5);
6047 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
6048
6049 {
6050 LUA_FREE_ARRAY( arg2 );
6051 }
6052 return SWIG_arg;
6053
6054 if(0) SWIG_fail;
6055
6056 fail:
6057 {
6058 LUA_FREE_ARRAY( arg2 );
6059 }
6060 lua_error(L);
6061 return SWIG_arg;
6062 }
6063
6064
6065 static int _wrap_hlsrgb(lua_State* L) {
6066 int SWIG_arg = 0;
6067 PLFLT arg1 ;
6068 PLFLT arg2 ;
6069 PLFLT arg3 ;
6070 PLFLT *arg4 = (PLFLT *) 0 ;
6071 PLFLT *arg5 = (PLFLT *) 0 ;
6072 PLFLT *arg6 = (PLFLT *) 0 ;
6073 PLFLT temp4 ;
6074 PLFLT temp5 ;
6075 PLFLT temp6 ;
6076
6077 arg4 = &temp4;
6078 arg5 = &temp5;
6079 arg6 = &temp6;
6080 SWIG_check_num_args("plhlsrgb",3,3)
6081 if(!lua_isnumber(L,1)) SWIG_fail_arg("plhlsrgb",1,"PLFLT");
6082 if(!lua_isnumber(L,2)) SWIG_fail_arg("plhlsrgb",2,"PLFLT");
6083 if(!lua_isnumber(L,3)) SWIG_fail_arg("plhlsrgb",3,"PLFLT");
6084 arg1 = (PLFLT)lua_tonumber(L, 1);
6085 arg2 = (PLFLT)lua_tonumber(L, 2);
6086 arg3 = (PLFLT)lua_tonumber(L, 3);
6087 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
6088
6089 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
6090 lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
6091 lua_pushnumber(L, (lua_Number) *arg6); SWIG_arg++;
6092 return SWIG_arg;
6093
6094 if(0) SWIG_fail;
6095
6096 fail:
6097 lua_error(L);
6098 return SWIG_arg;
6099 }
6100
6101
6102 static int _wrap_init(lua_State* L) {
6103 int SWIG_arg = 0;
6104
6105 SWIG_check_num_args("plinit",0,0)
6106 plinit();
6107
6108 return SWIG_arg;
6109
6110 if(0) SWIG_fail;
6111
6112 fail:
6113 lua_error(L);
6114 return SWIG_arg;
6115 }
6116
6117
6118 static int _wrap_join(lua_State* L) {
6119 int SWIG_arg = 0;
6120 PLFLT arg1 ;
6121 PLFLT arg2 ;
6122 PLFLT arg3 ;
6123 PLFLT arg4 ;
6124
6125 SWIG_check_num_args("pljoin",4,4)
6126 if(!lua_isnumber(L,1)) SWIG_fail_arg("pljoin",1,"PLFLT");
6127 if(!lua_isnumber(L,2)) SWIG_fail_arg("pljoin",2,"PLFLT");
6128 if(!lua_isnumber(L,3)) SWIG_fail_arg("pljoin",3,"PLFLT");
6129 if(!lua_isnumber(L,4)) SWIG_fail_arg("pljoin",4,"PLFLT");
6130 arg1 = (PLFLT)lua_tonumber(L, 1);
6131 arg2 = (PLFLT)lua_tonumber(L, 2);
6132 arg3 = (PLFLT)lua_tonumber(L, 3);
6133 arg4 = (PLFLT)lua_tonumber(L, 4);
6134 pljoin(arg1,arg2,arg3,arg4);
6135
6136 return SWIG_arg;
6137
6138 if(0) SWIG_fail;
6139
6140 fail:
6141 lua_error(L);
6142 return SWIG_arg;
6143 }
6144
6145
6146 static int _wrap_lab(lua_State* L) {
6147 int SWIG_arg = 0;
6148 char *arg1 = (char *) 0 ;
6149 char *arg2 = (char *) 0 ;
6150 char *arg3 = (char *) 0 ;
6151
6152 SWIG_check_num_args("pllab",3,3)
6153 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("pllab",1,"char const *");
6154 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("pllab",2,"char const *");
6155 if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("pllab",3,"char const *");
6156 arg1 = (char *)lua_tostring(L, 1);
6157 arg2 = (char *)lua_tostring(L, 2);
6158 arg3 = (char *)lua_tostring(L, 3);
6159 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
6160
6161 return SWIG_arg;
6162
6163 if(0) SWIG_fail;
6164
6165 fail:
6166 lua_error(L);
6167 return SWIG_arg;
6168 }
6169
6170
6171 static int _wrap_legend(lua_State* L) {
6172 int SWIG_arg = 0;
6173 PLFLT *arg1 = (PLFLT *) 0 ;
6174 PLFLT *arg2 = (PLFLT *) 0 ;
6175 PLINT arg3 ;
6176 PLINT arg4 ;
6177 PLFLT arg5 ;
6178 PLFLT arg6 ;
6179 PLFLT arg7 ;
6180 PLINT arg8 ;
6181 PLINT arg9 ;
6182 PLINT arg10 ;
6183 PLINT arg11 ;
6184 PLINT arg12 ;
6185 PLINT arg13 ;
6186 PLINT *arg14 = (PLINT *) 0 ;
6187 PLFLT arg15 ;
6188 PLFLT arg16 ;
6189 PLFLT arg17 ;
6190 PLFLT arg18 ;
6191 PLINT *arg19 = (PLINT *) 0 ;
6192 char **arg20 = (char **) 0 ;
6193 PLINT *arg21 = (PLINT *) 0 ;
6194 PLINT *arg22 = (PLINT *) 0 ;
6195 PLFLT *arg23 = (PLFLT *) 0 ;
6196 PLFLT *arg24 = (PLFLT *) 0 ;
6197 PLINT *arg25 = (PLINT *) 0 ;
6198 PLINT *arg26 = (PLINT *) 0 ;
6199 PLFLT *arg27 = (PLFLT *) 0 ;
6200 PLINT *arg28 = (PLINT *) 0 ;
6201 PLFLT *arg29 = (PLFLT *) 0 ;
6202 PLINT *arg30 = (PLINT *) 0 ;
6203 char **arg31 = (char **) 0 ;
6204 PLFLT temp1 ;
6205 PLFLT temp2 ;
6206 int temp19 ;
6207 int temp21 ;
6208 int temp22 ;
6209 int temp23 ;
6210 int temp24 ;
6211 int temp25 ;
6212 int temp26 ;
6213 int temp27 ;
6214 int temp28 ;
6215 int temp29 ;
6216 int temp30 ;
6217
6218 {
6219 arg21 = NULL;
6220 }
6221 {
6222 arg22 = NULL;
6223 }
6224 {
6225 arg23 = NULL;
6226 }
6227 {
6228 arg24 = NULL;
6229 }
6230 {
6231 arg25 = NULL;
6232 }
6233 {
6234 arg26 = NULL;
6235 }
6236 {
6237 arg27 = NULL;
6238 }
6239 {
6240 arg28 = NULL;
6241 }
6242 {
6243 arg29 = NULL;
6244 }
6245 {
6246 arg30 = NULL;
6247 }
6248 arg1 = &temp1;
6249 arg2 = &temp2;
6250 SWIG_check_num_args("pllegend",17,28)
6251 if(!lua_isnumber(L,1)) SWIG_fail_arg("pllegend",1,"PLINT");
6252 if(!lua_isnumber(L,2)) SWIG_fail_arg("pllegend",2,"PLINT");
6253 if(!lua_isnumber(L,3)) SWIG_fail_arg("pllegend",3,"PLFLT");
6254 if(!lua_isnumber(L,4)) SWIG_fail_arg("pllegend",4,"PLFLT");
6255 if(!lua_isnumber(L,5)) SWIG_fail_arg("pllegend",5,"PLFLT");
6256 if(!lua_isnumber(L,6)) SWIG_fail_arg("pllegend",6,"PLINT");
6257 if(!lua_isnumber(L,7)) SWIG_fail_arg("pllegend",7,"PLINT");
6258 if(!lua_isnumber(L,8)) SWIG_fail_arg("pllegend",8,"PLINT");
6259 if(!lua_isnumber(L,9)) SWIG_fail_arg("pllegend",9,"PLINT");
6260 if(!lua_isnumber(L,10)) SWIG_fail_arg("pllegend",10,"PLINT");
6261 if(!lua_isnumber(L,12)) SWIG_fail_arg("pllegend",12,"PLFLT");
6262 if(!lua_isnumber(L,13)) SWIG_fail_arg("pllegend",13,"PLFLT");
6263 if(!lua_isnumber(L,14)) SWIG_fail_arg("pllegend",14,"PLFLT");
6264 if(!lua_isnumber(L,15)) SWIG_fail_arg("pllegend",15,"PLFLT");
6265 if(!lua_istable(L,17)) SWIG_fail_arg("pllegend",17,"char const **");
6266 if(lua_gettop(L)>=28 && !lua_istable(L,28)) SWIG_fail_arg("pllegend",28,"char const **");
6267 arg3 = (PLINT)lua_tonumber(L, 1);
6268 arg4 = (PLINT)lua_tonumber(L, 2);
6269 arg5 = (PLFLT)lua_tonumber(L, 3);
6270 arg6 = (PLFLT)lua_tonumber(L, 4);
6271 arg7 = (PLFLT)lua_tonumber(L, 5);
6272 arg8 = (PLINT)lua_tonumber(L, 6);
6273 arg9 = (PLINT)lua_tonumber(L, 7);
6274 arg10 = (PLINT)lua_tonumber(L, 8);
6275 arg11 = (PLINT)lua_tonumber(L, 9);
6276 arg12 = (PLINT)lua_tonumber(L, 10);
6277 {
6278 arg14 = (PLINT *) LUA_get_int_num_array_var( L, 11, &arg13 );
6279 if ( !arg14 )
6280 SWIG_fail;
6281 Alen = arg13;
6282 }
6283 arg15 = (PLFLT)lua_tonumber(L, 12);
6284 arg16 = (PLFLT)lua_tonumber(L, 13);
6285 arg17 = (PLFLT)lua_tonumber(L, 14);
6286 arg18 = (PLFLT)lua_tonumber(L, 15);
6287 {
6288 arg19 = (PLINT *) LUA_get_int_num_array_var( L, 16, &temp19 );
6289 if ( !arg19 )
6290 SWIG_fail;
6291 if ( temp19 != Alen )
6292 {
6293 lua_pushfstring( L, "Tables must be of same length." );
6294 SWIG_fail;
6295 }
6296 }
6297 {
6298 int i;
6299 arg20 = NULL;
6300
6301 if ( SWIG_table_size( L, 17 ) != Alen )
6302 {
6303 lua_pushfstring( L, "Tables must be of same length." );
6304 SWIG_fail;
6305 }
6306 arg20 = malloc( sizeof ( char* ) * Alen );
6307 for ( i = 1; i <= Alen; i++ )
6308 {
6309 lua_rawgeti( L, 17, i );
6310 if ( lua_isstring( L, -1 ) )
6311 {
6312 arg20[i - 1] = (char *) lua_tostring( L, -1 );
6313 }
6314 else
6315 {
6316 lua_pop( L, 1 );
6317 lua_pushfstring( L, "Requires a sequence of strings." );
6318 SWIG_fail;
6319 // arg20 array is freed after 'fail:'
6320 }
6321 lua_pop( L, 1 );
6322 }
6323 }
6324 if(lua_gettop(L)>=18){
6325 {
6326 if ( lua_isnil( L, 18 ) )
6327 {
6328 arg21 = NULL;
6329 }
6330 else
6331 {
6332 arg21 = (PLINT *) LUA_get_int_num_array_var( L, 18, &temp21 );
6333 if ( !arg21 )
6334 SWIG_fail;
6335 if ( temp21 != Alen )
6336 {
6337 lua_pushfstring( L, "Tables must be of same length." );
6338 SWIG_fail;
6339 }
6340 }
6341 }
6342 }
6343 if(lua_gettop(L)>=19){
6344 {
6345 if ( lua_isnil( L, 19 ) )
6346 {
6347 arg22 = NULL;
6348 }
6349 else
6350 {
6351 arg22 = (PLINT *) LUA_get_int_num_array_var( L, 19, &temp22 );
6352 if ( !arg22 )
6353 SWIG_fail;
6354 if ( temp22 != Alen )
6355 {
6356 lua_pushfstring( L, "Tables must be of same length." );
6357 SWIG_fail;
6358 }
6359 }
6360 }
6361 }
6362 if(lua_gettop(L)>=20){
6363 {
6364 if ( lua_isnil( L, 20 ) )
6365 {
6366 arg23 = NULL;
6367 }
6368 else
6369 {
6370 arg23 = (PLFLT *) LUA_get_double_num_array_var( L, 20, &temp23 );
6371 if ( !arg23 )
6372 SWIG_fail;
6373 if ( temp23 != Alen )
6374 {
6375 lua_pushfstring( L, "Tables must be of same length." );
6376 SWIG_fail;
6377 }
6378 }
6379 }
6380 }
6381 if(lua_gettop(L)>=21){
6382 {
6383 if ( lua_isnil( L, 21 ) )
6384 {
6385 arg24 = NULL;
6386 }
6387 else
6388 {
6389 arg24 = (PLFLT *) LUA_get_double_num_array_var( L, 21, &temp24 );
6390 if ( !arg24 )
6391 SWIG_fail;
6392 if ( temp24 != Alen )
6393 {
6394 lua_pushfstring( L, "Tables must be of same length." );
6395 SWIG_fail;
6396 }
6397 }
6398 }
6399 }
6400 if(lua_gettop(L)>=22){
6401 {
6402 if ( lua_isnil( L, 22 ) )
6403 {
6404 arg25 = NULL;
6405 }
6406 else
6407 {
6408 arg25 = (PLINT *) LUA_get_int_num_array_var( L, 22, &temp25 );
6409 if ( !arg25 )
6410 SWIG_fail;
6411 if ( temp25 != Alen )
6412 {
6413 lua_pushfstring( L, "Tables must be of same length." );
6414 SWIG_fail;
6415 }
6416 }
6417 }
6418 }
6419 if(lua_gettop(L)>=23){
6420 {
6421 if ( lua_isnil( L, 23 ) )
6422 {
6423 arg26 = NULL;
6424 }
6425 else
6426 {
6427 arg26 = (PLINT *) LUA_get_int_num_array_var( L, 23, &temp26 );
6428 if ( !arg26 )
6429 SWIG_fail;
6430 if ( temp26 != Alen )
6431 {
6432 lua_pushfstring( L, "Tables must be of same length." );
6433 SWIG_fail;
6434 }
6435 }
6436 }
6437 }
6438 if(lua_gettop(L)>=24){
6439 {
6440 if ( lua_isnil( L, 24 ) )
6441 {
6442 arg27 = NULL;
6443 }
6444 else
6445 {
6446 arg27 = (PLFLT *) LUA_get_double_num_array_var( L, 24, &temp27 );
6447 if ( !arg27 )
6448 SWIG_fail;
6449 if ( temp27 != Alen )
6450 {
6451 lua_pushfstring( L, "Tables must be of same length." );
6452 SWIG_fail;
6453 }
6454 }
6455 }
6456 }
6457 if(lua_gettop(L)>=25){
6458 {
6459 if ( lua_isnil( L, 25 ) )
6460 {
6461 arg28 = NULL;
6462 }
6463 else
6464 {
6465 arg28 = (PLINT *) LUA_get_int_num_array_var( L, 25, &temp28 );
6466 if ( !arg28 )
6467 SWIG_fail;
6468 if ( temp28 != Alen )
6469 {
6470 lua_pushfstring( L, "Tables must be of same length." );
6471 SWIG_fail;
6472 }
6473 }
6474 }
6475 }
6476 if(lua_gettop(L)>=26){
6477 {
6478 if ( lua_isnil( L, 26 ) )
6479 {
6480 arg29 = NULL;
6481 }
6482 else
6483 {
6484 arg29 = (PLFLT *) LUA_get_double_num_array_var( L, 26, &temp29 );
6485 if ( !arg29 )
6486 SWIG_fail;
6487 if ( temp29 != Alen )
6488 {
6489 lua_pushfstring( L, "Tables must be of same length." );
6490 SWIG_fail;
6491 }
6492 }
6493 }
6494 }
6495 if(lua_gettop(L)>=27){
6496 {
6497 if ( lua_isnil( L, 27 ) )
6498 {
6499 arg30 = NULL;
6500 }
6501 else
6502 {
6503 arg30 = (PLINT *) LUA_get_int_num_array_var( L, 27, &temp30 );
6504 if ( !arg30 )
6505 SWIG_fail;
6506 if ( temp30 != Alen )
6507 {
6508 lua_pushfstring( L, "Tables must be of same length." );
6509 SWIG_fail;
6510 }
6511 }
6512 }
6513 }
6514 if(lua_gettop(L)>=28){
6515 {
6516 int i;
6517 arg31 = NULL;
6518
6519 if ( SWIG_table_size( L, 28 ) != Alen )
6520 {
6521 lua_pushfstring( L, "Tables must be of same length." );
6522 SWIG_fail;
6523 }
6524 arg31 = malloc( sizeof ( char* ) * Alen );
6525 for ( i = 1; i <= Alen; i++ )
6526 {
6527 lua_rawgeti( L, 28, i );
6528 if ( lua_isstring( L, -1 ) )
6529 {
6530 arg31[i - 1] = (char *) lua_tostring( L, -1 );
6531 }
6532 else
6533 {
6534 lua_pop( L, 1 );
6535 lua_pushfstring( L, "Requires a sequence of strings." );
6536 SWIG_fail;
6537 // arg31 array is freed after 'fail:'
6538 }
6539 lua_pop( L, 1 );
6540 }
6541 }
6542 }
6543 pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(int const *)arg14,arg15,arg16,arg17,arg18,(int const *)arg19,(char const **)arg20,(int const *)arg21,(int const *)arg22,(double const *)arg23,(double const *)arg24,(int const *)arg25,(int const *)arg26,(double const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
6544
6545 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
6546 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
6547 {
6548 LUA_FREE_ARRAY( arg14 );
6549 }
6550 {
6551 LUA_FREE_ARRAY( arg19 );
6552 }
6553 {
6554 if ( arg20 )
6555 {
6556 free( arg20 ); arg20 = NULL;
6557 }
6558 }
6559 {
6560 LUA_FREE_ARRAY( arg21 );
6561 }
6562 {
6563 LUA_FREE_ARRAY( arg22 );
6564 }
6565 {
6566 LUA_FREE_ARRAY( arg23 );
6567 }
6568 {
6569 LUA_FREE_ARRAY( arg24 );
6570 }
6571 {
6572 LUA_FREE_ARRAY( arg25 );
6573 }
6574 {
6575 LUA_FREE_ARRAY( arg26 );
6576 }
6577 {
6578 LUA_FREE_ARRAY( arg27 );
6579 }
6580 {
6581 LUA_FREE_ARRAY( arg28 );
6582 }
6583 {
6584 LUA_FREE_ARRAY( arg29 );
6585 }
6586 {
6587 LUA_FREE_ARRAY( arg30 );
6588 }
6589 {
6590 if ( arg31 )
6591 {
6592 free( arg31 ); arg31 = NULL;
6593 }
6594 }
6595 return SWIG_arg;
6596
6597 if(0) SWIG_fail;
6598
6599 fail:
6600 {
6601 LUA_FREE_ARRAY( arg14 );
6602 }
6603 {
6604 LUA_FREE_ARRAY( arg19 );
6605 }
6606 {
6607 if ( arg20 )
6608 {
6609 free( arg20 ); arg20 = NULL;
6610 }
6611 }
6612 {
6613 LUA_FREE_ARRAY( arg21 );
6614 }
6615 {
6616 LUA_FREE_ARRAY( arg22 );
6617 }
6618 {
6619 LUA_FREE_ARRAY( arg23 );
6620 }
6621 {
6622 LUA_FREE_ARRAY( arg24 );
6623 }
6624 {
6625 LUA_FREE_ARRAY( arg25 );
6626 }
6627 {
6628 LUA_FREE_ARRAY( arg26 );
6629 }
6630 {
6631 LUA_FREE_ARRAY( arg27 );
6632 }
6633 {
6634 LUA_FREE_ARRAY( arg28 );
6635 }
6636 {
6637 LUA_FREE_ARRAY( arg29 );
6638 }
6639 {
6640 LUA_FREE_ARRAY( arg30 );
6641 }
6642 {
6643 if ( arg31 )
6644 {
6645 free( arg31 ); arg31 = NULL;
6646 }
6647 }
6648 lua_error(L);
6649 return SWIG_arg;
6650 }
6651
6652
6653 static int _wrap_colorbar(lua_State* L) {
6654 int SWIG_arg = 0;
6655 PLFLT *arg1 = (PLFLT *) 0 ;
6656 PLFLT *arg2 = (PLFLT *) 0 ;
6657 PLINT arg3 ;
6658 PLINT arg4 ;
6659 PLFLT arg5 ;
6660 PLFLT arg6 ;
6661 PLFLT arg7 ;
6662 PLFLT arg8 ;
6663 PLINT arg9 ;
6664 PLINT arg10 ;
6665 PLINT arg11 ;
6666 PLFLT arg12 ;
6667 PLFLT arg13 ;
6668 PLINT arg14 ;
6669 PLFLT arg15 ;
6670 PLINT arg16 ;
6671 PLINT *arg17 = (PLINT *) 0 ;
6672 char **arg18 = (char **) 0 ;
6673 PLINT arg19 ;
6674 char **arg20 = (char **) 0 ;
6675 PLFLT *arg21 = (PLFLT *) 0 ;
6676 PLINT *arg22 = (PLINT *) 0 ;
6677 PLINT *arg23 = (PLINT *) 0 ;
6678 PLFLT **arg24 = (PLFLT **) 0 ;
6679 PLFLT temp1 ;
6680 PLFLT temp2 ;
6681 int temp21 ;
6682 int temp22 ;
6683 int temp23 ;
6684 int ii24 ;
6685
6686 arg1 = &temp1;
6687 arg2 = &temp2;
6688 SWIG_check_num_args("plcolorbar",20,20)
6689 if(!lua_isnumber(L,1)) SWIG_fail_arg("plcolorbar",1,"PLINT");
6690 if(!lua_isnumber(L,2)) SWIG_fail_arg("plcolorbar",2,"PLINT");
6691 if(!lua_isnumber(L,3)) SWIG_fail_arg("plcolorbar",3,"PLFLT");
6692 if(!lua_isnumber(L,4)) SWIG_fail_arg("plcolorbar",4,"PLFLT");
6693 if(!lua_isnumber(L,5)) SWIG_fail_arg("plcolorbar",5,"PLFLT");
6694 if(!lua_isnumber(L,6)) SWIG_fail_arg("plcolorbar",6,"PLFLT");
6695 if(!lua_isnumber(L,7)) SWIG_fail_arg("plcolorbar",7,"PLINT");
6696 if(!lua_isnumber(L,8)) SWIG_fail_arg("plcolorbar",8,"PLINT");
6697 if(!lua_isnumber(L,9)) SWIG_fail_arg("plcolorbar",9,"PLINT");
6698 if(!lua_isnumber(L,10)) SWIG_fail_arg("plcolorbar",10,"PLFLT");
6699 if(!lua_isnumber(L,11)) SWIG_fail_arg("plcolorbar",11,"PLFLT");
6700 if(!lua_isnumber(L,12)) SWIG_fail_arg("plcolorbar",12,"PLINT");
6701 if(!lua_isnumber(L,13)) SWIG_fail_arg("plcolorbar",13,"PLFLT");
6702 if(!lua_istable(L,15)) SWIG_fail_arg("plcolorbar",15,"char const **");
6703 arg3 = (PLINT)lua_tonumber(L, 1);
6704 arg4 = (PLINT)lua_tonumber(L, 2);
6705 arg5 = (PLFLT)lua_tonumber(L, 3);
6706 arg6 = (PLFLT)lua_tonumber(L, 4);
6707 arg7 = (PLFLT)lua_tonumber(L, 5);
6708 arg8 = (PLFLT)lua_tonumber(L, 6);
6709 arg9 = (PLINT)lua_tonumber(L, 7);
6710 arg10 = (PLINT)lua_tonumber(L, 8);
6711 arg11 = (PLINT)lua_tonumber(L, 9);
6712 arg12 = (PLFLT)lua_tonumber(L, 10);
6713 arg13 = (PLFLT)lua_tonumber(L, 11);
6714 arg14 = (PLINT)lua_tonumber(L, 12);
6715 arg15 = (PLFLT)lua_tonumber(L, 13);
6716 {
6717 arg17 = (PLINT *) LUA_get_int_num_array_var( L, 14, &arg16 );
6718 if ( !arg17 )
6719 SWIG_fail;
6720 Alen = arg16;
6721 }
6722 {
6723 int i;
6724 arg18 = NULL;
6725
6726 if ( SWIG_table_size( L, 15 ) != Alen )
6727 {
6728 lua_pushfstring( L, "Tables must be of same length." );
6729 SWIG_fail;
6730 }
6731 arg18 = malloc( sizeof ( char* ) * Alen );
6732 for ( i = 1; i <= Alen; i++ )
6733 {
6734 lua_rawgeti( L, 15, i );
6735 if ( lua_isstring( L, -1 ) )
6736 {
6737 arg18[i - 1] = (char *) lua_tostring( L, -1 );
6738 }
6739 else
6740 {
6741 lua_pop( L, 1 );
6742 lua_pushfstring( L, "Requires a sequence of strings." );
6743 SWIG_fail;
6744 // arg18 array is freed after 'fail:'
6745 }
6746 lua_pop( L, 1 );
6747 }
6748 }
6749 {
6750 int i;
6751 arg19 = SWIG_table_size( L, 16 );
6752 Alen = arg19;
6753
6754 arg20 = malloc( sizeof ( char* ) * Alen );
6755 for ( i = 1; i <= Alen; i++ )
6756 {
6757 lua_rawgeti( L, 16, i );
6758 if ( lua_isstring( L, -1 ) )
6759 {
6760 arg20[i - 1] = (char *) lua_tostring( L, -1 );
6761 }
6762 else
6763 {
6764 lua_pop( L, 1 );
6765 lua_pushfstring( L, "Requires a sequence of strings." );
6766 SWIG_fail;
6767 }
6768 lua_pop( L, 1 );
6769 }
6770 }
6771 {
6772 arg21 = (PLFLT *) LUA_get_double_num_array_var( L, 17, &temp21 );
6773 if ( !arg21 )
6774 SWIG_fail;
6775 if ( temp21 != Alen )
6776 {
6777 lua_pushfstring( L, "Tables must be of same length." );
6778 SWIG_fail;
6779 }
6780 }
6781 {
6782 arg22 = (PLINT *) LUA_get_int_num_array_var( L, 18, &temp22 );
6783 if ( !arg22 )
6784 SWIG_fail;
6785 if ( temp22 != Alen )
6786 {
6787 lua_pushfstring( L, "Tables must be of same length." );
6788 SWIG_fail;
6789 }
6790 }
6791 {
6792 int i;
6793
6794 arg23 = (PLINT *) LUA_get_int_num_array_var( L, 19, &temp23 );
6795 if ( !arg23 )
6796 SWIG_fail;
6797 if ( temp23 != Alen )
6798 {
6799 lua_pushfstring( L, "Tables must be of same length." );
6800 SWIG_fail;
6801 }
6802
6803 Xlen = temp23;
6804 Ylen = -1;
6805 for ( i = 0; i < Xlen; i++ )
6806 if ( arg23[i] > Ylen )
6807 Ylen = arg23[i];
6808 }
6809 {
6810 int jj;
6811
6812 arg24 = read_double_Matrix( L, 20, &ii24, &jj );
6813 if ( !arg24 )
6814 SWIG_fail;
6815 if ( ( ii24 != Xlen ) || ( jj != Ylen ) )
6816 {
6817 lua_pushfstring( L, "Vectors must match matrix." );
6818 SWIG_fail;
6819 }
6820 }
6821 plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(int const *)arg17,(char const **)arg18,arg19,(char const **)arg20,(double const *)arg21,(int const *)arg22,(int const *)arg23,(double const **)arg24);
6822
6823 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
6824 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
6825 {
6826 LUA_FREE_ARRAY( arg17 );
6827 }
6828 {
6829 if ( arg18 )
6830 {
6831 free( arg18 ); arg18 = NULL;
6832 }
6833 }
6834 {
6835 if ( arg20 )
6836 {
6837 free( arg20 ); arg20 = NULL;
6838 }
6839 }
6840 {
6841 LUA_FREE_ARRAY( arg21 );
6842 }
6843 {
6844 LUA_FREE_ARRAY( arg22 );
6845 }
6846 {
6847 LUA_FREE_ARRAY( arg23 );
6848 }
6849 {
6850 int i;
6851
6852 if ( arg24 )
6853 {
6854 for ( i = 0; i < ii24; i++ )
6855 LUA_FREE_ARRAY( arg24[i] );
6856 LUA_FREE_ARRAY( arg24 );
6857 }
6858 }
6859 return SWIG_arg;
6860
6861 if(0) SWIG_fail;
6862
6863 fail:
6864 {
6865 LUA_FREE_ARRAY( arg17 );
6866 }
6867 {
6868 if ( arg18 )
6869 {
6870 free( arg18 ); arg18 = NULL;
6871 }
6872 }
6873 {
6874 if ( arg20 )
6875 {
6876 free( arg20 ); arg20 = NULL;
6877 }
6878 }
6879 {
6880 LUA_FREE_ARRAY( arg21 );
6881 }
6882 {
6883 LUA_FREE_ARRAY( arg22 );
6884 }
6885 {
6886 LUA_FREE_ARRAY( arg23 );
6887 }
6888 {
6889 int i;
6890
6891 if ( arg24 )
6892 {
6893 for ( i = 0; i < ii24; i++ )
6894 LUA_FREE_ARRAY( arg24[i] );
6895 LUA_FREE_ARRAY( arg24 );
6896 }
6897 }
6898 lua_error(L);
6899 return SWIG_arg;
6900 }
6901
6902
6903 static int _wrap_lightsource(lua_State* L) {
6904 int SWIG_arg = 0;
6905 PLFLT arg1 ;
6906 PLFLT arg2 ;
6907 PLFLT arg3 ;
6908
6909 SWIG_check_num_args("pllightsource",3,3)
6910 if(!lua_isnumber(L,1)) SWIG_fail_arg("pllightsource",1,"PLFLT");
6911 if(!lua_isnumber(L,2)) SWIG_fail_arg("pllightsource",2,"PLFLT");
6912 if(!lua_isnumber(L,3)) SWIG_fail_arg("pllightsource",3,"PLFLT");
6913 arg1 = (PLFLT)lua_tonumber(L, 1);
6914 arg2 = (PLFLT)lua_tonumber(L, 2);
6915 arg3 = (PLFLT)lua_tonumber(L, 3);
6916 pllightsource(arg1,arg2,arg3);
6917
6918 return SWIG_arg;
6919
6920 if(0) SWIG_fail;
6921
6922 fail:
6923 lua_error(L);
6924 return SWIG_arg;
6925 }
6926
6927
6928 static int _wrap_line(lua_State* L) {
6929 int SWIG_arg = 0;
6930 PLINT arg1 ;
6931 PLFLT *arg2 = (PLFLT *) 0 ;
6932 PLFLT *arg3 = (PLFLT *) 0 ;
6933 int temp3 ;
6934
6935 SWIG_check_num_args("plline",2,2)
6936 {
6937 int temp;
6938 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
6939 if ( !arg2 )
6940 SWIG_fail;
6941 arg1 = Alen = temp;
6942 }
6943 {
6944 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
6945 if ( !arg3 )
6946 SWIG_fail;
6947 if ( temp3 != Alen )
6948 {
6949 lua_pushfstring( L, "Tables must be of same length." );
6950 SWIG_fail;
6951 }
6952 }
6953 plline(arg1,(double const *)arg2,(double const *)arg3);
6954
6955 {
6956 LUA_FREE_ARRAY( arg2 );
6957 }
6958 {
6959 LUA_FREE_ARRAY( arg3 );
6960 }
6961 return SWIG_arg;
6962
6963 if(0) SWIG_fail;
6964
6965 fail:
6966 {
6967 LUA_FREE_ARRAY( arg2 );
6968 }
6969 {
6970 LUA_FREE_ARRAY( arg3 );
6971 }
6972 lua_error(L);
6973 return SWIG_arg;
6974 }
6975
6976
6977 static int _wrap_line3(lua_State* L) {
6978 int SWIG_arg = 0;
6979 PLINT arg1 ;
6980 PLFLT *arg2 = (PLFLT *) 0 ;
6981 PLFLT *arg3 = (PLFLT *) 0 ;
6982 PLFLT *arg4 = (PLFLT *) 0 ;
6983 int temp3 ;
6984 int temp4 ;
6985
6986 SWIG_check_num_args("plline3",3,3)
6987 {
6988 int temp;
6989 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
6990 if ( !arg2 )
6991 SWIG_fail;
6992 arg1 = Alen = temp;
6993 }
6994 {
6995 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
6996 if ( !arg3 )
6997 SWIG_fail;
6998 if ( temp3 != Alen )
6999 {
7000 lua_pushfstring( L, "Tables must be of same length." );
7001 SWIG_fail;
7002 }
7003 }
7004 {
7005 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
7006 if ( !arg4 )
7007 SWIG_fail;
7008 if ( temp4 != Alen )
7009 {
7010 lua_pushfstring( L, "Tables must be of same length." );
7011 SWIG_fail;
7012 }
7013 }
7014 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
7015
7016 {
7017 LUA_FREE_ARRAY( arg2 );
7018 }
7019 {
7020 LUA_FREE_ARRAY( arg3 );
7021 }
7022 {
7023 LUA_FREE_ARRAY( arg4 );
7024 }
7025 return SWIG_arg;
7026
7027 if(0) SWIG_fail;
7028
7029 fail:
7030 {
7031 LUA_FREE_ARRAY( arg2 );
7032 }
7033 {
7034 LUA_FREE_ARRAY( arg3 );
7035 }
7036 {
7037 LUA_FREE_ARRAY( arg4 );
7038 }
7039 lua_error(L);
7040 return SWIG_arg;
7041 }
7042
7043
7044 static int _wrap_lsty(lua_State* L) {
7045 int SWIG_arg = 0;
7046 PLINT arg1 ;
7047
7048 SWIG_check_num_args("pllsty",1,1)
7049 if(!lua_isnumber(L,1)) SWIG_fail_arg("pllsty",1,"PLINT");
7050 arg1 = (PLINT)lua_tonumber(L, 1);
7051 pllsty(arg1);
7052
7053 return SWIG_arg;
7054
7055 if(0) SWIG_fail;
7056
7057 fail:
7058 lua_error(L);
7059 return SWIG_arg;
7060 }
7061
7062
7063 static int _wrap_mesh(lua_State* L) {
7064 int SWIG_arg = 0;
7065 PLFLT *arg1 = (PLFLT *) 0 ;
7066 PLFLT *arg2 = (PLFLT *) 0 ;
7067 PLFLT **arg3 = (PLFLT **) 0 ;
7068 PLINT arg4 ;
7069 PLINT arg5 ;
7070 PLINT arg6 ;
7071 int ii3 ;
7072
7073 SWIG_check_num_args("plmesh",4,4)
7074 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmesh",4,"PLINT");
7075 {
7076 int temp;
7077 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7078 if ( !arg1 )
7079 SWIG_fail;
7080 Xlen = temp;
7081 }
7082 {
7083 int temp;
7084 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7085 if ( !arg2 )
7086 SWIG_fail;
7087 Ylen = temp;
7088 }
7089 {
7090 int jj;
7091
7092 arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7093 if ( !arg3 )
7094 SWIG_fail;
7095 arg4 = ii3;
7096 arg5 = jj;
7097 if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7098 {
7099 lua_pushfstring( L, "Vectors must match matrix." );
7100 SWIG_fail;
7101 }
7102 }
7103 arg6 = (PLINT)lua_tonumber(L, 4);
7104 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
7105
7106 {
7107 LUA_FREE_ARRAY( arg1 );
7108 }
7109 {
7110 LUA_FREE_ARRAY( arg2 );
7111 }
7112 {
7113 int i;
7114
7115 if ( arg3 )
7116 {
7117 for ( i = 0; i < ii3; i++ )
7118 LUA_FREE_ARRAY( arg3[i] );
7119 LUA_FREE_ARRAY( arg3 );
7120 }
7121 }
7122 return SWIG_arg;
7123
7124 if(0) SWIG_fail;
7125
7126 fail:
7127 {
7128 LUA_FREE_ARRAY( arg1 );
7129 }
7130 {
7131 LUA_FREE_ARRAY( arg2 );
7132 }
7133 {
7134 int i;
7135
7136 if ( arg3 )
7137 {
7138 for ( i = 0; i < ii3; i++ )
7139 LUA_FREE_ARRAY( arg3[i] );
7140 LUA_FREE_ARRAY( arg3 );
7141 }
7142 }
7143 lua_error(L);
7144 return SWIG_arg;
7145 }
7146
7147
7148 static int _wrap_meshc(lua_State* L) {
7149 int SWIG_arg = 0;
7150 PLFLT *arg1 = (PLFLT *) 0 ;
7151 PLFLT *arg2 = (PLFLT *) 0 ;
7152 PLFLT **arg3 = (PLFLT **) 0 ;
7153 PLINT arg4 ;
7154 PLINT arg5 ;
7155 PLINT arg6 ;
7156 PLFLT *arg7 = (PLFLT *) 0 ;
7157 PLINT arg8 ;
7158 int ii3 ;
7159
7160 SWIG_check_num_args("plmeshc",5,5)
7161 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmeshc",4,"PLINT");
7162 {
7163 int temp;
7164 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7165 if ( !arg1 )
7166 SWIG_fail;
7167 Xlen = temp;
7168 }
7169 {
7170 int temp;
7171 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7172 if ( !arg2 )
7173 SWIG_fail;
7174 Ylen = temp;
7175 }
7176 {
7177 int jj;
7178
7179 arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7180 if ( !arg3 )
7181 SWIG_fail;
7182 arg4 = ii3;
7183 arg5 = jj;
7184 if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7185 {
7186 lua_pushfstring( L, "Vectors must match matrix." );
7187 SWIG_fail;
7188 }
7189 }
7190 arg6 = (PLINT)lua_tonumber(L, 4);
7191 {
7192 int temp;
7193 arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7194 if ( !arg7 )
7195 SWIG_fail;
7196 arg8 = Alen = temp;
7197 }
7198 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
7199
7200 {
7201 LUA_FREE_ARRAY( arg1 );
7202 }
7203 {
7204 LUA_FREE_ARRAY( arg2 );
7205 }
7206 {
7207 int i;
7208
7209 if ( arg3 )
7210 {
7211 for ( i = 0; i < ii3; i++ )
7212 LUA_FREE_ARRAY( arg3[i] );
7213 LUA_FREE_ARRAY( arg3 );
7214 }
7215 }
7216 {
7217 LUA_FREE_ARRAY( arg7 );
7218 }
7219 return SWIG_arg;
7220
7221 if(0) SWIG_fail;
7222
7223 fail:
7224 {
7225 LUA_FREE_ARRAY( arg1 );
7226 }
7227 {
7228 LUA_FREE_ARRAY( arg2 );
7229 }
7230 {
7231 int i;
7232
7233 if ( arg3 )
7234 {
7235 for ( i = 0; i < ii3; i++ )
7236 LUA_FREE_ARRAY( arg3[i] );
7237 LUA_FREE_ARRAY( arg3 );
7238 }
7239 }
7240 {
7241 LUA_FREE_ARRAY( arg7 );
7242 }
7243 lua_error(L);
7244 return SWIG_arg;
7245 }
7246
7247
7248 static int _wrap_mkstrm(lua_State* L) {
7249 int SWIG_arg = 0;
7250 PLINT *arg1 = (PLINT *) 0 ;
7251 PLINT temp1 ;
7252
7253 arg1 = &temp1;
7254 SWIG_check_num_args("plmkstrm",0,0)
7255 plmkstrm(arg1);
7256
7257 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
7258 return SWIG_arg;
7259
7260 if(0) SWIG_fail;
7261
7262 fail:
7263 lua_error(L);
7264 return SWIG_arg;
7265 }
7266
7267
7268 static int _wrap_mtex(lua_State* L) {
7269 int SWIG_arg = 0;
7270 char *arg1 = (char *) 0 ;
7271 PLFLT arg2 ;
7272 PLFLT arg3 ;
7273 PLFLT arg4 ;
7274 char *arg5 = (char *) 0 ;
7275
7276 SWIG_check_num_args("plmtex",5,5)
7277 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plmtex",1,"char const *");
7278 if(!lua_isnumber(L,2)) SWIG_fail_arg("plmtex",2,"PLFLT");
7279 if(!lua_isnumber(L,3)) SWIG_fail_arg("plmtex",3,"PLFLT");
7280 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmtex",4,"PLFLT");
7281 if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("plmtex",5,"char const *");
7282 arg1 = (char *)lua_tostring(L, 1);
7283 arg2 = (PLFLT)lua_tonumber(L, 2);
7284 arg3 = (PLFLT)lua_tonumber(L, 3);
7285 arg4 = (PLFLT)lua_tonumber(L, 4);
7286 arg5 = (char *)lua_tostring(L, 5);
7287 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
7288
7289 return SWIG_arg;
7290
7291 if(0) SWIG_fail;
7292
7293 fail:
7294 lua_error(L);
7295 return SWIG_arg;
7296 }
7297
7298
7299 static int _wrap_mtex3(lua_State* L) {
7300 int SWIG_arg = 0;
7301 char *arg1 = (char *) 0 ;
7302 PLFLT arg2 ;
7303 PLFLT arg3 ;
7304 PLFLT arg4 ;
7305 char *arg5 = (char *) 0 ;
7306
7307 SWIG_check_num_args("plmtex3",5,5)
7308 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plmtex3",1,"char const *");
7309 if(!lua_isnumber(L,2)) SWIG_fail_arg("plmtex3",2,"PLFLT");
7310 if(!lua_isnumber(L,3)) SWIG_fail_arg("plmtex3",3,"PLFLT");
7311 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmtex3",4,"PLFLT");
7312 if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("plmtex3",5,"char const *");
7313 arg1 = (char *)lua_tostring(L, 1);
7314 arg2 = (PLFLT)lua_tonumber(L, 2);
7315 arg3 = (PLFLT)lua_tonumber(L, 3);
7316 arg4 = (PLFLT)lua_tonumber(L, 4);
7317 arg5 = (char *)lua_tostring(L, 5);
7318 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
7319
7320 return SWIG_arg;
7321
7322 if(0) SWIG_fail;
7323
7324 fail:
7325 lua_error(L);
7326 return SWIG_arg;
7327 }
7328
7329
7330 static int _wrap_plot3d(lua_State* L) {
7331 int SWIG_arg = 0;
7332 PLFLT *arg1 = (PLFLT *) 0 ;
7333 PLFLT *arg2 = (PLFLT *) 0 ;
7334 PLFLT **arg3 = (PLFLT **) 0 ;
7335 PLINT arg4 ;
7336 PLINT arg5 ;
7337 PLINT arg6 ;
7338 PLBOOL arg7 ;
7339 int ii3 ;
7340
7341 SWIG_check_num_args("plot3d",5,5)
7342 if(!lua_isnumber(L,4)) SWIG_fail_arg("plot3d",4,"PLINT");
7343 if(!lua_isnumber(L,5)) SWIG_fail_arg("plot3d",5,"PLBOOL");
7344 {
7345 int temp;
7346 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7347 if ( !arg1 )
7348 SWIG_fail;
7349 Xlen = temp;
7350 }
7351 {
7352 int temp;
7353 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7354 if ( !arg2 )
7355 SWIG_fail;
7356 Ylen = temp;
7357 }
7358 {
7359 int jj;
7360
7361 arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7362 if ( !arg3 )
7363 SWIG_fail;
7364 arg4 = ii3;
7365 arg5 = jj;
7366 if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7367 {
7368 lua_pushfstring( L, "Vectors must match matrix." );
7369 SWIG_fail;
7370 }
7371 }
7372 arg6 = (PLINT)lua_tonumber(L, 4);
7373 arg7 = (PLBOOL)lua_tonumber(L, 5);
7374 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
7375
7376 {
7377 LUA_FREE_ARRAY( arg1 );
7378 }
7379 {
7380 LUA_FREE_ARRAY( arg2 );
7381 }
7382 {
7383 int i;
7384
7385 if ( arg3 )
7386 {
7387 for ( i = 0; i < ii3; i++ )
7388 LUA_FREE_ARRAY( arg3[i] );
7389 LUA_FREE_ARRAY( arg3 );
7390 }
7391 }
7392 return SWIG_arg;
7393
7394 if(0) SWIG_fail;
7395
7396 fail:
7397 {
7398 LUA_FREE_ARRAY( arg1 );
7399 }
7400 {
7401 LUA_FREE_ARRAY( arg2 );
7402 }
7403 {
7404 int i;
7405
7406 if ( arg3 )
7407 {
7408 for ( i = 0; i < ii3; i++ )
7409 LUA_FREE_ARRAY( arg3[i] );
7410 LUA_FREE_ARRAY( arg3 );
7411 }
7412 }
7413 lua_error(L);
7414 return SWIG_arg;
7415 }
7416
7417
7418 static int _wrap_plot3dc(lua_State* L) {
7419 int SWIG_arg = 0;
7420 PLFLT *arg1 = (PLFLT *) 0 ;
7421 PLFLT *arg2 = (PLFLT *) 0 ;
7422 PLFLT **arg3 = (PLFLT **) 0 ;
7423 PLINT arg4 ;
7424 PLINT arg5 ;
7425 PLINT arg6 ;
7426 PLFLT *arg7 = (PLFLT *) 0 ;
7427 PLINT arg8 ;
7428 int ii3 ;
7429
7430 SWIG_check_num_args("plot3dc",5,5)
7431 if(!lua_isnumber(L,4)) SWIG_fail_arg("plot3dc",4,"PLINT");
7432 {
7433 int temp;
7434 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7435 if ( !arg1 )
7436 SWIG_fail;
7437 Xlen = temp;
7438 }
7439 {
7440 int temp;
7441 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7442 if ( !arg2 )
7443 SWIG_fail;
7444 Ylen = temp;
7445 }
7446 {
7447 int jj;
7448
7449 arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7450 if ( !arg3 )
7451 SWIG_fail;
7452 arg4 = ii3;
7453 arg5 = jj;
7454 if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7455 {
7456 lua_pushfstring( L, "Vectors must match matrix." );
7457 SWIG_fail;
7458 }
7459 }
7460 arg6 = (PLINT)lua_tonumber(L, 4);
7461 {
7462 int temp;
7463 arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7464 if ( !arg7 )
7465 SWIG_fail;
7466 arg8 = Alen = temp;
7467 }
7468 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
7469
7470 {
7471 LUA_FREE_ARRAY( arg1 );
7472 }
7473 {
7474 LUA_FREE_ARRAY( arg2 );
7475 }
7476 {
7477 int i;
7478
7479 if ( arg3 )
7480 {
7481 for ( i = 0; i < ii3; i++ )
7482 LUA_FREE_ARRAY( arg3[i] );
7483 LUA_FREE_ARRAY( arg3 );
7484 }
7485 }
7486 {
7487 LUA_FREE_ARRAY( arg7 );
7488 }
7489 return SWIG_arg;
7490
7491 if(0) SWIG_fail;
7492
7493 fail:
7494 {
7495 LUA_FREE_ARRAY( arg1 );
7496 }
7497 {
7498 LUA_FREE_ARRAY( arg2 );
7499 }
7500 {
7501 int i;
7502
7503 if ( arg3 )
7504 {
7505 for ( i = 0; i < ii3; i++ )
7506 LUA_FREE_ARRAY( arg3[i] );
7507 LUA_FREE_ARRAY( arg3 );
7508 }
7509 }
7510 {
7511 LUA_FREE_ARRAY( arg7 );
7512 }
7513 lua_error(L);
7514 return SWIG_arg;
7515 }
7516
7517
7518 static int _wrap_plot3dcl(lua_State* L) {
7519 int SWIG_arg = 0;
7520 PLFLT *arg1 = (PLFLT *) 0 ;
7521 PLFLT *arg2 = (PLFLT *) 0 ;
7522 PLFLT **arg3 = (PLFLT **) 0 ;
7523 PLINT arg4 ;
7524 PLINT arg5 ;
7525 PLINT arg6 ;
7526 PLFLT *arg7 = (PLFLT *) 0 ;
7527 PLINT arg8 ;
7528 PLINT arg9 ;
7529 PLINT arg10 ;
7530 PLINT *arg11 = (PLINT *) 0 ;
7531 PLINT *arg12 = (PLINT *) 0 ;
7532 int ii3 ;
7533 int temp12 ;
7534
7535 SWIG_check_num_args("plot3dcl",8,8)
7536 if(!lua_isnumber(L,4)) SWIG_fail_arg("plot3dcl",4,"PLINT");
7537 if(!lua_isnumber(L,6)) SWIG_fail_arg("plot3dcl",6,"PLINT");
7538 {
7539 int temp;
7540 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7541 if ( !arg1 )
7542 SWIG_fail;
7543 Xlen = temp;
7544 }
7545 {
7546 int temp;
7547 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7548 if ( !arg2 )
7549 SWIG_fail;
7550 Ylen = temp;
7551 }
7552 {
7553 int jj;
7554
7555 arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7556 if ( !arg3 )
7557 SWIG_fail;
7558 arg4 = ii3;
7559 arg5 = jj;
7560 if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7561 {
7562 lua_pushfstring( L, "Vectors must match matrix." );
7563 SWIG_fail;
7564 }
7565 }
7566 arg6 = (PLINT)lua_tonumber(L, 4);
7567 {
7568 int temp;
7569 arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7570 if ( !arg7 )
7571 SWIG_fail;
7572 arg8 = Alen = temp;
7573 }
7574 arg9 = (PLINT)lua_tonumber(L, 6);
7575 {
7576 arg11 = (PLINT *) LUA_get_int_num_array_var( L, 7, &arg10 );
7577 if ( !arg11 )
7578 SWIG_fail;
7579 Alen = arg10;
7580 }
7581 {
7582 arg12 = (PLINT *) LUA_get_int_num_array_var( L, 8, &temp12 );
7583 if ( !arg12 )
7584 SWIG_fail;
7585 if ( temp12 != Alen )
7586 {
7587 lua_pushfstring( L, "Tables must be of same length." );
7588 SWIG_fail;
7589 }
7590 }
7591 plot3dcl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
7592
7593 {
7594 LUA_FREE_ARRAY( arg1 );
7595 }
7596 {
7597 LUA_FREE_ARRAY( arg2 );
7598 }
7599 {
7600 int i;
7601
7602 if ( arg3 )
7603 {
7604 for ( i = 0; i < ii3; i++ )
7605 LUA_FREE_ARRAY( arg3[i] );
7606 LUA_FREE_ARRAY( arg3 );
7607 }
7608 }
7609 {
7610 LUA_FREE_ARRAY( arg7 );
7611 }
7612 {
7613 LUA_FREE_ARRAY( arg11 );
7614 }
7615 {
7616 LUA_FREE_ARRAY( arg12 );
7617 }
7618 return SWIG_arg;
7619
7620 if(0) SWIG_fail;
7621
7622 fail:
7623 {
7624 LUA_FREE_ARRAY( arg1 );
7625 }
7626 {
7627 LUA_FREE_ARRAY( arg2 );
7628 }
7629 {
7630 int i;
7631
7632 if ( arg3 )
7633 {
7634 for ( i = 0; i < ii3; i++ )
7635 LUA_FREE_ARRAY( arg3[i] );
7636 LUA_FREE_ARRAY( arg3 );
7637 }
7638 }
7639 {
7640 LUA_FREE_ARRAY( arg7 );
7641 }
7642 {
7643 LUA_FREE_ARRAY( arg11 );
7644 }
7645 {
7646 LUA_FREE_ARRAY( arg12 );
7647 }
7648 lua_error(L);
7649 return SWIG_arg;
7650 }
7651
7652
7653 static int _wrap_surf3d(lua_State* L) {
7654 int SWIG_arg = 0;
7655 PLFLT *arg1 = (PLFLT *) 0 ;
7656 PLFLT *arg2 = (PLFLT *) 0 ;
7657 PLFLT **arg3 = (PLFLT **) 0 ;
7658 PLINT arg4 ;
7659 PLINT arg5 ;
7660 PLINT arg6 ;
7661 PLFLT *arg7 = (PLFLT *) 0 ;
7662 PLINT arg8 ;
7663 int ii3 ;
7664
7665 SWIG_check_num_args("plsurf3d",5,5)
7666 if(!lua_isnumber(L,4)) SWIG_fail_arg("plsurf3d",4,"PLINT");
7667 {
7668 int temp;
7669 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7670 if ( !arg1 )
7671 SWIG_fail;
7672 Xlen = temp;
7673 }
7674 {
7675 int temp;
7676 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7677 if ( !arg2 )
7678 SWIG_fail;
7679 Ylen = temp;
7680 }
7681 {
7682 int jj;
7683
7684 arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7685 if ( !arg3 )
7686 SWIG_fail;
7687 arg4 = ii3;
7688 arg5 = jj;
7689 if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7690 {
7691 lua_pushfstring( L, "Vectors must match matrix." );
7692 SWIG_fail;
7693 }
7694 }
7695 arg6 = (PLINT)lua_tonumber(L, 4);
7696 {
7697 int temp;
7698 arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7699 if ( !arg7 )
7700 SWIG_fail;
7701 arg8 = Alen = temp;
7702 }
7703 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
7704
7705 {
7706 LUA_FREE_ARRAY( arg1 );
7707 }
7708 {
7709 LUA_FREE_ARRAY( arg2 );
7710 }
7711 {
7712 int i;
7713
7714 if ( arg3 )
7715 {
7716 for ( i = 0; i < ii3; i++ )
7717 LUA_FREE_ARRAY( arg3[i] );
7718 LUA_FREE_ARRAY( arg3 );
7719 }
7720 }
7721 {
7722 LUA_FREE_ARRAY( arg7 );
7723 }
7724 return SWIG_arg;
7725
7726 if(0) SWIG_fail;
7727
7728 fail:
7729 {
7730 LUA_FREE_ARRAY( arg1 );
7731 }
7732 {
7733 LUA_FREE_ARRAY( arg2 );
7734 }
7735 {
7736 int i;
7737
7738 if ( arg3 )
7739 {
7740 for ( i = 0; i < ii3; i++ )
7741 LUA_FREE_ARRAY( arg3[i] );
7742 LUA_FREE_ARRAY( arg3 );
7743 }
7744 }
7745 {
7746 LUA_FREE_ARRAY( arg7 );
7747 }
7748 lua_error(L);
7749 return SWIG_arg;
7750 }
7751
7752
7753 static int _wrap_surf3dl(lua_State* L) {
7754 int SWIG_arg = 0;
7755 PLFLT *arg1 = (PLFLT *) 0 ;
7756 PLFLT *arg2 = (PLFLT *) 0 ;
7757 PLFLT **arg3 = (PLFLT **) 0 ;
7758 PLINT arg4 ;
7759 PLINT arg5 ;
7760 PLINT arg6 ;
7761 PLFLT *arg7 = (PLFLT *) 0 ;
7762 PLINT arg8 ;
7763 PLINT arg9 ;
7764 PLINT arg10 ;
7765 PLINT *arg11 = (PLINT *) 0 ;
7766 PLINT *arg12 = (PLINT *) 0 ;
7767 int ii3 ;
7768 int temp12 ;
7769
7770 SWIG_check_num_args("plsurf3dl",8,8)
7771 if(!lua_isnumber(L,4)) SWIG_fail_arg("plsurf3dl",4,"PLINT");
7772 if(!lua_isnumber(L,6)) SWIG_fail_arg("plsurf3dl",6,"PLINT");
7773 {
7774 int temp;
7775 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7776 if ( !arg1 )
7777 SWIG_fail;
7778 Xlen = temp;
7779 }
7780 {
7781 int temp;
7782 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7783 if ( !arg2 )
7784 SWIG_fail;
7785 Ylen = temp;
7786 }
7787 {
7788 int jj;
7789
7790 arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7791 if ( !arg3 )
7792 SWIG_fail;
7793 arg4 = ii3;
7794 arg5 = jj;
7795 if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7796 {
7797 lua_pushfstring( L, "Vectors must match matrix." );
7798 SWIG_fail;
7799 }
7800 }
7801 arg6 = (PLINT)lua_tonumber(L, 4);
7802 {
7803 int temp;
7804 arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7805 if ( !arg7 )
7806 SWIG_fail;
7807 arg8 = Alen = temp;
7808 }
7809 arg9 = (PLINT)lua_tonumber(L, 6);
7810 {
7811 arg11 = (PLINT *) LUA_get_int_num_array_var( L, 7, &arg10 );
7812 if ( !arg11 )
7813 SWIG_fail;
7814 Alen = arg10;
7815 }
7816 {
7817 arg12 = (PLINT *) LUA_get_int_num_array_var( L, 8, &temp12 );
7818 if ( !arg12 )
7819 SWIG_fail;
7820 if ( temp12 != Alen )
7821 {
7822 lua_pushfstring( L, "Tables must be of same length." );
7823 SWIG_fail;
7824 }
7825 }
7826 plsurf3dl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
7827
7828 {
7829 LUA_FREE_ARRAY( arg1 );
7830 }
7831 {
7832 LUA_FREE_ARRAY( arg2 );
7833 }
7834 {
7835 int i;
7836
7837 if ( arg3 )
7838 {
7839 for ( i = 0; i < ii3; i++ )
7840 LUA_FREE_ARRAY( arg3[i] );
7841 LUA_FREE_ARRAY( arg3 );
7842 }
7843 }
7844 {
7845 LUA_FREE_ARRAY( arg7 );
7846 }
7847 {
7848 LUA_FREE_ARRAY( arg11 );
7849 }
7850 {
7851 LUA_FREE_ARRAY( arg12 );
7852 }
7853 return SWIG_arg;
7854
7855 if(0) SWIG_fail;
7856
7857 fail:
7858 {
7859 LUA_FREE_ARRAY( arg1 );
7860 }
7861 {
7862 LUA_FREE_ARRAY( arg2 );
7863 }
7864 {
7865 int i;
7866
7867 if ( arg3 )
7868 {
7869 for ( i = 0; i < ii3; i++ )
7870 LUA_FREE_ARRAY( arg3[i] );
7871 LUA_FREE_ARRAY( arg3 );
7872 }
7873 }
7874 {
7875 LUA_FREE_ARRAY( arg7 );
7876 }
7877 {
7878 LUA_FREE_ARRAY( arg11 );
7879 }
7880 {
7881 LUA_FREE_ARRAY( arg12 );
7882 }
7883 lua_error(L);
7884 return SWIG_arg;
7885 }
7886
7887
7888 static int _wrap_parseopts(lua_State* L) {
7889 int SWIG_arg = 0;
7890 int *arg1 = (int *) 0 ;
7891 char **arg2 = (char **) 0 ;
7892 PLINT arg3 ;
7893 PLINT result;
7894
7895 SWIG_check_num_args("plparseopts",2,2)
7896 if(!lua_istable(L,1)) SWIG_fail_arg("plparseopts",1,"int *");
7897 if(!lua_isnumber(L,2)) SWIG_fail_arg("plparseopts",2,"PLINT");
7898 {
7899 int i, n;
7900
7901 // from lua 5.1 on there is no element "n" anymore,
7902 // so we need to find out the number of command line
7903 // options manually
7904 for ( i = 1;; i++ )
7905 {
7906 lua_rawgeti( L, 1, i );
7907 if ( lua_isnil( L, -1 ) )
7908 {
7909 // ok, this index doesn't exist anymore, we have i-1
7910 // command line options
7911 lua_pop( L, 1 );
7912 break;
7913 }
7914 }
7915 n = i;
7916 arg1 = &n;
7917
7918 arg2 = LUA_ALLOC_ARRAY( char*, ( n + 1 ) );
7919
7920 for ( i = 0; i < n; i++ )
7921 {
7922 lua_rawgeti( L, 1, i );
7923 if ( lua_isstring( L, -1 ) )
7924 {
7925 arg2[i] = (char *) lua_tostring( L, -1 );
7926 }
7927 else
7928 {
7929 lua_pop( L, 1 );
7930 lua_pushfstring( L, "List items must be strings" );
7931 SWIG_fail;
7932 // arg2 array is freed after 'fail:'
7933 }
7934 lua_pop( L, 1 );
7935 }
7936 arg2[n] = NULL;
7937 }
7938 arg3 = (PLINT)lua_tonumber(L, 2);
7939 result = (PLINT)plparseopts(arg1,arg2,arg3);
7940 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
7941 {
7942 LUA_FREE_ARRAY( arg2 );
7943 }
7944 return SWIG_arg;
7945
7946 if(0) SWIG_fail;
7947
7948 fail:
7949 {
7950 LUA_FREE_ARRAY( arg2 );
7951 }
7952 lua_error(L);
7953 return SWIG_arg;
7954 }
7955
7956
7957 static int _wrap_pat(lua_State* L) {
7958 int SWIG_arg = 0;
7959 PLINT arg1 ;
7960 PLINT *arg2 = (PLINT *) 0 ;
7961 PLINT *arg3 = (PLINT *) 0 ;
7962 int temp3 ;
7963
7964 SWIG_check_num_args("plpat",2,2)
7965 {
7966 arg2 = (PLINT *) LUA_get_int_num_array_var( L, 1, &arg1 );
7967 if ( !arg2 )
7968 SWIG_fail;
7969 Alen = arg1;
7970 }
7971 {
7972 arg3 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp3 );
7973 if ( !arg3 )
7974 SWIG_fail;
7975 if ( temp3 != Alen )
7976 {
7977 lua_pushfstring( L, "Tables must be of same length." );
7978 SWIG_fail;
7979 }
7980 }
7981 plpat(arg1,(int const *)arg2,(int const *)arg3);
7982
7983 {
7984 LUA_FREE_ARRAY( arg2 );
7985 }
7986 {
7987 LUA_FREE_ARRAY( arg3 );
7988 }
7989 return SWIG_arg;
7990
7991 if(0) SWIG_fail;
7992
7993 fail:
7994 {
7995 LUA_FREE_ARRAY( arg2 );
7996 }
7997 {
7998 LUA_FREE_ARRAY( arg3 );
7999 }
8000 lua_error(L);
8001 return SWIG_arg;
8002 }
8003
8004
8005 static int _wrap_path(lua_State* L) {
8006 int SWIG_arg = 0;
8007 PLINT arg1 ;
8008 PLFLT arg2 ;
8009 PLFLT arg3 ;
8010 PLFLT arg4 ;
8011 PLFLT arg5 ;
8012
8013 SWIG_check_num_args("plpath",5,5)
8014 if(!lua_isnumber(L,1)) SWIG_fail_arg("plpath",1,"PLINT");
8015 if(!lua_isnumber(L,2)) SWIG_fail_arg("plpath",2,"PLFLT");
8016 if(!lua_isnumber(L,3)) SWIG_fail_arg("plpath",3,"PLFLT");
8017 if(!lua_isnumber(L,4)) SWIG_fail_arg("plpath",4,"PLFLT");
8018 if(!lua_isnumber(L,5)) SWIG_fail_arg("plpath",5,"PLFLT");
8019 arg1 = (PLINT)lua_tonumber(L, 1);
8020 arg2 = (PLFLT)lua_tonumber(L, 2);
8021 arg3 = (PLFLT)lua_tonumber(L, 3);
8022 arg4 = (PLFLT)lua_tonumber(L, 4);
8023 arg5 = (PLFLT)lua_tonumber(L, 5);
8024 plpath(arg1,arg2,arg3,arg4,arg5);
8025
8026 return SWIG_arg;
8027
8028 if(0) SWIG_fail;
8029
8030 fail:
8031 lua_error(L);
8032 return SWIG_arg;
8033 }
8034
8035
8036 static int _wrap_poin(lua_State* L) {
8037 int SWIG_arg = 0;
8038 PLINT arg1 ;
8039 PLFLT *arg2 = (PLFLT *) 0 ;
8040 PLFLT *arg3 = (PLFLT *) 0 ;
8041 PLINT arg4 ;
8042 int temp3 ;
8043
8044 SWIG_check_num_args("plpoin",3,3)
8045 if(!lua_isnumber(L,3)) SWIG_fail_arg("plpoin",3,"PLINT");
8046 {
8047 int temp;
8048 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
8049 if ( !arg2 )
8050 SWIG_fail;
8051 arg1 = Alen = temp;
8052 }
8053 {
8054 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
8055 if ( !arg3 )
8056 SWIG_fail;
8057 if ( temp3 != Alen )
8058 {
8059 lua_pushfstring( L, "Tables must be of same length." );
8060 SWIG_fail;
8061 }
8062 }
8063 arg4 = (PLINT)lua_tonumber(L, 3);
8064 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
8065
8066 {
8067 LUA_FREE_ARRAY( arg2 );
8068 }
8069 {
8070 LUA_FREE_ARRAY( arg3 );
8071 }
8072 return SWIG_arg;
8073
8074 if(0) SWIG_fail;
8075
8076 fail:
8077 {
8078 LUA_FREE_ARRAY( arg2 );
8079 }
8080 {
8081 LUA_FREE_ARRAY( arg3 );
8082 }
8083 lua_error(L);
8084 return SWIG_arg;
8085 }
8086
8087
8088 static int _wrap_poin3(lua_State* L) {
8089 int SWIG_arg = 0;
8090 PLINT arg1 ;
8091 PLFLT *arg2 = (PLFLT *) 0 ;
8092 PLFLT *arg3 = (PLFLT *) 0 ;
8093 PLFLT *arg4 = (PLFLT *) 0 ;
8094 PLINT arg5 ;
8095 int temp3 ;
8096 int temp4 ;
8097
8098 SWIG_check_num_args("plpoin3",4,4)
8099 if(!lua_isnumber(L,4)) SWIG_fail_arg("plpoin3",4,"PLINT");
8100 {
8101 int temp;
8102 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
8103 if ( !arg2 )
8104 SWIG_fail;
8105 arg1 = Alen = temp;
8106 }
8107 {
8108 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
8109 if ( !arg3 )
8110 SWIG_fail;
8111 if ( temp3 != Alen )
8112 {
8113 lua_pushfstring( L, "Tables must be of same length." );
8114 SWIG_fail;
8115 }
8116 }
8117 {
8118 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
8119 if ( !arg4 )
8120 SWIG_fail;
8121 if ( temp4 != Alen )
8122 {
8123 lua_pushfstring( L, "Tables must be of same length." );
8124 SWIG_fail;
8125 }
8126 }
8127 arg5 = (PLINT)lua_tonumber(L, 4);
8128 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
8129
8130 {
8131 LUA_FREE_ARRAY( arg2 );
8132 }
8133 {
8134 LUA_FREE_ARRAY( arg3 );
8135 }
8136 {
8137 LUA_FREE_ARRAY( arg4 );
8138 }
8139 return SWIG_arg;
8140
8141 if(0) SWIG_fail;
8142
8143 fail:
8144 {
8145 LUA_FREE_ARRAY( arg2 );
8146 }
8147 {
8148 LUA_FREE_ARRAY( arg3 );
8149 }
8150 {
8151 LUA_FREE_ARRAY( arg4 );
8152 }
8153 lua_error(L);
8154 return SWIG_arg;
8155 }
8156
8157
8158 static int _wrap_poly3(lua_State* L) {
8159 int SWIG_arg = 0;
8160 PLINT arg1 ;
8161 PLFLT *arg2 = (PLFLT *) 0 ;
8162 PLFLT *arg3 = (PLFLT *) 0 ;
8163 PLFLT *arg4 = (PLFLT *) 0 ;
8164 PLBOOL *arg5 = (PLBOOL *) 0 ;
8165 PLBOOL arg6 ;
8166 int temp3 ;
8167 int temp4 ;
8168 int temp5 ;
8169
8170 SWIG_check_num_args("plpoly3",5,5)
8171 if(!lua_isnumber(L,5)) SWIG_fail_arg("plpoly3",5,"PLBOOL");
8172 {
8173 int temp;
8174 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
8175 if ( !arg2 )
8176 SWIG_fail;
8177 arg1 = Alen = temp;
8178 }
8179 {
8180 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
8181 if ( !arg3 )
8182 SWIG_fail;
8183 if ( temp3 != Alen )
8184 {
8185 lua_pushfstring( L, "Tables must be of same length." );
8186 SWIG_fail;
8187 }
8188 }
8189 {
8190 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
8191 if ( !arg4 )
8192 SWIG_fail;
8193 if ( temp4 != Alen )
8194 {
8195 lua_pushfstring( L, "Tables must be of same length." );
8196 SWIG_fail;
8197 }
8198 }
8199 {
8200 arg5 = (PLINT *) LUA_get_int_num_array_var( L, 4, &temp5 );
8201 if ( !arg5 )
8202 SWIG_fail;
8203 if ( temp5 < Alen - 1 )
8204 {
8205 lua_pushfstring( L, "Tables must be at least length of others minus 1." );
8206 SWIG_fail;
8207 }
8208 }
8209 arg6 = (PLBOOL)lua_tonumber(L, 5);
8210 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
8211
8212 {
8213 LUA_FREE_ARRAY( arg2 );
8214 }
8215 {
8216 LUA_FREE_ARRAY( arg3 );
8217 }
8218 {
8219 LUA_FREE_ARRAY( arg4 );
8220 }
8221 {
8222 LUA_FREE_ARRAY( arg5 );
8223 }
8224 return SWIG_arg;
8225
8226 if(0) SWIG_fail;
8227
8228 fail:
8229 {
8230 LUA_FREE_ARRAY( arg2 );
8231 }
8232 {
8233 LUA_FREE_ARRAY( arg3 );
8234 }
8235 {
8236 LUA_FREE_ARRAY( arg4 );
8237 }
8238 {
8239 LUA_FREE_ARRAY( arg5 );
8240 }
8241 lua_error(L);
8242 return SWIG_arg;
8243 }
8244
8245
8246 static int _wrap_prec(lua_State* L) {
8247 int SWIG_arg = 0;
8248 PLINT arg1 ;
8249 PLINT arg2 ;
8250
8251 SWIG_check_num_args("plprec",2,2)
8252 if(!lua_isnumber(L,1)) SWIG_fail_arg("plprec",1,"PLINT");
8253 if(!lua_isnumber(L,2)) SWIG_fail_arg("plprec",2,"PLINT");
8254 arg1 = (PLINT)lua_tonumber(L, 1);
8255 arg2 = (PLINT)lua_tonumber(L, 2);
8256 plprec(arg1,arg2);
8257
8258 return SWIG_arg;
8259
8260 if(0) SWIG_fail;
8261
8262 fail:
8263 lua_error(L);
8264 return SWIG_arg;
8265 }
8266
8267
8268 static int _wrap_psty(lua_State* L) {
8269 int SWIG_arg = 0;
8270 PLINT arg1 ;
8271
8272 SWIG_check_num_args("plpsty",1,1)
8273 if(!lua_isnumber(L,1)) SWIG_fail_arg("plpsty",1,"PLINT");
8274 arg1 = (PLINT)lua_tonumber(L, 1);
8275 plpsty(arg1);
8276
8277 return SWIG_arg;
8278
8279 if(0) SWIG_fail;
8280
8281 fail:
8282 lua_error(L);
8283 return SWIG_arg;
8284 }
8285
8286
8287 static int _wrap_ptex(lua_State* L) {
8288 int SWIG_arg = 0;
8289 PLFLT arg1 ;
8290 PLFLT arg2 ;
8291 PLFLT arg3 ;
8292 PLFLT arg4 ;
8293 PLFLT arg5 ;
8294 char *arg6 = (char *) 0 ;
8295
8296 SWIG_check_num_args("plptex",6,6)
8297 if(!lua_isnumber(L,1)) SWIG_fail_arg("plptex",1,"PLFLT");
8298 if(!lua_isnumber(L,2)) SWIG_fail_arg("plptex",2,"PLFLT");
8299 if(!lua_isnumber(L,3)) SWIG_fail_arg("plptex",3,"PLFLT");
8300 if(!lua_isnumber(L,4)) SWIG_fail_arg("plptex",4,"PLFLT");
8301 if(!lua_isnumber(L,5)) SWIG_fail_arg("plptex",5,"PLFLT");
8302 if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("plptex",6,"char const *");
8303 arg1 = (PLFLT)lua_tonumber(L, 1);
8304 arg2 = (PLFLT)lua_tonumber(L, 2);
8305 arg3 = (PLFLT)lua_tonumber(L, 3);
8306 arg4 = (PLFLT)lua_tonumber(L, 4);
8307 arg5 = (PLFLT)lua_tonumber(L, 5);
8308 arg6 = (char *)lua_tostring(L, 6);
8309 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
8310
8311 return SWIG_arg;
8312
8313 if(0) SWIG_fail;
8314
8315 fail:
8316 lua_error(L);
8317 return SWIG_arg;
8318 }
8319
8320
8321 static int _wrap_ptex3(lua_State* L) {
8322 int SWIG_arg = 0;
8323 PLFLT arg1 ;
8324 PLFLT arg2 ;
8325 PLFLT arg3 ;
8326 PLFLT arg4 ;
8327 PLFLT arg5 ;
8328 PLFLT arg6 ;
8329 PLFLT arg7 ;
8330 PLFLT arg8 ;
8331 PLFLT arg9 ;
8332 PLFLT arg10 ;
8333 char *arg11 = (char *) 0 ;
8334
8335 SWIG_check_num_args("plptex3",11,11)
8336 if(!lua_isnumber(L,1)) SWIG_fail_arg("plptex3",1,"PLFLT");
8337 if(!lua_isnumber(L,2)) SWIG_fail_arg("plptex3",2,"PLFLT");
8338 if(!lua_isnumber(L,3)) SWIG_fail_arg("plptex3",3,"PLFLT");
8339 if(!lua_isnumber(L,4)) SWIG_fail_arg("plptex3",4,"PLFLT");
8340 if(!lua_isnumber(L,5)) SWIG_fail_arg("plptex3",5,"PLFLT");
8341 if(!lua_isnumber(L,6)) SWIG_fail_arg("plptex3",6,"PLFLT");
8342 if(!lua_isnumber(L,7)) SWIG_fail_arg("plptex3",7,"PLFLT");
8343 if(!lua_isnumber(L,8)) SWIG_fail_arg("plptex3",8,"PLFLT");
8344 if(!lua_isnumber(L,9)) SWIG_fail_arg("plptex3",9,"PLFLT");
8345 if(!lua_isnumber(L,10)) SWIG_fail_arg("plptex3",10,"PLFLT");
8346 if(!SWIG_lua_isnilstring(L,11)) SWIG_fail_arg("plptex3",11,"char const *");
8347 arg1 = (PLFLT)lua_tonumber(L, 1);
8348 arg2 = (PLFLT)lua_tonumber(L, 2);
8349 arg3 = (PLFLT)lua_tonumber(L, 3);
8350 arg4 = (PLFLT)lua_tonumber(L, 4);
8351 arg5 = (PLFLT)lua_tonumber(L, 5);
8352 arg6 = (PLFLT)lua_tonumber(L, 6);
8353 arg7 = (PLFLT)lua_tonumber(L, 7);
8354 arg8 = (PLFLT)lua_tonumber(L, 8);
8355 arg9 = (PLFLT)lua_tonumber(L, 9);
8356 arg10 = (PLFLT)lua_tonumber(L, 10);
8357 arg11 = (char *)lua_tostring(L, 11);
8358 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
8359
8360 return SWIG_arg;
8361
8362 if(0) SWIG_fail;
8363
8364 fail:
8365 lua_error(L);
8366 return SWIG_arg;
8367 }
8368
8369
8370 static int _wrap_randd(lua_State* L) {
8371 int SWIG_arg = 0;
8372 PLFLT result;
8373
8374 SWIG_check_num_args("plrandd",0,0)
8375 result = (PLFLT)plrandd();
8376 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8377 return SWIG_arg;
8378
8379 if(0) SWIG_fail;
8380
8381 fail:
8382 lua_error(L);
8383 return SWIG_arg;
8384 }
8385
8386
8387 static int _wrap_replot(lua_State* L) {
8388 int SWIG_arg = 0;
8389
8390 SWIG_check_num_args("plreplot",0,0)
8391 plreplot();
8392
8393 return SWIG_arg;
8394
8395 if(0) SWIG_fail;
8396
8397 fail:
8398 lua_error(L);
8399 return SWIG_arg;
8400 }
8401
8402
8403 static int _wrap_rgbhls(lua_State* L) {
8404 int SWIG_arg = 0;
8405 PLFLT arg1 ;
8406 PLFLT arg2 ;
8407 PLFLT arg3 ;
8408 PLFLT *arg4 = (PLFLT *) 0 ;
8409 PLFLT *arg5 = (PLFLT *) 0 ;
8410 PLFLT *arg6 = (PLFLT *) 0 ;
8411 PLFLT temp4 ;
8412 PLFLT temp5 ;
8413 PLFLT temp6 ;
8414
8415 arg4 = &temp4;
8416 arg5 = &temp5;
8417 arg6 = &temp6;
8418 SWIG_check_num_args("plrgbhls",3,3)
8419 if(!lua_isnumber(L,1)) SWIG_fail_arg("plrgbhls",1,"PLFLT");
8420 if(!lua_isnumber(L,2)) SWIG_fail_arg("plrgbhls",2,"PLFLT");
8421 if(!lua_isnumber(L,3)) SWIG_fail_arg("plrgbhls",3,"PLFLT");
8422 arg1 = (PLFLT)lua_tonumber(L, 1);
8423 arg2 = (PLFLT)lua_tonumber(L, 2);
8424 arg3 = (PLFLT)lua_tonumber(L, 3);
8425 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
8426
8427 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
8428 lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
8429 lua_pushnumber(L, (lua_Number) *arg6); SWIG_arg++;
8430 return SWIG_arg;
8431
8432 if(0) SWIG_fail;
8433
8434 fail:
8435 lua_error(L);
8436 return SWIG_arg;
8437 }
8438
8439
8440 static int _wrap_schr(lua_State* L) {
8441 int SWIG_arg = 0;
8442 PLFLT arg1 ;
8443 PLFLT arg2 ;
8444
8445 SWIG_check_num_args("plschr",2,2)
8446 if(!lua_isnumber(L,1)) SWIG_fail_arg("plschr",1,"PLFLT");
8447 if(!lua_isnumber(L,2)) SWIG_fail_arg("plschr",2,"PLFLT");
8448 arg1 = (PLFLT)lua_tonumber(L, 1);
8449 arg2 = (PLFLT)lua_tonumber(L, 2);
8450 plschr(arg1,arg2);
8451
8452 return SWIG_arg;
8453
8454 if(0) SWIG_fail;
8455
8456 fail:
8457 lua_error(L);
8458 return SWIG_arg;
8459 }
8460
8461
8462 static int _wrap_scmap0(lua_State* L) {
8463 int SWIG_arg = 0;
8464 PLINT *arg1 = (PLINT *) 0 ;
8465 PLINT *arg2 = (PLINT *) 0 ;
8466 PLINT *arg3 = (PLINT *) 0 ;
8467 PLINT arg4 ;
8468 int temp1 ;
8469 int temp2 ;
8470 int temp3 ;
8471
8472 SWIG_check_num_args("plscmap0",3,3)
8473 {
8474 arg1 = (PLINT *) LUA_get_int_num_array_var( L, 1, &temp1 );
8475 if ( !arg1 )
8476 SWIG_fail;
8477 Alen = temp1;
8478 }
8479 {
8480 arg2 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp2 );
8481 if ( !arg2 )
8482 SWIG_fail;
8483 if ( temp2 != Alen )
8484 {
8485 lua_pushfstring( L, "Tables must be of same length." );
8486 SWIG_fail;
8487 }
8488 }
8489 {
8490 arg3 = (PLINT *) LUA_get_int_num_array_var( L, 3, &temp3 );
8491 if ( !arg3 )
8492 SWIG_fail;
8493 if ( temp3 != Alen )
8494 {
8495 lua_pushfstring( L, "Tables must be of same length." );
8496 SWIG_fail;
8497 }
8498 arg4 = temp3;
8499 }
8500 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
8501
8502 {
8503 LUA_FREE_ARRAY( arg1 );
8504 }
8505 {
8506 LUA_FREE_ARRAY( arg2 );
8507 }
8508 {
8509 LUA_FREE_ARRAY( arg3 );
8510 }
8511 return SWIG_arg;
8512
8513 if(0) SWIG_fail;
8514
8515 fail:
8516 {
8517 LUA_FREE_ARRAY( arg1 );
8518 }
8519 {
8520 LUA_FREE_ARRAY( arg2 );
8521 }
8522 {
8523 LUA_FREE_ARRAY( arg3 );
8524 }
8525 lua_error(L);
8526 return SWIG_arg;
8527 }
8528
8529
8530 static int _wrap_scmap0a(lua_State* L) {
8531 int SWIG_arg = 0;
8532 PLINT *arg1 = (PLINT *) 0 ;
8533 PLINT *arg2 = (PLINT *) 0 ;
8534 PLINT *arg3 = (PLINT *) 0 ;
8535 PLFLT *arg4 = (PLFLT *) 0 ;
8536 PLINT arg5 ;
8537 int temp1 ;
8538 int temp2 ;
8539 int temp3 ;
8540
8541 SWIG_check_num_args("plscmap0a",4,4)
8542 {
8543 arg1 = (PLINT *) LUA_get_int_num_array_var( L, 1, &temp1 );
8544 if ( !arg1 )
8545 SWIG_fail;
8546 Alen = temp1;
8547 }
8548 {
8549 arg2 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp2 );
8550 if ( !arg2 )
8551 SWIG_fail;
8552 if ( temp2 != Alen )
8553 {
8554 lua_pushfstring( L, "Tables must be of same length." );
8555 SWIG_fail;
8556 }
8557 }
8558 {
8559 arg3 = (PLINT *) LUA_get_int_num_array_var( L, 3, &temp3 );
8560 if ( !arg3 )
8561 SWIG_fail;
8562 if ( temp3 != Alen )
8563 {
8564 lua_pushfstring( L, "Tables must be of same length." );
8565 SWIG_fail;
8566 }
8567 }
8568 {
8569 int temp;
8570 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp );
8571 if ( !arg4 )
8572 SWIG_fail;
8573 if ( temp != Alen )
8574 {
8575 lua_pushfstring( L, "Tables must be of same length." );
8576 SWIG_fail;
8577 }
8578 arg5 = temp;
8579 }
8580 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
8581
8582 {
8583 LUA_FREE_ARRAY( arg1 );
8584 }
8585 {
8586 LUA_FREE_ARRAY( arg2 );
8587 }
8588 {
8589 LUA_FREE_ARRAY( arg3 );
8590 }
8591 {
8592 LUA_FREE_ARRAY( arg4 );
8593 }
8594 return SWIG_arg;
8595
8596 if(0) SWIG_fail;
8597
8598 fail:
8599 {
8600 LUA_FREE_ARRAY( arg1 );
8601 }
8602 {
8603 LUA_FREE_ARRAY( arg2 );
8604 }
8605 {
8606 LUA_FREE_ARRAY( arg3 );
8607 }
8608 {
8609 LUA_FREE_ARRAY( arg4 );
8610 }
8611 lua_error(L);
8612 return SWIG_arg;
8613 }
8614
8615
8616 static int _wrap_scmap0n(lua_State* L) {
8617 int SWIG_arg = 0;
8618 PLINT arg1 ;
8619
8620 SWIG_check_num_args("plscmap0n",1,1)
8621 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap0n",1,"PLINT");
8622 arg1 = (PLINT)lua_tonumber(L, 1);
8623 plscmap0n(arg1);
8624
8625 return SWIG_arg;
8626
8627 if(0) SWIG_fail;
8628
8629 fail:
8630 lua_error(L);
8631 return SWIG_arg;
8632 }
8633
8634
8635 static int _wrap_scmap1(lua_State* L) {
8636 int SWIG_arg = 0;
8637 PLINT *arg1 = (PLINT *) 0 ;
8638 PLINT *arg2 = (PLINT *) 0 ;
8639 PLINT *arg3 = (PLINT *) 0 ;
8640 PLINT arg4 ;
8641 int temp1 ;
8642 int temp2 ;
8643 int temp3 ;
8644
8645 SWIG_check_num_args("plscmap1",3,3)
8646 {
8647 arg1 = (PLINT *) LUA_get_int_num_array_var( L, 1, &temp1 );
8648 if ( !arg1 )
8649 SWIG_fail;
8650 Alen = temp1;
8651 }
8652 {
8653 arg2 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp2 );
8654 if ( !arg2 )
8655 SWIG_fail;
8656 if ( temp2 != Alen )
8657 {
8658 lua_pushfstring( L, "Tables must be of same length." );
8659 SWIG_fail;
8660 }
8661 }
8662 {
8663 arg3 = (PLINT *) LUA_get_int_num_array_var( L, 3, &temp3 );
8664 if ( !arg3 )
8665 SWIG_fail;
8666 if ( temp3 != Alen )
8667 {
8668 lua_pushfstring( L, "Tables must be of same length." );
8669 SWIG_fail;
8670 }
8671 arg4 = temp3;
8672 }
8673 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
8674
8675 {
8676 LUA_FREE_ARRAY( arg1 );
8677 }
8678 {
8679 LUA_FREE_ARRAY( arg2 );
8680 }
8681 {
8682 LUA_FREE_ARRAY( arg3 );
8683 }
8684 return SWIG_arg;
8685
8686 if(0) SWIG_fail;
8687
8688 fail:
8689 {
8690 LUA_FREE_ARRAY( arg1 );
8691 }
8692 {
8693 LUA_FREE_ARRAY( arg2 );
8694 }
8695 {
8696 LUA_FREE_ARRAY( arg3 );
8697 }
8698 lua_error(L);
8699 return SWIG_arg;
8700 }
8701
8702
8703 static int _wrap_scmap1a(lua_State* L) {
8704 int SWIG_arg = 0;
8705 PLINT *arg1 = (PLINT *) 0 ;
8706 PLINT *arg2 = (PLINT *) 0 ;
8707 PLINT *arg3 = (PLINT *) 0 ;
8708 PLFLT *arg4 = (PLFLT *) 0 ;
8709 PLINT arg5 ;
8710 int temp1 ;
8711 int temp2 ;
8712 int temp3 ;
8713
8714 SWIG_check_num_args("plscmap1a",4,4)
8715 {
8716 arg1 = (PLINT *) LUA_get_int_num_array_var( L, 1, &temp1 );
8717 if ( !arg1 )
8718 SWIG_fail;
8719 Alen = temp1;
8720 }
8721 {
8722 arg2 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp2 );
8723 if ( !arg2 )
8724 SWIG_fail;
8725 if ( temp2 != Alen )
8726 {
8727 lua_pushfstring( L, "Tables must be of same length." );
8728 SWIG_fail;
8729 }
8730 }
8731 {
8732 arg3 = (PLINT *) LUA_get_int_num_array_var( L, 3, &temp3 );
8733 if ( !arg3 )
8734 SWIG_fail;
8735 if ( temp3 != Alen )
8736 {
8737 lua_pushfstring( L, "Tables must be of same length." );
8738 SWIG_fail;
8739 }
8740 }
8741 {
8742 int temp;
8743 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp );
8744 if ( !arg4 )
8745 SWIG_fail;
8746 if ( temp != Alen )
8747 {
8748 lua_pushfstring( L, "Tables must be of same length." );
8749 SWIG_fail;
8750 }
8751 arg5 = temp;
8752 }
8753 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
8754
8755 {
8756 LUA_FREE_ARRAY( arg1 );
8757 }
8758 {
8759 LUA_FREE_ARRAY( arg2 );
8760 }
8761 {
8762 LUA_FREE_ARRAY( arg3 );
8763 }
8764 {
8765 LUA_FREE_ARRAY( arg4 );
8766 }
8767 return SWIG_arg;
8768
8769 if(0) SWIG_fail;
8770
8771 fail:
8772 {
8773 LUA_FREE_ARRAY( arg1 );
8774 }
8775 {
8776 LUA_FREE_ARRAY( arg2 );
8777 }
8778 {
8779 LUA_FREE_ARRAY( arg3 );
8780 }
8781 {
8782 LUA_FREE_ARRAY( arg4 );
8783 }
8784 lua_error(L);
8785 return SWIG_arg;
8786 }
8787
8788
8789 static int _wrap_scmap1l(lua_State* L) {
8790 int SWIG_arg = 0;
8791 PLBOOL arg1 ;
8792 PLINT arg2 ;
8793 PLFLT *arg3 = (PLFLT *) 0 ;
8794 PLFLT *arg4 = (PLFLT *) 0 ;
8795 PLFLT *arg5 = (PLFLT *) 0 ;
8796 PLFLT *arg6 = (PLFLT *) 0 ;
8797 PLBOOL *arg7 = (PLBOOL *) 0 ;
8798 int temp4 ;
8799 int temp5 ;
8800 int temp6 ;
8801 int temp7 ;
8802
8803 {
8804 arg7 = NULL;
8805 }
8806 SWIG_check_num_args("plscmap1l",5,6)
8807 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap1l",1,"PLBOOL");
8808 arg1 = (PLBOOL)lua_tonumber(L, 1);
8809 {
8810 int temp;
8811 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
8812 if ( !arg3 )
8813 SWIG_fail;
8814 arg2 = Alen = temp;
8815 }
8816 {
8817 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
8818 if ( !arg4 )
8819 SWIG_fail;
8820 if ( temp4 != Alen )
8821 {
8822 lua_pushfstring( L, "Tables must be of same length." );
8823 SWIG_fail;
8824 }
8825 }
8826 {
8827 arg5 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp5 );
8828 if ( !arg5 )
8829 SWIG_fail;
8830 if ( temp5 != Alen )
8831 {
8832 lua_pushfstring( L, "Tables must be of same length." );
8833 SWIG_fail;
8834 }
8835 }
8836 {
8837 arg6 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp6 );
8838 if ( !arg6 )
8839 SWIG_fail;
8840 if ( temp6 != Alen )
8841 {
8842 lua_pushfstring( L, "Tables must be of same length." );
8843 SWIG_fail;
8844 }
8845 }
8846 if(lua_gettop(L)>=6){
8847 {
8848 if ( lua_isnil( L, 6 ) )
8849 {
8850 arg7 = NULL;
8851 }
8852 else
8853 {
8854 arg7 = (PLINT *) LUA_get_int_num_array_var( L, 6, &temp7 );
8855 if ( !arg7 )
8856 SWIG_fail;
8857 if ( temp7 < Alen - 1 )
8858 {
8859 lua_pushfstring( L, "Tables must be at least length of others minus 1." );
8860 SWIG_fail;
8861 }
8862 }
8863 }
8864 }
8865 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
8866
8867 {
8868 LUA_FREE_ARRAY( arg3 );
8869 }
8870 {
8871 LUA_FREE_ARRAY( arg4 );
8872 }
8873 {
8874 LUA_FREE_ARRAY( arg5 );
8875 }
8876 {
8877 LUA_FREE_ARRAY( arg6 );
8878 }
8879 {
8880 LUA_FREE_ARRAY( arg7 );
8881 }
8882 return SWIG_arg;
8883
8884 if(0) SWIG_fail;
8885
8886 fail:
8887 {
8888 LUA_FREE_ARRAY( arg3 );
8889 }
8890 {
8891 LUA_FREE_ARRAY( arg4 );
8892 }
8893 {
8894 LUA_FREE_ARRAY( arg5 );
8895 }
8896 {
8897 LUA_FREE_ARRAY( arg6 );
8898 }
8899 {
8900 LUA_FREE_ARRAY( arg7 );
8901 }
8902 lua_error(L);
8903 return SWIG_arg;
8904 }
8905
8906
8907 static int _wrap_scmap1la(lua_State* L) {
8908 int SWIG_arg = 0;
8909 PLBOOL arg1 ;
8910 PLINT arg2 ;
8911 PLFLT *arg3 = (PLFLT *) 0 ;
8912 PLFLT *arg4 = (PLFLT *) 0 ;
8913 PLFLT *arg5 = (PLFLT *) 0 ;
8914 PLFLT *arg6 = (PLFLT *) 0 ;
8915 PLFLT *arg7 = (PLFLT *) 0 ;
8916 PLBOOL *arg8 = (PLBOOL *) 0 ;
8917 int temp4 ;
8918 int temp5 ;
8919 int temp6 ;
8920 int temp7 ;
8921 int temp8 ;
8922
8923 {
8924 arg8 = NULL;
8925 }
8926 SWIG_check_num_args("plscmap1la",6,7)
8927 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap1la",1,"PLBOOL");
8928 arg1 = (PLBOOL)lua_tonumber(L, 1);
8929 {
8930 int temp;
8931 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
8932 if ( !arg3 )
8933 SWIG_fail;
8934 arg2 = Alen = temp;
8935 }
8936 {
8937 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
8938 if ( !arg4 )
8939 SWIG_fail;
8940 if ( temp4 != Alen )
8941 {
8942 lua_pushfstring( L, "Tables must be of same length." );
8943 SWIG_fail;
8944 }
8945 }
8946 {
8947 arg5 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp5 );
8948 if ( !arg5 )
8949 SWIG_fail;
8950 if ( temp5 != Alen )
8951 {
8952 lua_pushfstring( L, "Tables must be of same length." );
8953 SWIG_fail;
8954 }
8955 }
8956 {
8957 arg6 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp6 );
8958 if ( !arg6 )
8959 SWIG_fail;
8960 if ( temp6 != Alen )
8961 {
8962 lua_pushfstring( L, "Tables must be of same length." );
8963 SWIG_fail;
8964 }
8965 }
8966 {
8967 arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 6, &temp7 );
8968 if ( !arg7 )
8969 SWIG_fail;
8970 if ( temp7 != Alen )
8971 {
8972 lua_pushfstring( L, "Tables must be of same length." );
8973 SWIG_fail;
8974 }
8975 }
8976 if(lua_gettop(L)>=7){
8977 {
8978 if ( lua_isnil( L, 7 ) )
8979 {
8980 arg8 = NULL;
8981 }
8982 else
8983 {
8984 arg8 = (PLINT *) LUA_get_int_num_array_var( L, 7, &temp8 );
8985 if ( !arg8 )
8986 SWIG_fail;
8987 if ( temp8 < Alen - 1 )
8988 {
8989 lua_pushfstring( L, "Tables must be at least length of others minus 1." );
8990 SWIG_fail;
8991 }
8992 }
8993 }
8994 }
8995 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
8996
8997 {
8998 LUA_FREE_ARRAY( arg3 );
8999 }
9000 {
9001 LUA_FREE_ARRAY( arg4 );
9002 }
9003 {
9004 LUA_FREE_ARRAY( arg5 );
9005 }
9006 {
9007 LUA_FREE_ARRAY( arg6 );
9008 }
9009 {
9010 LUA_FREE_ARRAY( arg7 );
9011 }
9012 {
9013 LUA_FREE_ARRAY( arg8 );
9014 }
9015 return SWIG_arg;
9016
9017 if(0) SWIG_fail;
9018
9019 fail:
9020 {
9021 LUA_FREE_ARRAY( arg3 );
9022 }
9023 {
9024 LUA_FREE_ARRAY( arg4 );
9025 }
9026 {
9027 LUA_FREE_ARRAY( arg5 );
9028 }
9029 {
9030 LUA_FREE_ARRAY( arg6 );
9031 }
9032 {
9033 LUA_FREE_ARRAY( arg7 );
9034 }
9035 {
9036 LUA_FREE_ARRAY( arg8 );
9037 }
9038 lua_error(L);
9039 return SWIG_arg;
9040 }
9041
9042
9043 static int _wrap_scmap1n(lua_State* L) {
9044 int SWIG_arg = 0;
9045 PLINT arg1 ;
9046
9047 SWIG_check_num_args("plscmap1n",1,1)
9048 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap1n",1,"PLINT");
9049 arg1 = (PLINT)lua_tonumber(L, 1);
9050 plscmap1n(arg1);
9051
9052 return SWIG_arg;
9053
9054 if(0) SWIG_fail;
9055
9056 fail:
9057 lua_error(L);
9058 return SWIG_arg;
9059 }
9060
9061
9062 static int _wrap_scmap1_range(lua_State* L) {
9063 int SWIG_arg = 0;
9064 PLFLT arg1 ;
9065 PLFLT arg2 ;
9066
9067 SWIG_check_num_args("plscmap1_range",2,2)
9068 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap1_range",1,"PLFLT");
9069 if(!lua_isnumber(L,2)) SWIG_fail_arg("plscmap1_range",2,"PLFLT");
9070 arg1 = (PLFLT)lua_tonumber(L, 1);
9071 arg2 = (PLFLT)lua_tonumber(L, 2);
9072 plscmap1_range(arg1,arg2);
9073
9074 return SWIG_arg;
9075
9076 if(0) SWIG_fail;
9077
9078 fail:
9079 lua_error(L);
9080 return SWIG_arg;
9081 }
9082
9083
9084 static int _wrap_gcmap1_range(lua_State* L) {
9085 int SWIG_arg = 0;
9086 PLFLT *arg1 = (PLFLT *) 0 ;
9087 PLFLT *arg2 = (PLFLT *) 0 ;
9088 PLFLT temp1 ;
9089 PLFLT temp2 ;
9090
9091 arg1 = &temp1;
9092 arg2 = &temp2;
9093 SWIG_check_num_args("plgcmap1_range",0,0)
9094 plgcmap1_range(arg1,arg2);
9095
9096 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
9097 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
9098 return SWIG_arg;
9099
9100 if(0) SWIG_fail;
9101
9102 fail:
9103 lua_error(L);
9104 return SWIG_arg;
9105 }
9106
9107
9108 static int _wrap_scol0(lua_State* L) {
9109 int SWIG_arg = 0;
9110 PLINT arg1 ;
9111 PLINT arg2 ;
9112 PLINT arg3 ;
9113 PLINT arg4 ;
9114
9115 SWIG_check_num_args("plscol0",4,4)
9116 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscol0",1,"PLINT");
9117 if(!lua_isnumber(L,2)) SWIG_fail_arg("plscol0",2,"PLINT");
9118 if(!lua_isnumber(L,3)) SWIG_fail_arg("plscol0",3,"PLINT");
9119 if(!lua_isnumber(L,4)) SWIG_fail_arg("plscol0",4,"PLINT");
9120 arg1 = (PLINT)lua_tonumber(L, 1);
9121 arg2 = (PLINT)lua_tonumber(L, 2);
9122 arg3 = (PLINT)lua_tonumber(L, 3);
9123 arg4 = (PLINT)lua_tonumber(L, 4);
9124 plscol0(arg1,arg2,arg3,arg4);
9125
9126 return SWIG_arg;
9127
9128 if(0) SWIG_fail;
9129
9130 fail:
9131 lua_error(L);
9132 return SWIG_arg;
9133 }
9134
9135
9136 static int _wrap_scol0a(lua_State* L) {
9137 int SWIG_arg = 0;
9138 PLINT arg1 ;
9139 PLINT arg2 ;
9140 PLINT arg3 ;
9141 PLINT arg4 ;
9142 PLFLT arg5 ;
9143
9144 SWIG_check_num_args("plscol0a",5,5)
9145 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscol0a",1,"PLINT");
9146 if(!lua_isnumber(L,2)) SWIG_fail_arg("plscol0a",2,"PLINT");
9147 if(!lua_isnumber(L,3)) SWIG_fail_arg("plscol0a",3,"PLINT");
9148 if(!lua_isnumber(L,4)) SWIG_fail_arg("plscol0a",4,"PLINT");
9149 if(!lua_isnumber(L,5)) SWIG_fail_arg("plscol0a",5,"PLFLT");
9150 arg1 = (PLINT)lua_tonumber(L, 1);
9151 arg2 = (PLINT)lua_tonumber(L, 2);
9152 arg3 = (PLINT)lua_tonumber(L, 3);
9153 arg4 = (PLINT)lua_tonumber(L, 4);
9154 arg5 = (PLFLT)lua_tonumber(L, 5);
9155 plscol0a(arg1,arg2,arg3,arg4,arg5);
9156
9157 return SWIG_arg;
9158
9159 if(0) SWIG_fail;
9160
9161 fail:
9162 lua_error(L);
9163 return SWIG_arg;
9164 }
9165
9166
9167 static int _wrap_scolbg(lua_State* L) {
9168 int SWIG_arg = 0;
9169 PLINT arg1 ;
9170 PLINT arg2 ;
9171 PLINT arg3 ;
9172
9173 SWIG_check_num_args("plscolbg",3,3)
9174 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscolbg",1,"PLINT");
9175 if(!lua_isnumber(L,2)) SWIG_fail_arg("plscolbg",2,"PLINT");
9176 if(!lua_isnumber(L,3)) SWIG_fail_arg("plscolbg",3,"PLINT");
9177 arg1 = (PLINT)lua_tonumber(L, 1);
9178 arg2 = (PLINT)lua_tonumber(L, 2);
9179 arg3 = (PLINT)lua_tonumber(L, 3);
9180 plscolbg(arg1,arg2,arg3);
9181
9182 return SWIG_arg;
9183
9184 if(0) SWIG_fail;
9185
9186 fail:
9187 lua_error(L);
9188 return SWIG_arg;
9189 }
9190
9191
9192 static int _wrap_scolbga(lua_State* L) {
9193 int SWIG_arg = 0;
9194 PLINT arg1 ;
9195 PLINT arg2 ;
9196 PLINT arg3 ;
9197 PLFLT arg4 ;
9198
9199 SWIG_check_num_args("plscolbga",4,4)
9200 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscolbga",1,"PLINT");
9201 if(!lua_isnumber(L,2)) SWIG_fail_arg("plscolbga",2,"PLINT");
9202 if(!lua_isnumber(L,3)) SWIG_fail_arg("plscolbga",3,"PLINT");
9203 if(!lua_isnumber(L,4)) SWIG_fail_arg("plscolbga",4,"PLFLT");
9204 arg1 = (PLINT)lua_tonumber(L, 1);
9205 arg2 = (PLINT)lua_tonumber(L, 2);
9206 arg3 = (PLINT)lua_tonumber(L, 3);
9207 arg4 = (PLFLT)lua_tonumber(L, 4);
9208 plscolbga(arg1,arg2,arg3,arg4);
9209
9210 return SWIG_arg;
9211
9212 if(0) SWIG_fail;
9213
9214 fail:
9215 lua_error(L);
9216 return SWIG_arg;
9217 }
9218
9219
9220 static int _wrap_scolor(lua_State* L) {
9221 int SWIG_arg = 0;
9222 PLINT arg1 ;
9223
9224 SWIG_check_num_args("plscolor",1,1)
9225 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscolor",1,"PLINT");
9226 arg1 = (PLINT)lua_tonumber(L, 1);
9227 plscolor(arg1);
9228
9229 return SWIG_arg;
9230
9231 if(0) SWIG_fail;
9232
9233 fail:
9234 lua_error(L);
9235 return SWIG_arg;
9236 }
9237
9238
9239 static int _wrap_scompression(lua_State* L) {
9240 int SWIG_arg = 0;
9241 PLINT arg1 ;
9242
9243 SWIG_check_num_args("plscompression",1,1)
9244 if(!lua_isnumber(L,1)) SWIG_fail_arg("plscompression",1,"PLINT");
9245 arg1 = (PLINT)lua_tonumber(L, 1);
9246 plscompression(arg1);
9247
9248 return SWIG_arg;
9249
9250 if(0) SWIG_fail;
9251
9252 fail:
9253 lua_error(L);
9254 return SWIG_arg;
9255 }
9256
9257
9258 static int _wrap_sdev(lua_State* L) {
9259 int SWIG_arg = 0;
9260 char *arg1 = (char *) 0 ;
9261
9262 SWIG_check_num_args("plsdev",1,1)
9263 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plsdev",1,"char const *");
9264 arg1 = (char *)lua_tostring(L, 1);
9265 plsdev((char const *)arg1);
9266
9267 return SWIG_arg;
9268
9269 if(0) SWIG_fail;
9270
9271 fail:
9272 lua_error(L);
9273 return SWIG_arg;
9274 }
9275
9276
9277 static int _wrap_sdidev(lua_State* L) {
9278 int SWIG_arg = 0;
9279 PLFLT arg1 ;
9280 PLFLT arg2 ;
9281 PLFLT arg3 ;
9282 PLFLT arg4 ;
9283
9284 SWIG_check_num_args("plsdidev",4,4)
9285 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdidev",1,"PLFLT");
9286 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsdidev",2,"PLFLT");
9287 if(!lua_isnumber(L,3)) SWIG_fail_arg("plsdidev",3,"PLFLT");
9288 if(!lua_isnumber(L,4)) SWIG_fail_arg("plsdidev",4,"PLFLT");
9289 arg1 = (PLFLT)lua_tonumber(L, 1);
9290 arg2 = (PLFLT)lua_tonumber(L, 2);
9291 arg3 = (PLFLT)lua_tonumber(L, 3);
9292 arg4 = (PLFLT)lua_tonumber(L, 4);
9293 plsdidev(arg1,arg2,arg3,arg4);
9294
9295 return SWIG_arg;
9296
9297 if(0) SWIG_fail;
9298
9299 fail:
9300 lua_error(L);
9301 return SWIG_arg;
9302 }
9303
9304
9305 static int _wrap_sdimap(lua_State* L) {
9306 int SWIG_arg = 0;
9307 PLINT arg1 ;
9308 PLINT arg2 ;
9309 PLINT arg3 ;
9310 PLINT arg4 ;
9311 PLFLT arg5 ;
9312 PLFLT arg6 ;
9313
9314 SWIG_check_num_args("plsdimap",6,6)
9315 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdimap",1,"PLINT");
9316 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsdimap",2,"PLINT");
9317 if(!lua_isnumber(L,3)) SWIG_fail_arg("plsdimap",3,"PLINT");
9318 if(!lua_isnumber(L,4)) SWIG_fail_arg("plsdimap",4,"PLINT");
9319 if(!lua_isnumber(L,5)) SWIG_fail_arg("plsdimap",5,"PLFLT");
9320 if(!lua_isnumber(L,6)) SWIG_fail_arg("plsdimap",6,"PLFLT");
9321 arg1 = (PLINT)lua_tonumber(L, 1);
9322 arg2 = (PLINT)lua_tonumber(L, 2);
9323 arg3 = (PLINT)lua_tonumber(L, 3);
9324 arg4 = (PLINT)lua_tonumber(L, 4);
9325 arg5 = (PLFLT)lua_tonumber(L, 5);
9326 arg6 = (PLFLT)lua_tonumber(L, 6);
9327 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
9328
9329 return SWIG_arg;
9330
9331 if(0) SWIG_fail;
9332
9333 fail:
9334 lua_error(L);
9335 return SWIG_arg;
9336 }
9337
9338
9339 static int _wrap_sdiori(lua_State* L) {
9340 int SWIG_arg = 0;
9341 PLFLT arg1 ;
9342
9343 SWIG_check_num_args("plsdiori",1,1)
9344 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdiori",1,"PLFLT");
9345 arg1 = (PLFLT)lua_tonumber(L, 1);
9346 plsdiori(arg1);
9347
9348 return SWIG_arg;
9349
9350 if(0) SWIG_fail;
9351
9352 fail:
9353 lua_error(L);
9354 return SWIG_arg;
9355 }
9356
9357
9358 static int _wrap_sdiplt(lua_State* L) {
9359 int SWIG_arg = 0;
9360 PLFLT arg1 ;
9361 PLFLT arg2 ;
9362 PLFLT arg3 ;
9363 PLFLT arg4 ;
9364
9365 SWIG_check_num_args("plsdiplt",4,4)
9366 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdiplt",1,"PLFLT");
9367 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsdiplt",2,"PLFLT");
9368 if(!lua_isnumber(L,3)) SWIG_fail_arg("plsdiplt",3,"PLFLT");
9369 if(!lua_isnumber(L,4)) SWIG_fail_arg("plsdiplt",4,"PLFLT");
9370 arg1 = (PLFLT)lua_tonumber(L, 1);
9371 arg2 = (PLFLT)lua_tonumber(L, 2);
9372 arg3 = (PLFLT)lua_tonumber(L, 3);
9373 arg4 = (PLFLT)lua_tonumber(L, 4);
9374 plsdiplt(arg1,arg2,arg3,arg4);
9375
9376 return SWIG_arg;
9377
9378 if(0) SWIG_fail;
9379
9380 fail:
9381 lua_error(L);
9382 return SWIG_arg;
9383 }
9384
9385
9386 static int _wrap_sdiplz(lua_State* L) {
9387 int SWIG_arg = 0;
9388 PLFLT arg1 ;
9389 PLFLT arg2 ;
9390 PLFLT arg3 ;
9391 PLFLT arg4 ;
9392
9393 SWIG_check_num_args("plsdiplz",4,4)
9394 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdiplz",1,"PLFLT");
9395 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsdiplz",2,"PLFLT");
9396 if(!lua_isnumber(L,3)) SWIG_fail_arg("plsdiplz",3,"PLFLT");
9397 if(!lua_isnumber(L,4)) SWIG_fail_arg("plsdiplz",4,"PLFLT");
9398 arg1 = (PLFLT)lua_tonumber(L, 1);
9399 arg2 = (PLFLT)lua_tonumber(L, 2);
9400 arg3 = (PLFLT)lua_tonumber(L, 3);
9401 arg4 = (PLFLT)lua_tonumber(L, 4);
9402 plsdiplz(arg1,arg2,arg3,arg4);
9403
9404 return SWIG_arg;
9405
9406 if(0) SWIG_fail;
9407
9408 fail:
9409 lua_error(L);
9410 return SWIG_arg;
9411 }
9412
9413
9414 static int _wrap_seed(lua_State* L) {
9415 int SWIG_arg = 0;
9416 unsigned int arg1 ;
9417
9418 SWIG_check_num_args("plseed",1,1)
9419 if(!lua_isnumber(L,1)) SWIG_fail_arg("plseed",1,"unsigned int");
9420 SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative")
9421 arg1 = (unsigned int)lua_tonumber(L, 1);
9422 plseed(arg1);
9423
9424 return SWIG_arg;
9425
9426 if(0) SWIG_fail;
9427
9428 fail:
9429 lua_error(L);
9430 return SWIG_arg;
9431 }
9432
9433
9434 static int _wrap_sesc(lua_State* L) {
9435 int SWIG_arg = 0;
9436 char arg1 ;
9437
9438 SWIG_check_num_args("plsesc",1,1)
9439 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plsesc",1,"char");
9440 arg1 = (lua_tostring(L, 1))[0];
9441 plsesc(arg1);
9442
9443 return SWIG_arg;
9444
9445 if(0) SWIG_fail;
9446
9447 fail:
9448 lua_error(L);
9449 return SWIG_arg;
9450 }
9451
9452
9453 static int _wrap_setopt(lua_State* L) {
9454 int SWIG_arg = 0;
9455 char *arg1 = (char *) 0 ;
9456 char *arg2 = (char *) 0 ;
9457 PLINT result;
9458
9459 SWIG_check_num_args("plsetopt",2,2)
9460 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plsetopt",1,"char const *");
9461 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plsetopt",2,"char const *");
9462 arg1 = (char *)lua_tostring(L, 1);
9463 arg2 = (char *)lua_tostring(L, 2);
9464 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
9465 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9466 return SWIG_arg;
9467
9468 if(0) SWIG_fail;
9469
9470 fail:
9471 lua_error(L);
9472 return SWIG_arg;
9473 }
9474
9475
9476 static int _wrap_sfam(lua_State* L) {
9477 int SWIG_arg = 0;
9478 PLINT arg1 ;
9479 PLINT arg2 ;
9480 PLINT arg3 ;
9481
9482 SWIG_check_num_args("plsfam",3,3)
9483 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsfam",1,"PLINT");
9484 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsfam",2,"PLINT");
9485 if(!lua_isnumber(L,3)) SWIG_fail_arg("plsfam",3,"PLINT");
9486 arg1 = (PLINT)lua_tonumber(L, 1);
9487 arg2 = (PLINT)lua_tonumber(L, 2);
9488 arg3 = (PLINT)lua_tonumber(L, 3);
9489 plsfam(arg1,arg2,arg3);
9490
9491 return SWIG_arg;
9492
9493 if(0) SWIG_fail;
9494
9495 fail:
9496 lua_error(L);
9497 return SWIG_arg;
9498 }
9499
9500
9501 static int _wrap_sfci(lua_State* L) {
9502 int SWIG_arg = 0;
9503 PLUNICODE arg1 ;
9504
9505 SWIG_check_num_args("plsfci",1,1)
9506 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsfci",1,"PLUNICODE");
9507 SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative")
9508 arg1 = (PLUNICODE)lua_tonumber(L, 1);
9509 plsfci(arg1);
9510
9511 return SWIG_arg;
9512
9513 if(0) SWIG_fail;
9514
9515 fail:
9516 lua_error(L);
9517 return SWIG_arg;
9518 }
9519
9520
9521 static int _wrap_sfnam(lua_State* L) {
9522 int SWIG_arg = 0;
9523 char *arg1 = (char *) 0 ;
9524
9525 SWIG_check_num_args("plsfnam",1,1)
9526 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plsfnam",1,"char const *");
9527 arg1 = (char *)lua_tostring(L, 1);
9528 plsfnam((char const *)arg1);
9529
9530 return SWIG_arg;
9531
9532 if(0) SWIG_fail;
9533
9534 fail:
9535 lua_error(L);
9536 return SWIG_arg;
9537 }
9538
9539
9540 static int _wrap_sfont(lua_State* L) {
9541 int SWIG_arg = 0;
9542 PLINT arg1 ;
9543 PLINT arg2 ;
9544 PLINT arg3 ;
9545
9546 SWIG_check_num_args("plsfont",3,3)
9547 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsfont",1,"PLINT");
9548 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsfont",2,"PLINT");
9549 if(!lua_isnumber(L,3)) SWIG_fail_arg("plsfont",3,"PLINT");
9550 arg1 = (PLINT)lua_tonumber(L, 1);
9551 arg2 = (PLINT)lua_tonumber(L, 2);
9552 arg3 = (PLINT)lua_tonumber(L, 3);
9553 plsfont(arg1,arg2,arg3);
9554
9555 return SWIG_arg;
9556
9557 if(0) SWIG_fail;
9558
9559 fail:
9560 lua_error(L);
9561 return SWIG_arg;
9562 }
9563
9564
9565 static int _wrap_shades(lua_State* L) {
9566 int SWIG_arg = 0;
9567 PLFLT **arg1 = (PLFLT **) 0 ;
9568 PLINT arg2 ;
9569 PLINT arg3 ;
9570 defined_func arg4 = (defined_func) 0 ;
9571 PLFLT arg5 ;
9572 PLFLT arg6 ;
9573 PLFLT arg7 ;
9574 PLFLT arg8 ;
9575 PLFLT *arg9 = (PLFLT *) 0 ;
9576 PLINT arg10 ;
9577 PLFLT arg11 ;
9578 PLINT arg12 ;
9579 PLFLT arg13 ;
9580 fill_func arg14 = (fill_func) 0 ;
9581 PLBOOL arg15 ;
9582 pltr_func arg16 = (pltr_func) 0 ;
9583 PLPointer arg17 = (PLPointer) 0 ;
9584 int ii1 ;
9585 PLcGrid cgrid117 ;
9586 PLcGrid2 cgrid217 ;
9587
9588 {
9589 cgrid117.xg = cgrid117.yg = cgrid117.zg = NULL;
9590 cgrid117.nx = cgrid117.ny = cgrid117.nz = 0;
9591 cgrid217.xg = cgrid217.yg = cgrid217.zg = NULL;
9592 cgrid217.nx = cgrid217.ny = 0;
9593 }
9594 {
9595 arg16 = NULL;
9596 }
9597 {
9598 arg17 = NULL;
9599 }
9600 {
9601 arg4 = NULL;
9602 }
9603 {
9604 arg14 = plfill;
9605 }
9606 SWIG_check_num_args("plshades",10,12)
9607 if(!lua_isnumber(L,2)) SWIG_fail_arg("plshades",2,"PLFLT");
9608 if(!lua_isnumber(L,3)) SWIG_fail_arg("plshades",3,"PLFLT");
9609 if(!lua_isnumber(L,4)) SWIG_fail_arg("plshades",4,"PLFLT");
9610 if(!lua_isnumber(L,5)) SWIG_fail_arg("plshades",5,"PLFLT");
9611 if(!lua_isnumber(L,7)) SWIG_fail_arg("plshades",7,"PLFLT");
9612 if(!lua_isnumber(L,8)) SWIG_fail_arg("plshades",8,"PLINT");
9613 if(!lua_isnumber(L,9)) SWIG_fail_arg("plshades",9,"PLFLT");
9614 if(!lua_isnumber(L,10)) SWIG_fail_arg("plshades",10,"PLBOOL");
9615 {
9616 int jj;
9617
9618 arg1 = read_double_Matrix( L, 1, &ii1, &jj );
9619 if ( !arg1 )
9620 SWIG_fail;
9621 Xlen = arg2 = ii1;
9622 Ylen = arg3 = jj;
9623 }
9624 arg5 = (PLFLT)lua_tonumber(L, 2);
9625 arg6 = (PLFLT)lua_tonumber(L, 3);
9626 arg7 = (PLFLT)lua_tonumber(L, 4);
9627 arg8 = (PLFLT)lua_tonumber(L, 5);
9628 {
9629 int temp;
9630 arg9 = (PLFLT *) LUA_get_double_num_array_var( L, 6, &temp );
9631 if ( !arg9 )
9632 SWIG_fail;
9633 arg10 = Alen = temp;
9634 }
9635 arg11 = (PLFLT)lua_tonumber(L, 7);
9636 arg12 = (PLINT)lua_tonumber(L, 8);
9637 arg13 = (PLFLT)lua_tonumber(L, 9);
9638 arg15 = (PLBOOL)lua_tonumber(L, 10);
9639 if(lua_gettop(L)>=11){
9640 {
9641 arg16 = NULL;
9642 mypltr_funcstr[0] = '\0';
9643
9644 if ( lua_isstring( L, 11 ) )
9645 {
9646 const char* funcstr = lua_tostring( L, 11 );
9647 if ( strcmp( "pltr0", funcstr ) == 0 )
9648 {
9649 arg16 = pltr0;
9650 }
9651 else if ( strcmp( "pltr1", funcstr ) == 0 )
9652 {
9653 arg16 = pltr1;
9654 }
9655 else if ( strcmp( "pltr2", funcstr ) == 0 )
9656 {
9657 arg16 = pltr2;
9658 }
9659 else
9660 {
9661 arg16 = mypltr;
9662 strncpy( mypltr_funcstr, funcstr, 255 );
9663 myL = L;
9664 }
9665 }
9666 else
9667 SWIG_fail_arg( "shades", 16, "pltr_func" );
9668 }
9669 }
9670 if(lua_gettop(L)>=12){
9671 {
9672 int nx, ny;
9673 int gridmode = 0;
9674
9675 lua_pushstring( L, "xg" );
9676 lua_gettable( L, 12 );
9677 if ( !lua_istable( L, -1 ) )
9678 {
9679 lua_pop( L, 1 ); // pop "xg"
9680 lua_pushstring( L, "expected a table xg" );
9681 SWIG_fail;
9682 }
9683 lua_rawgeti( L, -1, 1 );
9684 if ( lua_istable( L, -1 ) )
9685 gridmode = 2; // two dimensional array
9686 else if ( lua_isnumber( L, -1 ) )
9687 gridmode = 1; // one dimensional array
9688 else
9689 {
9690 lua_pop( L, 1 ); // pop "1"
9691 lua_pop( L, 1 ); // pop "xg"
9692 lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
9693 SWIG_fail;
9694 }
9695 lua_pop( L, 1 ); // pop test element
9696 if ( gridmode == 1 )
9697 {
9698 cgrid117.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
9699 if ( !cgrid117.xg )
9700 {
9701 lua_pop( L, 1 ); // pop "xg"
9702 SWIG_fail;
9703 }
9704 if ( nx != Xlen )
9705 {
9706 lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
9707 SWIG_fail;
9708 }
9709 cgrid117.nx = nx;
9710 }
9711 else
9712 {
9713 cgrid217.xg = read_double_Matrix( L, -1, &nx, &ny );
9714 if ( !cgrid217.xg )
9715 {
9716 lua_pop( L, 1 ); // pop "xg"
9717 SWIG_fail;
9718 }
9719 if ( ( nx != Xlen ) || ( ny != Ylen ) )
9720 {
9721 lua_pop( L, 1 ); // pop "xg"
9722 lua_pushfstring( L, "Vectors must match matrix." );
9723 SWIG_fail;
9724 }
9725 cgrid217.nx = nx;
9726 cgrid217.ny = ny;
9727 }
9728 lua_pop( L, 1 ); // pop "xg"
9729
9730 lua_pushstring( L, "yg" );
9731 lua_gettable( L, 12 );
9732 if ( !lua_istable( L, -1 ) )
9733 {
9734 lua_pop( L, 1 );
9735 lua_pushstring( L, "expected a table yg" );
9736 SWIG_fail;
9737 }
9738 lua_rawgeti( L, -1, 1 );
9739 if ( gridmode == 2 )
9740 {
9741 if ( !lua_istable( L, -1 ) )
9742 {
9743 lua_pop( L, 1 ); // pop "1"
9744 lua_pop( L, 1 ); // pop "yg"
9745 lua_pushstring( L, "expected a two dimensional array/table in yg" );
9746 SWIG_fail;
9747 }
9748 }
9749 else
9750 {
9751 if ( !lua_isnumber( L, -1 ) )
9752 {
9753 lua_pop( L, 1 ); // pop "1"
9754 lua_pop( L, 1 ); // pop "yg"
9755 lua_pushstring( L, "expected a one dimensional array/table in yg" );
9756 SWIG_fail;
9757 }
9758 }
9759 lua_pop( L, 1 ); // pop "1"
9760 if ( gridmode == 1 )
9761 {
9762 cgrid117.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
9763 if ( !cgrid117.yg )
9764 {
9765 lua_pop( L, 1 ); // pop "yg"
9766 SWIG_fail;
9767 }
9768 if ( ny != Ylen )
9769 {
9770 lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
9771 SWIG_fail;
9772 }
9773 cgrid117.ny = ny;
9774 }
9775 else
9776 {
9777 cgrid217.yg = read_double_Matrix( L, -1, &nx, &ny );
9778 if ( !cgrid217.yg )
9779 {
9780 lua_pop( L, 1 ); // pop "xg"
9781 SWIG_fail;
9782 }
9783 if ( ( nx != Xlen ) || ( ny != Ylen ) )
9784 {
9785 lua_pop( L, 1 ); // pop "xg"
9786 lua_pushfstring( L, "Vectors must match matrix." );
9787 SWIG_fail;
9788 }
9789 // cgrid217.nx/ny already set
9790 }
9791 lua_pop( L, 1 ); // pop "yg"
9792
9793 if ( gridmode == 1 )
9794 arg17 = &cgrid117;
9795 else if ( gridmode == 2 )
9796 arg17 = &cgrid217;
9797 }
9798 }
9799 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
9800
9801 {
9802 int i;
9803
9804 if ( arg1 )
9805 {
9806 for ( i = 0; i < ii1; i++ )
9807 LUA_FREE_ARRAY( arg1[i] );
9808 LUA_FREE_ARRAY( arg1 );
9809 }
9810 }
9811 {
9812 LUA_FREE_ARRAY( arg9 );
9813 }
9814 {
9815 mypltr_funcstr[0] = '\0';
9816 }
9817 {
9818 int i;
9819
9820 LUA_FREE_ARRAY( cgrid117.xg );
9821 LUA_FREE_ARRAY( cgrid117.yg );
9822
9823 if ( cgrid217.xg )
9824 {
9825 for ( i = 0; i < Xlen; i++ )
9826 LUA_FREE_ARRAY( cgrid217.xg[i] );
9827 LUA_FREE_ARRAY( cgrid217.xg );
9828 }
9829 if ( cgrid217.yg )
9830 {
9831 for ( i = 0; i < Xlen; i++ )
9832 LUA_FREE_ARRAY( cgrid217.yg[i] );
9833 LUA_FREE_ARRAY( cgrid217.yg );
9834 }
9835 }
9836 return SWIG_arg;
9837
9838 if(0) SWIG_fail;
9839
9840 fail:
9841 {
9842 int i;
9843
9844 if ( arg1 )
9845 {
9846 for ( i = 0; i < ii1; i++ )
9847 LUA_FREE_ARRAY( arg1[i] );
9848 LUA_FREE_ARRAY( arg1 );
9849 }
9850 }
9851 {
9852 LUA_FREE_ARRAY( arg9 );
9853 }
9854 {
9855 mypltr_funcstr[0] = '\0';
9856 }
9857 {
9858 int i;
9859
9860 LUA_FREE_ARRAY( cgrid117.xg );
9861 LUA_FREE_ARRAY( cgrid117.yg );
9862
9863 if ( cgrid217.xg )
9864 {
9865 for ( i = 0; i < Xlen; i++ )
9866 LUA_FREE_ARRAY( cgrid217.xg[i] );
9867 LUA_FREE_ARRAY( cgrid217.xg );
9868 }
9869 if ( cgrid217.yg )
9870 {
9871 for ( i = 0; i < Xlen; i++ )
9872 LUA_FREE_ARRAY( cgrid217.yg[i] );
9873 LUA_FREE_ARRAY( cgrid217.yg );
9874 }
9875 }
9876 lua_error(L);
9877 return SWIG_arg;
9878 }
9879
9880
9881 static int _wrap_shade(lua_State* L) {
9882 int SWIG_arg = 0;
9883 PLFLT **arg1 = (PLFLT **) 0 ;
9884 PLINT arg2 ;
9885 PLINT arg3 ;
9886 defined_func arg4 = (defined_func) 0 ;
9887 PLFLT arg5 ;
9888 PLFLT arg6 ;
9889 PLFLT arg7 ;
9890 PLFLT arg8 ;
9891 PLFLT arg9 ;
9892 PLFLT arg10 ;
9893 PLINT arg11 ;
9894 PLFLT arg12 ;
9895 PLFLT arg13 ;
9896 PLINT arg14 ;
9897 PLFLT arg15 ;
9898 PLINT arg16 ;
9899 PLFLT arg17 ;
9900 fill_func arg18 = (fill_func) 0 ;
9901 PLBOOL arg19 ;
9902 pltr_func arg20 = (pltr_func) 0 ;
9903 PLPointer arg21 = (PLPointer) 0 ;
9904 int ii1 ;
9905 PLcGrid cgrid121 ;
9906 PLcGrid2 cgrid221 ;
9907
9908 {
9909 cgrid121.xg = cgrid121.yg = cgrid121.zg = NULL;
9910 cgrid121.nx = cgrid121.ny = cgrid121.nz = 0;
9911 cgrid221.xg = cgrid221.yg = cgrid221.zg = NULL;
9912 cgrid221.nx = cgrid221.ny = 0;
9913 }
9914 {
9915 arg20 = NULL;
9916 }
9917 {
9918 arg21 = NULL;
9919 }
9920 {
9921 arg4 = NULL;
9922 }
9923 {
9924 arg18 = plfill;
9925 }
9926 SWIG_check_num_args("plshade",15,17)
9927 if(!lua_isnumber(L,2)) SWIG_fail_arg("plshade",2,"PLFLT");
9928 if(!lua_isnumber(L,3)) SWIG_fail_arg("plshade",3,"PLFLT");
9929 if(!lua_isnumber(L,4)) SWIG_fail_arg("plshade",4,"PLFLT");
9930 if(!lua_isnumber(L,5)) SWIG_fail_arg("plshade",5,"PLFLT");
9931 if(!lua_isnumber(L,6)) SWIG_fail_arg("plshade",6,"PLFLT");
9932 if(!lua_isnumber(L,7)) SWIG_fail_arg("plshade",7,"PLFLT");
9933 if(!lua_isnumber(L,8)) SWIG_fail_arg("plshade",8,"PLINT");
9934 if(!lua_isnumber(L,9)) SWIG_fail_arg("plshade",9,"PLFLT");
9935 if(!lua_isnumber(L,10)) SWIG_fail_arg("plshade",10,"PLFLT");
9936 if(!lua_isnumber(L,11)) SWIG_fail_arg("plshade",11,"PLINT");
9937 if(!lua_isnumber(L,12)) SWIG_fail_arg("plshade",12,"PLFLT");
9938 if(!lua_isnumber(L,13)) SWIG_fail_arg("plshade",13,"PLINT");
9939 if(!lua_isnumber(L,14)) SWIG_fail_arg("plshade",14,"PLFLT");
9940 if(!lua_isnumber(L,15)) SWIG_fail_arg("plshade",15,"PLBOOL");
9941 {
9942 int jj;
9943
9944 arg1 = read_double_Matrix( L, 1, &ii1, &jj );
9945 if ( !arg1 )
9946 SWIG_fail;
9947 Xlen = arg2 = ii1;
9948 Ylen = arg3 = jj;
9949 }
9950 arg5 = (PLFLT)lua_tonumber(L, 2);
9951 arg6 = (PLFLT)lua_tonumber(L, 3);
9952 arg7 = (PLFLT)lua_tonumber(L, 4);
9953 arg8 = (PLFLT)lua_tonumber(L, 5);
9954 arg9 = (PLFLT)lua_tonumber(L, 6);
9955 arg10 = (PLFLT)lua_tonumber(L, 7);
9956 arg11 = (PLINT)lua_tonumber(L, 8);
9957 arg12 = (PLFLT)lua_tonumber(L, 9);
9958 arg13 = (PLFLT)lua_tonumber(L, 10);
9959 arg14 = (PLINT)lua_tonumber(L, 11);
9960 arg15 = (PLFLT)lua_tonumber(L, 12);
9961 arg16 = (PLINT)lua_tonumber(L, 13);
9962 arg17 = (PLFLT)lua_tonumber(L, 14);
9963 arg19 = (PLBOOL)lua_tonumber(L, 15);
9964 if(lua_gettop(L)>=16){
9965 {
9966 arg20 = NULL;
9967 mypltr_funcstr[0] = '\0';
9968
9969 if ( lua_isstring( L, 16 ) )
9970 {
9971 const char* funcstr = lua_tostring( L, 16 );
9972 if ( strcmp( "pltr0", funcstr ) == 0 )
9973 {
9974 arg20 = pltr0;
9975 }
9976 else if ( strcmp( "pltr1", funcstr ) == 0 )
9977 {
9978 arg20 = pltr1;
9979 }
9980 else if ( strcmp( "pltr2", funcstr ) == 0 )
9981 {
9982 arg20 = pltr2;
9983 }
9984 else
9985 {
9986 arg20 = mypltr;
9987 strncpy( mypltr_funcstr, funcstr, 255 );
9988 myL = L;
9989 }
9990 }
9991 else
9992 SWIG_fail_arg( "shade", 20, "pltr_func" );
9993 }
9994 }
9995 if(lua_gettop(L)>=17){
9996 {
9997 int nx, ny;
9998 int gridmode = 0;
9999
10000 lua_pushstring( L, "xg" );
10001 lua_gettable( L, 17 );
10002 if ( !lua_istable( L, -1 ) )
10003 {
10004 lua_pop( L, 1 ); // pop "xg"
10005 lua_pushstring( L, "expected a table xg" );
10006 SWIG_fail;
10007 }
10008 lua_rawgeti( L, -1, 1 );
10009 if ( lua_istable( L, -1 ) )
10010 gridmode = 2; // two dimensional array
10011 else if ( lua_isnumber( L, -1 ) )
10012 gridmode = 1; // one dimensional array
10013 else
10014 {
10015 lua_pop( L, 1 ); // pop "1"
10016 lua_pop( L, 1 ); // pop "xg"
10017 lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
10018 SWIG_fail;
10019 }
10020 lua_pop( L, 1 ); // pop test element
10021 if ( gridmode == 1 )
10022 {
10023 cgrid121.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
10024 if ( !cgrid121.xg )
10025 {
10026 lua_pop( L, 1 ); // pop "xg"
10027 SWIG_fail;
10028 }
10029 if ( nx != Xlen )
10030 {
10031 lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
10032 SWIG_fail;
10033 }
10034 cgrid121.nx = nx;
10035 }
10036 else
10037 {
10038 cgrid221.xg = read_double_Matrix( L, -1, &nx, &ny );
10039 if ( !cgrid221.xg )
10040 {
10041 lua_pop( L, 1 ); // pop "xg"
10042 SWIG_fail;
10043 }
10044 if ( ( nx != Xlen ) || ( ny != Ylen ) )
10045 {
10046 lua_pop( L, 1 ); // pop "xg"
10047 lua_pushfstring( L, "Vectors must match matrix." );
10048 SWIG_fail;
10049 }
10050 cgrid221.nx = nx;
10051 cgrid221.ny = ny;
10052 }
10053 lua_pop( L, 1 ); // pop "xg"
10054
10055 lua_pushstring( L, "yg" );
10056 lua_gettable( L, 17 );
10057 if ( !lua_istable( L, -1 ) )
10058 {
10059 lua_pop( L, 1 );
10060 lua_pushstring( L, "expected a table yg" );
10061 SWIG_fail;
10062 }
10063 lua_rawgeti( L, -1, 1 );
10064 if ( gridmode == 2 )
10065 {
10066 if ( !lua_istable( L, -1 ) )
10067 {
10068 lua_pop( L, 1 ); // pop "1"
10069 lua_pop( L, 1 ); // pop "yg"
10070 lua_pushstring( L, "expected a two dimensional array/table in yg" );
10071 SWIG_fail;
10072 }
10073 }
10074 else
10075 {
10076 if ( !lua_isnumber( L, -1 ) )
10077 {
10078 lua_pop( L, 1 ); // pop "1"
10079 lua_pop( L, 1 ); // pop "yg"
10080 lua_pushstring( L, "expected a one dimensional array/table in yg" );
10081 SWIG_fail;
10082 }
10083 }
10084 lua_pop( L, 1 ); // pop "1"
10085 if ( gridmode == 1 )
10086 {
10087 cgrid121.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
10088 if ( !cgrid121.yg )
10089 {
10090 lua_pop( L, 1 ); // pop "yg"
10091 SWIG_fail;
10092 }
10093 if ( ny != Ylen )
10094 {
10095 lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
10096 SWIG_fail;
10097 }
10098 cgrid121.ny = ny;
10099 }
10100 else
10101 {
10102 cgrid221.yg = read_double_Matrix( L, -1, &nx, &ny );
10103 if ( !cgrid221.yg )
10104 {
10105 lua_pop( L, 1 ); // pop "xg"
10106 SWIG_fail;
10107 }
10108 if ( ( nx != Xlen ) || ( ny != Ylen ) )
10109 {
10110 lua_pop( L, 1 ); // pop "xg"
10111 lua_pushfstring( L, "Vectors must match matrix." );
10112 SWIG_fail;
10113 }
10114 // cgrid221.nx/ny already set
10115 }
10116 lua_pop( L, 1 ); // pop "yg"
10117
10118 if ( gridmode == 1 )
10119 arg21 = &cgrid121;
10120 else if ( gridmode == 2 )
10121 arg21 = &cgrid221;
10122 }
10123 }
10124 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
10125
10126 {
10127 int i;
10128
10129 if ( arg1 )
10130 {
10131 for ( i = 0; i < ii1; i++ )
10132 LUA_FREE_ARRAY( arg1[i] );
10133 LUA_FREE_ARRAY( arg1 );
10134 }
10135 }
10136 {
10137 mypltr_funcstr[0] = '\0';
10138 }
10139 {
10140 int i;
10141
10142 LUA_FREE_ARRAY( cgrid121.xg );
10143 LUA_FREE_ARRAY( cgrid121.yg );
10144
10145 if ( cgrid221.xg )
10146 {
10147 for ( i = 0; i < Xlen; i++ )
10148 LUA_FREE_ARRAY( cgrid221.xg[i] );
10149 LUA_FREE_ARRAY( cgrid221.xg );
10150 }
10151 if ( cgrid221.yg )
10152 {
10153 for ( i = 0; i < Xlen; i++ )
10154 LUA_FREE_ARRAY( cgrid221.yg[i] );
10155 LUA_FREE_ARRAY( cgrid221.yg );
10156 }
10157 }
10158 return SWIG_arg;
10159
10160 if(0) SWIG_fail;
10161
10162 fail:
10163 {
10164 int i;
10165
10166 if ( arg1 )
10167 {
10168 for ( i = 0; i < ii1; i++ )
10169 LUA_FREE_ARRAY( arg1[i] );
10170 LUA_FREE_ARRAY( arg1 );
10171 }
10172 }
10173 {
10174 mypltr_funcstr[0] = '\0';
10175 }
10176 {
10177 int i;
10178
10179 LUA_FREE_ARRAY( cgrid121.xg );
10180 LUA_FREE_ARRAY( cgrid121.yg );
10181
10182 if ( cgrid221.xg )
10183 {
10184 for ( i = 0; i < Xlen; i++ )
10185 LUA_FREE_ARRAY( cgrid221.xg[i] );
10186 LUA_FREE_ARRAY( cgrid221.xg );
10187 }
10188 if ( cgrid221.yg )
10189 {
10190 for ( i = 0; i < Xlen; i++ )
10191 LUA_FREE_ARRAY( cgrid221.yg[i] );
10192 LUA_FREE_ARRAY( cgrid221.yg );
10193 }
10194 }
10195 lua_error(L);
10196 return SWIG_arg;
10197 }
10198
10199
10200 static int _wrap_slabelfunc(lua_State* L) {
10201 int SWIG_arg = 0;
10202 label_func arg1 = (label_func) 0 ;
10203 PLPointer arg2 = (PLPointer) 0 ;
10204
10205 {
10206 arg2 = NULL;
10207 }
10208 SWIG_check_num_args("plslabelfunc",1,1)
10209 {
10210 arg1 = NULL;
10211 mylabel_funcstr[0] = '\0';
10212
10213 if ( lua_isnil( L, 1 ) )
10214 {
10215 arg1 = NULL;
10216 }
10217 else if ( lua_isstring( L, 1 ) )
10218 {
10219 arg1 = mylabel;
10220 strncpy( mylabel_funcstr, lua_tostring( L, 1 ), 255 );
10221 myL = L;
10222 }
10223 else
10224 SWIG_fail_arg( "slabelfunc", 1, "label_func" );
10225 }
10226 plslabelfunc(arg1,arg2);
10227
10228 {
10229
10230 }
10231 return SWIG_arg;
10232
10233 if(0) SWIG_fail;
10234
10235 fail:
10236 {
10237
10238 }
10239 lua_error(L);
10240 return SWIG_arg;
10241 }
10242
10243
10244 static int _wrap_smaj(lua_State* L) {
10245 int SWIG_arg = 0;
10246 PLFLT arg1 ;
10247 PLFLT arg2 ;
10248
10249 SWIG_check_num_args("plsmaj",2,2)
10250 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsmaj",1,"PLFLT");
10251 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsmaj",2,"PLFLT");
10252 arg1 = (PLFLT)lua_tonumber(L, 1);
10253 arg2 = (PLFLT)lua_tonumber(L, 2);
10254 plsmaj(arg1,arg2);
10255
10256 return SWIG_arg;
10257
10258 if(0) SWIG_fail;
10259
10260 fail:
10261 lua_error(L);
10262 return SWIG_arg;
10263 }
10264
10265
10266 static int _wrap_smin(lua_State* L) {
10267 int SWIG_arg = 0;
10268 PLFLT arg1 ;
10269 PLFLT arg2 ;
10270
10271 SWIG_check_num_args("plsmin",2,2)
10272 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsmin",1,"PLFLT");
10273 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsmin",2,"PLFLT");
10274 arg1 = (PLFLT)lua_tonumber(L, 1);
10275 arg2 = (PLFLT)lua_tonumber(L, 2);
10276 plsmin(arg1,arg2);
10277
10278 return SWIG_arg;
10279
10280 if(0) SWIG_fail;
10281
10282 fail:
10283 lua_error(L);
10284 return SWIG_arg;
10285 }
10286
10287
10288 static int _wrap_sori(lua_State* L) {
10289 int SWIG_arg = 0;
10290 PLINT arg1 ;
10291
10292 SWIG_check_num_args("plsori",1,1)
10293 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsori",1,"PLINT");
10294 arg1 = (PLINT)lua_tonumber(L, 1);
10295 plsori(arg1);
10296
10297 return SWIG_arg;
10298
10299 if(0) SWIG_fail;
10300
10301 fail:
10302 lua_error(L);
10303 return SWIG_arg;
10304 }
10305
10306
10307 static int _wrap_spage(lua_State* L) {
10308 int SWIG_arg = 0;
10309 PLFLT arg1 ;
10310 PLFLT arg2 ;
10311 PLINT arg3 ;
10312 PLINT arg4 ;
10313 PLINT arg5 ;
10314 PLINT arg6 ;
10315
10316 SWIG_check_num_args("plspage",6,6)
10317 if(!lua_isnumber(L,1)) SWIG_fail_arg("plspage",1,"PLFLT");
10318 if(!lua_isnumber(L,2)) SWIG_fail_arg("plspage",2,"PLFLT");
10319 if(!lua_isnumber(L,3)) SWIG_fail_arg("plspage",3,"PLINT");
10320 if(!lua_isnumber(L,4)) SWIG_fail_arg("plspage",4,"PLINT");
10321 if(!lua_isnumber(L,5)) SWIG_fail_arg("plspage",5,"PLINT");
10322 if(!lua_isnumber(L,6)) SWIG_fail_arg("plspage",6,"PLINT");
10323 arg1 = (PLFLT)lua_tonumber(L, 1);
10324 arg2 = (PLFLT)lua_tonumber(L, 2);
10325 arg3 = (PLINT)lua_tonumber(L, 3);
10326 arg4 = (PLINT)lua_tonumber(L, 4);
10327 arg5 = (PLINT)lua_tonumber(L, 5);
10328 arg6 = (PLINT)lua_tonumber(L, 6);
10329 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
10330
10331 return SWIG_arg;
10332
10333 if(0) SWIG_fail;
10334
10335 fail:
10336 lua_error(L);
10337 return SWIG_arg;
10338 }
10339
10340
10341 static int _wrap_spal0(lua_State* L) {
10342 int SWIG_arg = 0;
10343 char *arg1 = (char *) 0 ;
10344
10345 SWIG_check_num_args("plspal0",1,1)
10346 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plspal0",1,"char const *");
10347 arg1 = (char *)lua_tostring(L, 1);
10348 plspal0((char const *)arg1);
10349
10350 return SWIG_arg;
10351
10352 if(0) SWIG_fail;
10353
10354 fail:
10355 lua_error(L);
10356 return SWIG_arg;
10357 }
10358
10359
10360 static int _wrap_spal1(lua_State* L) {
10361 int SWIG_arg = 0;
10362 char *arg1 = (char *) 0 ;
10363 PLBOOL arg2 ;
10364
10365 SWIG_check_num_args("plspal1",2,2)
10366 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plspal1",1,"char const *");
10367 if(!lua_isnumber(L,2)) SWIG_fail_arg("plspal1",2,"PLBOOL");
10368 arg1 = (char *)lua_tostring(L, 1);
10369 arg2 = (PLBOOL)lua_tonumber(L, 2);
10370 plspal1((char const *)arg1,arg2);
10371
10372 return SWIG_arg;
10373
10374 if(0) SWIG_fail;
10375
10376 fail:
10377 lua_error(L);
10378 return SWIG_arg;
10379 }
10380
10381
10382 static int _wrap_spause(lua_State* L) {
10383 int SWIG_arg = 0;
10384 PLBOOL arg1 ;
10385
10386 SWIG_check_num_args("plspause",1,1)
10387 if(!lua_isnumber(L,1)) SWIG_fail_arg("plspause",1,"PLBOOL");
10388 arg1 = (PLBOOL)lua_tonumber(L, 1);
10389 plspause(arg1);
10390
10391 return SWIG_arg;
10392
10393 if(0) SWIG_fail;
10394
10395 fail:
10396 lua_error(L);
10397 return SWIG_arg;
10398 }
10399
10400
10401 static int _wrap_sstrm(lua_State* L) {
10402 int SWIG_arg = 0;
10403 PLINT arg1 ;
10404
10405 SWIG_check_num_args("plsstrm",1,1)
10406 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsstrm",1,"PLINT");
10407 arg1 = (PLINT)lua_tonumber(L, 1);
10408 plsstrm(arg1);
10409
10410 return SWIG_arg;
10411
10412 if(0) SWIG_fail;
10413
10414 fail:
10415 lua_error(L);
10416 return SWIG_arg;
10417 }
10418
10419
10420 static int _wrap_ssub(lua_State* L) {
10421 int SWIG_arg = 0;
10422 PLINT arg1 ;
10423 PLINT arg2 ;
10424
10425 SWIG_check_num_args("plssub",2,2)
10426 if(!lua_isnumber(L,1)) SWIG_fail_arg("plssub",1,"PLINT");
10427 if(!lua_isnumber(L,2)) SWIG_fail_arg("plssub",2,"PLINT");
10428 arg1 = (PLINT)lua_tonumber(L, 1);
10429 arg2 = (PLINT)lua_tonumber(L, 2);
10430 plssub(arg1,arg2);
10431
10432 return SWIG_arg;
10433
10434 if(0) SWIG_fail;
10435
10436 fail:
10437 lua_error(L);
10438 return SWIG_arg;
10439 }
10440
10441
10442 static int _wrap_ssym(lua_State* L) {
10443 int SWIG_arg = 0;
10444 PLFLT arg1 ;
10445 PLFLT arg2 ;
10446
10447 SWIG_check_num_args("plssym",2,2)
10448 if(!lua_isnumber(L,1)) SWIG_fail_arg("plssym",1,"PLFLT");
10449 if(!lua_isnumber(L,2)) SWIG_fail_arg("plssym",2,"PLFLT");
10450 arg1 = (PLFLT)lua_tonumber(L, 1);
10451 arg2 = (PLFLT)lua_tonumber(L, 2);
10452 plssym(arg1,arg2);
10453
10454 return SWIG_arg;
10455
10456 if(0) SWIG_fail;
10457
10458 fail:
10459 lua_error(L);
10460 return SWIG_arg;
10461 }
10462
10463
10464 static int _wrap_star(lua_State* L) {
10465 int SWIG_arg = 0;
10466 PLINT arg1 ;
10467 PLINT arg2 ;
10468
10469 SWIG_check_num_args("plstar",2,2)
10470 if(!lua_isnumber(L,1)) SWIG_fail_arg("plstar",1,"PLINT");
10471 if(!lua_isnumber(L,2)) SWIG_fail_arg("plstar",2,"PLINT");
10472 arg1 = (PLINT)lua_tonumber(L, 1);
10473 arg2 = (PLINT)lua_tonumber(L, 2);
10474 plstar(arg1,arg2);
10475
10476 return SWIG_arg;
10477
10478 if(0) SWIG_fail;
10479
10480 fail:
10481 lua_error(L);
10482 return SWIG_arg;
10483 }
10484
10485
10486 static int _wrap_start(lua_State* L) {
10487 int SWIG_arg = 0;
10488 char *arg1 = (char *) 0 ;
10489 PLINT arg2 ;
10490 PLINT arg3 ;
10491
10492 SWIG_check_num_args("plstart",3,3)
10493 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plstart",1,"char const *");
10494 if(!lua_isnumber(L,2)) SWIG_fail_arg("plstart",2,"PLINT");
10495 if(!lua_isnumber(L,3)) SWIG_fail_arg("plstart",3,"PLINT");
10496 arg1 = (char *)lua_tostring(L, 1);
10497 arg2 = (PLINT)lua_tonumber(L, 2);
10498 arg3 = (PLINT)lua_tonumber(L, 3);
10499 plstart((char const *)arg1,arg2,arg3);
10500
10501 return SWIG_arg;
10502
10503 if(0) SWIG_fail;
10504
10505 fail:
10506 lua_error(L);
10507 return SWIG_arg;
10508 }
10509
10510
10511 static int _wrap_stransform(lua_State* L) {
10512 int SWIG_arg = 0;
10513 ct_func arg1 = (ct_func) 0 ;
10514 PLPointer arg2 = (PLPointer) 0 ;
10515
10516 {
10517 arg1 = NULL;
10518 myct_funcstr[0] = '\0';
10519 }
10520 {
10521 arg2 = NULL;
10522 }
10523 SWIG_check_num_args("plstransform",0,1)
10524 if(lua_gettop(L)>=1){
10525 {
10526 arg1 = NULL;
10527 myct_funcstr[0] = '\0';
10528
10529 if ( lua_isstring( L, 1 ) )
10530 {
10531 const char* funcstr = lua_tostring( L, 1 );
10532 arg1 = myct;
10533 strncpy( myct_funcstr, funcstr, 255 );
10534 myL = L;
10535 }
10536 else
10537 SWIG_fail_arg( "stransform", 1, "ct_func" );
10538 }
10539 }
10540 plstransform(arg1,arg2);
10541
10542 return SWIG_arg;
10543
10544 if(0) SWIG_fail;
10545
10546 fail:
10547 lua_error(L);
10548 return SWIG_arg;
10549 }
10550
10551
10552 static int _wrap_string(lua_State* L) {
10553 int SWIG_arg = 0;
10554 PLINT arg1 ;
10555 PLFLT *arg2 = (PLFLT *) 0 ;
10556 PLFLT *arg3 = (PLFLT *) 0 ;
10557 char *arg4 = (char *) 0 ;
10558 int temp3 ;
10559
10560 SWIG_check_num_args("plstring",3,3)
10561 if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("plstring",3,"char const *");
10562 {
10563 int temp;
10564 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
10565 if ( !arg2 )
10566 SWIG_fail;
10567 arg1 = Alen = temp;
10568 }
10569 {
10570 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
10571 if ( !arg3 )
10572 SWIG_fail;
10573 if ( temp3 != Alen )
10574 {
10575 lua_pushfstring( L, "Tables must be of same length." );
10576 SWIG_fail;
10577 }
10578 }
10579 arg4 = (char *)lua_tostring(L, 3);
10580 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
10581
10582 {
10583 LUA_FREE_ARRAY( arg2 );
10584 }
10585 {
10586 LUA_FREE_ARRAY( arg3 );
10587 }
10588 return SWIG_arg;
10589
10590 if(0) SWIG_fail;
10591
10592 fail:
10593 {
10594 LUA_FREE_ARRAY( arg2 );
10595 }
10596 {
10597 LUA_FREE_ARRAY( arg3 );
10598 }
10599 lua_error(L);
10600 return SWIG_arg;
10601 }
10602
10603
10604 static int _wrap_string3(lua_State* L) {
10605 int SWIG_arg = 0;
10606 PLINT arg1 ;
10607 PLFLT *arg2 = (PLFLT *) 0 ;
10608 PLFLT *arg3 = (PLFLT *) 0 ;
10609 PLFLT *arg4 = (PLFLT *) 0 ;
10610 char *arg5 = (char *) 0 ;
10611 int temp3 ;
10612 int temp4 ;
10613
10614 SWIG_check_num_args("plstring3",4,4)
10615 if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("plstring3",4,"char const *");
10616 {
10617 int temp;
10618 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
10619 if ( !arg2 )
10620 SWIG_fail;
10621 arg1 = Alen = temp;
10622 }
10623 {
10624 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
10625 if ( !arg3 )
10626 SWIG_fail;
10627 if ( temp3 != Alen )
10628 {
10629 lua_pushfstring( L, "Tables must be of same length." );
10630 SWIG_fail;
10631 }
10632 }
10633 {
10634 arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
10635 if ( !arg4 )
10636 SWIG_fail;
10637 if ( temp4 != Alen )
10638 {
10639 lua_pushfstring( L, "Tables must be of same length." );
10640 SWIG_fail;
10641 }
10642 }
10643 arg5 = (char *)lua_tostring(L, 4);
10644 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
10645
10646 {
10647 LUA_FREE_ARRAY( arg2 );
10648 }
10649 {
10650 LUA_FREE_ARRAY( arg3 );
10651 }
10652 {
10653 LUA_FREE_ARRAY( arg4 );
10654 }
10655 return SWIG_arg;
10656
10657 if(0) SWIG_fail;
10658
10659 fail:
10660 {
10661 LUA_FREE_ARRAY( arg2 );
10662 }
10663 {
10664 LUA_FREE_ARRAY( arg3 );
10665 }
10666 {
10667 LUA_FREE_ARRAY( arg4 );
10668 }
10669 lua_error(L);
10670 return SWIG_arg;
10671 }
10672
10673
10674 static int _wrap_stripa(lua_State* L) {
10675 int SWIG_arg = 0;
10676 PLINT arg1 ;
10677 PLINT arg2 ;
10678 PLFLT arg3 ;
10679 PLFLT arg4 ;
10680
10681 SWIG_check_num_args("plstripa",4,4)
10682 if(!lua_isnumber(L,1)) SWIG_fail_arg("plstripa",1,"PLINT");
10683 if(!lua_isnumber(L,2)) SWIG_fail_arg("plstripa",2,"PLINT");
10684 if(!lua_isnumber(L,3)) SWIG_fail_arg("plstripa",3,"PLFLT");
10685 if(!lua_isnumber(L,4)) SWIG_fail_arg("plstripa",4,"PLFLT");
10686 arg1 = (PLINT)lua_tonumber(L, 1);
10687 arg2 = (PLINT)lua_tonumber(L, 2);
10688 arg3 = (PLFLT)lua_tonumber(L, 3);
10689 arg4 = (PLFLT)lua_tonumber(L, 4);
10690 plstripa(arg1,arg2,arg3,arg4);
10691
10692 return SWIG_arg;
10693
10694 if(0) SWIG_fail;
10695
10696 fail:
10697 lua_error(L);
10698 return SWIG_arg;
10699 }
10700
10701
10702 static int _wrap_stripc(lua_State* L) {
10703 int SWIG_arg = 0;
10704 PLINT *arg1 = (PLINT *) 0 ;
10705 char *arg2 = (char *) 0 ;
10706 char *arg3 = (char *) 0 ;
10707 PLFLT arg4 ;
10708 PLFLT arg5 ;
10709 PLFLT arg6 ;
10710 PLFLT arg7 ;
10711 PLFLT arg8 ;
10712 PLFLT arg9 ;
10713 PLFLT arg10 ;
10714 PLBOOL arg11 ;
10715 PLBOOL arg12 ;
10716 PLINT arg13 ;
10717 PLINT arg14 ;
10718 PLINT *arg15 = (PLINT *) 0 ;
10719 PLINT *arg16 = (PLINT *) 0 ;
10720 char **arg17 ;
10721 char *arg18 = (char *) 0 ;
10722 char *arg19 = (char *) 0 ;
10723 char *arg20 = (char *) 0 ;
10724 PLINT temp1 ;
10725 int temp15 ;
10726 int temp16 ;
10727
10728 {
10729 arg17 = NULL;
10730 }
10731 arg1 = &temp1;
10732 SWIG_check_num_args("plstripc",15,19)
10733 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plstripc",1,"char const *");
10734 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plstripc",2,"char const *");
10735 if(!lua_isnumber(L,3)) SWIG_fail_arg("plstripc",3,"PLFLT");
10736 if(!lua_isnumber(L,4)) SWIG_fail_arg("plstripc",4,"PLFLT");
10737 if(!lua_isnumber(L,5)) SWIG_fail_arg("plstripc",5,"PLFLT");
10738 if(!lua_isnumber(L,6)) SWIG_fail_arg("plstripc",6,"PLFLT");
10739 if(!lua_isnumber(L,7)) SWIG_fail_arg("plstripc",7,"PLFLT");
10740 if(!lua_isnumber(L,8)) SWIG_fail_arg("plstripc",8,"PLFLT");
10741 if(!lua_isnumber(L,9)) SWIG_fail_arg("plstripc",9,"PLFLT");
10742 if(!lua_isnumber(L,10)) SWIG_fail_arg("plstripc",10,"PLBOOL");
10743 if(!lua_isnumber(L,11)) SWIG_fail_arg("plstripc",11,"PLBOOL");
10744 if(!lua_isnumber(L,12)) SWIG_fail_arg("plstripc",12,"PLINT");
10745 if(!lua_isnumber(L,13)) SWIG_fail_arg("plstripc",13,"PLINT");
10746 if(lua_gettop(L)>=16 && !lua_istable(L,16)) SWIG_fail_arg("plstripc",16,"char const *[4]");
10747 if(lua_gettop(L)>=17 && !SWIG_lua_isnilstring(L,17)) SWIG_fail_arg("plstripc",17,"char const *");
10748 if(lua_gettop(L)>=18 && !SWIG_lua_isnilstring(L,18)) SWIG_fail_arg("plstripc",18,"char const *");
10749 if(lua_gettop(L)>=19 && !SWIG_lua_isnilstring(L,19)) SWIG_fail_arg("plstripc",19,"char const *");
10750 arg2 = (char *)lua_tostring(L, 1);
10751 arg3 = (char *)lua_tostring(L, 2);
10752 arg4 = (PLFLT)lua_tonumber(L, 3);
10753 arg5 = (PLFLT)lua_tonumber(L, 4);
10754 arg6 = (PLFLT)lua_tonumber(L, 5);
10755 arg7 = (PLFLT)lua_tonumber(L, 6);
10756 arg8 = (PLFLT)lua_tonumber(L, 7);
10757 arg9 = (PLFLT)lua_tonumber(L, 8);
10758 arg10 = (PLFLT)lua_tonumber(L, 9);
10759 arg11 = (PLBOOL)lua_tonumber(L, 10);
10760 arg12 = (PLBOOL)lua_tonumber(L, 11);
10761 arg13 = (PLINT)lua_tonumber(L, 12);
10762 arg14 = (PLINT)lua_tonumber(L, 13);
10763 {
10764 arg15 = (PLINT *) LUA_get_int_num_array_var( L, 14, &temp15 );
10765 if ( !arg15 )
10766 SWIG_fail;
10767 Alen = temp15;
10768 }
10769 {
10770 arg16 = (PLINT *) LUA_get_int_num_array_var( L, 15, &temp16 );
10771 if ( !arg16 )
10772 SWIG_fail;
10773 if ( temp16 != Alen )
10774 {
10775 lua_pushfstring( L, "Tables must be of same length." );
10776 SWIG_fail;
10777 }
10778 }
10779 if(lua_gettop(L)>=16){
10780 {
10781 int i;
10782 arg17 = NULL;
10783
10784 if ( SWIG_table_size( L, 16 ) != 4 )
10785 {
10786 lua_pushfstring( L, "Requires a sequence of 4 strings." );
10787 SWIG_fail;
10788 }
10789 if ( Alen != 4 )
10790 {
10791 lua_pushfstring( L, "colline and styline args must be length 4." );
10792 SWIG_fail;
10793 }
10794
10795 arg17 = malloc( sizeof ( char* ) * 4 );
10796 for ( i = 1; i <= 4; i++ )
10797 {
10798 lua_rawgeti( L, 16, i );
10799 if ( lua_isstring( L, -1 ) )
10800 {
10801 arg17[i - 1] = (char *) lua_tostring( L, -1 );
10802 }
10803 else
10804 {
10805 lua_pop( L, 1 );
10806 lua_pushfstring( L, "Requires a sequence of 4 strings." );
10807 SWIG_fail;
10808 // arg17 array is freed after 'fail:'
10809 }
10810 lua_pop( L, 1 );
10811 }
10812 }
10813 }
10814 if(lua_gettop(L)>=17){
10815 arg18 = (char *)lua_tostring(L, 17);
10816 }
10817 if(lua_gettop(L)>=18){
10818 arg19 = (char *)lua_tostring(L, 18);
10819 }
10820 if(lua_gettop(L)>=19){
10821 arg20 = (char *)lua_tostring(L, 19);
10822 }
10823 plstripc(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(int const *)arg15,(int const *)arg16,(char const *(*))arg17,(char const *)arg18,(char const *)arg19,(char const *)arg20);
10824
10825 lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
10826 {
10827 LUA_FREE_ARRAY( arg15 );
10828 }
10829 {
10830 LUA_FREE_ARRAY( arg16 );
10831 }
10832 {
10833 if ( arg17 )
10834 {
10835 free( arg17 ); arg17 = NULL;
10836 }
10837 }
10838 return SWIG_arg;
10839
10840 if(0) SWIG_fail;
10841
10842 fail:
10843 {
10844 LUA_FREE_ARRAY( arg15 );
10845 }
10846 {
10847 LUA_FREE_ARRAY( arg16 );
10848 }
10849 {
10850 if ( arg17 )
10851 {
10852 free( arg17 ); arg17 = NULL;
10853 }
10854 }
10855 lua_error(L);
10856 return SWIG_arg;
10857 }
10858
10859
10860 static int _wrap_stripd(lua_State* L) {
10861 int SWIG_arg = 0;
10862 PLINT arg1 ;
10863
10864 SWIG_check_num_args("plstripd",1,1)
10865 if(!lua_isnumber(L,1)) SWIG_fail_arg("plstripd",1,"PLINT");
10866 arg1 = (PLINT)lua_tonumber(L, 1);
10867 plstripd(arg1);
10868
10869 return SWIG_arg;
10870
10871 if(0) SWIG_fail;
10872
10873 fail:
10874 lua_error(L);
10875 return SWIG_arg;
10876 }
10877
10878
10879 static int _wrap_styl(lua_State* L) {
10880 int SWIG_arg = 0;
10881 PLINT arg1 ;
10882 PLINT *arg2 = (PLINT *) 0 ;
10883 PLINT *arg3 = (PLINT *) 0 ;
10884 int temp3 ;
10885
10886 SWIG_check_num_args("plstyl",2,2)
10887 {
10888 arg2 = (PLINT *) LUA_get_int_num_array_var( L, 1, &arg1 );
10889 if ( !arg2 )
10890 SWIG_fail;
10891 Alen = arg1;
10892 }
10893 {
10894 arg3 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp3 );
10895 if ( !arg3 )
10896 SWIG_fail;
10897 if ( temp3 != Alen )
10898 {
10899 lua_pushfstring( L, "Tables must be of same length." );
10900 SWIG_fail;
10901 }
10902 }
10903 plstyl(arg1,(int const *)arg2,(int const *)arg3);
10904
10905 {
10906 LUA_FREE_ARRAY( arg2 );
10907 }
10908 {
10909 LUA_FREE_ARRAY( arg3 );
10910 }
10911 return SWIG_arg;
10912
10913 if(0) SWIG_fail;
10914
10915 fail:
10916 {
10917 LUA_FREE_ARRAY( arg2 );
10918 }
10919 {
10920 LUA_FREE_ARRAY( arg3 );
10921 }
10922 lua_error(L);
10923 return SWIG_arg;
10924 }
10925
10926
10927 static int _wrap_svect(lua_State* L) {
10928 int SWIG_arg = 0;
10929 PLFLT *arg1 = (PLFLT *) 0 ;
10930 PLFLT *arg2 = (PLFLT *) 0 ;
10931 PLINT arg3 ;
10932 PLBOOL arg4 ;
10933
10934 {
10935 arg2 = NULL; arg3 = 0;
10936 }
10937 {
10938 arg4 = 0;
10939 }
10940 SWIG_check_num_args("plsvect",1,3)
10941 if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("plsvect",3,"PLBOOL");
10942 {
10943 int temp;
10944 if ( lua_isnil( L, 1 ) )
10945 {
10946 arg1 = NULL;
10947 Alen = 0;
10948 }
10949 else
10950 {
10951 arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
10952 if ( !arg1 )
10953 SWIG_fail;
10954 Alen = temp;
10955 }
10956 }
10957 if(lua_gettop(L)>=2){
10958 {
10959 int temp = 0;
10960 if ( lua_isnil( L, 2 ) )
10961 {
10962 arg2 = NULL;
10963 }
10964 else
10965 {
10966 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
10967 if ( !arg2 )
10968 SWIG_fail;
10969 if ( temp != Alen )
10970 {
10971 lua_pushfstring( L, "Tables must be of same length." );
10972 SWIG_fail;
10973 }
10974 }
10975 arg3 = temp;
10976 }
10977 }
10978 if(lua_gettop(L)>=3){
10979 arg4 = (PLBOOL)lua_tonumber(L, 3);
10980 }
10981 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
10982
10983 {
10984 LUA_FREE_ARRAY( arg2 );
10985 }
10986 return SWIG_arg;
10987
10988 if(0) SWIG_fail;
10989
10990 fail:
10991 {
10992 LUA_FREE_ARRAY( arg2 );
10993 }
10994 lua_error(L);
10995 return SWIG_arg;
10996 }
10997
10998
10999 static int _wrap_svpa(lua_State* L) {
11000 int SWIG_arg = 0;
11001 PLFLT arg1 ;
11002 PLFLT arg2 ;
11003 PLFLT arg3 ;
11004 PLFLT arg4 ;
11005
11006 SWIG_check_num_args("plsvpa",4,4)
11007 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsvpa",1,"PLFLT");
11008 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsvpa",2,"PLFLT");
11009 if(!lua_isnumber(L,3)) SWIG_fail_arg("plsvpa",3,"PLFLT");
11010 if(!lua_isnumber(L,4)) SWIG_fail_arg("plsvpa",4,"PLFLT");
11011 arg1 = (PLFLT)lua_tonumber(L, 1);
11012 arg2 = (PLFLT)lua_tonumber(L, 2);
11013 arg3 = (PLFLT)lua_tonumber(L, 3);
11014 arg4 = (PLFLT)lua_tonumber(L, 4);
11015 plsvpa(arg1,arg2,arg3,arg4);
11016
11017 return SWIG_arg;
11018
11019 if(0) SWIG_fail;
11020
11021 fail:
11022 lua_error(L);
11023 return SWIG_arg;
11024 }
11025
11026
11027 static int _wrap_sxax(lua_State* L) {
11028 int SWIG_arg = 0;
11029 PLINT arg1 ;
11030 PLINT arg2 ;
11031
11032 SWIG_check_num_args("plsxax",2,2)
11033 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsxax",1,"PLINT");
11034 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsxax",2,"PLINT");
11035 arg1 = (PLINT)lua_tonumber(L, 1);
11036 arg2 = (PLINT)lua_tonumber(L, 2);
11037 plsxax(arg1,arg2);
11038
11039 return SWIG_arg;
11040
11041 if(0) SWIG_fail;
11042
11043 fail:
11044 lua_error(L);
11045 return SWIG_arg;
11046 }
11047
11048
11049 static int _wrap_syax(lua_State* L) {
11050 int SWIG_arg = 0;
11051 PLINT arg1 ;
11052 PLINT arg2 ;
11053
11054 SWIG_check_num_args("plsyax",2,2)
11055 if(!lua_isnumber(L,1)) SWIG_fail_arg("plsyax",1,"PLINT");
11056 if(!lua_isnumber(L,2)) SWIG_fail_arg("plsyax",2,"PLINT");
11057 arg1 = (PLINT)lua_tonumber(L, 1);
11058 arg2 = (PLINT)lua_tonumber(L, 2);
11059 plsyax(arg1,arg2);
11060
11061 return SWIG_arg;
11062
11063 if(0) SWIG_fail;
11064
11065 fail:
11066 lua_error(L);
11067 return SWIG_arg;
11068 }
11069
11070
11071 static int _wrap_sym(lua_State* L) {
11072 int SWIG_arg = 0;
11073 PLINT arg1 ;
11074 PLFLT *arg2 = (PLFLT *) 0 ;
11075 PLFLT *arg3 = (PLFLT *) 0 ;
11076 PLINT arg4 ;
11077 int temp3 ;
11078
11079 SWIG_check_num_args("plsym",3,3)
11080 if(!lua_isnumber(L,3)) SWIG_fail_arg("plsym",3,"PLINT");
11081 {
11082 int temp;
11083 arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
11084 if ( !arg2 )
11085 SWIG_fail;
11086 arg1 = Alen = temp;
11087 }
11088 {
11089 arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
11090 if ( !arg3 )
11091 SWIG_fail;
11092 if ( temp3 != Alen )
11093 {
11094 lua_pushfstring( L, "Tables must be of same length." );
11095 SWIG_fail;
11096 }
11097 }
11098 arg4 = (PLINT)lua_tonumber(L, 3);
11099 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
11100
11101 {
11102 LUA_FREE_ARRAY( arg2 );
11103 }
11104 {
11105 LUA_FREE_ARRAY( arg3 );
11106 }
11107 return SWIG_arg;
11108
11109 if(0) SWIG_fail;
11110
11111 fail:
11112 {
11113 LUA_FREE_ARRAY( arg2 );
11114 }
11115 {
11116 LUA_FREE_ARRAY( arg3 );
11117 }
11118 lua_error(L);
11119 return SWIG_arg;
11120 }
11121
11122
11123 static int _wrap_szax(lua_State* L) {
11124 int SWIG_arg = 0;
11125 PLINT arg1 ;
11126 PLINT arg2 ;
11127
11128 SWIG_check_num_args("plszax",2,2)
11129 if(!lua_isnumber(L,1)) SWIG_fail_arg("plszax",1,"PLINT");
11130 if(!lua_isnumber(L,2)) SWIG_fail_arg("plszax",2,"PLINT");
11131 arg1 = (PLINT)lua_tonumber(L, 1);
11132 arg2 = (PLINT)lua_tonumber(L, 2);
11133 plszax(arg1,arg2);
11134
11135 return SWIG_arg;
11136
11137 if(0) SWIG_fail;
11138
11139 fail:
11140 lua_error(L);
11141 return SWIG_arg;
11142 }
11143
11144
11145 static int _wrap_text(lua_State* L) {
11146 int SWIG_arg = 0;
11147
11148 SWIG_check_num_args("pltext",0,0)
11149 pltext();
11150
11151 return SWIG_arg;
11152
11153 if(0) SWIG_fail;
11154
11155 fail:
11156 lua_error(L);
11157 return SWIG_arg;
11158 }
11159
11160
11161 static int _wrap_timefmt(lua_State* L) {
11162 int SWIG_arg = 0;
11163 char *arg1 = (char *) 0 ;
11164
11165 SWIG_check_num_args("pltimefmt",1,1)
11166 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("pltimefmt",1,"char const *");
11167 arg1 = (char *)lua_tostring(L, 1);
11168 pltimefmt((char const *)arg1);
11169
11170 return SWIG_arg;
11171
11172 if(0) SWIG_fail;
11173
11174 fail:
11175 lua_error(L);
11176 return SWIG_arg;
11177 }
11178
11179
11180 static int _wrap_vasp(lua_State* L) {
11181 int SWIG_arg = 0;
11182 PLFLT arg1 ;
11183
11184 SWIG_check_num_args("plvasp",1,1)
11185 if(!lua_isnumber(L,1)) SWIG_fail_arg("plvasp",1,"PLFLT");
11186 arg1 = (PLFLT)lua_tonumber(L, 1);
11187 plvasp(arg1);
11188
11189 return SWIG_arg;
11190
11191 if(0) SWIG_fail;
11192
11193 fail:
11194 lua_error(L);
11195 return SWIG_arg;
11196 }
11197
11198
11199 static int _wrap_vect(lua_State* L) {
11200 int SWIG_arg = 0;
11201 PLFLT **arg1 = (PLFLT **) 0 ;
11202 PLFLT **arg2 = (PLFLT **) 0 ;
11203 PLINT arg3 ;
11204 PLINT arg4 ;
11205 PLFLT arg5 ;
11206 pltr_func arg6 = (pltr_func) 0 ;
11207 PLPointer arg7 = (PLPointer) 0 ;
11208 int ii1 ;
11209 int ii2 ;
11210 PLcGrid cgrid17 ;
11211 PLcGrid2 cgrid27 ;
11212
11213 {
11214 cgrid17.xg = cgrid17.yg = cgrid17.zg = NULL;
11215 cgrid17.nx = cgrid17.ny = cgrid17.nz = 0;
11216 cgrid27.xg = cgrid27.yg = cgrid27.zg = NULL;
11217 cgrid27.nx = cgrid27.ny = 0;
11218 }
11219 {
11220 arg6 = NULL;
11221 }
11222 {
11223 arg7 = NULL;
11224 }
11225 SWIG_check_num_args("plvect",3,5)
11226 if(!lua_isnumber(L,3)) SWIG_fail_arg("plvect",3,"PLFLT");
11227 {
11228 int jj;
11229
11230 arg1 = read_double_Matrix( L, 1, &ii1, &jj );
11231 if ( !arg1 )
11232 SWIG_fail;
11233 Xlen = ii1;
11234 Ylen = jj;
11235 }
11236 {
11237 int jj;
11238
11239 arg2 = read_double_Matrix( L, 2, &ii2, &jj );
11240 if ( !arg2 )
11241 SWIG_fail;
11242 arg3 = ii2;
11243 arg4 = jj;
11244 if ( ( arg3 != Xlen ) || ( arg4 != Ylen ) )
11245 {
11246 lua_pushfstring( L, "Vectors must match matrix." );
11247 SWIG_fail;
11248 }
11249 }
11250 arg5 = (PLFLT)lua_tonumber(L, 3);
11251 if(lua_gettop(L)>=4){
11252 {
11253 arg6 = NULL;
11254 mypltr_funcstr[0] = '\0';
11255
11256 if ( lua_isstring( L, 4 ) )
11257 {
11258 const char* funcstr = lua_tostring( L, 4 );
11259 if ( strcmp( "pltr0", funcstr ) == 0 )
11260 {
11261 arg6 = pltr0;
11262 }
11263 else if ( strcmp( "pltr1", funcstr ) == 0 )
11264 {
11265 arg6 = pltr1;
11266 }
11267 else if ( strcmp( "pltr2", funcstr ) == 0 )
11268 {
11269 arg6 = pltr2;
11270 }
11271 else
11272 {
11273 arg6 = mypltr;
11274 strncpy( mypltr_funcstr, funcstr, 255 );
11275 myL = L;
11276 }
11277 }
11278 else
11279 SWIG_fail_arg( "vect", 6, "pltr_func" );
11280 }
11281 }
11282 if(lua_gettop(L)>=5){
11283 {
11284 int nx, ny;
11285 int gridmode = 0;
11286
11287 lua_pushstring( L, "xg" );
11288 lua_gettable( L, 5 );
11289 if ( !lua_istable( L, -1 ) )
11290 {
11291 lua_pop( L, 1 ); // pop "xg"
11292 lua_pushstring( L, "expected a table xg" );
11293 SWIG_fail;
11294 }
11295 lua_rawgeti( L, -1, 1 );
11296 if ( lua_istable( L, -1 ) )
11297 gridmode = 2; // two dimensional array
11298 else if ( lua_isnumber( L, -1 ) )
11299 gridmode = 1; // one dimensional array
11300 else
11301 {
11302 lua_pop( L, 1 ); // pop "1"
11303 lua_pop( L, 1 ); // pop "xg"
11304 lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
11305 SWIG_fail;
11306 }
11307 lua_pop( L, 1 ); // pop test element
11308 if ( gridmode == 1 )
11309 {
11310 cgrid17.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
11311 if ( !cgrid17.xg )
11312 {
11313 lua_pop( L, 1 ); // pop "xg"
11314 SWIG_fail;
11315 }
11316 if ( nx != Xlen )
11317 {
11318 lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
11319 SWIG_fail;
11320 }
11321 cgrid17.nx = nx;
11322 }
11323 else
11324 {
11325 cgrid27.xg = read_double_Matrix( L, -1, &nx, &ny );
11326 if ( !cgrid27.xg )
11327 {
11328 lua_pop( L, 1 ); // pop "xg"
11329 SWIG_fail;
11330 }
11331 if ( ( nx != Xlen ) || ( ny != Ylen ) )
11332 {
11333 lua_pop( L, 1 ); // pop "xg"
11334 lua_pushfstring( L, "Vectors must match matrix." );
11335 SWIG_fail;
11336 }
11337 cgrid27.nx = nx;
11338 cgrid27.ny = ny;
11339 }
11340 lua_pop( L, 1 ); // pop "xg"
11341
11342 lua_pushstring( L, "yg" );
11343 lua_gettable( L, 5 );
11344 if ( !lua_istable( L, -1 ) )
11345 {
11346 lua_pop( L, 1 );
11347 lua_pushstring( L, "expected a table yg" );
11348 SWIG_fail;
11349 }
11350 lua_rawgeti( L, -1, 1 );
11351 if ( gridmode == 2 )
11352 {
11353 if ( !lua_istable( L, -1 ) )
11354 {
11355 lua_pop( L, 1 ); // pop "1"
11356 lua_pop( L, 1 ); // pop "yg"
11357 lua_pushstring( L, "expected a two dimensional array/table in yg" );
11358 SWIG_fail;
11359 }
11360 }
11361 else
11362 {
11363 if ( !lua_isnumber( L, -1 ) )
11364 {
11365 lua_pop( L, 1 ); // pop "1"
11366 lua_pop( L, 1 ); // pop "yg"
11367 lua_pushstring( L, "expected a one dimensional array/table in yg" );
11368 SWIG_fail;
11369 }
11370 }
11371 lua_pop( L, 1 ); // pop "1"
11372 if ( gridmode == 1 )
11373 {
11374 cgrid17.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
11375 if ( !cgrid17.yg )
11376 {
11377 lua_pop( L, 1 ); // pop "yg"
11378 SWIG_fail;
11379 }
11380 if ( ny != Ylen )
11381 {
11382 lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
11383 SWIG_fail;
11384 }
11385 cgrid17.ny = ny;
11386 }
11387 else
11388 {
11389 cgrid27.yg = read_double_Matrix( L, -1, &nx, &ny );
11390 if ( !cgrid27.yg )
11391 {
11392 lua_pop( L, 1 ); // pop "xg"
11393 SWIG_fail;
11394 }
11395 if ( ( nx != Xlen ) || ( ny != Ylen ) )
11396 {
11397 lua_pop( L, 1 ); // pop "xg"
11398 lua_pushfstring( L, "Vectors must match matrix." );
11399 SWIG_fail;
11400 }
11401 // cgrid27.nx/ny already set
11402 }
11403 lua_pop( L, 1 ); // pop "yg"
11404
11405 if ( gridmode == 1 )
11406 arg7 = &cgrid17;
11407 else if ( gridmode == 2 )
11408 arg7 = &cgrid27;
11409 }
11410 }
11411 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
11412
11413 {
11414 int i;
11415
11416 if ( arg1 )
11417 {
11418 for ( i = 0; i < ii1; i++ )
11419 LUA_FREE_ARRAY( arg1[i] );
11420 LUA_FREE_ARRAY( arg1 );
11421 }
11422 }
11423 {
11424 int i;
11425
11426 if ( arg2 )
11427 {
11428 for ( i = 0; i < ii2; i++ )
11429 LUA_FREE_ARRAY( arg2[i] );
11430 LUA_FREE_ARRAY( arg2 );
11431 }
11432 }
11433 {
11434 mypltr_funcstr[0] = '\0';
11435 }
11436 {
11437 int i;
11438
11439 LUA_FREE_ARRAY( cgrid17.xg );
11440 LUA_FREE_ARRAY( cgrid17.yg );
11441
11442 if ( cgrid27.xg )
11443 {
11444 for ( i = 0; i < Xlen; i++ )
11445 LUA_FREE_ARRAY( cgrid27.xg[i] );
11446 LUA_FREE_ARRAY( cgrid27.xg );
11447 }
11448 if ( cgrid27.yg )
11449 {
11450 for ( i = 0; i < Xlen; i++ )
11451 LUA_FREE_ARRAY( cgrid27.yg[i] );
11452 LUA_FREE_ARRAY( cgrid27.yg );
11453 }
11454 }
11455 return SWIG_arg;
11456
11457 if(0) SWIG_fail;
11458
11459 fail:
11460 {
11461 int i;
11462
11463 if ( arg1 )
11464 {
11465 for ( i = 0; i < ii1; i++ )
11466 LUA_FREE_ARRAY( arg1[i] );
11467 LUA_FREE_ARRAY( arg1 );
11468 }
11469 }
11470 {
11471 int i;
11472
11473 if ( arg2 )
11474 {
11475 for ( i = 0; i < ii2; i++ )
11476 LUA_FREE_ARRAY( arg2[i] );
11477 LUA_FREE_ARRAY( arg2 );
11478 }
11479 }
11480 {
11481 mypltr_funcstr[0] = '\0';
11482 }
11483 {
11484 int i;
11485
11486 LUA_FREE_ARRAY( cgrid17.xg );
11487 LUA_FREE_ARRAY( cgrid17.yg );
11488
11489 if ( cgrid27.xg )
11490 {
11491 for ( i = 0; i < Xlen; i++ )
11492 LUA_FREE_ARRAY( cgrid27.xg[i] );
11493 LUA_FREE_ARRAY( cgrid27.xg );
11494 }
11495 if ( cgrid27.yg )
11496 {
11497 for ( i = 0; i < Xlen; i++ )
11498 LUA_FREE_ARRAY( cgrid27.yg[i] );
11499 LUA_FREE_ARRAY( cgrid27.yg );
11500 }
11501 }
11502 lua_error(L);
11503 return SWIG_arg;
11504 }
11505
11506
11507 static int _wrap_vpas(lua_State* L) {
11508 int SWIG_arg = 0;
11509 PLFLT arg1 ;
11510 PLFLT arg2 ;
11511 PLFLT arg3 ;
11512 PLFLT arg4 ;
11513 PLFLT arg5 ;
11514
11515 SWIG_check_num_args("plvpas",5,5)
11516 if(!lua_isnumber(L,1)) SWIG_fail_arg("plvpas",1,"PLFLT");
11517 if(!lua_isnumber(L,2)) SWIG_fail_arg("plvpas",2,"PLFLT");
11518 if(!lua_isnumber(L,3)) SWIG_fail_arg("plvpas",3,"PLFLT");
11519 if(!lua_isnumber(L,4)) SWIG_fail_arg("plvpas",4,"PLFLT");
11520 if(!lua_isnumber(L,5)) SWIG_fail_arg("plvpas",5,"PLFLT");
11521 arg1 = (PLFLT)lua_tonumber(L, 1);
11522 arg2 = (PLFLT)lua_tonumber(L, 2);
11523 arg3 = (PLFLT)lua_tonumber(L, 3);
11524 arg4 = (PLFLT)lua_tonumber(L, 4);
11525 arg5 = (PLFLT)lua_tonumber(L, 5);
11526 plvpas(arg1,arg2,arg3,arg4,arg5);
11527
11528 return SWIG_arg;
11529
11530 if(0) SWIG_fail;
11531
11532 fail:
11533 lua_error(L);
11534 return SWIG_arg;
11535 }
11536
11537
11538 static int _wrap_vpor(lua_State* L) {
11539 int SWIG_arg = 0;
11540 PLFLT arg1 ;
11541 PLFLT arg2 ;
11542 PLFLT arg3 ;
11543 PLFLT arg4 ;
11544
11545 SWIG_check_num_args("plvpor",4,4)
11546 if(!lua_isnumber(L,1)) SWIG_fail_arg("plvpor",1,"PLFLT");
11547 if(!lua_isnumber(L,2)) SWIG_fail_arg("plvpor",2,"PLFLT");
11548 if(!lua_isnumber(L,3)) SWIG_fail_arg("plvpor",3,"PLFLT");
11549 if(!lua_isnumber(L,4)) SWIG_fail_arg("plvpor",4,"PLFLT");
11550 arg1 = (PLFLT)lua_tonumber(L, 1);
11551 arg2 = (PLFLT)lua_tonumber(L, 2);
11552 arg3 = (PLFLT)lua_tonumber(L, 3);
11553 arg4 = (PLFLT)lua_tonumber(L, 4);
11554 plvpor(arg1,arg2,arg3,arg4);
11555
11556 return SWIG_arg;
11557
11558 if(0) SWIG_fail;
11559
11560 fail:
11561 lua_error(L);
11562 return SWIG_arg;
11563 }
11564
11565
11566 static int _wrap_vsta(lua_State* L) {
11567 int SWIG_arg = 0;
11568
11569 SWIG_check_num_args("plvsta",0,0)
11570 plvsta();
11571
11572 return SWIG_arg;
11573
11574 if(0) SWIG_fail;
11575
11576 fail:
11577 lua_error(L);
11578 return SWIG_arg;
11579 }
11580
11581
11582 static int _wrap_w3d(lua_State* L) {
11583 int SWIG_arg = 0;
11584 PLFLT arg1 ;
11585 PLFLT arg2 ;
11586 PLFLT arg3 ;
11587 PLFLT arg4 ;
11588 PLFLT arg5 ;
11589 PLFLT arg6 ;
11590 PLFLT arg7 ;
11591 PLFLT arg8 ;
11592 PLFLT arg9 ;
11593 PLFLT arg10 ;
11594 PLFLT arg11 ;
11595
11596 SWIG_check_num_args("plw3d",11,11)
11597 if(!lua_isnumber(L,1)) SWIG_fail_arg("plw3d",1,"PLFLT");
11598 if(!lua_isnumber(L,2)) SWIG_fail_arg("plw3d",2,"PLFLT");
11599 if(!lua_isnumber(L,3)) SWIG_fail_arg("plw3d",3,"PLFLT");
11600 if(!lua_isnumber(L,4)) SWIG_fail_arg("plw3d",4,"PLFLT");
11601 if(!lua_isnumber(L,5)) SWIG_fail_arg("plw3d",5,"PLFLT");
11602 if(!lua_isnumber(L,6)) SWIG_fail_arg("plw3d",6,"PLFLT");
11603 if(!lua_isnumber(L,7)) SWIG_fail_arg("plw3d",7,"PLFLT");
11604 if(!lua_isnumber(L,8)) SWIG_fail_arg("plw3d",8,"PLFLT");
11605 if(!lua_isnumber(L,9)) SWIG_fail_arg("plw3d",9,"PLFLT");
11606 if(!lua_isnumber(L,10)) SWIG_fail_arg("plw3d",10,"PLFLT");
11607 if(!lua_isnumber(L,11)) SWIG_fail_arg("plw3d",11,"PLFLT");
11608 arg1 = (PLFLT)lua_tonumber(L, 1);
11609 arg2 = (PLFLT)lua_tonumber(L, 2);
11610 arg3 = (PLFLT)lua_tonumber(L, 3);
11611 arg4 = (PLFLT)lua_tonumber(L, 4);
11612 arg5 = (PLFLT)lua_tonumber(L, 5);
11613 arg6 = (PLFLT)lua_tonumber(L, 6);
11614 arg7 = (PLFLT)lua_tonumber(L, 7);
11615 arg8 = (PLFLT)lua_tonumber(L, 8);
11616 arg9 = (PLFLT)lua_tonumber(L, 9);
11617 arg10 = (PLFLT)lua_tonumber(L, 10);
11618 arg11 = (PLFLT)lua_tonumber(L, 11);
11619 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11620
11621 return SWIG_arg;
11622
11623 if(0) SWIG_fail;
11624
11625 fail:
11626 lua_error(L);
11627 return SWIG_arg;
11628 }
11629
11630
11631 static int _wrap_width(lua_State* L) {
11632 int SWIG_arg = 0;
11633 PLFLT arg1 ;
11634
11635 SWIG_check_num_args("plwidth",1,1)
11636 if(!lua_isnumber(L,1)) SWIG_fail_arg("plwidth",1,"PLFLT");
11637 arg1 = (PLFLT)lua_tonumber(L, 1);
11638 plwidth(arg1);
11639
11640 return SWIG_arg;
11641
11642 if(0) SWIG_fail;
11643
11644 fail:
11645 lua_error(L);
11646 return SWIG_arg;
11647 }
11648
11649
11650 static int _wrap_wind(lua_State* L) {
11651 int SWIG_arg = 0;
11652 PLFLT arg1 ;
11653 PLFLT arg2 ;
11654 PLFLT arg3 ;
11655 PLFLT arg4 ;
11656
11657 SWIG_check_num_args("plwind",4,4)
11658 if(!lua_isnumber(L,1)) SWIG_fail_arg("plwind",1,"PLFLT");
11659 if(!lua_isnumber(L,2)) SWIG_fail_arg("plwind",2,"PLFLT");
11660 if(!lua_isnumber(L,3)) SWIG_fail_arg("plwind",3,"PLFLT");
11661 if(!lua_isnumber(L,4)) SWIG_fail_arg("plwind",4,"PLFLT");
11662 arg1 = (PLFLT)lua_tonumber(L, 1);
11663 arg2 = (PLFLT)lua_tonumber(L, 2);
11664 arg3 = (PLFLT)lua_tonumber(L, 3);
11665 arg4 = (PLFLT)lua_tonumber(L, 4);
11666 plwind(arg1,arg2,arg3,arg4);
11667
11668 return SWIG_arg;
11669
11670 if(0) SWIG_fail;
11671
11672 fail:
11673 lua_error(L);
11674 return SWIG_arg;
11675 }
11676
11677
11678 static int _wrap_xormod(lua_State* L) {
11679 int SWIG_arg = 0;
11680 PLBOOL arg1 ;
11681 PLBOOL *arg2 = (PLBOOL *) 0 ;
11682 PLBOOL temp2 ;
11683
11684 arg2 = &temp2;
11685 SWIG_check_num_args("plxormod",1,1)
11686 if(!lua_isnumber(L,1)) SWIG_fail_arg("plxormod",1,"PLBOOL");
11687 arg1 = (PLBOOL)lua_tonumber(L, 1);
11688 plxormod(arg1,arg2);
11689
11690 lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
11691 return SWIG_arg;
11692
11693 if(0) SWIG_fail;
11694
11695 fail:
11696 lua_error(L);
11697 return SWIG_arg;
11698 }
11699
11700
11701 static int _wrap_map(lua_State* L) {
11702 int SWIG_arg = 0;
11703 mapform_func arg1 = (mapform_func) 0 ;
11704 char *arg2 = (char *) 0 ;
11705 PLFLT arg3 ;
11706 PLFLT arg4 ;
11707 PLFLT arg5 ;
11708 PLFLT arg6 ;
11709
11710 SWIG_check_num_args("plmap",6,6)
11711 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmap",2,"char const *");
11712 if(!lua_isnumber(L,3)) SWIG_fail_arg("plmap",3,"PLFLT");
11713 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmap",4,"PLFLT");
11714 if(!lua_isnumber(L,5)) SWIG_fail_arg("plmap",5,"PLFLT");
11715 if(!lua_isnumber(L,6)) SWIG_fail_arg("plmap",6,"PLFLT");
11716 {
11717 arg1 = NULL;
11718 mapform_funcstr[0] = '\0';
11719
11720 if ( lua_isnil( L, 1 ) )
11721 {
11722 arg1 = NULL;
11723 }
11724 else if ( lua_isstring( L, 1 ) )
11725 {
11726 arg1 = mapform;
11727 strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
11728 myL = L;
11729 }
11730 else
11731 SWIG_fail_arg( "map", 1, "mapform_func" );
11732 }
11733 arg2 = (char *)lua_tostring(L, 2);
11734 arg3 = (PLFLT)lua_tonumber(L, 3);
11735 arg4 = (PLFLT)lua_tonumber(L, 4);
11736 arg5 = (PLFLT)lua_tonumber(L, 5);
11737 arg6 = (PLFLT)lua_tonumber(L, 6);
11738 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
11739
11740 {
11741 mapform_funcstr[0] = '\0';
11742 }
11743 return SWIG_arg;
11744
11745 if(0) SWIG_fail;
11746
11747 fail:
11748 {
11749 mapform_funcstr[0] = '\0';
11750 }
11751 lua_error(L);
11752 return SWIG_arg;
11753 }
11754
11755
11756 static int _wrap_mapline(lua_State* L) {
11757 int SWIG_arg = 0;
11758 mapform_func arg1 = (mapform_func) 0 ;
11759 char *arg2 = (char *) 0 ;
11760 PLFLT arg3 ;
11761 PLFLT arg4 ;
11762 PLFLT arg5 ;
11763 PLFLT arg6 ;
11764 PLINT *arg7 = (PLINT *) 0 ;
11765 PLINT arg8 ;
11766 int temp7 ;
11767
11768 SWIG_check_num_args("plmapline",7,7)
11769 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmapline",2,"char const *");
11770 if(!lua_isnumber(L,3)) SWIG_fail_arg("plmapline",3,"PLFLT");
11771 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmapline",4,"PLFLT");
11772 if(!lua_isnumber(L,5)) SWIG_fail_arg("plmapline",5,"PLFLT");
11773 if(!lua_isnumber(L,6)) SWIG_fail_arg("plmapline",6,"PLFLT");
11774 {
11775 arg1 = NULL;
11776 mapform_funcstr[0] = '\0';
11777
11778 if ( lua_isnil( L, 1 ) )
11779 {
11780 arg1 = NULL;
11781 }
11782 else if ( lua_isstring( L, 1 ) )
11783 {
11784 arg1 = mapform;
11785 strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
11786 myL = L;
11787 }
11788 else
11789 SWIG_fail_arg( "mapline", 1, "mapform_func" );
11790 }
11791 arg2 = (char *)lua_tostring(L, 2);
11792 arg3 = (PLFLT)lua_tonumber(L, 3);
11793 arg4 = (PLFLT)lua_tonumber(L, 4);
11794 arg5 = (PLFLT)lua_tonumber(L, 5);
11795 arg6 = (PLFLT)lua_tonumber(L, 6);
11796 {
11797 if ( lua_isnil( L, 7 ) )
11798 {
11799 arg7 = NULL;
11800 arg8 = 0;
11801 }
11802 else
11803 {
11804 arg7 = (PLINT *) LUA_get_int_num_array_var( L, 7, &temp7 );
11805 if ( !arg7 )
11806 SWIG_fail;
11807 arg8 = temp7;
11808 }
11809 }
11810 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
11811
11812 {
11813 mapform_funcstr[0] = '\0';
11814 }
11815 {
11816 LUA_FREE_ARRAY( arg7 );
11817 }
11818 return SWIG_arg;
11819
11820 if(0) SWIG_fail;
11821
11822 fail:
11823 {
11824 mapform_funcstr[0] = '\0';
11825 }
11826 {
11827 LUA_FREE_ARRAY( arg7 );
11828 }
11829 lua_error(L);
11830 return SWIG_arg;
11831 }
11832
11833
11834 static int _wrap_mapstring(lua_State* L) {
11835 int SWIG_arg = 0;
11836 mapform_func arg1 = (mapform_func) 0 ;
11837 char *arg2 = (char *) 0 ;
11838 char *arg3 = (char *) 0 ;
11839 PLFLT arg4 ;
11840 PLFLT arg5 ;
11841 PLFLT arg6 ;
11842 PLFLT arg7 ;
11843 PLINT *arg8 = (PLINT *) 0 ;
11844 PLINT arg9 ;
11845 int temp8 ;
11846
11847 SWIG_check_num_args("plmapstring",8,8)
11848 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmapstring",2,"char const *");
11849 if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("plmapstring",3,"char const *");
11850 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmapstring",4,"PLFLT");
11851 if(!lua_isnumber(L,5)) SWIG_fail_arg("plmapstring",5,"PLFLT");
11852 if(!lua_isnumber(L,6)) SWIG_fail_arg("plmapstring",6,"PLFLT");
11853 if(!lua_isnumber(L,7)) SWIG_fail_arg("plmapstring",7,"PLFLT");
11854 {
11855 arg1 = NULL;
11856 mapform_funcstr[0] = '\0';
11857
11858 if ( lua_isnil( L, 1 ) )
11859 {
11860 arg1 = NULL;
11861 }
11862 else if ( lua_isstring( L, 1 ) )
11863 {
11864 arg1 = mapform;
11865 strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
11866 myL = L;
11867 }
11868 else
11869 SWIG_fail_arg( "mapstring", 1, "mapform_func" );
11870 }
11871 arg2 = (char *)lua_tostring(L, 2);
11872 arg3 = (char *)lua_tostring(L, 3);
11873 arg4 = (PLFLT)lua_tonumber(L, 4);
11874 arg5 = (PLFLT)lua_tonumber(L, 5);
11875 arg6 = (PLFLT)lua_tonumber(L, 6);
11876 arg7 = (PLFLT)lua_tonumber(L, 7);
11877 {
11878 if ( lua_isnil( L, 8 ) )
11879 {
11880 arg8 = NULL;
11881 arg9 = 0;
11882 }
11883 else
11884 {
11885 arg8 = (PLINT *) LUA_get_int_num_array_var( L, 8, &temp8 );
11886 if ( !arg8 )
11887 SWIG_fail;
11888 arg9 = temp8;
11889 }
11890 }
11891 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
11892
11893 {
11894 mapform_funcstr[0] = '\0';
11895 }
11896 {
11897 LUA_FREE_ARRAY( arg8 );
11898 }
11899 return SWIG_arg;
11900
11901 if(0) SWIG_fail;
11902
11903 fail:
11904 {
11905 mapform_funcstr[0] = '\0';
11906 }
11907 {
11908 LUA_FREE_ARRAY( arg8 );
11909 }
11910 lua_error(L);
11911 return SWIG_arg;
11912 }
11913
11914
11915 static int _wrap_maptex(lua_State* L) {
11916 int SWIG_arg = 0;
11917 mapform_func arg1 = (mapform_func) 0 ;
11918 char *arg2 = (char *) 0 ;
11919 PLFLT arg3 ;
11920 PLFLT arg4 ;
11921 PLFLT arg5 ;
11922 char *arg6 = (char *) 0 ;
11923 PLFLT arg7 ;
11924 PLFLT arg8 ;
11925 PLFLT arg9 ;
11926 PLFLT arg10 ;
11927 PLINT arg11 ;
11928
11929 SWIG_check_num_args("plmaptex",11,11)
11930 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmaptex",2,"char const *");
11931 if(!lua_isnumber(L,3)) SWIG_fail_arg("plmaptex",3,"PLFLT");
11932 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmaptex",4,"PLFLT");
11933 if(!lua_isnumber(L,5)) SWIG_fail_arg("plmaptex",5,"PLFLT");
11934 if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("plmaptex",6,"char const *");
11935 if(!lua_isnumber(L,7)) SWIG_fail_arg("plmaptex",7,"PLFLT");
11936 if(!lua_isnumber(L,8)) SWIG_fail_arg("plmaptex",8,"PLFLT");
11937 if(!lua_isnumber(L,9)) SWIG_fail_arg("plmaptex",9,"PLFLT");
11938 if(!lua_isnumber(L,10)) SWIG_fail_arg("plmaptex",10,"PLFLT");
11939 if(!lua_isnumber(L,11)) SWIG_fail_arg("plmaptex",11,"PLINT");
11940 {
11941 arg1 = NULL;
11942 mapform_funcstr[0] = '\0';
11943
11944 if ( lua_isnil( L, 1 ) )
11945 {
11946 arg1 = NULL;
11947 }
11948 else if ( lua_isstring( L, 1 ) )
11949 {
11950 arg1 = mapform;
11951 strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
11952 myL = L;
11953 }
11954 else
11955 SWIG_fail_arg( "maptex", 1, "mapform_func" );
11956 }
11957 arg2 = (char *)lua_tostring(L, 2);
11958 arg3 = (PLFLT)lua_tonumber(L, 3);
11959 arg4 = (PLFLT)lua_tonumber(L, 4);
11960 arg5 = (PLFLT)lua_tonumber(L, 5);
11961 arg6 = (char *)lua_tostring(L, 6);
11962 arg7 = (PLFLT)lua_tonumber(L, 7);
11963 arg8 = (PLFLT)lua_tonumber(L, 8);
11964 arg9 = (PLFLT)lua_tonumber(L, 9);
11965 arg10 = (PLFLT)lua_tonumber(L, 10);
11966 arg11 = (PLINT)lua_tonumber(L, 11);
11967 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
11968
11969 {
11970 mapform_funcstr[0] = '\0';
11971 }
11972 return SWIG_arg;
11973
11974 if(0) SWIG_fail;
11975
11976 fail:
11977 {
11978 mapform_funcstr[0] = '\0';
11979 }
11980 lua_error(L);
11981 return SWIG_arg;
11982 }
11983
11984
11985 static int _wrap_mapfill(lua_State* L) {
11986 int SWIG_arg = 0;
11987 mapform_func arg1 = (mapform_func) 0 ;
11988 char *arg2 = (char *) 0 ;
11989 PLFLT arg3 ;
11990 PLFLT arg4 ;
11991 PLFLT arg5 ;
11992 PLFLT arg6 ;
11993 PLINT *arg7 = (PLINT *) 0 ;
11994 PLINT arg8 ;
11995 int temp7 ;
11996
11997 SWIG_check_num_args("plmapfill",7,7)
11998 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmapfill",2,"char const *");
11999 if(!lua_isnumber(L,3)) SWIG_fail_arg("plmapfill",3,"PLFLT");
12000 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmapfill",4,"PLFLT");
12001 if(!lua_isnumber(L,5)) SWIG_fail_arg("plmapfill",5,"PLFLT");
12002 if(!lua_isnumber(L,6)) SWIG_fail_arg("plmapfill",6,"PLFLT");
12003 {
12004 arg1 = NULL;
12005 mapform_funcstr[0] = '\0';
12006
12007 if ( lua_isnil( L, 1 ) )
12008 {
12009 arg1 = NULL;
12010 }
12011 else if ( lua_isstring( L, 1 ) )
12012 {
12013 arg1 = mapform;
12014 strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
12015 myL = L;
12016 }
12017 else
12018 SWIG_fail_arg( "mapfill", 1, "mapform_func" );
12019 }
12020 arg2 = (char *)lua_tostring(L, 2);
12021 arg3 = (PLFLT)lua_tonumber(L, 3);
12022 arg4 = (PLFLT)lua_tonumber(L, 4);
12023 arg5 = (PLFLT)lua_tonumber(L, 5);
12024 arg6 = (PLFLT)lua_tonumber(L, 6);
12025 {
12026 if ( lua_isnil( L, 7 ) )
12027 {
12028 arg7 = NULL;
12029 arg8 = 0;
12030 }
12031 else
12032 {
12033 arg7 = (PLINT *) LUA_get_int_num_array_var( L, 7, &temp7 );
12034 if ( !arg7 )
12035 SWIG_fail;
12036 arg8 = temp7;
12037 }
12038 }
12039 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
12040
12041 {
12042 mapform_funcstr[0] = '\0';
12043 }
12044 {
12045 LUA_FREE_ARRAY( arg7 );
12046 }
12047 return SWIG_arg;
12048
12049 if(0) SWIG_fail;
12050
12051 fail:
12052 {
12053 mapform_funcstr[0] = '\0';
12054 }
12055 {
12056 LUA_FREE_ARRAY( arg7 );
12057 }
12058 lua_error(L);
12059 return SWIG_arg;
12060 }
12061
12062
12063 static int _wrap_meridians(lua_State* L) {
12064 int SWIG_arg = 0;
12065 mapform_func arg1 = (mapform_func) 0 ;
12066 PLFLT arg2 ;
12067 PLFLT arg3 ;
12068 PLFLT arg4 ;
12069 PLFLT arg5 ;
12070 PLFLT arg6 ;
12071 PLFLT arg7 ;
12072
12073 SWIG_check_num_args("plmeridians",7,7)
12074 if(!lua_isnumber(L,2)) SWIG_fail_arg("plmeridians",2,"PLFLT");
12075 if(!lua_isnumber(L,3)) SWIG_fail_arg("plmeridians",3,"PLFLT");
12076 if(!lua_isnumber(L,4)) SWIG_fail_arg("plmeridians",4,"PLFLT");
12077 if(!lua_isnumber(L,5)) SWIG_fail_arg("plmeridians",5,"PLFLT");
12078 if(!lua_isnumber(L,6)) SWIG_fail_arg("plmeridians",6,"PLFLT");
12079 if(!lua_isnumber(L,7)) SWIG_fail_arg("plmeridians",7,"PLFLT");
12080 {
12081 arg1 = NULL;
12082 mapform_funcstr[0] = '\0';
12083
12084 if ( lua_isnil( L, 1 ) )
12085 {
12086 arg1 = NULL;
12087 }
12088 else if ( lua_isstring( L, 1 ) )
12089 {
12090 arg1 = mapform;
12091 strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
12092 myL = L;
12093 }
12094 else
12095 SWIG_fail_arg( "meridians", 1, "mapform_func" );
12096 }
12097 arg2 = (PLFLT)lua_tonumber(L, 2);
12098 arg3 = (PLFLT)lua_tonumber(L, 3);
12099 arg4 = (PLFLT)lua_tonumber(L, 4);
12100 arg5 = (PLFLT)lua_tonumber(L, 5);
12101 arg6 = (PLFLT)lua_tonumber(L, 6);
12102 arg7 = (PLFLT)lua_tonumber(L, 7);
12103 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
12104
12105 {
12106 mapform_funcstr[0] = '\0';
12107 }
12108 return SWIG_arg;
12109
12110 if(0) SWIG_fail;
12111
12112 fail:
12113 {
12114 mapform_funcstr[0] = '\0';
12115 }
12116 lua_error(L);
12117 return SWIG_arg;
12118 }
12119
12120
12121 static int _wrap_image(lua_State* L) {
12122 int SWIG_arg = 0;
12123 PLFLT **arg1 = (PLFLT **) 0 ;
12124 PLINT arg2 ;
12125 PLINT arg3 ;
12126 PLFLT arg4 ;
12127 PLFLT arg5 ;
12128 PLFLT arg6 ;
12129 PLFLT arg7 ;
12130 PLFLT arg8 ;
12131 PLFLT arg9 ;
12132 PLFLT arg10 ;
12133 PLFLT arg11 ;
12134 PLFLT arg12 ;
12135 PLFLT arg13 ;
12136 int ii1 ;
12137
12138 SWIG_check_num_args("plimage",11,11)
12139 if(!lua_isnumber(L,2)) SWIG_fail_arg("plimage",2,"PLFLT");
12140 if(!lua_isnumber(L,3)) SWIG_fail_arg("plimage",3,"PLFLT");
12141 if(!lua_isnumber(L,4)) SWIG_fail_arg("plimage",4,"PLFLT");
12142 if(!lua_isnumber(L,5)) SWIG_fail_arg("plimage",5,"PLFLT");
12143 if(!lua_isnumber(L,6)) SWIG_fail_arg("plimage",6,"PLFLT");
12144 if(!lua_isnumber(L,7)) SWIG_fail_arg("plimage",7,"PLFLT");
12145 if(!lua_isnumber(L,8)) SWIG_fail_arg("plimage",8,"PLFLT");
12146 if(!lua_isnumber(L,9)) SWIG_fail_arg("plimage",9,"PLFLT");
12147 if(!lua_isnumber(L,10)) SWIG_fail_arg("plimage",10,"PLFLT");
12148 if(!lua_isnumber(L,11)) SWIG_fail_arg("plimage",11,"PLFLT");
12149 {
12150 int jj;
12151
12152 arg1 = read_double_Matrix( L, 1, &ii1, &jj );
12153 if ( !arg1 )
12154 SWIG_fail;
12155 Xlen = arg2 = ii1;
12156 Ylen = arg3 = jj;
12157 }
12158 arg4 = (PLFLT)lua_tonumber(L, 2);
12159 arg5 = (PLFLT)lua_tonumber(L, 3);
12160 arg6 = (PLFLT)lua_tonumber(L, 4);
12161 arg7 = (PLFLT)lua_tonumber(L, 5);
12162 arg8 = (PLFLT)lua_tonumber(L, 6);
12163 arg9 = (PLFLT)lua_tonumber(L, 7);
12164 arg10 = (PLFLT)lua_tonumber(L, 8);
12165 arg11 = (PLFLT)lua_tonumber(L, 9);
12166 arg12 = (PLFLT)lua_tonumber(L, 10);
12167 arg13 = (PLFLT)lua_tonumber(L, 11);
12168 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
12169
12170 {
12171 int i;
12172
12173 if ( arg1 )
12174 {
12175 for ( i = 0; i < ii1; i++ )
12176 LUA_FREE_ARRAY( arg1[i] );
12177 LUA_FREE_ARRAY( arg1 );
12178 }
12179 }
12180 return SWIG_arg;
12181
12182 if(0) SWIG_fail;
12183
12184 fail:
12185 {
12186 int i;
12187
12188 if ( arg1 )
12189 {
12190 for ( i = 0; i < ii1; i++ )
12191 LUA_FREE_ARRAY( arg1[i] );
12192 LUA_FREE_ARRAY( arg1 );
12193 }
12194 }
12195 lua_error(L);
12196 return SWIG_arg;
12197 }
12198
12199
12200 static int _wrap_imagefr(lua_State* L) {
12201 int SWIG_arg = 0;
12202 PLFLT **arg1 = (PLFLT **) 0 ;
12203 PLINT arg2 ;
12204 PLINT arg3 ;
12205 PLFLT arg4 ;
12206 PLFLT arg5 ;
12207 PLFLT arg6 ;
12208 PLFLT arg7 ;
12209 PLFLT arg8 ;
12210 PLFLT arg9 ;
12211 PLFLT arg10 ;
12212 PLFLT arg11 ;
12213 pltr_func arg12 = (pltr_func) 0 ;
12214 PLPointer arg13 = (PLPointer) 0 ;
12215 int ii1 ;
12216 PLcGrid cgrid113 ;
12217 PLcGrid2 cgrid213 ;
12218
12219 {
12220 cgrid113.xg = cgrid113.yg = cgrid113.zg = NULL;
12221 cgrid113.nx = cgrid113.ny = cgrid113.nz = 0;
12222 cgrid213.xg = cgrid213.yg = cgrid213.zg = NULL;
12223 cgrid213.nx = cgrid213.ny = 0;
12224 }
12225 {
12226 arg12 = NULL;
12227 }
12228 {
12229 arg13 = NULL;
12230 }
12231 SWIG_check_num_args("plimagefr",9,11)
12232 if(!lua_isnumber(L,2)) SWIG_fail_arg("plimagefr",2,"PLFLT");
12233 if(!lua_isnumber(L,3)) SWIG_fail_arg("plimagefr",3,"PLFLT");
12234 if(!lua_isnumber(L,4)) SWIG_fail_arg("plimagefr",4,"PLFLT");
12235 if(!lua_isnumber(L,5)) SWIG_fail_arg("plimagefr",5,"PLFLT");
12236 if(!lua_isnumber(L,6)) SWIG_fail_arg("plimagefr",6,"PLFLT");
12237 if(!lua_isnumber(L,7)) SWIG_fail_arg("plimagefr",7,"PLFLT");
12238 if(!lua_isnumber(L,8)) SWIG_fail_arg("plimagefr",8,"PLFLT");
12239 if(!lua_isnumber(L,9)) SWIG_fail_arg("plimagefr",9,"PLFLT");
12240 {
12241 int jj;
12242
12243 arg1 = read_double_Matrix( L, 1, &ii1, &jj );
12244 if ( !arg1 )
12245 SWIG_fail;
12246 Xlen = arg2 = ii1;
12247 Ylen = arg3 = jj;
12248 }
12249 arg4 = (PLFLT)lua_tonumber(L, 2);
12250 arg5 = (PLFLT)lua_tonumber(L, 3);
12251 arg6 = (PLFLT)lua_tonumber(L, 4);
12252 arg7 = (PLFLT)lua_tonumber(L, 5);
12253 arg8 = (PLFLT)lua_tonumber(L, 6);
12254 arg9 = (PLFLT)lua_tonumber(L, 7);
12255 arg10 = (PLFLT)lua_tonumber(L, 8);
12256 arg11 = (PLFLT)lua_tonumber(L, 9);
12257 if(lua_gettop(L)>=10){
12258 {
12259 arg12 = NULL;
12260 mypltr_funcstr[0] = '\0';
12261
12262 if ( lua_isstring( L, 10 ) )
12263 {
12264 const char* funcstr = lua_tostring( L, 10 );
12265 if ( strcmp( "pltr0", funcstr ) == 0 )
12266 {
12267 arg12 = pltr0;
12268 }
12269 else if ( strcmp( "pltr1", funcstr ) == 0 )
12270 {
12271 arg12 = pltr1;
12272 }
12273 else if ( strcmp( "pltr2", funcstr ) == 0 )
12274 {
12275 arg12 = pltr2;
12276 }
12277 else
12278 {
12279 arg12 = mypltr;
12280 strncpy( mypltr_funcstr, funcstr, 255 );
12281 myL = L;
12282 }
12283 }
12284 else
12285 SWIG_fail_arg( "imagefr", 12, "pltr_func" );
12286 }
12287 }
12288 if(lua_gettop(L)>=11){
12289 {
12290 int nx, ny;
12291 int gridmode = 0;
12292
12293 lua_pushstring( L, "xg" );
12294 lua_gettable( L, 11 );
12295 if ( !lua_istable( L, -1 ) )
12296 {
12297 lua_pop( L, 1 ); // pop "xg"
12298 lua_pushstring( L, "expected a table xg" );
12299 SWIG_fail;
12300 }
12301 lua_rawgeti( L, -1, 1 );
12302 if ( lua_istable( L, -1 ) )
12303 gridmode = 2; // two dimensional array
12304 else if ( lua_isnumber( L, -1 ) )
12305 gridmode = 1; // one dimensional array
12306 else
12307 {
12308 lua_pop( L, 1 ); // pop "1"
12309 lua_pop( L, 1 ); // pop "xg"
12310 lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
12311 SWIG_fail;
12312 }
12313 lua_pop( L, 1 ); // pop test element
12314 if ( gridmode == 1 )
12315 {
12316 cgrid113.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
12317 if ( !cgrid113.xg )
12318 {
12319 lua_pop( L, 1 ); // pop "xg"
12320 SWIG_fail;
12321 }
12322 if ( nx != Xlen )
12323 {
12324 lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
12325 SWIG_fail;
12326 }
12327 cgrid113.nx = nx;
12328 }
12329 else
12330 {
12331 cgrid213.xg = read_double_Matrix( L, -1, &nx, &ny );
12332 if ( !cgrid213.xg )
12333 {
12334 lua_pop( L, 1 ); // pop "xg"
12335 SWIG_fail;
12336 }
12337 if ( ( nx != Xlen ) || ( ny != Ylen ) )
12338 {
12339 lua_pop( L, 1 ); // pop "xg"
12340 lua_pushfstring( L, "Vectors must match matrix." );
12341 SWIG_fail;
12342 }
12343 cgrid213.nx = nx;
12344 cgrid213.ny = ny;
12345 }
12346 lua_pop( L, 1 ); // pop "xg"
12347
12348 lua_pushstring( L, "yg" );
12349 lua_gettable( L, 11 );
12350 if ( !lua_istable( L, -1 ) )
12351 {
12352 lua_pop( L, 1 );
12353 lua_pushstring( L, "expected a table yg" );
12354 SWIG_fail;
12355 }
12356 lua_rawgeti( L, -1, 1 );
12357 if ( gridmode == 2 )
12358 {
12359 if ( !lua_istable( L, -1 ) )
12360 {
12361 lua_pop( L, 1 ); // pop "1"
12362 lua_pop( L, 1 ); // pop "yg"
12363 lua_pushstring( L, "expected a two dimensional array/table in yg" );
12364 SWIG_fail;
12365 }
12366 }
12367 else
12368 {
12369 if ( !lua_isnumber( L, -1 ) )
12370 {
12371 lua_pop( L, 1 ); // pop "1"
12372 lua_pop( L, 1 ); // pop "yg"
12373 lua_pushstring( L, "expected a one dimensional array/table in yg" );
12374 SWIG_fail;
12375 }
12376 }
12377 lua_pop( L, 1 ); // pop "1"
12378 if ( gridmode == 1 )
12379 {
12380 cgrid113.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
12381 if ( !cgrid113.yg )
12382 {
12383 lua_pop( L, 1 ); // pop "yg"
12384 SWIG_fail;
12385 }
12386 if ( ny != Ylen )
12387 {
12388 lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
12389 SWIG_fail;
12390 }
12391 cgrid113.ny = ny;
12392 }
12393 else
12394 {
12395 cgrid213.yg = read_double_Matrix( L, -1, &nx, &ny );
12396 if ( !cgrid213.yg )
12397 {
12398 lua_pop( L, 1 ); // pop "xg"
12399 SWIG_fail;
12400 }
12401 if ( ( nx != Xlen ) || ( ny != Ylen ) )
12402 {
12403 lua_pop( L, 1 ); // pop "xg"
12404 lua_pushfstring( L, "Vectors must match matrix." );
12405 SWIG_fail;
12406 }
12407 // cgrid213.nx/ny already set
12408 }
12409 lua_pop( L, 1 ); // pop "yg"
12410
12411 if ( gridmode == 1 )
12412 arg13 = &cgrid113;
12413 else if ( gridmode == 2 )
12414 arg13 = &cgrid213;
12415 }
12416 }
12417 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
12418
12419 {
12420 int i;
12421
12422 if ( arg1 )
12423 {
12424 for ( i = 0; i < ii1; i++ )
12425 LUA_FREE_ARRAY( arg1[i] );
12426 LUA_FREE_ARRAY( arg1 );
12427 }
12428 }
12429 {
12430 mypltr_funcstr[0] = '\0';
12431 }
12432 {
12433 int i;
12434
12435 LUA_FREE_ARRAY( cgrid113.xg );
12436 LUA_FREE_ARRAY( cgrid113.yg );
12437
12438 if ( cgrid213.xg )
12439 {
12440 for ( i = 0; i < Xlen; i++ )
12441 LUA_FREE_ARRAY( cgrid213.xg[i] );
12442 LUA_FREE_ARRAY( cgrid213.xg );
12443 }
12444 if ( cgrid213.yg )
12445 {
12446 for ( i = 0; i < Xlen; i++ )
12447 LUA_FREE_ARRAY( cgrid213.yg[i] );
12448 LUA_FREE_ARRAY( cgrid213.yg );
12449 }
12450 }
12451 return SWIG_arg;
12452
12453 if(0) SWIG_fail;
12454
12455 fail:
12456 {
12457 int i;
12458
12459 if ( arg1 )
12460 {
12461 for ( i = 0; i < ii1; i++ )
12462 LUA_FREE_ARRAY( arg1[i] );
12463 LUA_FREE_ARRAY( arg1 );
12464 }
12465 }
12466 {
12467 mypltr_funcstr[0] = '\0';
12468 }
12469 {
12470 int i;
12471
12472 LUA_FREE_ARRAY( cgrid113.xg );
12473 LUA_FREE_ARRAY( cgrid113.yg );
12474
12475 if ( cgrid213.xg )
12476 {
12477 for ( i = 0; i < Xlen; i++ )
12478 LUA_FREE_ARRAY( cgrid213.xg[i] );
12479 LUA_FREE_ARRAY( cgrid213.xg );
12480 }
12481 if ( cgrid213.yg )
12482 {
12483 for ( i = 0; i < Xlen; i++ )
12484 LUA_FREE_ARRAY( cgrid213.yg[i] );
12485 LUA_FREE_ARRAY( cgrid213.yg );
12486 }
12487 }
12488 lua_error(L);
12489 return SWIG_arg;
12490 }
12491
12492
12493 static int _wrap_plClearOpts(lua_State* L) {
12494 int SWIG_arg = 0;
12495
12496 SWIG_check_num_args("plClearOpts",0,0)
12497 plClearOpts();
12498
12499 return SWIG_arg;
12500
12501 if(0) SWIG_fail;
12502
12503 fail:
12504 lua_error(L);
12505 return SWIG_arg;
12506 }
12507
12508
12509 static int _wrap_plResetOpts(lua_State* L) {
12510 int SWIG_arg = 0;
12511
12512 SWIG_check_num_args("plResetOpts",0,0)
12513 plResetOpts();
12514
12515 return SWIG_arg;
12516
12517 if(0) SWIG_fail;
12518
12519 fail:
12520 lua_error(L);
12521 return SWIG_arg;
12522 }
12523
12524
12525 static int _wrap_plSetUsage(lua_State* L) {
12526 int SWIG_arg = 0;
12527 char *arg1 = (char *) 0 ;
12528 char *arg2 = (char *) 0 ;
12529
12530 SWIG_check_num_args("plSetUsage",2,2)
12531 if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plSetUsage",1,"char const *");
12532 if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plSetUsage",2,"char const *");
12533 arg1 = (char *)lua_tostring(L, 1);
12534 arg2 = (char *)lua_tostring(L, 2);
12535 plSetUsage((char const *)arg1,(char const *)arg2);
12536
12537 return SWIG_arg;
12538
12539 if(0) SWIG_fail;
12540
12541 fail:
12542 lua_error(L);
12543 return SWIG_arg;
12544 }
12545
12546
12547 static int _wrap_plOptUsage(lua_State* L) {
12548 int SWIG_arg = 0;
12549
12550 SWIG_check_num_args("plOptUsage",0,0)
12551 plOptUsage();
12552
12553 return SWIG_arg;
12554
12555 if(0) SWIG_fail;
12556
12557 fail:
12558 lua_error(L);
12559 return SWIG_arg;
12560 }
12561
12562
12563 static int _wrap_MinMax2dGrid(lua_State* L) {
12564 int SWIG_arg = 0;
12565 PLFLT **arg1 = (PLFLT **) 0 ;
12566 PLINT arg2 ;
12567 PLINT arg3 ;
12568 PLFLT *arg4 = (PLFLT *) 0 ;
12569 PLFLT *arg5 = (PLFLT *) 0 ;
12570 int ii1 ;
12571 PLFLT temp4 ;
12572 PLFLT temp5 ;
12573
12574 arg4 = &temp4;
12575 arg5 = &temp5;
12576 SWIG_check_num_args("plMinMax2dGrid",1,1)
12577 {
12578 int jj;
12579
12580 arg1 = read_double_Matrix( L, 1, &ii1, &jj );
12581 if ( !arg1 )
12582 SWIG_fail;
12583 Xlen = arg2 = ii1;
12584 Ylen = arg3 = jj;
12585 }
12586 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
12587
12588 lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
12589 lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
12590 {
12591 int i;
12592
12593 if ( arg1 )
12594 {
12595 for ( i = 0; i < ii1; i++ )
12596 LUA_FREE_ARRAY( arg1[i] );
12597 LUA_FREE_ARRAY( arg1 );
12598 }
12599 }
12600 return SWIG_arg;
12601
12602 if(0) SWIG_fail;
12603
12604 fail:
12605 {
12606 int i;
12607
12608 if ( arg1 )
12609 {
12610 for ( i = 0; i < ii1; i++ )
12611 LUA_FREE_ARRAY( arg1[i] );
12612 LUA_FREE_ARRAY( arg1 );
12613 }
12614 }
12615 lua_error(L);
12616 return SWIG_arg;
12617 }
12618
12619
12620 static int _wrap_plGetCursor(lua_State* L) {
12621 int SWIG_arg = 0;
12622 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12623 PLINT result;
12624
12625 SWIG_check_num_args("plGetCursor",1,1)
12626 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("plGetCursor",1,"PLGraphicsIn *");
12627
12628 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
12629 SWIG_fail_ptr("plGetCursor",1,SWIGTYPE_p_PLGraphicsIn);
12630 }
12631
12632 result = (PLINT)plGetCursor(arg1);
12633 lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
12634 return SWIG_arg;
12635
12636 if(0) SWIG_fail;
12637
12638 fail:
12639 lua_error(L);
12640 return SWIG_arg;
12641 }
12642
12643
12644 static int _wrap_warn(lua_State* L) {
12645 int SWIG_arg = 0;
12646 char *arg1 = (char *) 0 ;
12647
12648 SWIG_check_num_args("plwarn",1,1)
12649 if(!lua_isstring(L,1)) SWIG_fail_arg("plwarn",1,"char const *");
12650 {
12651 arg1 = (char *) lua_tostring( L, 1 );
12652 }
12653 plwarn((char const *)arg1);
12654
12655 return SWIG_arg;
12656
12657 if(0) SWIG_fail;
12658
12659 fail:
12660 lua_error(L);
12661 return SWIG_arg;
12662 }
12663
12664
12665 static int _wrap_abort(lua_State* L) {
12666 int SWIG_arg = 0;
12667 char *arg1 = (char *) 0 ;
12668
12669 SWIG_check_num_args("plabort",1,1)
12670 if(!lua_isstring(L,1)) SWIG_fail_arg("plabort",1,"char const *");
12671 {
12672 arg1 = (char *) lua_tostring( L, 1 );
12673 }
12674 plabort((char const *)arg1);
12675
12676 return SWIG_arg;
12677
12678 if(0) SWIG_fail;
12679
12680 fail:
12681 lua_error(L);
12682 return SWIG_arg;
12683 }
12684
12685
12686 static swig_lua_attribute swig_SwigModule_attributes[] = {
12687 {0,0,0}
12688 };
12689 static swig_lua_const_info swig_SwigModule_constants[]= {
12690 {SWIG_LUA_CONSTTAB_INT("PLESC_SET_RGB", 1)},
12691 {SWIG_LUA_CONSTTAB_INT("PLESC_ALLOC_NCOL", 2)},
12692 {SWIG_LUA_CONSTTAB_INT("PLESC_SET_LPB", 3)},
12693 {SWIG_LUA_CONSTTAB_INT("PLESC_EXPOSE", 4)},
12694 {SWIG_LUA_CONSTTAB_INT("PLESC_RESIZE", 5)},
12695 {SWIG_LUA_CONSTTAB_INT("PLESC_REDRAW", 6)},
12696 {SWIG_LUA_CONSTTAB_INT("PLESC_TEXT", 7)},
12697 {SWIG_LUA_CONSTTAB_INT("PLESC_GRAPH", 8)},
12698 {SWIG_LUA_CONSTTAB_INT("PLESC_FILL", 9)},
12699 {SWIG_LUA_CONSTTAB_INT("PLESC_DI", 10)},
12700 {SWIG_LUA_CONSTTAB_INT("PLESC_FLUSH", 11)},
12701 {SWIG_LUA_CONSTTAB_INT("PLESC_EH", 12)},
12702 {SWIG_LUA_CONSTTAB_INT("PLESC_GETC", 13)},
12703 {SWIG_LUA_CONSTTAB_INT("PLESC_SWIN", 14)},
12704 {SWIG_LUA_CONSTTAB_INT("PLESC_DOUBLEBUFFERING", 15)},
12705 {SWIG_LUA_CONSTTAB_INT("PLESC_XORMOD", 16)},
12706 {SWIG_LUA_CONSTTAB_INT("PLESC_SET_COMPRESSION", 17)},
12707 {SWIG_LUA_CONSTTAB_INT("PLESC_CLEAR", 18)},
12708 {SWIG_LUA_CONSTTAB_INT("PLESC_DASH", 19)},
12709 {SWIG_LUA_CONSTTAB_INT("PLESC_HAS_TEXT", 20)},
12710 {SWIG_LUA_CONSTTAB_INT("PLESC_IMAGE", 21)},
12711 {SWIG_LUA_CONSTTAB_INT("PLESC_IMAGEOPS", 22)},
12712 {SWIG_LUA_CONSTTAB_INT("PLESC_PL2DEVCOL", 23)},
12713 {SWIG_LUA_CONSTTAB_INT("PLESC_DEV2PLCOL", 24)},
12714 {SWIG_LUA_CONSTTAB_INT("PLESC_SETBGFG", 25)},
12715 {SWIG_LUA_CONSTTAB_INT("PLESC_DEVINIT", 26)},
12716 {SWIG_LUA_CONSTTAB_INT("PLESC_GETBACKEND", 27)},
12717 {SWIG_LUA_CONSTTAB_INT("PLESC_BEGIN_TEXT", 28)},
12718 {SWIG_LUA_CONSTTAB_INT("PLESC_TEXT_CHAR", 29)},
12719 {SWIG_LUA_CONSTTAB_INT("PLESC_CONTROL_CHAR", 30)},
12720 {SWIG_LUA_CONSTTAB_INT("PLESC_END_TEXT", 31)},
12721 {SWIG_LUA_CONSTTAB_INT("PLESC_START_RASTERIZE", 32)},
12722 {SWIG_LUA_CONSTTAB_INT("PLESC_END_RASTERIZE", 33)},
12723 {SWIG_LUA_CONSTTAB_INT("PLESC_ARC", 34)},
12724 {SWIG_LUA_CONSTTAB_INT("PLESC_GRADIENT", 35)},
12725 {SWIG_LUA_CONSTTAB_INT("PLESC_MODESET", 36)},
12726 {SWIG_LUA_CONSTTAB_INT("PLESC_MODEGET", 37)},
12727 {SWIG_LUA_CONSTTAB_INT("PLESC_FIXASPECT", 38)},
12728 {SWIG_LUA_CONSTTAB_INT("PLESC_IMPORT_BUFFER", 39)},
12729 {SWIG_LUA_CONSTTAB_INT("PLESC_APPEND_BUFFER", 40)},
12730 {SWIG_LUA_CONSTTAB_INT("PLESC_FLUSH_REMAINING_BUFFER", 41)},
12731 {SWIG_LUA_CONSTTAB_INT("PLTEXT_FONTCHANGE", 0)},
12732 {SWIG_LUA_CONSTTAB_INT("PLTEXT_SUPERSCRIPT", 1)},
12733 {SWIG_LUA_CONSTTAB_INT("PLTEXT_SUBSCRIPT", 2)},
12734 {SWIG_LUA_CONSTTAB_INT("PLTEXT_BACKCHAR", 3)},
12735 {SWIG_LUA_CONSTTAB_INT("PLTEXT_OVERLINE", 4)},
12736 {SWIG_LUA_CONSTTAB_INT("PLTEXT_UNDERLINE", 5)},
12737 {SWIG_LUA_CONSTTAB_INT("ZEROW2B", 1)},
12738 {SWIG_LUA_CONSTTAB_INT("ZEROW2D", 2)},
12739 {SWIG_LUA_CONSTTAB_INT("ONEW2B", 3)},
12740 {SWIG_LUA_CONSTTAB_INT("ONEW2D", 4)},
12741 {SWIG_LUA_CONSTTAB_INT("PLSWIN_DEVICE", 1)},
12742 {SWIG_LUA_CONSTTAB_INT("PLSWIN_WORLD", 2)},
12743 {SWIG_LUA_CONSTTAB_INT("PL_X_AXIS", 1)},
12744 {SWIG_LUA_CONSTTAB_INT("PL_Y_AXIS", 2)},
12745 {SWIG_LUA_CONSTTAB_INT("PL_Z_AXIS", 3)},
12746 {SWIG_LUA_CONSTTAB_INT("PL_OPT_ENABLED", 0x0001)},
12747 {SWIG_LUA_CONSTTAB_INT("PL_OPT_ARG", 0x0002)},
12748 {SWIG_LUA_CONSTTAB_INT("PL_OPT_NODELETE", 0x0004)},
12749 {SWIG_LUA_CONSTTAB_INT("PL_OPT_INVISIBLE", 0x0008)},
12750 {SWIG_LUA_CONSTTAB_INT("PL_OPT_DISABLED", 0x0010)},
12751 {SWIG_LUA_CONSTTAB_INT("PL_OPT_FUNC", 0x0100)},
12752 {SWIG_LUA_CONSTTAB_INT("PL_OPT_BOOL", 0x0200)},
12753 {SWIG_LUA_CONSTTAB_INT("PL_OPT_INT", 0x0400)},
12754 {SWIG_LUA_CONSTTAB_INT("PL_OPT_FLOAT", 0x0800)},
12755 {SWIG_LUA_CONSTTAB_INT("PL_OPT_STRING", 0x1000)},
12756 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_PARTIAL", 0x0000)},
12757 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_FULL", 0x0001)},
12758 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_QUIET", 0x0002)},
12759 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_NODELETE", 0x0004)},
12760 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_SHOWALL", 0x0008)},
12761 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_OVERRIDE", 0x0010)},
12762 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_NOPROGRAM", 0x0020)},
12763 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_NODASH", 0x0040)},
12764 {SWIG_LUA_CONSTTAB_INT("PL_PARSE_SKIP", 0x0080)},
12765 {SWIG_LUA_CONSTTAB_INT("PL_FCI_MARK", 0x80000000)},
12766 {SWIG_LUA_CONSTTAB_INT("PL_FCI_IMPOSSIBLE", 0x00000000)},
12767 {SWIG_LUA_CONSTTAB_INT("PL_FCI_HEXDIGIT_MASK", 0xf)},
12768 {SWIG_LUA_CONSTTAB_INT("PL_FCI_HEXPOWER_MASK", 0x7)},
12769 {SWIG_LUA_CONSTTAB_INT("PL_FCI_HEXPOWER_IMPOSSIBLE", 0xf)},
12770 {SWIG_LUA_CONSTTAB_INT("PL_FCI_FAMILY", 0x0)},
12771 {SWIG_LUA_CONSTTAB_INT("PL_FCI_STYLE", 0x1)},
12772 {SWIG_LUA_CONSTTAB_INT("PL_FCI_WEIGHT", 0x2)},
12773 {SWIG_LUA_CONSTTAB_INT("PL_FCI_SANS", 0x0)},
12774 {SWIG_LUA_CONSTTAB_INT("PL_FCI_SERIF", 0x1)},
12775 {SWIG_LUA_CONSTTAB_INT("PL_FCI_MONO", 0x2)},
12776 {SWIG_LUA_CONSTTAB_INT("PL_FCI_SCRIPT", 0x3)},
12777 {SWIG_LUA_CONSTTAB_INT("PL_FCI_SYMBOL", 0x4)},
12778 {SWIG_LUA_CONSTTAB_INT("PL_FCI_UPRIGHT", 0x0)},
12779 {SWIG_LUA_CONSTTAB_INT("PL_FCI_ITALIC", 0x1)},
12780 {SWIG_LUA_CONSTTAB_INT("PL_FCI_OBLIQUE", 0x2)},
12781 {SWIG_LUA_CONSTTAB_INT("PL_FCI_MEDIUM", 0x0)},
12782 {SWIG_LUA_CONSTTAB_INT("PL_FCI_BOLD", 0x1)},
12783 {SWIG_LUA_CONSTTAB_INT("PL_MAXKEY", 16)},
12784 {SWIG_LUA_CONSTTAB_INT("PL_MASK_SHIFT", 0x1)},
12785 {SWIG_LUA_CONSTTAB_INT("PL_MASK_CAPS", 0x2)},
12786 {SWIG_LUA_CONSTTAB_INT("PL_MASK_CONTROL", 0x4)},
12787 {SWIG_LUA_CONSTTAB_INT("PL_MASK_ALT", 0x8)},
12788 {SWIG_LUA_CONSTTAB_INT("PL_MASK_NUM", 0x10)},
12789 {SWIG_LUA_CONSTTAB_INT("PL_MASK_ALTGR", 0x20)},
12790 {SWIG_LUA_CONSTTAB_INT("PL_MASK_WIN", 0x40)},
12791 {SWIG_LUA_CONSTTAB_INT("PL_MASK_SCROLL", 0x80)},
12792 {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON1", 0x100)},
12793 {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON2", 0x200)},
12794 {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON3", 0x400)},
12795 {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON4", 0x800)},
12796 {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON5", 0x1000)},
12797 {SWIG_LUA_CONSTTAB_INT("PL_MAXWINDOWS", 64)},
12798 {SWIG_LUA_CONSTTAB_INT("PL_NOTSET", (-42))},
12799 {SWIG_LUA_CONSTTAB_INT("PL_DEFAULT_NCOL0", 16)},
12800 {SWIG_LUA_CONSTTAB_INT("PL_DEFAULT_NCOL1", 128)},
12801 {SWIG_LUA_CONSTTAB_INT("MIN_PLINT_RGB", 0)},
12802 {SWIG_LUA_CONSTTAB_INT("MAX_PLINT_RGB", 255)},
12803 {SWIG_LUA_CONSTTAB_FLOAT("MIN_PLFLT_CMAP1", 0.)},
12804 {SWIG_LUA_CONSTTAB_FLOAT("MAX_PLFLT_CMAP1", 1.)},
12805 {SWIG_LUA_CONSTTAB_FLOAT("MIN_PLFLT_ALPHA", 0.)},
12806 {SWIG_LUA_CONSTTAB_FLOAT("MAX_PLFLT_ALPHA", 1.)},
12807 {SWIG_LUA_CONSTTAB_INT("PLESC_DOUBLEBUFFERING_ENABLE", 1)},
12808 {SWIG_LUA_CONSTTAB_INT("PLESC_DOUBLEBUFFERING_DISABLE", 2)},
12809 {SWIG_LUA_CONSTTAB_INT("PLESC_DOUBLEBUFFERING_QUERY", 3)},
12810 {SWIG_LUA_CONSTTAB_INT("PL_BIN_DEFAULT", 0x0)},
12811 {SWIG_LUA_CONSTTAB_INT("PL_BIN_CENTRED", 0x1)},
12812 {SWIG_LUA_CONSTTAB_INT("PL_BIN_NOEXPAND", 0x2)},
12813 {SWIG_LUA_CONSTTAB_INT("PL_BIN_NOEMPTY", 0x4)},
12814 {SWIG_LUA_CONSTTAB_INT("GRID_CSA", 1)},
12815 {SWIG_LUA_CONSTTAB_INT("GRID_DTLI", 2)},
12816 {SWIG_LUA_CONSTTAB_INT("GRID_NNI", 3)},
12817 {SWIG_LUA_CONSTTAB_INT("GRID_NNIDW", 4)},
12818 {SWIG_LUA_CONSTTAB_INT("GRID_NNLI", 5)},
12819 {SWIG_LUA_CONSTTAB_INT("GRID_NNAIDW", 6)},
12820 {SWIG_LUA_CONSTTAB_INT("PL_HIST_DEFAULT", 0x00)},
12821 {SWIG_LUA_CONSTTAB_INT("PL_HIST_NOSCALING", 0x01)},
12822 {SWIG_LUA_CONSTTAB_INT("PL_HIST_IGNORE_OUTLIERS", 0x02)},
12823 {SWIG_LUA_CONSTTAB_INT("PL_HIST_NOEXPAND", 0x08)},
12824 {SWIG_LUA_CONSTTAB_INT("PL_HIST_NOEMPTY", 0x10)},
12825 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_NULL", 0x0)},
12826 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_LEFT", 0x1)},
12827 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_RIGHT", 0x2)},
12828 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_TOP", 0x4)},
12829 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_BOTTOM", 0x8)},
12830 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_INSIDE", 0x10)},
12831 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_OUTSIDE", 0x20)},
12832 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_VIEWPORT", 0x40)},
12833 {SWIG_LUA_CONSTTAB_INT("PL_POSITION_SUBPAGE", 0x80)},
12834 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_NULL", 0x0)},
12835 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_NONE", 0x1)},
12836 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_COLOR_BOX", 0x2)},
12837 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_LINE", 0x4)},
12838 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_SYMBOL", 0x8)},
12839 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_TEXT_LEFT", 0x10)},
12840 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_BACKGROUND", 0x20)},
12841 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_BOUNDING_BOX", 0x40)},
12842 {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_ROW_MAJOR", 0x80)},
12843 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_NULL", 0x0)},
12844 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_LABEL_LEFT", 0x1)},
12845 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_LABEL_RIGHT", 0x2)},
12846 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_LABEL_TOP", 0x4)},
12847 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_LABEL_BOTTOM", 0x8)},
12848 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_IMAGE", 0x10)},
12849 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_SHADE", 0x20)},
12850 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_GRADIENT", 0x40)},
12851 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_CAP_NONE", 0x80)},
12852 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_CAP_LOW", 0x100)},
12853 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_CAP_HIGH", 0x200)},
12854 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_SHADE_LABEL", 0x400)},
12855 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_ORIENT_RIGHT", 0x800)},
12856 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_ORIENT_TOP", 0x1000)},
12857 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_ORIENT_LEFT", 0x2000)},
12858 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_ORIENT_BOTTOM", 0x4000)},
12859 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_BACKGROUND", 0x8000)},
12860 {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_BOUNDING_BOX", 0x10000)},
12861 {SWIG_LUA_CONSTTAB_INT("PL_DRAWMODE_UNKNOWN", 0x0)},
12862 {SWIG_LUA_CONSTTAB_INT("PL_DRAWMODE_DEFAULT", 0x1)},
12863 {SWIG_LUA_CONSTTAB_INT("PL_DRAWMODE_REPLACE", 0x2)},
12864 {SWIG_LUA_CONSTTAB_INT("PL_DRAWMODE_XOR", 0x4)},
12865 {SWIG_LUA_CONSTTAB_INT("DRAW_LINEX", 0x001)},
12866 {SWIG_LUA_CONSTTAB_INT("DRAW_LINEY", 0x002)},
12867 {SWIG_LUA_CONSTTAB_INT("DRAW_LINEXY", 0x003)},
12868 {SWIG_LUA_CONSTTAB_INT("MAG_COLOR", 0x004)},
12869 {SWIG_LUA_CONSTTAB_INT("BASE_CONT", 0x008)},
12870 {SWIG_LUA_CONSTTAB_INT("TOP_CONT", 0x010)},
12871 {SWIG_LUA_CONSTTAB_INT("SURF_CONT", 0x020)},
12872 {SWIG_LUA_CONSTTAB_INT("DRAW_SIDES", 0x040)},
12873 {SWIG_LUA_CONSTTAB_INT("FACETED", 0x080)},
12874 {SWIG_LUA_CONSTTAB_INT("MESH", 0x100)},
12875 {0,0,0,0,0,0}
12876 };
12877 static swig_lua_method swig_SwigModule_methods[]= {
12878 { "setcontlabelformat", _wrap_setcontlabelformat},
12879 { "setcontlabelparam", _wrap_setcontlabelparam},
12880 { "adv", _wrap_adv},
12881 { "arc", _wrap_arc},
12882 { "axes", _wrap_axes},
12883 { "bin", _wrap_bin},
12884 { "btime", _wrap_btime},
12885 { "bop", _wrap_bop},
12886 { "box", _wrap_box},
12887 { "box3", _wrap_box3},
12888 { "calc_world", _wrap_calc_world},
12889 { "clear", _wrap_clear},
12890 { "col0", _wrap_col0},
12891 { "col1", _wrap_col1},
12892 { "configtime", _wrap_configtime},
12893 { "cont", _wrap_cont},
12894 { "ctime", _wrap_ctime},
12895 { "cpstrm", _wrap_cpstrm},
12896 { "plend", _wrap_plend},
12897 { "plend1", _wrap_plend1},
12898 { "env", _wrap_env},
12899 { "env0", _wrap_env0},
12900 { "eop", _wrap_eop},
12901 { "errx", _wrap_errx},
12902 { "erry", _wrap_erry},
12903 { "famadv", _wrap_famadv},
12904 { "fill", _wrap_fill},
12905 { "fill3", _wrap_fill3},
12906 { "gradient", _wrap_gradient},
12907 { "flush", _wrap_flush},
12908 { "font", _wrap_font},
12909 { "fontld", _wrap_fontld},
12910 { "gchr", _wrap_gchr},
12911 { "gcol0", _wrap_gcol0},
12912 { "gcol0a", _wrap_gcol0a},
12913 { "gcolbg", _wrap_gcolbg},
12914 { "gcolbga", _wrap_gcolbga},
12915 { "gcompression", _wrap_gcompression},
12916 { "gdev", _wrap_gdev},
12917 { "gdidev", _wrap_gdidev},
12918 { "gdiori", _wrap_gdiori},
12919 { "gdiplt", _wrap_gdiplt},
12920 { "gfam", _wrap_gfam},
12921 { "gfci", _wrap_gfci},
12922 { "gfnam", _wrap_gfnam},
12923 { "gfont", _wrap_gfont},
12924 { "glevel", _wrap_glevel},
12925 { "gpage", _wrap_gpage},
12926 { "gra", _wrap_gra},
12927 { "griddata", _wrap_griddata},
12928 { "gspa", _wrap_gspa},
12929 { "gstrm", _wrap_gstrm},
12930 { "gver", _wrap_gver},
12931 { "gvpd", _wrap_gvpd},
12932 { "gvpw", _wrap_gvpw},
12933 { "gxax", _wrap_gxax},
12934 { "gyax", _wrap_gyax},
12935 { "gzax", _wrap_gzax},
12936 { "hist", _wrap_hist},
12937 { "hlsrgb", _wrap_hlsrgb},
12938 { "init", _wrap_init},
12939 { "join", _wrap_join},
12940 { "lab", _wrap_lab},
12941 { "legend", _wrap_legend},
12942 { "colorbar", _wrap_colorbar},
12943 { "lightsource", _wrap_lightsource},
12944 { "line", _wrap_line},
12945 { "line3", _wrap_line3},
12946 { "lsty", _wrap_lsty},
12947 { "mesh", _wrap_mesh},
12948 { "meshc", _wrap_meshc},
12949 { "mkstrm", _wrap_mkstrm},
12950 { "mtex", _wrap_mtex},
12951 { "mtex3", _wrap_mtex3},
12952 { "plot3d", _wrap_plot3d},
12953 { "plot3dc", _wrap_plot3dc},
12954 { "plot3dcl", _wrap_plot3dcl},
12955 { "surf3d", _wrap_surf3d},
12956 { "surf3dl", _wrap_surf3dl},
12957 { "parseopts", _wrap_parseopts},
12958 { "pat", _wrap_pat},
12959 { "path", _wrap_path},
12960 { "poin", _wrap_poin},
12961 { "poin3", _wrap_poin3},
12962 { "poly3", _wrap_poly3},
12963 { "prec", _wrap_prec},
12964 { "psty", _wrap_psty},
12965 { "ptex", _wrap_ptex},
12966 { "ptex3", _wrap_ptex3},
12967 { "randd", _wrap_randd},
12968 { "replot", _wrap_replot},
12969 { "rgbhls", _wrap_rgbhls},
12970 { "schr", _wrap_schr},
12971 { "scmap0", _wrap_scmap0},
12972 { "scmap0a", _wrap_scmap0a},
12973 { "scmap0n", _wrap_scmap0n},
12974 { "scmap1", _wrap_scmap1},
12975 { "scmap1a", _wrap_scmap1a},
12976 { "scmap1l", _wrap_scmap1l},
12977 { "scmap1la", _wrap_scmap1la},
12978 { "scmap1n", _wrap_scmap1n},
12979 { "scmap1_range", _wrap_scmap1_range},
12980 { "gcmap1_range", _wrap_gcmap1_range},
12981 { "scol0", _wrap_scol0},
12982 { "scol0a", _wrap_scol0a},
12983 { "scolbg", _wrap_scolbg},
12984 { "scolbga", _wrap_scolbga},
12985 { "scolor", _wrap_scolor},
12986 { "scompression", _wrap_scompression},
12987 { "sdev", _wrap_sdev},
12988 { "sdidev", _wrap_sdidev},
12989 { "sdimap", _wrap_sdimap},
12990 { "sdiori", _wrap_sdiori},
12991 { "sdiplt", _wrap_sdiplt},
12992 { "sdiplz", _wrap_sdiplz},
12993 { "seed", _wrap_seed},
12994 { "sesc", _wrap_sesc},
12995 { "setopt", _wrap_setopt},
12996 { "sfam", _wrap_sfam},
12997 { "sfci", _wrap_sfci},
12998 { "sfnam", _wrap_sfnam},
12999 { "sfont", _wrap_sfont},
13000 { "shades", _wrap_shades},
13001 { "shade", _wrap_shade},
13002 { "slabelfunc", _wrap_slabelfunc},
13003 { "smaj", _wrap_smaj},
13004 { "smin", _wrap_smin},
13005 { "sori", _wrap_sori},
13006 { "spage", _wrap_spage},
13007 { "spal0", _wrap_spal0},
13008 { "spal1", _wrap_spal1},
13009 { "spause", _wrap_spause},
13010 { "sstrm", _wrap_sstrm},
13011 { "ssub", _wrap_ssub},
13012 { "ssym", _wrap_ssym},
13013 { "star", _wrap_star},
13014 { "start", _wrap_start},
13015 { "stransform", _wrap_stransform},
13016 { "string", _wrap_string},
13017 { "string3", _wrap_string3},
13018 { "stripa", _wrap_stripa},
13019 { "stripc", _wrap_stripc},
13020 { "stripd", _wrap_stripd},
13021 { "styl", _wrap_styl},
13022 { "svect", _wrap_svect},
13023 { "svpa", _wrap_svpa},
13024 { "sxax", _wrap_sxax},
13025 { "syax", _wrap_syax},
13026 { "sym", _wrap_sym},
13027 { "szax", _wrap_szax},
13028 { "text", _wrap_text},
13029 { "timefmt", _wrap_timefmt},
13030 { "vasp", _wrap_vasp},
13031 { "vect", _wrap_vect},
13032 { "vpas", _wrap_vpas},
13033 { "vpor", _wrap_vpor},
13034 { "vsta", _wrap_vsta},
13035 { "w3d", _wrap_w3d},
13036 { "width", _wrap_width},
13037 { "wind", _wrap_wind},
13038 { "xormod", _wrap_xormod},
13039 { "map", _wrap_map},
13040 { "mapline", _wrap_mapline},
13041 { "mapstring", _wrap_mapstring},
13042 { "maptex", _wrap_maptex},
13043 { "mapfill", _wrap_mapfill},
13044 { "meridians", _wrap_meridians},
13045 { "image", _wrap_image},
13046 { "imagefr", _wrap_imagefr},
13047 { "plClearOpts", _wrap_plClearOpts},
13048 { "plResetOpts", _wrap_plResetOpts},
13049 { "plSetUsage", _wrap_plSetUsage},
13050 { "plOptUsage", _wrap_plOptUsage},
13051 { "MinMax2dGrid", _wrap_MinMax2dGrid},
13052 { "plGetCursor", _wrap_plGetCursor},
13053 { "warn", _wrap_warn},
13054 { "abort", _wrap_abort},
13055 {0,0}
13056 };
13057 static swig_lua_class* swig_SwigModule_classes[]= {
13058 &_wrap_class_PLGraphicsIn,
13059 0
13060 };
13061 static swig_lua_namespace* swig_SwigModule_namespaces[] = {
13062 0
13063 };
13064
13065 static swig_lua_namespace swig_SwigModule = {
13066 "plplotluac",
13067 swig_SwigModule_methods,
13068 swig_SwigModule_attributes,
13069 swig_SwigModule_constants,
13070 swig_SwigModule_classes,
13071 swig_SwigModule_namespaces
13072 };
13073 #ifdef __cplusplus
13074 }
13075 #endif
13076
13077 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
13078
13079 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
13080 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
13081 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
13082 static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
13083 static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void = {"_p_f_double_double_p_double_p_double_p_void__void", "ct_func|pltr_func|void (*)(double,double,double *,double *,void *)", 0, 0, (void*)0, 0};
13084 static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "void (*)(int,double,char *,int,void *)|label_func", 0, 0, (void*)0, 0};
13085 static swig_type_info _swigt__p_f_int_p_double_p_double__void = {"_p_f_int_p_double_p_double__void", "mapform_func|void (*)(int,double *,double *)", 0, 0, (void*)0, 0};
13086 static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void = {"_p_f_int_p_q_const__double_p_q_const__double__void", "void (*)(int,double const *,double const *)|fill_func", 0, 0, (void*)0, 0};
13087 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
13088 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
13089 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
13090 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
13091
13092 static swig_type_info *swig_type_initial[] = {
13093 &_swigt__p_PLGraphicsIn,
13094 &_swigt__p_char,
13095 &_swigt__p_double,
13096 &_swigt__p_f_double_double__int,
13097 &_swigt__p_f_double_double_p_double_p_double_p_void__void,
13098 &_swigt__p_f_int_double_p_char_int_p_void__void,
13099 &_swigt__p_f_int_p_double_p_double__void,
13100 &_swigt__p_f_int_p_q_const__double_p_q_const__double__void,
13101 &_swigt__p_int,
13102 &_swigt__p_p_char,
13103 &_swigt__p_p_double,
13104 &_swigt__p_unsigned_int,
13105 };
13106
13107 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
13108 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
13109 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
13110 static swig_cast_info _swigc__p_f_double_double__int[] = { {&_swigt__p_f_double_double__int, 0, 0, 0},{0, 0, 0, 0}};
13111 static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[] = { {&_swigt__p_f_double_double_p_double_p_double_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
13112 static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[] = { {&_swigt__p_f_int_double_p_char_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
13113 static swig_cast_info _swigc__p_f_int_p_double_p_double__void[] = { {&_swigt__p_f_int_p_double_p_double__void, 0, 0, 0},{0, 0, 0, 0}};
13114 static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[] = { {&_swigt__p_f_int_p_q_const__double_p_q_const__double__void, 0, 0, 0},{0, 0, 0, 0}};
13115 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
13116 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
13117 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
13118 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
13119
13120 static swig_cast_info *swig_cast_initial[] = {
13121 _swigc__p_PLGraphicsIn,
13122 _swigc__p_char,
13123 _swigc__p_double,
13124 _swigc__p_f_double_double__int,
13125 _swigc__p_f_double_double_p_double_p_double_p_void__void,
13126 _swigc__p_f_int_double_p_char_int_p_void__void,
13127 _swigc__p_f_int_p_double_p_double__void,
13128 _swigc__p_f_int_p_q_const__double_p_q_const__double__void,
13129 _swigc__p_int,
13130 _swigc__p_p_char,
13131 _swigc__p_p_double,
13132 _swigc__p_unsigned_int,
13133 };
13134
13135
13136 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
13137
13138 /* -----------------------------------------------------------------------------
13139 * Type initialization:
13140 * This problem is tough by the requirement that no dynamic
13141 * memory is used. Also, since swig_type_info structures store pointers to
13142 * swig_cast_info structures and swig_cast_info structures store pointers back
13143 * to swig_type_info structures, we need some lookup code at initialization.
13144 * The idea is that swig generates all the structures that are needed.
13145 * The runtime then collects these partially filled structures.
13146 * The SWIG_InitializeModule function takes these initial arrays out of
13147 * swig_module, and does all the lookup, filling in the swig_module.types
13148 * array with the correct data and linking the correct swig_cast_info
13149 * structures together.
13150 *
13151 * The generated swig_type_info structures are assigned statically to an initial
13152 * array. We just loop through that array, and handle each type individually.
13153 * First we lookup if this type has been already loaded, and if so, use the
13154 * loaded structure instead of the generated one. Then we have to fill in the
13155 * cast linked list. The cast data is initially stored in something like a
13156 * two-dimensional array. Each row corresponds to a type (there are the same
13157 * number of rows as there are in the swig_type_initial array). Each entry in
13158 * a column is one of the swig_cast_info structures for that type.
13159 * The cast_initial array is actually an array of arrays, because each row has
13160 * a variable number of columns. So to actually build the cast linked list,
13161 * we find the array of casts associated with the type, and loop through it
13162 * adding the casts to the list. The one last trick we need to do is making
13163 * sure the type pointer in the swig_cast_info struct is correct.
13164 *
13165 * First off, we lookup the cast->type name to see if it is already loaded.
13166 * There are three cases to handle:
13167 * 1) If the cast->type has already been loaded AND the type we are adding
13168 * casting info to has not been loaded (it is in this module), THEN we
13169 * replace the cast->type pointer with the type pointer that has already
13170 * been loaded.
13171 * 2) If BOTH types (the one we are adding casting info to, and the
13172 * cast->type) are loaded, THEN the cast info has already been loaded by
13173 * the previous module so we just ignore it.
13174 * 3) Finally, if cast->type has not already been loaded, then we add that
13175 * swig_cast_info to the linked list (because the cast->type) pointer will
13176 * be correct.
13177 * ----------------------------------------------------------------------------- */
13178
13179 #ifdef __cplusplus
13180 extern "C" {
13181 #if 0
13182 } /* c-mode */
13183 #endif
13184 #endif
13185
13186 #if 0
13187 #define SWIGRUNTIME_DEBUG
13188 #endif
13189
13190
13191 SWIGRUNTIME void
13192 SWIG_InitializeModule(void *clientdata) {
13193 size_t i;
13194 swig_module_info *module_head, *iter;
13195 int init;
13196
13197 /* check to see if the circular list has been setup, if not, set it up */
13198 if (swig_module.next==0) {
13199 /* Initialize the swig_module */
13200 swig_module.type_initial = swig_type_initial;
13201 swig_module.cast_initial = swig_cast_initial;
13202 swig_module.next = &swig_module;
13203 init = 1;
13204 } else {
13205 init = 0;
13206 }
13207
13208 /* Try and load any already created modules */
13209 module_head = SWIG_GetModule(clientdata);
13210 if (!module_head) {
13211 /* This is the first module loaded for this interpreter */
13212 /* so set the swig module into the interpreter */
13213 SWIG_SetModule(clientdata, &swig_module);
13214 } else {
13215 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
13216 iter=module_head;
13217 do {
13218 if (iter==&swig_module) {
13219 /* Our module is already in the list, so there's nothing more to do. */
13220 return;
13221 }
13222 iter=iter->next;
13223 } while (iter!= module_head);
13224
13225 /* otherwise we must add our module into the list */
13226 swig_module.next = module_head->next;
13227 module_head->next = &swig_module;
13228 }
13229
13230 /* When multiple interpreters are used, a module could have already been initialized in
13231 a different interpreter, but not yet have a pointer in this interpreter.
13232 In this case, we do not want to continue adding types... everything should be
13233 set up already */
13234 if (init == 0) return;
13235
13236 /* Now work on filling in swig_module.types */
13237 #ifdef SWIGRUNTIME_DEBUG
13238 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
13239 #endif
13240 for (i = 0; i < swig_module.size; ++i) {
13241 swig_type_info *type = 0;
13242 swig_type_info *ret;
13243 swig_cast_info *cast;
13244
13245 #ifdef SWIGRUNTIME_DEBUG
13246 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
13247 #endif
13248
13249 /* if there is another module already loaded */
13250 if (swig_module.next != &swig_module) {
13251 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
13252 }
13253 if (type) {
13254 /* Overwrite clientdata field */
13255 #ifdef SWIGRUNTIME_DEBUG
13256 printf("SWIG_InitializeModule: found type %s\n", type->name);
13257 #endif
13258 if (swig_module.type_initial[i]->clientdata) {
13259 type->clientdata = swig_module.type_initial[i]->clientdata;
13260 #ifdef SWIGRUNTIME_DEBUG
13261 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
13262 #endif
13263 }
13264 } else {
13265 type = swig_module.type_initial[i];
13266 }
13267
13268 /* Insert casting types */
13269 cast = swig_module.cast_initial[i];
13270 while (cast->type) {
13271
13272 /* Don't need to add information already in the list */
13273 ret = 0;
13274 #ifdef SWIGRUNTIME_DEBUG
13275 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
13276 #endif
13277 if (swig_module.next != &swig_module) {
13278 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
13279 #ifdef SWIGRUNTIME_DEBUG
13280 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
13281 #endif
13282 }
13283 if (ret) {
13284 if (type == swig_module.type_initial[i]) {
13285 #ifdef SWIGRUNTIME_DEBUG
13286 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
13287 #endif
13288 cast->type = ret;
13289 ret = 0;
13290 } else {
13291 /* Check for casting already in the list */
13292 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
13293 #ifdef SWIGRUNTIME_DEBUG
13294 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
13295 #endif
13296 if (!ocast) ret = 0;
13297 }
13298 }
13299
13300 if (!ret) {
13301 #ifdef SWIGRUNTIME_DEBUG
13302 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
13303 #endif
13304 if (type->cast) {
13305 type->cast->prev = cast;
13306 cast->next = type->cast;
13307 }
13308 type->cast = cast;
13309 }
13310 cast++;
13311 }
13312 /* Set entry in modules->types array equal to the type */
13313 swig_module.types[i] = type;
13314 }
13315 swig_module.types[i] = 0;
13316
13317 #ifdef SWIGRUNTIME_DEBUG
13318 printf("**** SWIG_InitializeModule: Cast List ******\n");
13319 for (i = 0; i < swig_module.size; ++i) {
13320 int j = 0;
13321 swig_cast_info *cast = swig_module.cast_initial[i];
13322 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
13323 while (cast->type) {
13324 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
13325 cast++;
13326 ++j;
13327 }
13328 printf("---- Total casts: %d\n",j);
13329 }
13330 printf("**** SWIG_InitializeModule: Cast List ******\n");
13331 #endif
13332 }
13333
13334 /* This function will propagate the clientdata field of type to
13335 * any new swig_type_info structures that have been added into the list
13336 * of equivalent types. It is like calling
13337 * SWIG_TypeClientData(type, clientdata) a second time.
13338 */
13339 SWIGRUNTIME void
13340 SWIG_PropagateClientData(void) {
13341 size_t i;
13342 swig_cast_info *equiv;
13343 static int init_run = 0;
13344
13345 if (init_run) return;
13346 init_run = 1;
13347
13348 for (i = 0; i < swig_module.size; i++) {
13349 if (swig_module.types[i]->clientdata) {
13350 equiv = swig_module.types[i]->cast;
13351 while (equiv) {
13352 if (!equiv->converter) {
13353 if (equiv->type && !equiv->type->clientdata)
13354 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
13355 }
13356 equiv = equiv->next;
13357 }
13358 }
13359 }
13360 }
13361
13362 #ifdef __cplusplus
13363 #if 0
13364 { /* c-mode */
13365 #endif
13366 }
13367 #endif
13368
13369
13370
13371 /* Forward declaration of where the user's %init{} gets inserted */
13372 void SWIG_init_user(lua_State* L );
13373
13374 #ifdef __cplusplus
13375 extern "C" {
13376 #endif
13377 /* this is the initialization function
13378 added at the very end of the code
13379 the function is always called SWIG_init, but an earlier #define will rename it
13380 */
13381 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
13382 LUALIB_API int SWIG_init(lua_State* L)
13383 #else
13384 SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
13385 #endif
13386 {
13387 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */
13388 int i;
13389 int globalRegister = 0;
13390 /* start with global table */
13391 lua_pushglobaltable (L);
13392 /* SWIG's internal initialisation */
13393 SWIG_InitializeModule((void*)L);
13394 SWIG_PropagateClientData();
13395 #endif
13396
13397 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE)
13398 /* add a global fn */
13399 SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
13400 SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal);
13401 #endif
13402
13403 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
13404 /* set up base class pointers (the hierarchy) */
13405 for (i = 0; swig_types[i]; i++){
13406 if (swig_types[i]->clientdata){
13407 SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
13408 }
13409 }
13410 #ifdef SWIG_LUA_MODULE_GLOBAL
13411 globalRegister = 1;
13412 #endif
13413
13414
13415 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
13416 SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister);
13417 #endif
13418
13419 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
13420 for (i = 0; swig_types[i]; i++){
13421 if (swig_types[i]->clientdata){
13422 SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata));
13423 }
13424 }
13425 #endif
13426
13427 #if defined(SWIG_LUA_ELUA_EMULATE)
13428 lua_newtable(L);
13429 SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods);
13430 SWIG_Lua_elua_emulate_register_clear(L);
13431 if(globalRegister) {
13432 lua_pushstring(L,swig_SwigModule.name);
13433 lua_pushvalue(L,-2);
13434 lua_rawset(L,-4);
13435 }
13436 #endif
13437
13438 #endif
13439
13440 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
13441 /* invoke user-specific initialization */
13442 SWIG_init_user(L);
13443 /* end module */
13444 /* Note: We do not clean up the stack here (Lua will do this for us). At this
13445 point, we have the globals table and out module table on the stack. Returning
13446 one value makes the module table the result of the require command. */
13447 return 1;
13448 #else
13449 return 0;
13450 #endif
13451 }
13452
13453 #ifdef __cplusplus
13454 }
13455 #endif
13456
13457
13458 const char* SWIG_LUACODE=
13459 "\n"
13460 " pl = plplotluac";
13461
13462 void SWIG_init_user(lua_State* L)
13463 {
13464 /* exec Lua code if applicable */
13465 SWIG_Lua_dostring(L,SWIG_LUACODE);
13466 }
13467
_wrap_bin
static int _wrap_bin(lua_State *L)
Definition: plplotluacLUA_wrap.c:4024
swig_SwigModule
static swig_lua_namespace swig_SwigModule
Definition: plplotluacLUA_wrap.c:13065
swig_lua_class::metatable
swig_lua_method * metatable
Definition: plplotluacLUA_wrap.c:986
_swigc__p_f_double_double__int
static swig_cast_info _swigc__p_f_double_double__int[]
Definition: plplotluacLUA_wrap.c:13110
swig_type_info
struct swig_type_info swig_type_info
SWIG_fail
#define SWIG_fail
Definition: plplotluacLUA_wrap.c:1029
plplotP.h
_wrap_rgbhls
static int _wrap_rgbhls(lua_State *L)
Definition: plplotluacLUA_wrap.c:8403
myL
static lua_State * myL
Definition: plplotluacLUA_wrap.c:2980
plsfam
#define plsfam
Definition: plplot.h:816
myct_funcstr
static char myct_funcstr[255]
Definition: plplotluacLUA_wrap.c:3100
plplotc.plClearOpts
def plClearOpts
Definition: plplotc.py:8448
plw3d
#define plw3d
Definition: plplot.h:862
_wrap_box
static int _wrap_box(lua_State *L)
Definition: plplotluacLUA_wrap.c:4135
_wrap_PLGraphicsIn_pX_get
static int _wrap_PLGraphicsIn_pX_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3525
plpath
#define plpath
Definition: plplot.h:761
swig_module
static swig_module_info swig_module
Definition: plplotluacLUA_wrap.c:2667
SWIG_Lua_get_class_registry
SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L)
Definition: plplotluacLUA_wrap.c:1846
ct_func
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotluacLUA_wrap.c:3046
SWIG_PackData
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
Definition: plplotluacLUA_wrap.c:617
_wrap_mtex3
static int _wrap_mtex3(lua_State *L)
Definition: plplotluacLUA_wrap.c:7299
plgxax
#define plgxax
Definition: plplot.h:748
plsstrm
#define plsstrm
Definition: plplot.h:835
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplotluacLUA_wrap.c:3044
_wrap_PLGraphicsIn_string_set
static int _wrap_PLGraphicsIn_string_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3442
plGetCursor
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
swig_PLGraphicsIn_attributes
static swig_lua_attribute swig_PLGraphicsIn_attributes[]
Definition: plplotluacLUA_wrap.c:3828
_wrap_plot3d
static int _wrap_plot3d(lua_State *L)
Definition: plplotluacLUA_wrap.c:7330
_wrap_spal1
static int _wrap_spal1(lua_State *L)
Definition: plplotluacLUA_wrap.c:10360
_swigt__p_char
static swig_type_info _swigt__p_char
Definition: plplotluacLUA_wrap.c:13080
plspage
#define plspage
Definition: plplot.h:831
swig_lua_namespace::ns_classes
struct swig_lua_class ** ns_classes
Definition: plplotluacLUA_wrap.c:973
_wrap_scmap1a
static int _wrap_scmap1a(lua_State *L)
Definition: plplotluacLUA_wrap.c:8703
plvpor
#define plvpor
Definition: plplot.h:860
SWIG_write_ptr_array
SWIGINTERN void SWIG_write_ptr_array(lua_State *L, void **array, int size, swig_type_info *type, int own)
Definition: plplotluacLUA_wrap.c:2879
SWIG_Lua_do_resolve_metamethod
SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx, int skip_check)
Definition: plplotluacLUA_wrap.c:2078
_wrap_sfont
static int _wrap_sfont(lua_State *L)
Definition: plplotluacLUA_wrap.c:9540
_wrap_imagefr
static int _wrap_imagefr(lua_State *L)
Definition: plplotluacLUA_wrap.c:12200
_wrap_gfam
static int _wrap_gfam(lua_State *L)
Definition: plplotluacLUA_wrap.c:5481
_wrap_gra
static int _wrap_gra(lua_State *L)
Definition: plplotluacLUA_wrap.c:5642
_wrap_PLGraphicsIn_keysym_set
static int _wrap_PLGraphicsIn_keysym_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3290
SWIG_LUA_CONSTTAB_INT
#define SWIG_LUA_CONSTTAB_INT(B, C)
Definition: plplotluacLUA_wrap.c:821
plmtex3
#define plmtex3
Definition: plplot.h:774
plerry
#define plerry
Definition: plplot.h:715
swig_lua_rawdata::data
char data[1]
Definition: plplotluacLUA_wrap.c:1007
_wrap_PLGraphicsIn_wX_get
static int _wrap_PLGraphicsIn_wX_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3725
SWIG_TypeDynamicCast
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
Definition: plplotluacLUA_wrap.c:469
swig_module_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:354
plsyax
#define plsyax
Definition: plplot.h:852
SWIG_Lua_InstallConstants
SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[])
Definition: plplotluacLUA_wrap.c:2572
plschr
#define plschr
Definition: plplot.h:790
plsdev
#define plsdev
Definition: plplot.h:806
SWIG_get_ptr_array_fixed
SWIGINTERN void ** SWIG_get_ptr_array_fixed(lua_State *L, int index, int size, swig_type_info *type)
Definition: plplotluacLUA_wrap.c:2846
swig_delete_PLGraphicsIn
static void swig_delete_PLGraphicsIn(void *obj)
Definition: plplotluacLUA_wrap.c:3816
plgdev
#define plgdev
Definition: plplot.h:729
_wrap_scolor
static int _wrap_scolor(lua_State *L)
Definition: plplotluacLUA_wrap.c:9220
_wrap_setopt
static int _wrap_setopt(lua_State *L)
Definition: plplotluacLUA_wrap.c:9453
SWIG_Lua_get_table
#define SWIG_Lua_get_table(L, n)
Definition: plplotluacLUA_wrap.c:1042
_wrap_vsta
static int _wrap_vsta(lua_State *L)
Definition: plplotluacLUA_wrap.c:11566
_wrap_PLGraphicsIn_subwindow_get
static int _wrap_PLGraphicsIn_subwindow_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3418
pllegend
#define pllegend
Definition: plplot.h:758
_wrap_plGetCursor
static int _wrap_plGetCursor(lua_State *L)
Definition: plplotluacLUA_wrap.c:12620
SWIG_Lua_get_class_metatable
SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L, const char *cname)
Definition: plplotluacLUA_wrap.c:1876
SWIG_LUA_INT
#define SWIG_LUA_INT
Definition: plplotluacLUA_wrap.c:927
mylabel_funcstr
static char mylabel_funcstr[255]
Definition: plplotluacLUA_wrap.c:3144
_wrap_pat
static int _wrap_pat(lua_State *L)
Definition: plplotluacLUA_wrap.c:7957
_wrap_PLGraphicsIn_dY_set
static int _wrap_PLGraphicsIn_dY_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3649
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplotluacLUA_wrap.c:3047
_wrap_scmap1la
static int _wrap_scmap1la(lua_State *L)
Definition: plplotluacLUA_wrap.c:8907
plshade
#define plshade
Definition: plplot.h:820
plscompression
#define plscompression
Definition: plplot.h:805
_wrap_scompression
static int _wrap_scompression(lua_State *L)
Definition: plplotluacLUA_wrap.c:9239
plarc
#define plarc
Definition: plplot.h:693
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
SWIG_Lua_create_class_registry
SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L)
Definition: plplotluacLUA_wrap.c:1822
_wrap_spause
static int _wrap_spause(lua_State *L)
Definition: plplotluacLUA_wrap.c:10382
swig_SwigModule_attributes
static swig_lua_attribute swig_SwigModule_attributes[]
Definition: plplotluacLUA_wrap.c:12686
SWIG_Lua_class_set
SWIGINTERN int SWIG_Lua_class_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:1707
_wrap_poin
static int _wrap_poin(lua_State *L)
Definition: plplotluacLUA_wrap.c:8036
SWIG_Lua_namespace_set
SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:1284
swig_lua_const_info::pvalue
void * pvalue
Definition: plplotluacLUA_wrap.c:953
PLcGrid::nz
PLINT nz
Definition: plplot.h:509
plot3dc
#define plot3dc
Definition: plplot.h:776
plot3dcl
#define plot3dcl
Definition: plplot.h:777
_wrap_arc
static int _wrap_arc(lua_State *L)
Definition: plplotluacLUA_wrap.c:3944
SWIG_TypeCmp
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
Definition: plplotluacLUA_wrap.c:380
SWIG_Lua_class_register
SWIGINTERN void SWIG_Lua_class_register(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:2371
pllsty
#define pllsty
Definition: plplot.h:763
_wrap_eop
static int _wrap_eop(lua_State *L)
Definition: plplotluacLUA_wrap.c:4814
SWIG_TypeName
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
Definition: plplotluacLUA_wrap.c:483
SWIG_Lua_init_base_class
SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:1891
plsmin
#define plsmin
Definition: plplot.h:829
plwind
#define plwind
Definition: plplot.h:864
plclear
#define plclear
Definition: plplot.h:701
plfill
#define plfill
Definition: plplot.h:717
plconfigtime
#define plconfigtime
Definition: plplot.h:705
plsurf3dl
#define plsurf3dl
Definition: plplot.h:848
SWIG_get_ptr_array_var
SWIGINTERN void ** SWIG_get_ptr_array_var(lua_State *L, int index, int *size, swig_type_info *type)
Definition: plplotluacLUA_wrap.c:2860
SWIG_Lua_dostring
SWIGINTERN int SWIG_Lua_dostring(lua_State *L, const char *str)
Definition: plplotluacLUA_wrap.c:2629
_wrap_gdev
static int _wrap_gdev(lua_State *L)
Definition: plplotluacLUA_wrap.c:5372
_wrap_mapline
static int _wrap_mapline(lua_State *L)
Definition: plplotluacLUA_wrap.c:11756
plmapline
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:594
_wrap_scolbg
static int _wrap_scolbg(lua_State *L)
Definition: plplotluacLUA_wrap.c:9167
plbtime
#define plbtime
Definition: plplot.h:699
pl_setcontlabelparam
#define pl_setcontlabelparam
Definition: plplot.h:691
SWIG_DOSTRING_FAIL
#define SWIG_DOSTRING_FAIL(S)
Definition: plplotluacLUA_wrap.c:2621
_wrap_szax
static int _wrap_szax(lua_State *L)
Definition: plplotluacLUA_wrap.c:11123
LUA_DECLARE_TYPEMAP_ARR_FN
#define LUA_DECLARE_TYPEMAP_ARR_FN(NAME, TYPE)
Definition: plplotluacLUA_wrap.c:2687
swig_lua_const_info::type
int type
Definition: plplotluacLUA_wrap.c:949
_wrap_vpas
static int _wrap_vpas(lua_State *L)
Definition: plplotluacLUA_wrap.c:11507
_wrap_plClearOpts
static int _wrap_plClearOpts(lua_State *L)
Definition: plplotluacLUA_wrap.c:12493
_wrap_scol0a
static int _wrap_scol0a(lua_State *L)
Definition: plplotluacLUA_wrap.c:9136
_wrap_PLGraphicsIn_pY_set
static int _wrap_PLGraphicsIn_pY_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3549
swig_lua_class::cls_static
swig_lua_namespace * cls_static
Definition: plplotluacLUA_wrap.c:985
_swigt__p_p_double
static swig_type_info _swigt__p_p_double
Definition: plplotluacLUA_wrap.c:13089
plscolbg
#define plscolbg
Definition: plplot.h:802
swig_type_info::dcast
swig_dycast_func dcast
Definition: plplotluacLUA_wrap.c:331
_wrap_PLGraphicsIn_dX_set
static int _wrap_PLGraphicsIn_dX_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3599
swig_type_info::cast
struct swig_cast_info * cast
Definition: plplotluacLUA_wrap.c:332
plfont
#define plfont
Definition: plplot.h:720
_wrap_PLGraphicsIn_type_get
static int _wrap_PLGraphicsIn_type_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3215
plstyl
#define plstyl
Definition: plplot.h:846
plpoly3
#define plpoly3
Definition: plplot.h:782
SWIG_ConvertPtr
#define SWIG_ConvertPtr(L, idx, ptr, type, flags)
Definition: plplotluacLUA_wrap.c:1012
swig_lua_class::type
swig_type_info ** type
Definition: plplotluacLUA_wrap.c:980
plimage
#define plimage
Definition: plplot.h:753
swig_cast_info::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:339
_wrap_lightsource
static int _wrap_lightsource(lua_State *L)
Definition: plplotluacLUA_wrap.c:6903
SWIG_TypeCheck
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
Definition: plplotluacLUA_wrap.c:407
plfontld
#define plfontld
Definition: plplot.h:721
SWIG_RUNTIME_VERSION
#define SWIG_RUNTIME_VERSION
Definition: plplotluacLUA_wrap.c:152
_wrap_image
static int _wrap_image(lua_State *L)
Definition: plplotluacLUA_wrap.c:12121
plscolbga
#define plscolbga
Definition: plplot.h:803
SWIGRUNTIMEINLINE
#define SWIGRUNTIMEINLINE
Definition: plplotluacLUA_wrap.c:177
plbin
#define plbin
Definition: plplot.h:695
_wrap_plot3dcl
static int _wrap_plot3dcl(lua_State *L)
Definition: plplotluacLUA_wrap.c:7518
_wrap_setcontlabelformat
static int _wrap_setcontlabelformat(lua_State *L)
Definition: plplotluacLUA_wrap.c:3875
plsdiori
#define plsdiori
Definition: plplot.h:809
_wrap_PLGraphicsIn_dY_get
static int _wrap_PLGraphicsIn_dY_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3675
SWIG_Lua_NewPointerObj
SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L, void *ptr, swig_type_info *type, int own)
Definition: plplotluacLUA_wrap.c:2461
plmeridians
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
plparseopts
#define plparseopts
Definition: plplot.h:778
plmaptex
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:639
SWIGRUNTIME
#define SWIGRUNTIME
Definition: plplotluacLUA_wrap.c:173
plsym
#define plsym
Definition: plplot.h:853
_wrap_scol0
static int _wrap_scol0(lua_State *L)
Definition: plplotluacLUA_wrap.c:9108
swig_lua_const_info::name
char * name
Definition: plplotluacLUA_wrap.c:950
plscmap1
#define plscmap1
Definition: plplot.h:794
_wrap_poin3
static int _wrap_poin3(lua_State *L)
Definition: plplotluacLUA_wrap.c:8088
plinit
#define plinit
Definition: plplot.h:755
lua_rawsetp
#define lua_rawsetp(L, index, ptr)
Definition: plplotluacLUA_wrap.c:882
plctime
#define plctime
Definition: plplot.h:708
pltimefmt
#define pltimefmt
Definition: plplot.h:856
SWIG_Lua_class_tostring
SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L)
Definition: plplotluacLUA_wrap.c:1753
plscmap1n
#define plscmap1n
Definition: plplot.h:798
_wrap_gcol0
static int _wrap_gcol0(lua_State *L)
Definition: plplotluacLUA_wrap.c:5226
_wrap_prec
static int _wrap_prec(lua_State *L)
Definition: plplotluacLUA_wrap.c:8246
plbop
#define plbop
Definition: plplot.h:696
_wrap_scolbga
static int _wrap_scolbga(lua_State *L)
Definition: plplotluacLUA_wrap.c:9192
_wrap_plend
static int _wrap_plend(lua_State *L)
Definition: plplotluacLUA_wrap.c:4714
plplotc.pltr0
def pltr0
Definition: plplotc.py:101
_wrap_slabelfunc
static int _wrap_slabelfunc(lua_State *L)
Definition: plplotluacLUA_wrap.c:10200
plabort
void plabort(PLCHAR_VECTOR errormsg)
Definition: plctrl.c:1894
_wrap_plOptUsage
static int _wrap_plOptUsage(lua_State *L)
Definition: plplotluacLUA_wrap.c:12547
plsdiplt
#define plsdiplt
Definition: plplot.h:810
plsvect
#define plsvect
Definition: plplot.h:849
plscmap1a
#define plscmap1a
Definition: plplot.h:795
plssub
#define plssub
Definition: plplot.h:836
_wrap_start
static int _wrap_start(lua_State *L)
Definition: plplotluacLUA_wrap.c:10486
_swigt__p_int
static swig_type_info _swigt__p_int
Definition: plplotluacLUA_wrap.c:13087
_swigt__p_double
static swig_type_info _swigt__p_double
Definition: plplotluacLUA_wrap.c:13081
PLPointer
void * PLPointer
Definition: plplot.h:209
plspal1
#define plspal1
Definition: plplot.h:833
swig_lua_userdata::ptr
void * ptr
Definition: plplotluacLUA_wrap.c:996
plsetopt
#define plsetopt
Definition: plplot.h:815
_wrap_lab
static int _wrap_lab(lua_State *L)
Definition: plplotluacLUA_wrap.c:6146
plmeshc
#define plmeshc
Definition: plplot.h:771
plgcompression
#define plgcompression
Definition: plplot.h:728
_wrap_sesc
static int _wrap_sesc(lua_State *L)
Definition: plplotluacLUA_wrap.c:9434
SWIG_DECLARE_TYPEMAP_ARR_FN
#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME, TYPE)
Definition: plplotluacLUA_wrap.c:2765
SWIG_GetModule
#define SWIG_GetModule(clientdata)
Definition: plplotluacLUA_wrap.c:1019
plszax
#define plszax
Definition: plplot.h:854
plvsta
#define plvsta
Definition: plplot.h:861
_wrap_map
static int _wrap_map(lua_State *L)
Definition: plplotluacLUA_wrap.c:11701
SWIG_Lua_class_register_instance
SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:2289
_swigt__p_f_int_p_double_p_double__void
static swig_type_info _swigt__p_f_int_p_double_p_double__void
Definition: plplotluacLUA_wrap.c:13085
_wrap_replot
static int _wrap_replot(lua_State *L)
Definition: plplotluacLUA_wrap.c:8387
SWIG_Lua_class_get
SWIGINTERN int SWIG_Lua_class_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:1618
_wrap_gcolbga
static int _wrap_gcolbga(lua_State *L)
Definition: plplotluacLUA_wrap.c:5320
swig_lua_const_info
Definition: plplotluacLUA_wrap.c:948
SWIG_itable_size
SWIGINTERN int SWIG_itable_size(lua_State *L, int index)
Definition: plplotluacLUA_wrap.c:2740
plgpage
#define plgpage
Definition: plplot.h:739
plaxes
#define plaxes
Definition: plplot.h:694
plsori
#define plsori
Definition: plplot.h:830
mapform_funcstr
static char mapform_funcstr[255]
Definition: plplotluacLUA_wrap.c:2981
plgdiplt
#define plgdiplt
Definition: plplot.h:732
plscmap0a
#define plscmap0a
Definition: plplot.h:792
lua_rawlen
#define lua_rawlen
Definition: plplotluacLUA_wrap.c:862
PLcGrid2::ny
PLINT ny
Definition: plplot.h:521
swig_PLGraphicsIn_base_names
static const char * swig_PLGraphicsIn_base_names[]
Definition: plplotluacLUA_wrap.c:3872
plfamadv
#define plfamadv
Definition: plplot.h:716
_wrap_gcolbg
static int _wrap_gcolbg(lua_State *L)
Definition: plplotluacLUA_wrap.c:5292
_wrap_schr
static int _wrap_schr(lua_State *L)
Definition: plplotluacLUA_wrap.c:8440
SWIG_Lua_class_disown
SWIGINTERN int SWIG_Lua_class_disown(lua_State *L)
Definition: plplotluacLUA_wrap.c:1772
swig_module_info::size
size_t size
Definition: plplotluacLUA_wrap.c:350
_wrap_randd
static int _wrap_randd(lua_State *L)
Definition: plplotluacLUA_wrap.c:8370
plend
#define plend
Definition: plplot.h:709
SWIG_Lua_ConvertPtr
SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L, int index, void **ptr, swig_type_info *type, int flags)
Definition: plplotluacLUA_wrap.c:2479
_wrap_poly3
static int _wrap_poly3(lua_State *L)
Definition: plplotluacLUA_wrap.c:8158
SWIG_Lua_iterate_bases
SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info *SWIGUNUSED swig_type, int first_arg, swig_lua_base_iterator_func func, int *const ret)
Definition: plplotluacLUA_wrap.c:1428
SWIG_TypeCheckStruct
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
Definition: plplotluacLUA_wrap.c:434
swig_lua_class::attributes
swig_lua_attribute * attributes
Definition: plplotluacLUA_wrap.c:984
SWIG_Lua_class_register_static
SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:2255
SWIG_Lua_populate_inheritable_metamethods
SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L)
Definition: plplotluacLUA_wrap.c:1802
_wrap_string3
static int _wrap_string3(lua_State *L)
Definition: plplotluacLUA_wrap.c:10604
_swigt__p_f_double_double_p_double_p_double_p_void__void
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
Definition: plplotluacLUA_wrap.c:13083
SWIG_TypeEquiv
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
Definition: plplotluacLUA_wrap.c:399
_wrap_PLGraphicsIn_wY_get
static int _wrap_PLGraphicsIn_wY_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3775
_wrap_stripa
static int _wrap_stripa(lua_State *L)
Definition: plplotluacLUA_wrap.c:10674
swig_lua_attribute::setmethod
lua_CFunction setmethod
Definition: plplotluacLUA_wrap.c:962
defined_func
PLINT(* defined_func)(PLFLT, PLFLT)
Definition: plplotluacLUA_wrap.c:3043
SWIGUNUSED
#define SWIGUNUSED
Definition: plplotluacLUA_wrap.c:57
plgfont
#define plgfont
Definition: plplot.h:737
plplotc.plSetUsage
def plSetUsage
Definition: plplotc.py:8456
SWIG_Lua_namespace_register
SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg)
Definition: plplotluacLUA_wrap.c:1368
SWIG_init
#define SWIG_init
Definition: plplotluacLUA_wrap.c:2674
_wrap_PLGraphicsIn_state_set
static int _wrap_PLGraphicsIn_state_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3239
plend1
#define plend1
Definition: plplot.h:710
PLINT
int PLINT
Definition: plplot.h:181
plenv0
#define plenv0
Definition: plplot.h:712
_wrap_mapstring
static int _wrap_mapstring(lua_State *L)
Definition: plplotluacLUA_wrap.c:11834
_wrap_sdiori
static int _wrap_sdiori(lua_State *L)
Definition: plplotluacLUA_wrap.c:9339
_wrap_erry
static int _wrap_erry(lua_State *L)
Definition: plplotluacLUA_wrap.c:4897
SWIG_Lua_add_variable
SWIGINTERN void SWIG_Lua_add_variable(lua_State *L, const char *name, lua_CFunction getFn, lua_CFunction setFn)
Definition: plplotluacLUA_wrap.c:1973
plgdiori
#define plgdiori
Definition: plplot.h:731
swig_lua_const_info::lvalue
long lvalue
Definition: plplotluacLUA_wrap.c:951
SWIG_TypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplotluacLUA_wrap.c:588
plshades
#define plshades
Definition: plplot.h:824
_wrap_scmap1n
static int _wrap_scmap1n(lua_State *L)
Definition: plplotluacLUA_wrap.c:9043
PLBOOL
PLINT PLBOOL
Definition: plplot.h:204
SWIG_LUA_FLOAT
#define SWIG_LUA_FLOAT
Definition: plplotluacLUA_wrap.c:928
SWIG_fail_arg
#define SWIG_fail_arg(func_name, argnum, type)
Definition: plplotluacLUA_wrap.c:1030
swig_lua_attribute::getmethod
lua_CFunction getmethod
Definition: plplotluacLUA_wrap.c:961
lua_rawgetp
#define lua_rawgetp(L, index, ptr)
Definition: plplotluacLUA_wrap.c:887
SWIG_FREE_ARRAY
#define SWIG_FREE_ARRAY(PTR)
Definition: plplotluacLUA_wrap.c:2737
_wrap_meshc
static int _wrap_meshc(lua_State *L)
Definition: plplotluacLUA_wrap.c:7148
_swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_PLGraphicsIn
Definition: plplotluacLUA_wrap.c:13079
SWIG_Lua_add_class_instance_details
SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:2007
_wrap_PLGraphicsIn_wX_set
static int _wrap_PLGraphicsIn_wX_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3699
plssym
#define plssym
Definition: plplot.h:837
_wrap_smaj
static int _wrap_smaj(lua_State *L)
Definition: plplotluacLUA_wrap.c:10244
swig_lua_namespace
Definition: plplotluacLUA_wrap.c:968
PLcGrid2::yg
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
pljoin
#define pljoin
Definition: plplot.h:756
plgzax
#define plgzax
Definition: plplot.h:750
_wrap_sori
static int _wrap_sori(lua_State *L)
Definition: plplotluacLUA_wrap.c:10288
_wrap_surf3d
static int _wrap_surf3d(lua_State *L)
Definition: plplotluacLUA_wrap.c:7653
_wrap_line
static int _wrap_line(lua_State *L)
Definition: plplotluacLUA_wrap.c:6928
SWIGEXPORT
#define SWIGEXPORT
Definition: plplotluacLUA_wrap.c:105
SWIG_Lua_add_namespace_classes
SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
Definition: plplotluacLUA_wrap.c:1346
SWIG_Lua_ConvertPacked
SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L, int index, void *ptr, size_t size, swig_type_info *type)
Definition: plplotluacLUA_wrap.c:2531
_wrap_new_PLGraphicsIn
static int _wrap_new_PLGraphicsIn(lua_State *L)
Definition: plplotluacLUA_wrap.c:3799
plgfam
#define plgfam
Definition: plplot.h:734
PLcGrid::ny
PLINT ny
Definition: plplot.h:509
plgdidev
#define plgdidev
Definition: plplot.h:730
_wrap_col1
static int _wrap_col1(lua_State *L)
Definition: plplotluacLUA_wrap.c:4290
_wrap_legend
static int _wrap_legend(lua_State *L)
Definition: plplotluacLUA_wrap.c:6171
plstar
#define plstar
Definition: plplot.h:838
_wrap_stransform
static int _wrap_stransform(lua_State *L)
Definition: plplotluacLUA_wrap.c:10511
SWIG_LUA_CONSTTAB_FLOAT
#define SWIG_LUA_CONSTTAB_FLOAT(B, C)
Definition: plplotluacLUA_wrap.c:822
_wrap_glevel
static int _wrap_glevel(lua_State *L)
Definition: plplotluacLUA_wrap.c:5582
_swigc__p_f_int_p_double_p_double__void
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
Definition: plplotluacLUA_wrap.c:13113
plcpstrm
#define plcpstrm
Definition: plplot.h:707
swig_lua_class::name
const char * name
Definition: plplotluacLUA_wrap.c:978
plimagefr
#define plimagefr
Definition: plplot.h:754
plcalc_world
#define plcalc_world
Definition: plplot.h:700
mypltr
void mypltr(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
_swigc__p_double
static swig_cast_info _swigc__p_double[]
Definition: plplotluacLUA_wrap.c:13109
lua_pushglobaltable
#define lua_pushglobaltable(L)
Definition: plplotluacLUA_wrap.c:872
plsfnam
#define plsfnam
Definition: plplot.h:818
swig_lua_rawdata::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:1005
plhist
#define plhist
Definition: plplot.h:751
_wrap_font
static int _wrap_font(lua_State *L)
Definition: plplotluacLUA_wrap.c:5164
PLcGrid
Definition: plplot.h:506
_wrap_scmap1
static int _wrap_scmap1(lua_State *L)
Definition: plplotluacLUA_wrap.c:8635
swig_PLGraphicsIn_meta
static swig_lua_method swig_PLGraphicsIn_meta[]
Definition: plplotluacLUA_wrap.c:3846
swig_lua_rawdata
Definition: plplotluacLUA_wrap.c:1004
SWIG_InitializeModule
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
Definition: plplotluacLUA_wrap.c:13192
_wrap_ssym
static int _wrap_ssym(lua_State *L)
Definition: plplotluacLUA_wrap.c:10442
plgchr
#define plgchr
Definition: plplot.h:722
swig_module_info::next
struct swig_module_info * next
Definition: plplotluacLUA_wrap.c:351
SWIG_ERROR
#define SWIG_ERROR
Definition: plplotluacLUA_wrap.c:273
SWIGTYPE_p_PLGraphicsIn
#define SWIGTYPE_p_PLGraphicsIn
Definition: plplotluacLUA_wrap.c:2654
_wrap_path
static int _wrap_path(lua_State *L)
Definition: plplotluacLUA_wrap.c:8005
plsdidev
#define plsdidev
Definition: plplot.h:807
SWIG_Lua_SetModule
SWIGRUNTIME void SWIG_Lua_SetModule(lua_State *L, swig_module_info *module)
Definition: plplotluacLUA_wrap.c:1077
SWIG_SetModule
#define SWIG_SetModule(clientdata, pointer)
Definition: plplotluacLUA_wrap.c:1020
plspal0
#define plspal0
Definition: plplot.h:832
_wrap_scmap0n
static int _wrap_scmap0n(lua_State *L)
Definition: plplotluacLUA_wrap.c:8616
plfill3
#define plfill3
Definition: plplot.h:718
_wrap_box3
static int _wrap_box3(lua_State *L)
Definition: plplotluacLUA_wrap.c:4169
swig_lua_class::base_names
const char ** base_names
Definition: plplotluacLUA_wrap.c:988
_wrap_spal0
static int _wrap_spal0(lua_State *L)
Definition: plplotluacLUA_wrap.c:10341
SWIG_TypeNameComp
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
Definition: plplotluacLUA_wrap.c:365
_wrap_plend1
static int _wrap_plend1(lua_State *L)
Definition: plplotluacLUA_wrap.c:4730
swig_lua_attribute
Definition: plplotluacLUA_wrap.c:959
_wrap_gspa
static int _wrap_gspa(lua_State *L)
Definition: plplotluacLUA_wrap.c:5809
_wrap_plSetUsage
static int _wrap_plSetUsage(lua_State *L)
Definition: plplotluacLUA_wrap.c:12525
swig_PLGraphicsIn_Sf_SwigStatic_classes
static swig_lua_class * swig_PLGraphicsIn_Sf_SwigStatic_classes[]
Definition: plplotluacLUA_wrap.c:3859
swig_SwigModule_constants
static swig_lua_const_info swig_SwigModule_constants[]
Definition: plplotluacLUA_wrap.c:12689
_wrap_gfont
static int _wrap_gfont(lua_State *L)
Definition: plplotluacLUA_wrap.c:5554
_wrap_sdiplz
static int _wrap_sdiplz(lua_State *L)
Definition: plplotluacLUA_wrap.c:9386
_wrap_gdidev
static int _wrap_gdidev(lua_State *L)
Definition: plplotluacLUA_wrap.c:5397
swig_cast_info::converter
swig_converter_func converter
Definition: plplotluacLUA_wrap.c:340
_wrap_ptex3
static int _wrap_ptex3(lua_State *L)
Definition: plplotluacLUA_wrap.c:8321
plseed
#define plseed
Definition: plplot.h:813
_wrap_PLGraphicsIn_type_set
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3189
plplotc.plOptUsage
def plOptUsage
Definition: plplotc.py:8460
PLcGrid::yg
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
plstring
#define plstring
Definition: plplot.h:841
plstransform
#define plstransform
Definition: plplot.h:840
plvect
#define plvect
Definition: plplot.h:858
swig_lua_userdata::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:994
_wrap_adv
static int _wrap_adv(lua_State *L)
Definition: plplotluacLUA_wrap.c:3925
PLcGrid::zg
PLFLT_NC_FE_POINTER zg
Definition: plplot.h:508
mapform
void mapform(PLINT n, PLFLT *x, PLFLT *y)
Definition: plplotluacLUA_wrap.c:2983
_wrap_sfam
static int _wrap_sfam(lua_State *L)
Definition: plplotluacLUA_wrap.c:9476
plplotc.plResetOpts
def plResetOpts
Definition: plplotc.py:8452
PLcGrid2
Definition: plplot.h:518
plscmap1la
#define plscmap1la
Definition: plplot.h:797
plgfnam
#define plgfnam
Definition: plplot.h:736
_swigc__p_f_double_double_p_double_p_double_p_void__void
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
Definition: plplotluacLUA_wrap.c:13111
swig_lua_namespace
struct swig_lua_namespace swig_lua_namespace
SWIG_Lua_add_class_user_metamethod
SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index)
Definition: plplotluacLUA_wrap.c:2150
_wrap_vasp
static int _wrap_vasp(lua_State *L)
Definition: plplotluacLUA_wrap.c:11180
plcont
#define plcont
Definition: plplot.h:706
plsxax
#define plsxax
Definition: plplot.h:851
plstart
#define plstart
Definition: plplot.h:839
pleop
#define pleop
Definition: plplot.h:713
_swigt__p_p_char
static swig_type_info _swigt__p_p_char
Definition: plplotluacLUA_wrap.c:13088
plmesh
#define plmesh
Definition: plplot.h:770
_wrap_PLGraphicsIn_button_set
static int _wrap_PLGraphicsIn_button_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3341
_wrap_bop
static int _wrap_bop(lua_State *L)
Definition: plplotluacLUA_wrap.c:4119
plhlsrgb
#define plhlsrgb
Definition: plplot.h:752
swig_module_info::types
swig_type_info ** types
Definition: plplotluacLUA_wrap.c:349
_wrap_cont
static int _wrap_cont(lua_State *L)
Definition: plplotluacLUA_wrap.c:4358
plsmaj
#define plsmaj
Definition: plplot.h:826
PLcGrid2::nx
PLINT nx
Definition: plplot.h:521
SWIG_fail_ptr
#define SWIG_fail_ptr(func_name, argnum, type)
Definition: plplotluacLUA_wrap.c:1034
_wrap_plot3dc
static int _wrap_plot3dc(lua_State *L)
Definition: plplotluacLUA_wrap.c:7418
_wrap_surf3dl
static int _wrap_surf3dl(lua_State *L)
Definition: plplotluacLUA_wrap.c:7753
SWIG_Lua_GetModule
SWIGRUNTIME swig_module_info * SWIG_Lua_GetModule(lua_State *L)
Definition: plplotluacLUA_wrap.c:1066
read_double_Matrix
PLFLT ** read_double_Matrix(lua_State *L, int index, int *nx, int *ny)
Definition: plplotluacLUA_wrap.c:2891
SWIG_lua_isnilstring
SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx)
Definition: plplotluacLUA_wrap.c:3179
swig_PLGraphicsIn_bases
static swig_lua_class * swig_PLGraphicsIn_bases[]
Definition: plplotluacLUA_wrap.c:3871
plcol1
#define plcol1
Definition: plplot.h:703
swig_lua_base_iterator_func
int(* swig_lua_base_iterator_func)(lua_State *, swig_type_info *, int, int *ret)
Definition: plplotluacLUA_wrap.c:1426
pllab
#define pllab
Definition: plplot.h:757
pllightsource
#define pllightsource
Definition: plplot.h:759
swig_PLGraphicsIn_Sf_SwigStatic_methods
static swig_lua_method swig_PLGraphicsIn_Sf_SwigStatic_methods[]
Definition: plplotluacLUA_wrap.c:3856
SWIG_Lua_add_class_static_details
SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:1990
SWIGINTERN
#define SWIGINTERN
Definition: plplotluacLUA_wrap.c:77
plbox
#define plbox
Definition: plplot.h:697
swig_PLGraphicsIn_Sf_SwigStatic
static swig_lua_namespace swig_PLGraphicsIn_Sf_SwigStatic
Definition: plplotluacLUA_wrap.c:3863
SWIG_init_user
#define SWIG_init_user
Definition: plplotluacLUA_wrap.c:2675
SWIG_TypeCast
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
Definition: plplotluacLUA_wrap.c:461
swig_lua_class::constructor
lua_CFunction constructor
Definition: plplotluacLUA_wrap.c:981
pltext
#define pltext
Definition: plplot.h:855
swig_lua_rawdata::own
int own
Definition: plplotluacLUA_wrap.c:1006
swig_cast_info
Definition: plplotluacLUA_wrap.c:338
_wrap_lsty
static int _wrap_lsty(lua_State *L)
Definition: plplotluacLUA_wrap.c:7044
plwidth
#define plwidth
Definition: plplot.h:863
plgver
#define plgver
Definition: plplot.h:745
_wrap_smin
static int _wrap_smin(lua_State *L)
Definition: plplotluacLUA_wrap.c:10266
_wrap_mkstrm
static int _wrap_mkstrm(lua_State *L)
Definition: plplotluacLUA_wrap.c:7248
plscol0a
#define plscol0a
Definition: plplot.h:801
_swigc__p_p_char
static swig_cast_info _swigc__p_p_char[]
Definition: plplotluacLUA_wrap.c:13116
_wrap_wind
static int _wrap_wind(lua_State *L)
Definition: plplotluacLUA_wrap.c:11650
plptex3
#define plptex3
Definition: plplot.h:786
_wrap_vect
static int _wrap_vect(lua_State *L)
Definition: plplotluacLUA_wrap.c:11199
_wrap_cpstrm
static int _wrap_cpstrm(lua_State *L)
Definition: plplotluacLUA_wrap.c:4692
_proxy__wrap_new_PLGraphicsIn
static int _proxy__wrap_new_PLGraphicsIn(lua_State *L)
Definition: plplotluacLUA_wrap.c:3820
plsdiplz
#define plsdiplz
Definition: plplot.h:811
value
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
_wrap_sfci
static int _wrap_sfci(lua_State *L)
Definition: plplotluacLUA_wrap.c:9501
_wrap_text
static int _wrap_text(lua_State *L)
Definition: plplotluacLUA_wrap.c:11145
_wrap_parseopts
static int _wrap_parseopts(lua_State *L)
Definition: plplotluacLUA_wrap.c:7888
SWIG_TYPE_TABLE_NAME
#define SWIG_TYPE_TABLE_NAME
Definition: plplotluacLUA_wrap.c:160
plspause
#define plspause
Definition: plplot.h:834
SWIG_Lua_typename
SWIGRUNTIME const char * SWIG_Lua_typename(lua_State *L, int tp)
Definition: plplotluacLUA_wrap.c:2545
_wrap_hist
static int _wrap_hist(lua_State *L)
Definition: plplotluacLUA_wrap.c:6022
Ylen
static PLINT Ylen
Definition: plplotluacLUA_wrap.c:2729
plline3
#define plline3
Definition: plplot.h:762
mypltr_funcstr
static char mypltr_funcstr[255]
Definition: plplotluacLUA_wrap.c:3056
plstripd
#define plstripd
Definition: plplot.h:845
plgfci
#define plgfci
Definition: plplot.h:735
plgspa
#define plgspa
Definition: plplot.h:743
plgcolbg
#define plgcolbg
Definition: plplot.h:726
SWIG_Lua_AddMetatable
SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L, swig_type_info *type)
Definition: plplotluacLUA_wrap.c:2444
plstripc
#define plstripc
Definition: plplot.h:844
_wrap_gpage
static int _wrap_gpage(lua_State *L)
Definition: plplotluacLUA_wrap.c:5602
swig_type_info::str
const char * str
Definition: plplotluacLUA_wrap.c:330
swig_lua_var_info::name
const char * name
Definition: plplotluacLUA_wrap.c:936
SWIG_TypeNewClientData
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
Definition: plplotluacLUA_wrap.c:529
plstripa
#define plstripa
Definition: plplot.h:843
SWIG_LUA_STRING
#define SWIG_LUA_STRING
Definition: plplotluacLUA_wrap.c:929
_wrap_mapfill
static int _wrap_mapfill(lua_State *L)
Definition: plplotluacLUA_wrap.c:11985
_wrap_svpa
static int _wrap_svpa(lua_State *L)
Definition: plplotluacLUA_wrap.c:10999
plstring3
#define plstring3
Definition: plplot.h:842
Alen
static PLINT Alen
Definition: plplotluacLUA_wrap.c:2728
SWIG_NewMemberObj
#define SWIG_NewMemberObj(L, ptr, sz, type)
Definition: plplotluacLUA_wrap.c:1016
plvpas
#define plvpas
Definition: plplot.h:859
myct
void myct(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
plplotc.plMinMax2dGrid
def plMinMax2dGrid
Definition: plplotc.py:8464
_swigt__p_f_int_double_p_char_int_p_void__void
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
Definition: plplotluacLUA_wrap.c:13084
plsfont
#define plsfont
Definition: plplot.h:819
plmapfill
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:661
_wrap_fill
static int _wrap_fill(lua_State *L)
Definition: plplotluacLUA_wrap.c:4980
SWIG_table_size
SWIGINTERN int SWIG_table_size(lua_State *L, int index)
Definition: plplotluacLUA_wrap.c:2753
_wrap_gver
static int _wrap_gver(lua_State *L)
Definition: plplotluacLUA_wrap.c:5861
_wrap_gfci
static int _wrap_gfci(lua_State *L)
Definition: plplotluacLUA_wrap.c:5509
_wrap_famadv
static int _wrap_famadv(lua_State *L)
Definition: plplotluacLUA_wrap.c:4964
_wrap_fontld
static int _wrap_fontld(lua_State *L)
Definition: plplotluacLUA_wrap.c:5183
plpsty
#define plpsty
Definition: plplot.h:784
_wrap_sym
static int _wrap_sym(lua_State *L)
Definition: plplotluacLUA_wrap.c:11071
_wrap_gyax
static int _wrap_gyax(lua_State *L)
Definition: plplotluacLUA_wrap.c:5974
SWIG_TypeClientData
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
Definition: plplotluacLUA_wrap.c:513
SWIG_Lua_type
SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
Definition: plplotluacLUA_wrap.c:2559
SWIG_UnpackData
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
Definition: plplotluacLUA_wrap.c:633
plgvpd
#define plgvpd
Definition: plplot.h:746
plpoin
#define plpoin
Definition: plplot.h:780
plgriddata
#define plgriddata
Definition: plplot.h:742
plgvpw
#define plgvpw
Definition: plplot.h:747
_wrap_plResetOpts
static int _wrap_plResetOpts(lua_State *L)
Definition: plplotluacLUA_wrap.c:12509
_wrap_PLGraphicsIn_state_get
static int _wrap_PLGraphicsIn_state_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3266
SWIG_NewPointerObj
#define SWIG_NewPointerObj(L, ptr, type, owner)
Definition: plplotluacLUA_wrap.c:1011
swig_lua_namespace::ns_namespaces
struct swig_lua_namespace ** ns_namespaces
Definition: plplotluacLUA_wrap.c:974
_wrap_ptex
static int _wrap_ptex(lua_State *L)
Definition: plplotluacLUA_wrap.c:8287
SWIG_Lua_class_destruct
SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L)
Definition: plplotluacLUA_wrap.c:1732
_wrap_env
static int _wrap_env(lua_State *L)
Definition: plplotluacLUA_wrap.c:4746
SWIG_ALLOC_ARRAY
#define SWIG_ALLOC_ARRAY(TYPE, LEN)
Definition: plplotluacLUA_wrap.c:2736
_wrap_mesh
static int _wrap_mesh(lua_State *L)
Definition: plplotluacLUA_wrap.c:7063
SWIG_MangledTypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplotluacLUA_wrap.c:543
_wrap_maptex
static int _wrap_maptex(lua_State *L)
Definition: plplotluacLUA_wrap.c:11915
SWIG_read_ptr_array
SWIGINTERN int SWIG_read_ptr_array(lua_State *L, int index, void **array, int size, swig_type_info *type)
Definition: plplotluacLUA_wrap.c:2834
_wrap_gvpw
static int _wrap_gvpw(lua_State *L)
Definition: plplotluacLUA_wrap.c:5918
SWIG_Lua_add_function
#define SWIG_Lua_add_function(L, n, f)
Definition: plplotluacLUA_wrap.c:1045
_wrap_w3d
static int _wrap_w3d(lua_State *L)
Definition: plplotluacLUA_wrap.c:11582
_wrap_griddata
static int _wrap_griddata(lua_State *L)
Definition: plplotluacLUA_wrap.c:5658
swig_converter_func
void *(* swig_converter_func)(void *, int *)
Definition: plplotluacLUA_wrap.c:324
_wrap_MinMax2dGrid
static int _wrap_MinMax2dGrid(lua_State *L)
Definition: plplotluacLUA_wrap.c:12563
SWIG_PackDataName
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
Definition: plplotluacLUA_wrap.c:685
plmkstrm
#define plmkstrm
Definition: plplot.h:772
PL_UNUSED
#define PL_UNUSED(x)
Definition: plplot.h:138
swig_SwigModule_methods
static swig_lua_method swig_SwigModule_methods[]
Definition: plplotluacLUA_wrap.c:12877
PLFLT
float PLFLT
Definition: plplot.h:163
mylabel
void mylabel(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
plscol0
#define plscol0
Definition: plplot.h:800
swig_module_info
struct swig_module_info swig_module_info
plplotc.pltr2
def pltr2
Definition: plplotc.py:109
swig_type_info
Definition: plplotluacLUA_wrap.c:328
_wrap_warn
static int _wrap_warn(lua_State *L)
Definition: plplotluacLUA_wrap.c:12644
plxormod
#define plxormod
Definition: plplot.h:865
_wrap_mtex
static int _wrap_mtex(lua_State *L)
Definition: plplotluacLUA_wrap.c:7268
swig_lua_class::methods
swig_lua_method * methods
Definition: plplotluacLUA_wrap.c:983
_wrap_flush
static int _wrap_flush(lua_State *L)
Definition: plplotluacLUA_wrap.c:5148
plflush
#define plflush
Definition: plplot.h:719
plerrx
#define plerrx
Definition: plplot.h:714
PLcGrid2::zg
PLFLT_NC_MATRIX zg
Definition: plplot.h:520
SWIG_TypePrettyName
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
Definition: plplotluacLUA_wrap.c:492
SWIG_LUACODE
#define SWIG_LUACODE
Definition: plplotluacLUA_wrap.c:2677
SWIG_LUA_CHAR
#define SWIG_LUA_CHAR
Definition: plplotluacLUA_wrap.c:932
_wrap_configtime
static int _wrap_configtime(lua_State *L)
Definition: plplotluacLUA_wrap.c:4309
plgcol0a
#define plgcol0a
Definition: plplot.h:725
swig_types
static swig_type_info * swig_types[13]
Definition: plplotluacLUA_wrap.c:2666
_wrap_sxax
static int _wrap_sxax(lua_State *L)
Definition: plplotluacLUA_wrap.c:11027
SWIG_Lua_resolve_metamethod
SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L)
Definition: plplotluacLUA_wrap.c:2113
SWIG_Lua_class_do_set
SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret)
Definition: plplotluacLUA_wrap.c:1645
SWIG_PropagateClientData
SWIGRUNTIME void SWIG_PropagateClientData(void)
Definition: plplotluacLUA_wrap.c:13340
plgcolbga
#define plgcolbga
Definition: plplot.h:727
_swigc__p_f_int_p_q_const__double_p_q_const__double__void
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
Definition: plplotluacLUA_wrap.c:13114
SWIG_Lua_add_boolean
#define SWIG_Lua_add_boolean(L, n, b)
Definition: plplotluacLUA_wrap.c:1050
_wrap_init
static int _wrap_init(lua_State *L)
Definition: plplotluacLUA_wrap.c:6102
_wrap_shades
static int _wrap_shades(lua_State *L)
Definition: plplotluacLUA_wrap.c:9565
plgyax
#define plgyax
Definition: plplot.h:749
plsesc
#define plsesc
Definition: plplot.h:814
_swigt__p_f_int_p_q_const__double_p_q_const__double__void
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
Definition: plplotluacLUA_wrap.c:13086
_wrap_gzax
static int _wrap_gzax(lua_State *L)
Definition: plplotluacLUA_wrap.c:5998
SWIG_isptrtype
#define SWIG_isptrtype(L, I)
Definition: plplotluacLUA_wrap.c:1056
swig_lua_namespace::ns_constants
swig_lua_const_info * ns_constants
Definition: plplotluacLUA_wrap.c:972
plenv
#define plenv
Definition: plplot.h:711
_wrap_star
static int _wrap_star(lua_State *L)
Definition: plplotluacLUA_wrap.c:10464
SWIG_LUA_BINARY
#define SWIG_LUA_BINARY
Definition: plplotluacLUA_wrap.c:931
swig_cast_initial
static swig_cast_info * swig_cast_initial[]
Definition: plplotluacLUA_wrap.c:13120
_wrap_scmap1l
static int _wrap_scmap1l(lua_State *L)
Definition: plplotluacLUA_wrap.c:8789
swig_cast_info::next
struct swig_cast_info * next
Definition: plplotluacLUA_wrap.c:341
_wrap_meridians
static int _wrap_meridians(lua_State *L)
Definition: plplotluacLUA_wrap.c:12063
swig_lua_class
struct swig_lua_class swig_lua_class
swig_type_info::owndata
int owndata
Definition: plplotluacLUA_wrap.c:334
swig_lua_namespace::ns_methods
swig_lua_method * ns_methods
Definition: plplotluacLUA_wrap.c:970
_swigc__p_int
static swig_cast_info _swigc__p_int[]
Definition: plplotluacLUA_wrap.c:13115
plgcmap1_range
#define plgcmap1_range
Definition: plplot.h:723
swig_lua_userdata
Definition: plplotluacLUA_wrap.c:993
plcol0
#define plcol0
Definition: plplot.h:702
_wrap_PLGraphicsIn_pX_set
static int _wrap_PLGraphicsIn_pX_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3499
swig_lua_class
Definition: plplotluacLUA_wrap.c:977
_wrap_gcompression
static int _wrap_gcompression(lua_State *L)
Definition: plplotluacLUA_wrap.c:5352
plbox3
#define plbox3
Definition: plplot.h:698
_wrap_ctime
static int _wrap_ctime(lua_State *L)
Definition: plplotluacLUA_wrap.c:4654
swig_dycast_func
struct swig_type_info *(* swig_dycast_func)(void **)
Definition: plplotluacLUA_wrap.c:325
_wrap_scmap0
static int _wrap_scmap0(lua_State *L)
Definition: plplotluacLUA_wrap.c:8462
LUA_FREE_ARRAY
#define LUA_FREE_ARRAY(PTR)
Definition: plplotluacLUA_wrap.c:2683
SWIG_CheckState
#define SWIG_CheckState(r)
Definition: plplotluacLUA_wrap.c:314
_wrap_timefmt
static int _wrap_timefmt(lua_State *L)
Definition: plplotluacLUA_wrap.c:11161
plcolorbar
#define plcolorbar
Definition: plplot.h:704
_wrap_axes
static int _wrap_axes(lua_State *L)
Definition: plplotluacLUA_wrap.c:3984
Xlen
static PLINT Xlen
Definition: plplotluacLUA_wrap.c:2729
_wrap_gcmap1_range
static int _wrap_gcmap1_range(lua_State *L)
Definition: plplotluacLUA_wrap.c:9084
_swigc__p_p_double
static swig_cast_info _swigc__p_p_double[]
Definition: plplotluacLUA_wrap.c:13117
LUA_ALLOC_ARRAY
#define LUA_ALLOC_ARRAY(TYPE, LEN)
Definition: plplotluacLUA_wrap.c:2682
swig_lua_var_info
Definition: plplotluacLUA_wrap.c:935
_wrap_stripd
static int _wrap_stripd(lua_State *L)
Definition: plplotluacLUA_wrap.c:10860
plglevel
#define plglevel
Definition: plplot.h:738
PLcGrid::xg
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
_wrap_PLGraphicsIn_pY_get
static int _wrap_PLGraphicsIn_pY_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3575
_wrap_class_PLGraphicsIn
static swig_lua_class _wrap_class_PLGraphicsIn
Definition: plplotluacLUA_wrap.c:3873
_swigt__p_unsigned_int
static swig_type_info _swigt__p_unsigned_int
Definition: plplotluacLUA_wrap.c:13090
_swigt__p_f_double_double__int
static swig_type_info _swigt__p_f_double_double__int
Definition: plplotluacLUA_wrap.c:13082
swig_lua_namespace::name
const char * name
Definition: plplotluacLUA_wrap.c:969
SWIG_Lua_class_do_get_item
SWIGINTERN int SWIG_Lua_class_do_get_item(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
Definition: plplotluacLUA_wrap.c:1528
_wrap_sdev
static int _wrap_sdev(lua_State *L)
Definition: plplotluacLUA_wrap.c:9258
_wrap_stripc
static int _wrap_stripc(lua_State *L)
Definition: plplotluacLUA_wrap.c:10702
SWIG_LUA_POINTER
#define SWIG_LUA_POINTER
Definition: plplotluacLUA_wrap.c:930
plpoin3
#define plpoin3
Definition: plplot.h:781
_wrap_PLGraphicsIn_keysym_get
static int _wrap_PLGraphicsIn_keysym_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3317
_wrap_gxax
static int _wrap_gxax(lua_State *L)
Definition: plplotluacLUA_wrap.c:5950
plwarn
void plwarn(PLCHAR_VECTOR errormsg)
Definition: plctrl.c:1863
_wrap_PLGraphicsIn_string_get
static int _wrap_PLGraphicsIn_string_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3475
plscmap0n
#define plscmap0n
Definition: plplot.h:793
SWIG_AddCast
#define SWIG_AddCast(r)
Definition: plplotluacLUA_wrap.c:313
plscolor
#define plscolor
Definition: plplot.h:804
plsvpa
#define plsvpa
Definition: plplot.h:850
swig_lua_attribute::name
const char * name
Definition: plplotluacLUA_wrap.c:960
plpat
#define plpat
Definition: plplot.h:779
pl_setcontlabelformat
#define pl_setcontlabelformat
Definition: plplot.h:690
_wrap_gvpd
static int _wrap_gvpd(lua_State *L)
Definition: plplotluacLUA_wrap.c:5886
swig_lua_class::bases
struct swig_lua_class ** bases
Definition: plplotluacLUA_wrap.c:987
_wrap_gchr
static int _wrap_gchr(lua_State *L)
Definition: plplotluacLUA_wrap.c:5202
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
SWIG_Lua_add_class_user_metamethods
SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:2198
SWIG_check_num_args
#define SWIG_check_num_args(func_name, a, b)
Definition: plplotluacLUA_wrap.c:1036
swig_cast_info::prev
struct swig_cast_info * prev
Definition: plplotluacLUA_wrap.c:342
plgcol0
#define plgcol0
Definition: plplot.h:724
_wrap_sdidev
static int _wrap_sdidev(lua_State *L)
Definition: plplotluacLUA_wrap.c:9277
swig_PLGraphicsIn_methods
static swig_lua_method swig_PLGraphicsIn_methods[]
Definition: plplotluacLUA_wrap.c:3843
_wrap_scmap1_range
static int _wrap_scmap1_range(lua_State *L)
Definition: plplotluacLUA_wrap.c:9062
plreplot
#define plreplot
Definition: plplot.h:788
swig_module_info::cast_initial
swig_cast_info ** cast_initial
Definition: plplotluacLUA_wrap.c:353
SWIG_POINTER_DISOWN
#define SWIG_POINTER_DISOWN
Definition: plplotluacLUA_wrap.c:186
_wrap_PLGraphicsIn_button_get
static int _wrap_PLGraphicsIn_button_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3368
swig_lua_namespace::ns_attributes
swig_lua_attribute * ns_attributes
Definition: plplotluacLUA_wrap.c:971
_wrap_colorbar
static int _wrap_colorbar(lua_State *L)
Definition: plplotluacLUA_wrap.c:6653
plscmap1l
#define plscmap1l
Definition: plplot.h:796
plmap
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
plprec
#define plprec
Definition: plplot.h:783
lua_absindex
#define lua_absindex(L, i)
Definition: plplotluacLUA_wrap.c:877
plptex
#define plptex
Definition: plplot.h:785
plline
#define plline
Definition: plplot.h:760
PLcGrid2::xg
PLFLT_NC_MATRIX xg
Definition: plplot.h:520
swig_PLGraphicsIn_Sf_SwigStatic_attributes
static swig_lua_attribute swig_PLGraphicsIn_Sf_SwigStatic_attributes[]
Definition: plplotluacLUA_wrap.c:3850
SWIG_contract_assert
#define SWIG_contract_assert(expr, msg)
Definition: plplotluacLUA_wrap.c:1024
_wrap_width
static int _wrap_width(lua_State *L)
Definition: plplotluacLUA_wrap.c:11631
SWIG_Lua_class_do_get
SWIGINTERN int SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
Definition: plplotluacLUA_wrap.c:1566
_swigc__p_char
static swig_cast_info _swigc__p_char[]
Definition: plplotluacLUA_wrap.c:13108
swig_cast_info
struct swig_cast_info swig_cast_info
plgradient
#define plgradient
Definition: plplot.h:741
SWIG_UnpackDataName
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
Definition: plplotluacLUA_wrap.c:700
_wrap_shade
static int _wrap_shade(lua_State *L)
Definition: plplotluacLUA_wrap.c:9881
swig_lua_method
luaL_Reg swig_lua_method
Definition: plplotluacLUA_wrap.c:945
swig_lua_const_info::ptype
swig_type_info ** ptype
Definition: plplotluacLUA_wrap.c:954
_wrap_gradient
static int _wrap_gradient(lua_State *L)
Definition: plplotluacLUA_wrap.c:5096
_wrap_join
static int _wrap_join(lua_State *L)
Definition: plplotluacLUA_wrap.c:6118
swig_module_info::type_initial
swig_type_info ** type_initial
Definition: plplotluacLUA_wrap.c:352
_wrap_PLGraphicsIn_dX_get
static int _wrap_PLGraphicsIn_dX_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3625
_wrap_hlsrgb
static int _wrap_hlsrgb(lua_State *L)
Definition: plplotluacLUA_wrap.c:6065
_wrap_psty
static int _wrap_psty(lua_State *L)
Definition: plplotluacLUA_wrap.c:8268
_wrap_gdiplt
static int _wrap_gdiplt(lua_State *L)
Definition: plplotluacLUA_wrap.c:5449
_wrap_setcontlabelparam
static int _wrap_setcontlabelparam(lua_State *L)
Definition: plplotluacLUA_wrap.c:3897
_wrap_gdiori
static int _wrap_gdiori(lua_State *L)
Definition: plplotluacLUA_wrap.c:5429
SWIG_Lua_namespace_get
SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:1247
pladv
#define pladv
Definition: plplot.h:692
SWIG_OK
#define SWIG_OK
Definition: plplotluacLUA_wrap.c:272
swig_type_info::name
const char * name
Definition: plplotluacLUA_wrap.c:329
swig_lua_const_info::dvalue
double dvalue
Definition: plplotluacLUA_wrap.c:952
SWIGINTERNINLINE
#define SWIGINTERNINLINE
Definition: plplotluacLUA_wrap.c:82
SWIG_PackVoidPtr
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
Definition: plplotluacLUA_wrap.c:661
swig_lua_class::fqname
const char * fqname
Definition: plplotluacLUA_wrap.c:979
plvasp
#define plvasp
Definition: plplot.h:857
_wrap_line3
static int _wrap_line3(lua_State *L)
Definition: plplotluacLUA_wrap.c:6977
plrandd
#define plrandd
Definition: plplot.h:787
_wrap_sstrm
static int _wrap_sstrm(lua_State *L)
Definition: plplotluacLUA_wrap.c:10401
SWIG_Lua_pusherrstring
SWIGRUNTIME void SWIG_Lua_pusherrstring(lua_State *L, const char *str)
Definition: plplotluacLUA_wrap.c:901
swig_type_initial
static swig_type_info * swig_type_initial[]
Definition: plplotluacLUA_wrap.c:13092
plscmap0
#define plscmap0
Definition: plplot.h:791
_swigc__p_unsigned_int
static swig_cast_info _swigc__p_unsigned_int[]
Definition: plplotluacLUA_wrap.c:13118
plmapstring
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:616
_wrap_sfnam
static int _wrap_sfnam(lua_State *L)
Definition: plplotluacLUA_wrap.c:9521
plgstrm
#define plgstrm
Definition: plplot.h:744
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotluacLUA_wrap.c:3045
SWIG_IsOK
#define SWIG_IsOK(r)
Definition: plplotluacLUA_wrap.c:274
_wrap_seed
static int _wrap_seed(lua_State *L)
Definition: plplotluacLUA_wrap.c:9414
_wrap_abort
static int _wrap_abort(lua_State *L)
Definition: plplotluacLUA_wrap.c:12665
_swigc__p_PLGraphicsIn
static swig_cast_info _swigc__p_PLGraphicsIn[]
Definition: plplotluacLUA_wrap.c:13107
_wrap_gfnam
static int _wrap_gfnam(lua_State *L)
Definition: plplotluacLUA_wrap.c:5529
_wrap_sdimap
static int _wrap_sdimap(lua_State *L)
Definition: plplotluacLUA_wrap.c:9305
plsfci
#define plsfci
Definition: plplot.h:817
_wrap_col0
static int _wrap_col0(lua_State *L)
Definition: plplotluacLUA_wrap.c:4271
swig_type_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:333
SWIG_Lua_get_inheritable_metamethods
SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L)
Definition: plplotluacLUA_wrap.c:1861
_wrap_svect
static int _wrap_svect(lua_State *L)
Definition: plplotluacLUA_wrap.c:10927
_wrap_styl
static int _wrap_styl(lua_State *L)
Definition: plplotluacLUA_wrap.c:10879
_wrap_gstrm
static int _wrap_gstrm(lua_State *L)
Definition: plplotluacLUA_wrap.c:5841
swig_module_info
Definition: plplotluacLUA_wrap.c:348
swig_lua_class::destructor
void(* destructor)(void *)
Definition: plplotluacLUA_wrap.c:982
_wrap_clear
static int _wrap_clear(lua_State *L)
Definition: plplotluacLUA_wrap.c:4255
_wrap_spage
static int _wrap_spage(lua_State *L)
Definition: plplotluacLUA_wrap.c:10307
_swigc__p_f_int_double_p_char_int_p_void__void
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
Definition: plplotluacLUA_wrap.c:13112
_wrap_vpor
static int _wrap_vpor(lua_State *L)
Definition: plplotluacLUA_wrap.c:11538
plmtex
#define plmtex
Definition: plplot.h:773
label_func
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
Definition: plplotluacLUA_wrap.c:3049
plrgbhls
#define plrgbhls
Definition: plplot.h:789
plsurf3d
#define plsurf3d
Definition: plplot.h:847
swig_SwigModule_classes
static swig_lua_class * swig_SwigModule_classes[]
Definition: plplotluacLUA_wrap.c:13057
plplotc.pltr1
def pltr1
Definition: plplotc.py:105
_wrap_errx
static int _wrap_errx(lua_State *L)
Definition: plplotluacLUA_wrap.c:4830
plgra
#define plgra
Definition: plplot.h:740
_wrap_gcol0a
static int _wrap_gcol0a(lua_State *L)
Definition: plplotluacLUA_wrap.c:5257
plsdimap
#define plsdimap
Definition: plplot.h:808
_wrap_scmap0a
static int _wrap_scmap0a(lua_State *L)
Definition: plplotluacLUA_wrap.c:8530
_wrap_calc_world
static int _wrap_calc_world(lua_State *L)
Definition: plplotluacLUA_wrap.c:4221
SWIG_Lua_NewPackedObj
SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L, void *ptr, size_t size, swig_type_info *type)
Definition: plplotluacLUA_wrap.c:2519
swig_SwigModule_namespaces
static swig_lua_namespace * swig_SwigModule_namespaces[]
Definition: plplotluacLUA_wrap.c:13061
SWIG_Lua_class_equal
SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L)
Definition: plplotluacLUA_wrap.c:1787
f2eval_func
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
Definition: plplotluacLUA_wrap.c:3048
_wrap_sdiplt
static int _wrap_sdiplt(lua_State *L)
Definition: plplotluacLUA_wrap.c:9358
_wrap_string
static int _wrap_string(lua_State *L)
Definition: plplotluacLUA_wrap.c:10552
swig_PLGraphicsIn_Sf_SwigStatic_constants
static swig_lua_const_info swig_PLGraphicsIn_Sf_SwigStatic_constants[]
Definition: plplotluacLUA_wrap.c:3853
_wrap_PLGraphicsIn_wY_set
static int _wrap_PLGraphicsIn_wY_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3749
_wrap_btime
static int _wrap_btime(lua_State *L)
Definition: plplotluacLUA_wrap.c:4076
SWIG_Lua_MustGetPtr
SWIGRUNTIME void * SWIG_Lua_MustGetPtr(lua_State *L, int index, swig_type_info *type, int flags, int argnum, const char *func_name)
Definition: plplotluacLUA_wrap.c:2508
plot3d
#define plot3d
Definition: plplot.h:775
SWIG_Lua_set_immutable
SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
Definition: plplotluacLUA_wrap.c:1091
swig_lua_userdata::own
int own
Definition: plplotluacLUA_wrap.c:995
_wrap_env0
static int _wrap_env0(lua_State *L)
Definition: plplotluacLUA_wrap.c:4780
SWIG_Lua_add_namespace_details
SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
Definition: plplotluacLUA_wrap.c:1322
_wrap_PLGraphicsIn_subwindow_set
static int _wrap_PLGraphicsIn_subwindow_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3392
plslabelfunc
#define plslabelfunc
Definition: plplot.h:825
PLcGrid::nx
PLINT nx
Definition: plplot.h:509
SWIG_Lua_pushferrstring
SWIGRUNTIME void SWIG_Lua_pushferrstring(lua_State *L, const char *fmt,...)
Definition: plplotluacLUA_wrap.c:912
_wrap_ssub
static int _wrap_ssub(lua_State *L)
Definition: plplotluacLUA_wrap.c:10420
SWIG_UnpackVoidPtr
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
Definition: plplotluacLUA_wrap.c:672
_wrap_xormod
static int _wrap_xormod(lua_State *L)
Definition: plplotluacLUA_wrap.c:11678
_wrap_fill3
static int _wrap_fill3(lua_State *L)
Definition: plplotluacLUA_wrap.c:5029
_wrap_syax
static int _wrap_syax(lua_State *L)
Definition: plplotluacLUA_wrap.c:11049
PLGraphicsIn
Definition: plplot.h:433