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 4.0.1
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 #define SWIG_POINTER_NO_NULL 0x4
189 
190 /* Flags for new pointer objects */
191 #define SWIG_POINTER_OWN 0x1
192 
193 
194 /*
195  Flags/methods for returning states.
196 
197  The SWIG conversion methods, as ConvertPtr, return an integer
198  that tells if the conversion was successful or not. And if not,
199  an error code can be returned (see swigerrors.swg for the codes).
200 
201  Use the following macros/flags to set or process the returning
202  states.
203 
204  In old versions of SWIG, code such as the following was usually written:
205 
206  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
207  // success code
208  } else {
209  //fail code
210  }
211 
212  Now you can be more explicit:
213 
214  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
215  if (SWIG_IsOK(res)) {
216  // success code
217  } else {
218  // fail code
219  }
220 
221  which is the same really, but now you can also do
222 
223  Type *ptr;
224  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
225  if (SWIG_IsOK(res)) {
226  // success code
227  if (SWIG_IsNewObj(res) {
228  ...
229  delete *ptr;
230  } else {
231  ...
232  }
233  } else {
234  // fail code
235  }
236 
237  I.e., now SWIG_ConvertPtr can return new objects and you can
238  identify the case and take care of the deallocation. Of course that
239  also requires SWIG_ConvertPtr to return new result values, such as
240 
241  int SWIG_ConvertPtr(obj, ptr,...) {
242  if (<obj is ok>) {
243  if (<need new object>) {
244  *ptr = <ptr to new allocated object>;
245  return SWIG_NEWOBJ;
246  } else {
247  *ptr = <ptr to old object>;
248  return SWIG_OLDOBJ;
249  }
250  } else {
251  return SWIG_BADOBJ;
252  }
253  }
254 
255  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
256  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
257  SWIG errors code.
258 
259  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
260  allows to return the 'cast rank', for example, if you have this
261 
262  int food(double)
263  int fooi(int);
264 
265  and you call
266 
267  food(1) // cast rank '1' (1 -> 1.0)
268  fooi(1) // cast rank '0'
269 
270  just use the SWIG_AddCast()/SWIG_CheckState()
271 */
272 
273 #define SWIG_OK (0)
274 #define SWIG_ERROR (-1)
275 #define SWIG_IsOK(r) (r >= 0)
276 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
277 
278 /* The CastRankLimit says how many bits are used for the cast rank */
279 #define SWIG_CASTRANKLIMIT (1 << 8)
280 /* The NewMask denotes the object was created (using new/malloc) */
281 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
282 /* The TmpMask is for in/out typemaps that use temporal objects */
283 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
284 /* Simple returning values */
285 #define SWIG_BADOBJ (SWIG_ERROR)
286 #define SWIG_OLDOBJ (SWIG_OK)
287 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
288 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
289 /* Check, add and del mask methods */
290 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
291 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
292 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
293 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
294 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
295 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
296 
297 /* Cast-Rank Mode */
298 #if defined(SWIG_CASTRANK_MODE)
299 # ifndef SWIG_TypeRank
300 # define SWIG_TypeRank unsigned long
301 # endif
302 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
303 # define SWIG_MAXCASTRANK (2)
304 # endif
305 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
306 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
307 SWIGINTERNINLINE int SWIG_AddCast(int r) {
308  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
309 }
311  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
312 }
313 #else /* no cast-rank mode */
314 # define SWIG_AddCast(r) (r)
315 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
316 #endif
317 
318 
319 #include <string.h>
320 
321 #ifdef __cplusplus
322 extern "C" {
323 #endif
324 
325 typedef void *(*swig_converter_func)(void *, int *);
326 typedef struct swig_type_info *(*swig_dycast_func)(void **);
327 
328 /* Structure to store information on one type */
329 typedef struct swig_type_info {
330  const char *name; /* mangled name of this type */
331  const char *str; /* human readable name of this type */
332  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
333  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
334  void *clientdata; /* language specific type data */
335  int owndata; /* flag if the structure owns the clientdata */
337 
338 /* Structure to store a type and conversion function used for casting */
339 typedef struct swig_cast_info {
340  swig_type_info *type; /* pointer to type that is equivalent to this type */
341  swig_converter_func converter; /* function to cast the void pointers */
342  struct swig_cast_info *next; /* pointer to next cast in linked list */
343  struct swig_cast_info *prev; /* pointer to the previous cast */
345 
346 /* Structure used to store module information
347  * Each module generates one structure like this, and the runtime collects
348  * all of these structures and stores them in a circularly linked list.*/
349 typedef struct swig_module_info {
350  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
351  size_t size; /* Number of types in this module */
352  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
353  swig_type_info **type_initial; /* Array of initially generated type structures */
354  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
355  void *clientdata; /* Language specific module data */
357 
358 /*
359  Compare two type names skipping the space characters, therefore
360  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
361 
362  Return 0 when the two name types are equivalent, as in
363  strncmp, but skipping ' '.
364 */
365 SWIGRUNTIME int
366 SWIG_TypeNameComp(const char *f1, const char *l1,
367  const char *f2, const char *l2) {
368  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
369  while ((*f1 == ' ') && (f1 != l1)) ++f1;
370  while ((*f2 == ' ') && (f2 != l2)) ++f2;
371  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
372  }
373  return (int)((l1 - f1) - (l2 - f2));
374 }
375 
376 /*
377  Check type equivalence in a name list like <name1>|<name2>|...
378  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
379 */
380 SWIGRUNTIME int
381 SWIG_TypeCmp(const char *nb, const char *tb) {
382  int equiv = 1;
383  const char* te = tb + strlen(tb);
384  const char* ne = nb;
385  while (equiv != 0 && *ne) {
386  for (nb = ne; *ne; ++ne) {
387  if (*ne == '|') break;
388  }
389  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
390  if (*ne) ++ne;
391  }
392  return equiv;
393 }
394 
395 /*
396  Check type equivalence in a name list like <name1>|<name2>|...
397  Return 0 if not equal, 1 if equal
398 */
399 SWIGRUNTIME int
400 SWIG_TypeEquiv(const char *nb, const char *tb) {
401  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
402 }
403 
404 /*
405  Check the typename
406 */
408 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
409  if (ty) {
410  swig_cast_info *iter = ty->cast;
411  while (iter) {
412  if (strcmp(iter->type->name, c) == 0) {
413  if (iter == ty->cast)
414  return iter;
415  /* Move iter to the top of the linked list */
416  iter->prev->next = iter->next;
417  if (iter->next)
418  iter->next->prev = iter->prev;
419  iter->next = ty->cast;
420  iter->prev = 0;
421  if (ty->cast) ty->cast->prev = iter;
422  ty->cast = iter;
423  return iter;
424  }
425  iter = iter->next;
426  }
427  }
428  return 0;
429 }
430 
431 /*
432  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
433 */
436  if (ty) {
437  swig_cast_info *iter = ty->cast;
438  while (iter) {
439  if (iter->type == from) {
440  if (iter == ty->cast)
441  return iter;
442  /* Move iter to the top of the linked list */
443  iter->prev->next = iter->next;
444  if (iter->next)
445  iter->next->prev = iter->prev;
446  iter->next = ty->cast;
447  iter->prev = 0;
448  if (ty->cast) ty->cast->prev = iter;
449  ty->cast = iter;
450  return iter;
451  }
452  iter = iter->next;
453  }
454  }
455  return 0;
456 }
457 
458 /*
459  Cast a pointer up an inheritance hierarchy
460 */
461 SWIGRUNTIMEINLINE void *
462 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
463  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
464 }
465 
466 /*
467  Dynamic pointer casting. Down an inheritance hierarchy
468 */
471  swig_type_info *lastty = ty;
472  if (!ty || !ty->dcast) return ty;
473  while (ty && (ty->dcast)) {
474  ty = (*ty->dcast)(ptr);
475  if (ty) lastty = ty;
476  }
477  return lastty;
478 }
479 
480 /*
481  Return the name associated with this type
482 */
483 SWIGRUNTIMEINLINE const char *
485  return ty->name;
486 }
487 
488 /*
489  Return the pretty name associated with this type,
490  that is an unmangled type name in a form presentable to the user.
491 */
492 SWIGRUNTIME const char *
494  /* The "str" field contains the equivalent pretty names of the
495  type, separated by vertical-bar characters. We choose
496  to print the last name, as it is often (?) the most
497  specific. */
498  if (!type) return NULL;
499  if (type->str != NULL) {
500  const char *last_name = type->str;
501  const char *s;
502  for (s = type->str; *s; s++)
503  if (*s == '|') last_name = s+1;
504  return last_name;
505  }
506  else
507  return type->name;
508 }
509 
510 /*
511  Set the clientdata field for a type
512 */
513 SWIGRUNTIME void
515  swig_cast_info *cast = ti->cast;
516  /* if (ti->clientdata == clientdata) return; */
517  ti->clientdata = clientdata;
518 
519  while (cast) {
520  if (!cast->converter) {
521  swig_type_info *tc = cast->type;
522  if (!tc->clientdata) {
524  }
525  }
526  cast = cast->next;
527  }
528 }
529 SWIGRUNTIME void
532  ti->owndata = 1;
533 }
534 
535 /*
536  Search for a swig_type_info structure only by mangled name
537  Search is a O(log #types)
538 
539  We start searching at module start, and finish searching when start == end.
540  Note: if start == end at the beginning of the function, we go all the way around
541  the circular list.
542 */
545  swig_module_info *end,
546  const char *name) {
547  swig_module_info *iter = start;
548  do {
549  if (iter->size) {
550  size_t l = 0;
551  size_t r = iter->size - 1;
552  do {
553  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
554  size_t i = (l + r) >> 1;
555  const char *iname = iter->types[i]->name;
556  if (iname) {
557  int compare = strcmp(name, iname);
558  if (compare == 0) {
559  return iter->types[i];
560  } else if (compare < 0) {
561  if (i) {
562  r = i - 1;
563  } else {
564  break;
565  }
566  } else if (compare > 0) {
567  l = i + 1;
568  }
569  } else {
570  break; /* should never happen */
571  }
572  } while (l <= r);
573  }
574  iter = iter->next;
575  } while (iter != end);
576  return 0;
577 }
578 
579 /*
580  Search for a swig_type_info structure for either a mangled name or a human readable name.
581  It first searches the mangled names of the types, which is a O(log #types)
582  If a type is not found it then searches the human readable names, which is O(#types).
583 
584  We start searching at module start, and finish searching when start == end.
585  Note: if start == end at the beginning of the function, we go all the way around
586  the circular list.
587 */
590  swig_module_info *end,
591  const char *name) {
592  /* STEP 1: Search the name field using binary search */
593  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
594  if (ret) {
595  return ret;
596  } else {
597  /* STEP 2: If the type hasn't been found, do a complete search
598  of the str field (the human readable name) */
599  swig_module_info *iter = start;
600  do {
601  size_t i = 0;
602  for (; i < iter->size; ++i) {
603  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
604  return iter->types[i];
605  }
606  iter = iter->next;
607  } while (iter != end);
608  }
609 
610  /* neither found a match */
611  return 0;
612 }
613 
614 /*
615  Pack binary data into a string
616 */
617 SWIGRUNTIME char *
618 SWIG_PackData(char *c, void *ptr, size_t sz) {
619  static const char hex[17] = "0123456789abcdef";
620  const unsigned char *u = (unsigned char *) ptr;
621  const unsigned char *eu = u + sz;
622  for (; u != eu; ++u) {
623  unsigned char uu = *u;
624  *(c++) = hex[(uu & 0xf0) >> 4];
625  *(c++) = hex[uu & 0xf];
626  }
627  return c;
628 }
629 
630 /*
631  Unpack binary data from a string
632 */
633 SWIGRUNTIME const char *
634 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
635  unsigned char *u = (unsigned char *) ptr;
636  const unsigned char *eu = u + sz;
637  for (; u != eu; ++u) {
638  char d = *(c++);
639  unsigned char uu;
640  if ((d >= '0') && (d <= '9'))
641  uu = (unsigned char)((d - '0') << 4);
642  else if ((d >= 'a') && (d <= 'f'))
643  uu = (unsigned char)((d - ('a'-10)) << 4);
644  else
645  return (char *) 0;
646  d = *(c++);
647  if ((d >= '0') && (d <= '9'))
648  uu |= (unsigned char)(d - '0');
649  else if ((d >= 'a') && (d <= 'f'))
650  uu |= (unsigned char)(d - ('a'-10));
651  else
652  return (char *) 0;
653  *u = uu;
654  }
655  return c;
656 }
657 
658 /*
659  Pack 'void *' into a string buffer.
660 */
661 SWIGRUNTIME char *
662 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
663  char *r = buff;
664  if ((2*sizeof(void *) + 2) > bsz) return 0;
665  *(r++) = '_';
666  r = SWIG_PackData(r,&ptr,sizeof(void *));
667  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
668  strcpy(r,name);
669  return buff;
670 }
671 
672 SWIGRUNTIME const char *
673 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
674  if (*c != '_') {
675  if (strcmp(c,"NULL") == 0) {
676  *ptr = (void *) 0;
677  return name;
678  } else {
679  return 0;
680  }
681  }
682  return SWIG_UnpackData(++c,ptr,sizeof(void *));
683 }
684 
685 SWIGRUNTIME char *
686 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
687  char *r = buff;
688  size_t lname = (name ? strlen(name) : 0);
689  if ((2*sz + 2 + lname) > bsz) return 0;
690  *(r++) = '_';
691  r = SWIG_PackData(r,ptr,sz);
692  if (lname) {
693  strncpy(r,name,lname+1);
694  } else {
695  *r = 0;
696  }
697  return buff;
698 }
699 
700 SWIGRUNTIME const char *
701 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
702  if (*c != '_') {
703  if (strcmp(c,"NULL") == 0) {
704  memset(ptr,0,sz);
705  return name;
706  } else {
707  return 0;
708  }
709  }
710  return SWIG_UnpackData(++c,ptr,sz);
711 }
712 
713 #ifdef __cplusplus
714 }
715 #endif
716 
717 /* Errors in SWIG */
718 #define SWIG_UnknownError -1
719 #define SWIG_IOError -2
720 #define SWIG_RuntimeError -3
721 #define SWIG_IndexError -4
722 #define SWIG_TypeError -5
723 #define SWIG_DivisionByZero -6
724 #define SWIG_OverflowError -7
725 #define SWIG_SyntaxError -8
726 #define SWIG_ValueError -9
727 #define SWIG_SystemError -10
728 #define SWIG_AttributeError -11
729 #define SWIG_MemoryError -12
730 #define SWIG_NullReferenceError -13
731 
732 
733 
734 /* -----------------------------------------------------------------------------
735  * luarun.swg
736  *
737  * This file contains the runtime support for Lua modules
738  * and includes code for managing global variables and pointer
739  * type checking.
740  * ----------------------------------------------------------------------------- */
741 
742 #ifdef __cplusplus
743 extern "C" {
744 #endif
745 
746 #include "lua.h"
747 #include "lauxlib.h"
748 #include <stdlib.h> /* for malloc */
749 #include <assert.h> /* for a few sanity tests */
750 
751 /* -----------------------------------------------------------------------------
752  * Lua flavors
753  * ----------------------------------------------------------------------------- */
754 
755 #define SWIG_LUA_FLAVOR_LUA 1
756 #define SWIG_LUA_FLAVOR_ELUA 2
757 #define SWIG_LUA_FLAVOR_ELUAC 3
758 
759 #if !defined(SWIG_LUA_TARGET)
760 # error SWIG_LUA_TARGET not defined
761 #endif
762 
763 #if defined(SWIG_LUA_ELUA_EMULATE)
764 
765 struct swig_elua_entry;
766 
767 typedef struct swig_elua_key {
768  int type;
769  union {
770  const char* strkey;
771  lua_Number numkey;
772  } key;
773 } swig_elua_key;
774 
775 typedef struct swig_elua_val {
776  int type;
777  union {
778  lua_Number number;
779  const struct swig_elua_entry *table;
780  const char *string;
781  lua_CFunction function;
782  struct {
783  char member;
784  long lvalue;
785  void *pvalue;
786  swig_type_info **ptype;
787  } userdata;
788  } value;
789 } swig_elua_val;
790 
791 typedef struct swig_elua_entry {
792  swig_elua_key key;
793  swig_elua_val value;
794 } swig_elua_entry;
795 
796 #define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} }
797 #define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} }
798 #define LNILKEY {LUA_TNIL, {.strkey = 0} }
799 
800 #define LNUMVAL(x) {LUA_TNUMBER, {.number = x} }
801 #define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} }
802 #define LROVAL(x) {LUA_TTABLE, {.table = x} }
803 #define LNILVAL {LUA_TNIL, {.string = 0} }
804 #define LSTRVAL(x) {LUA_TSTRING, {.string = x} }
805 
806 #define LUA_REG_TYPE swig_elua_entry
807 
808 #define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable"
809 
810 #define lua_pushrotable(L,p)\
811  lua_newtable(L);\
812  assert(p);\
813  SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p));
814 
815 #define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
816  LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } }
817 
818 #define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\
819  LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } }
820 #endif
821 
822 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
823 # define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
824 # define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
825 # define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
826 # define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
827  /* Those two types of constants are not supported in elua */
828 
829 #ifndef SWIG_LUA_CONSTTAB_POINTER
830 #warning eLua does not support pointers as constants. By default, nil will be used as value
831 #define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL
832 #endif
833 
834 #ifndef SWIG_LUA_CONSTTAB_BINARY
835 #warning eLua does not support pointers to member as constants. By default, nil will be used as value
836 #define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL
837 #endif
838 #else /* SWIG_LUA_FLAVOR_LUA */
839 # define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
840 # define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
841 # define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
842 # define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
843 # define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
844  SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D
845 # define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\
846  SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D
847 #endif
848 
849 #ifndef SWIG_LUA_ELUA_EMULATE
850 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
851 # define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
852 # define LSTRVAL LRO_STRVAL
853 #endif
854 #endif /* SWIG_LUA_ELUA_EMULATE*/
855 
856 #ifndef SWIG_LUA_ELUA_EMULATE
857 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
858 
859 #ifndef MIN_OPT_LEVEL
860 #define MIN_OPT_LEVEL 2
861 #endif
862 
863 #include "lrodefs.h"
864 #include "lrotable.h"
865 #endif
866 #endif /* SWIG_LUA_ELUA_EMULATE*/
867 /* -----------------------------------------------------------------------------
868  * compatibility defines
869  * ----------------------------------------------------------------------------- */
870 
871 /* History of Lua C API length functions: In Lua 5.0 (and before?)
872  there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen",
873  but a compatibility define of "lua_strlen" was added. In Lua 5.2,
874  this function was again renamed, to "lua_rawlen" (to emphasize that
875  it doesn't call the "__len" metamethod), and the compatibility
876  define of lua_strlen was removed. All SWIG uses have been updated
877  to "lua_rawlen", and we add our own defines of that here for older
878  versions of Lua. */
879 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
880 # define lua_rawlen lua_strlen
881 #elif LUA_VERSION_NUM == 501
882 # define lua_rawlen lua_objlen
883 #endif
884 
885 
886 /* lua_pushglobaltable is the recommended "future-proof" way to get
887  the global table for Lua 5.2 and later. Here we define
888  lua_pushglobaltable ourselves for Lua versions before 5.2. */
889 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
890 # define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
891 #endif
892 
893 /* lua_absindex was introduced in Lua 5.2 */
894 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
895 # define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1)
896 #endif
897 
898 /* lua_rawsetp was introduced in Lua 5.2 */
899 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
900 #define lua_rawsetp(L,index,ptr)\
901  lua_pushlightuserdata(L,(void*)(ptr));\
902  lua_insert(L,-2);\
903  lua_rawset(L,index);
904 
905 #define lua_rawgetp(L,index,ptr)\
906  lua_pushlightuserdata(L,(void*)(ptr));\
907  lua_rawget(L,index);
908 
909 #endif
910 
911 /* --------------------------------------------------------------------------
912  * Helper functions for error handling
913  * -------------------------------------------------------------------------- */
914 
915 /* Push the string STR on the Lua stack, like lua_pushstring, but
916  prefixed with the location of the innermost Lua call-point
917  (as formatted by luaL_where). */
918 SWIGRUNTIME void
919 SWIG_Lua_pusherrstring (lua_State *L, const char *str)
920 {
921  luaL_where (L, 1);
922  lua_pushstring (L, str);
923  lua_concat (L, 2);
924 }
925 
926 /* Push a formatted string generated from FMT and following args on
927  the Lua stack, like lua_pushfstring, but prefixed with the
928  location of the innermost Lua call-point (as formatted by luaL_where). */
929 SWIGRUNTIME void
930 SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...)
931 {
932  va_list argp;
933  va_start(argp, fmt);
934  luaL_where(L, 1);
935  lua_pushvfstring(L, fmt, argp);
936  va_end(argp);
937  lua_concat(L, 2);
938 }
939 
940 
941 /* -----------------------------------------------------------------------------
942  * global swig types
943  * ----------------------------------------------------------------------------- */
944 /* Constant table */
945 #define SWIG_LUA_INT 1
946 #define SWIG_LUA_FLOAT 2
947 #define SWIG_LUA_STRING 3
948 #define SWIG_LUA_POINTER 4
949 #define SWIG_LUA_BINARY 5
950 #define SWIG_LUA_CHAR 6
951 
952 /* Structure for variable linking table */
953 typedef struct {
954  const char *name;
955  lua_CFunction get;
956  lua_CFunction set;
958 
959 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
960 typedef const LUA_REG_TYPE swig_lua_method;
961 typedef const LUA_REG_TYPE swig_lua_const_info;
962 #else /* Normal lua */
963 typedef luaL_Reg swig_lua_method;
964 
965 /* Constant information structure */
966 typedef struct {
967  int type;
968  char *name;
969  long lvalue;
970  double dvalue;
971  void *pvalue;
974 
975 #endif
976 
977 typedef struct {
978  const char *name;
979  lua_CFunction getmethod;
980  lua_CFunction setmethod;
982 
983 
984 struct swig_lua_class;
985 /* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */
986 typedef struct swig_lua_namespace {
987  const char *name;
994 
995 typedef struct swig_lua_class {
996  const char *name; /* Name that this class has in Lua */
997  const char *fqname; /* Fully qualified name - Scope + class name */
999  lua_CFunction constructor;
1000  void (*destructor)(void *);
1004  swig_lua_method *metatable; /* 0 for -eluac */
1006  const char **base_names;
1007 } swig_lua_class;
1008 
1009 /* this is the struct for wrapping all pointers in SwigLua
1010 */
1011 typedef struct {
1013  int own; /* 1 if owned & must be destroyed */
1014  void *ptr;
1016 
1017 /* this is the struct for wrapping arbitrary packed binary data
1018 (currently it is only used for member function pointers)
1019 the data ordering is similar to swig_lua_userdata, but it is currently not possible
1020 to tell the two structures apart within SWIG, other than by looking at the type
1021 */
1022 typedef struct {
1024  int own; /* 1 if owned & must be destroyed */
1025  char data[1]; /* arbitrary amount of data */
1027 
1028 /* Common SWIG API */
1029 #define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
1030 #define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
1031 #define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
1032 /* for C++ member pointers, ie, member methods */
1033 #define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
1034 #define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type)
1035 
1036 /* Runtime API */
1037 #define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
1038 #define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
1039 #define SWIG_MODULE_CLIENTDATA_TYPE lua_State*
1040 
1041 /* Contract support */
1042 #define SWIG_contract_assert(expr, msg) \
1043  if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else
1044 
1045 
1046 /* helper #defines */
1047 #define SWIG_fail {goto fail;}
1048 #define SWIG_fail_arg(func_name,argnum,type) \
1049  {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
1050  func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
1051  goto fail;}
1052 #define SWIG_fail_ptr(func_name,argnum,type) \
1053  SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
1054 #define SWIG_check_num_args(func_name,a,b) \
1055  if (lua_gettop(L)<a || lua_gettop(L)>b) \
1056  {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
1057  goto fail;}
1058 
1059 
1060 #define SWIG_Lua_get_table(L,n) \
1061  (lua_pushstring(L, n), lua_rawget(L,-2))
1062 
1063 #define SWIG_Lua_add_function(L,n,f) \
1064  (lua_pushstring(L, n), \
1065  lua_pushcfunction(L, f), \
1066  lua_rawset(L,-3))
1067 
1068 #define SWIG_Lua_add_boolean(L,n,b) \
1069  (lua_pushstring(L, n), \
1070  lua_pushboolean(L, b), \
1071  lua_rawset(L,-3))
1072 
1073 /* special helper for allowing 'nil' for usertypes */
1074 #define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))
1075 
1076 #ifdef __cplusplus
1077 /* Special helper for member function pointers
1078 it gets the address, casts it, then dereferences it */
1079 /*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */
1080 #endif
1081 
1082 /* storing/access of swig_module_info */
1084 SWIG_Lua_GetModule(lua_State *L) {
1085  swig_module_info *ret = 0;
1086  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1087  lua_rawget(L,LUA_REGISTRYINDEX);
1088  if (lua_islightuserdata(L,-1))
1089  ret=(swig_module_info*)lua_touserdata(L,-1);
1090  lua_pop(L,1); /* tidy */
1091  return ret;
1092 }
1093 
1094 SWIGRUNTIME void
1095 SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) {
1096  /* add this all into the Lua registry: */
1097  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1098  lua_pushlightuserdata(L,(void*)module);
1099  lua_rawset(L,LUA_REGISTRYINDEX);
1100 }
1101 
1102 /* -----------------------------------------------------------------------------
1103  * global variable support code: modules
1104  * ----------------------------------------------------------------------------- */
1105 
1106 /* this function is called when trying to set an immutable.
1107 default action is to print an error.
1108 This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
1110 {
1111 /* there should be 1 param passed in: the new value */
1112 #ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
1113  lua_pop(L,1); /* remove it */
1114  luaL_error(L,"This variable is immutable");
1115 #endif
1116  return 0; /* should not return anything */
1117 }
1118 
1119 #ifdef SWIG_LUA_ELUA_EMULATE
1120 
1121 SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own);
1122 SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type);
1123 static int swig_lua_elua_emulate_unique_key;
1124 
1125 /* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */
1126 SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table)
1127 {
1128  int i, table_parsed, parsed_tables_array, target_table;
1129  assert(lua_istable(L,-1));
1130  target_table = lua_gettop(L);
1131  /* Get the registry where we put all parsed tables to avoid loops */
1132  lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
1133  if(lua_isnil(L,-1)) {
1134  lua_pop(L,1);
1135  lua_newtable(L);
1136  lua_pushvalue(L,-1);
1137  lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key));
1138  }
1139  parsed_tables_array = lua_gettop(L);
1140  lua_pushvalue(L,target_table);
1141  lua_rawsetp(L, parsed_tables_array, table);
1142  table_parsed = 0;
1143  const int SWIGUNUSED pairs_start = lua_gettop(L);
1144  for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++)
1145  {
1146  const swig_elua_entry *entry = table + i;
1147  int is_metatable = 0;
1148  switch(entry->key.type) {
1149  case LUA_TSTRING:
1150  lua_pushstring(L,entry->key.key.strkey);
1151  if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0)
1152  is_metatable = 1;
1153  break;
1154  case LUA_TNUMBER:
1155  lua_pushnumber(L,entry->key.key.numkey);
1156  break;
1157  case LUA_TNIL:
1158  lua_pushnil(L);
1159  break;
1160  default:
1161  assert(0);
1162  }
1163  switch(entry->value.type) {
1164  case LUA_TSTRING:
1165  lua_pushstring(L,entry->value.value.string);
1166  break;
1167  case LUA_TNUMBER:
1168  lua_pushnumber(L,entry->value.value.number);
1169  break;
1170  case LUA_TFUNCTION:
1171  lua_pushcfunction(L,entry->value.value.function);
1172  break;
1173  case LUA_TTABLE:
1174  lua_rawgetp(L,parsed_tables_array, entry->value.value.table);
1175  table_parsed = !lua_isnil(L,-1);
1176  if(!table_parsed) {
1177  lua_pop(L,1); /*remove nil */
1178  lua_newtable(L);
1179  SWIG_Lua_elua_emulate_register(L,entry->value.value.table);
1180  }
1181  if(is_metatable) {
1182  assert(lua_istable(L,-1));
1183  lua_pushvalue(L,-1);
1184  lua_setmetatable(L,target_table);
1185  }
1186 
1187  break;
1188  case LUA_TUSERDATA:
1189  if(entry->value.value.userdata.member)
1190  SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue,
1191  entry->value.value.userdata.lvalue,
1192  *(entry->value.value.userdata.ptype));
1193  else
1194  SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue,
1195  *(entry->value.value.userdata.ptype),0);
1196  break;
1197  case LUA_TNIL:
1198  lua_pushnil(L);
1199  break;
1200  default:
1201  assert(0);
1202  }
1203  assert(lua_gettop(L) == pairs_start + 2);
1204  lua_rawset(L,target_table);
1205  }
1206  lua_pop(L,1); /* Removing parsed tables storage */
1207  assert(lua_gettop(L) == target_table);
1208 }
1209 
1210 SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L)
1211 {
1212  lua_pushnil(L);
1213  lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
1214 }
1215 
1216 SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L);
1217 
1218 SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L)
1219 {
1220  SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1);
1222  lua_getfield(L,-1,"lua_getmetatable");
1223  lua_remove(L,-2); /* remove the registry*/
1224  assert(!lua_isnil(L,-1));
1225  lua_pushvalue(L,1);
1226  assert(lua_gettop(L) == 3); /* object | function | object again */
1227  lua_call(L,1,1);
1228  if(!lua_isnil(L,-1)) /*There is an ordinary metatable */
1229  return 1;
1230  /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/
1231  assert(lua_gettop(L) == 2);
1232  if(lua_istable(L,-2)) {
1233  lua_pop(L,1); /*remove the nil*/
1234  lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY);
1235  }
1236  assert(lua_gettop(L) == 2);
1237  return 1;
1238 
1239 fail:
1240  lua_error(L);
1241  return 0;
1242 }
1243 
1244 SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L)
1245 {
1248  lua_pushstring(L,"lua_getmetatable");
1249  lua_getfield(L,-2,"getmetatable");
1250  assert(!lua_isnil(L,-1));
1251  lua_rawset(L,-4);
1252  lua_pushstring(L, "getmetatable");
1253  lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable);
1254  lua_rawset(L,-3);
1255  lua_pop(L,2);
1256 
1257 }
1258 /* END OF REMOVE */
1259 
1260 #endif
1261 /* -----------------------------------------------------------------------------
1262  * global variable support code: namespaces and modules (which are the same thing)
1263  * ----------------------------------------------------------------------------- */
1264 
1266 {
1267 /* there should be 2 params passed in
1268  (1) table (not the meta table)
1269  (2) string name of the attribute
1270 */
1271  assert(lua_istable(L,-2)); /* just in case */
1272  lua_getmetatable(L,-2);
1273  assert(lua_istable(L,-1));
1274  SWIG_Lua_get_table(L,".get"); /* find the .get table */
1275  assert(lua_istable(L,-1));
1276  /* look for the key in the .get table */
1277  lua_pushvalue(L,2); /* key */
1278  lua_rawget(L,-2);
1279  lua_remove(L,-2); /* stack tidy, remove .get table */
1280  if (lua_iscfunction(L,-1))
1281  { /* found it so call the fn & return its value */
1282  lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */
1283  lua_remove(L,-2); /* stack tidy, remove metatable */
1284  return 1;
1285  }
1286  lua_pop(L,1); /* remove whatever was there */
1287  /* ok, so try the .fn table */
1288  SWIG_Lua_get_table(L,".fn"); /* find the .get table */
1289  assert(lua_istable(L,-1)); /* just in case */
1290  lua_pushvalue(L,2); /* key */
1291  lua_rawget(L,-2); /* look for the fn */
1292  lua_remove(L,-2); /* stack tidy, remove .fn table */
1293  if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */
1294  { /* found it so return the fn & let lua call it */
1295  lua_remove(L,-2); /* stack tidy, remove metatable */
1296  return 1;
1297  }
1298  lua_pop(L,1); /* remove whatever was there */
1299  return 0;
1300 }
1301 
1303 {
1304 /* there should be 3 params passed in
1305  (1) table (not the meta table)
1306  (2) string name of the attribute
1307  (3) any for the new value
1308 */
1309 
1310  assert(lua_istable(L,1));
1311  lua_getmetatable(L,1); /* get the meta table */
1312  assert(lua_istable(L,-1));
1313 
1314  SWIG_Lua_get_table(L,".set"); /* find the .set table */
1315  if (lua_istable(L,-1))
1316  {
1317  /* look for the key in the .set table */
1318  lua_pushvalue(L,2); /* key */
1319  lua_rawget(L,-2);
1320  if (lua_iscfunction(L,-1))
1321  { /* found it so call the fn & return its value */
1322  lua_pushvalue(L,3); /* value */
1323  lua_call(L,1,0);
1324  return 0;
1325  }
1326  lua_pop(L,1); /* remove the value */
1327  }
1328  lua_pop(L,1); /* remove the value .set table */
1329  lua_pop(L,1); /* remote metatable */
1330  lua_rawset(L,-3);
1331  return 0;
1332 }
1333 
1334 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
1335 SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */
1336 SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */
1337 SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss);
1338 
1339 /* helper function - register namespace methods and attributes into namespace */
1341 {
1342  int i;
1343  /* There must be namespace table (not metatable) at the top of the stack */
1344  assert(lua_istable(L,-1));
1346 
1347  /* add methods to the namespace/module table */
1348  for(i=0;ns->ns_methods[i].name;i++){
1349  SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func);
1350  }
1351  lua_getmetatable(L,-1);
1352 
1353  /* add fns */
1354  for(i=0;ns->ns_attributes[i].name;i++){
1356  }
1357 
1358  /* clear stack - remove metatble */
1359  lua_pop(L,1);
1360  return 0;
1361 }
1362 
1363 /* Register all classes in the namespace */
1365 {
1366  swig_lua_class **classes;
1367 
1368  /* There must be a module/namespace table at the top of the stack */
1369  assert(lua_istable(L,-1));
1370 
1371  classes = ns->ns_classes;
1372 
1373  if( classes != 0 ) {
1374  while(*classes != 0) {
1375  SWIG_Lua_class_register(L, *classes);
1376  classes++;
1377  }
1378  }
1379 }
1380 
1381 /* Helper function. Creates namespace table and adds it to module table
1382  if 'reg' is true, then will register namespace table to parent one (must be on top of the stack
1383  when function is called).
1384  Function always returns newly registered table on top of the stack.
1385 */
1387 {
1388  swig_lua_namespace **sub_namespace;
1389  /* 1 argument - table on the top of the stack */
1390  const int SWIGUNUSED begin = lua_gettop(L);
1391  assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */
1392  lua_checkstack(L,5);
1393  lua_newtable(L); /* namespace itself */
1394  lua_newtable(L); /* metatable for namespace */
1395 
1396  /* add a table called ".get" */
1397  lua_pushstring(L,".get");
1398  lua_newtable(L);
1399  lua_rawset(L,-3);
1400  /* add a table called ".set" */
1401  lua_pushstring(L,".set");
1402  lua_newtable(L);
1403  lua_rawset(L,-3);
1404  /* add a table called ".fn" */
1405  lua_pushstring(L,".fn");
1406  lua_newtable(L);
1407  lua_rawset(L,-3);
1408 
1409  /* add accessor fns for using the .get,.set&.fn */
1412 
1413  lua_setmetatable(L,-2); /* set metatable */
1414 
1415  /* Register all functions, variables etc */
1417  /* Register classes */
1419 
1420  sub_namespace = ns->ns_namespaces;
1421  if( sub_namespace != 0) {
1422  while(*sub_namespace != 0) {
1423  SWIG_Lua_namespace_register(L, *sub_namespace, 1);
1424  lua_pop(L,1); /* removing sub-namespace table */
1425  sub_namespace++;
1426  }
1427  }
1428 
1429  if (reg) {
1430  lua_pushstring(L,ns->name);
1431  lua_pushvalue(L,-2);
1432  lua_rawset(L,-4); /* add namespace to module table */
1433  }
1434  assert(lua_gettop(L) == begin+1);
1435 }
1436 #endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
1437 
1438 /* -----------------------------------------------------------------------------
1439  * global variable support code: classes
1440  * ----------------------------------------------------------------------------- */
1441 
1442 SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname);
1443 
1444 typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret);
1445 
1447  int first_arg, swig_lua_base_iterator_func func, int *const ret)
1448 {
1449  /* first_arg - position of the object in stack. Everything that is above are arguments
1450  * and is passed to every evocation of the func */
1451  int last_arg = lua_gettop(L);/* position of last argument */
1452  int original_metatable = last_arg + 1;
1453  size_t bases_count;
1454  int result = SWIG_ERROR;
1455  int bases_table;
1456  (void)swig_type;
1457  lua_getmetatable(L,first_arg);
1458 
1459  /* initialise base search */
1460 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1461  SWIG_Lua_get_table(L,".bases");
1462  assert(lua_istable(L,-1));
1463  bases_count = lua_rawlen(L,-1);
1464  bases_table = lua_gettop(L);
1465 #else
1466  /* In elua .bases table doesn't exist. Use table from swig_lua_class */
1467  (void)bases_table;
1468  assert(swig_type!=0);
1469  swig_module_info *module=SWIG_GetModule(L);
1470  swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases;
1471  const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names;
1472  bases_count = 0;
1473  for(;base_names[bases_count];
1474  bases_count++);/* get length of bases */
1475 #endif
1476 
1477  if(ret)
1478  *ret = 0;
1479  if(bases_count>0)
1480  {
1481  int to_remove;
1482  size_t i;
1483  int j;
1484  int subcall_last_arg;
1485  int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */
1486  int valid = 1;
1487  swig_type_info *base_swig_type = 0;
1488  for(j=first_arg;j<=last_arg;j++)
1489  lua_pushvalue(L,j);
1490  subcall_last_arg = lua_gettop(L);
1491 
1492  /* Trick: temporarily replacing original metatable with metatable for base class and call getter */
1493  for(i=0;i<bases_count;i++) {
1494  /* Iteration through class bases */
1495 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1496  lua_rawgeti(L,bases_table,i+1);
1497  base_swig_type = 0;
1498  if(lua_isnil(L,-1)) {
1499  valid = 0;
1500  lua_pop(L,1);
1501  } else {
1502  valid = 1;
1503  }
1504 #else /* In elua .bases table doesn't exist. Use table from swig_lua_class */
1505  swig_lua_class *base_class = bases[i];
1506  if(!base_class) {
1507  valid = 0;
1508  } else {
1509  valid = 1;
1510  SWIG_Lua_get_class_metatable(L,base_class->fqname);
1511  base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]);
1512  assert(base_swig_type != 0);
1513  }
1514 #endif
1515 
1516  if(!valid)
1517  continue;
1518  assert(lua_isuserdata(L, subcall_first_arg));
1519  assert(lua_istable(L,-1));
1520  lua_setmetatable(L,subcall_first_arg); /* Set new metatable */
1521  assert(lua_gettop(L) == subcall_last_arg);
1522  result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */
1523  if(result != SWIG_ERROR) {
1524  break;
1525  }
1526  }
1527  /* Restore original metatable */
1528  lua_pushvalue(L,original_metatable);
1529  lua_setmetatable(L,first_arg);
1530  /* Clear - remove everything between last_arg and subcall_last_arg including */
1531  to_remove = subcall_last_arg - last_arg;
1532  for(j=0;j<to_remove;j++)
1533  lua_remove(L,last_arg+1);
1534  } else {
1535  /* Remove everything after last_arg */
1536  lua_pop(L, lua_gettop(L) - last_arg);
1537  }
1538  if(ret) assert(lua_gettop(L) == last_arg + *ret);
1539  return result;
1540 }
1541 
1542 /* The class.get method helper, performs the lookup of class attributes.
1543  * It returns an error code. Number of function return values is passed inside 'ret'.
1544  * first_arg is not used in this function because function always has 2 arguments.
1545  */
1546 SWIGINTERN int SWIG_Lua_class_do_get_item(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
1547 {
1548 /* there should be 2 params passed in
1549  (1) userdata (not the meta table)
1550  (2) string name of the attribute
1551 */
1552  int bases_search_result;
1553  int substack_start = lua_gettop(L)-2;
1554  assert(first_arg == substack_start+1);
1555  lua_checkstack(L,5);
1556  assert(lua_isuserdata(L,-2)); /* just in case */
1557  lua_getmetatable(L,-2); /* get the meta table */
1558  assert(lua_istable(L,-1)); /* just in case */
1559  /* NEW: looks for the __getitem() fn
1560  this is a user provided get fn */
1561  SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
1562  if (lua_iscfunction(L,-1)) /* if its there */
1563  { /* found it so call the fn & return its value */
1564  lua_pushvalue(L,substack_start+1); /* the userdata */
1565  lua_pushvalue(L,substack_start+2); /* the parameter */
1566  lua_call(L,2,1); /* 2 value in (userdata),1 out (result) */
1567  lua_remove(L,-2); /* stack tidy, remove metatable */
1568  if(ret) *ret = 1;
1569  return SWIG_OK;
1570  }
1571  lua_pop(L,1);
1572  /* Remove the metatable */
1573  lua_pop(L,1);
1574  /* Search in base classes */
1575  bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get_item,ret);
1576  return bases_search_result; /* sorry not known */
1577 }
1578 
1579 
1580 /* The class.get method helper, performs the lookup of class attributes.
1581  * It returns an error code. Number of function return values is passed inside 'ret'.
1582  * first_arg is not used in this function because function always has 2 arguments.
1583  */
1584 SWIGINTERN int SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
1585 {
1586 /* there should be 2 params passed in
1587  (1) userdata (not the meta table)
1588  (2) string name of the attribute
1589 */
1590  int bases_search_result;
1591  int substack_start = lua_gettop(L)-2;
1592  assert(first_arg == substack_start+1);
1593  lua_checkstack(L,5);
1594  assert(lua_isuserdata(L,-2)); /* just in case */
1595  lua_getmetatable(L,-2); /* get the meta table */
1596  assert(lua_istable(L,-1)); /* just in case */
1597  SWIG_Lua_get_table(L,".get"); /* find the .get table */
1598  assert(lua_istable(L,-1)); /* just in case */
1599  /* look for the key in the .get table */
1600  lua_pushvalue(L,substack_start+2); /* key */
1601  lua_rawget(L,-2);
1602  lua_remove(L,-2); /* stack tidy, remove .get table */
1603  if (lua_iscfunction(L,-1))
1604  { /* found it so call the fn & return its value */
1605  lua_pushvalue(L,substack_start+1); /* the userdata */
1606  lua_call(L,1,1); /* 1 value in (userdata),1 out (result) */
1607  lua_remove(L,-2); /* stack tidy, remove metatable */
1608  if(ret)
1609  *ret = 1;
1610  return SWIG_OK;
1611  }
1612  lua_pop(L,1); /* remove whatever was there */
1613  /* ok, so try the .fn table */
1614  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
1615  assert(lua_istable(L,-1)); /* just in case */
1616  lua_pushvalue(L,substack_start+2); /* key */
1617  lua_rawget(L,-2); /* look for the fn */
1618  lua_remove(L,-2); /* stack tidy, remove .fn table */
1619  if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
1620  { /* found it so return the fn & let lua call it */
1621  lua_remove(L,-2); /* stack tidy, remove metatable */
1622  if(ret)
1623  *ret = 1;
1624  return SWIG_OK;
1625  }
1626  lua_pop(L,1); /* remove whatever was there */
1627  /* Remove the metatable */
1628  lua_pop(L,1);
1629  /* Search in base classes */
1630  bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get,ret);
1631  return bases_search_result; /* sorry not known */
1632 }
1633 
1634 /* the class.get method, performs the lookup of class attributes
1635  */
1637 {
1638 /* there should be 2 params passed in
1639  (1) userdata (not the meta table)
1640  (2) string name of the attribute
1641 */
1642  int result;
1643  swig_lua_userdata *usr;
1644  swig_type_info *type;
1645  int ret = 0;
1646  assert(lua_isuserdata(L,1));
1647  usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1648  type = usr->type;
1649  result = SWIG_Lua_class_do_get(L,type,1,&ret);
1650  if(result == SWIG_OK)
1651  return ret;
1652 
1653  result = SWIG_Lua_class_do_get_item(L,type,1,&ret);
1654  if(result == SWIG_OK)
1655  return ret;
1656 
1657  return 0;
1658 }
1659 
1660 /* helper for the class.set method, performs the lookup of class attributes
1661  * It returns error code. Number of function return values is passed inside 'ret'
1662  */
1663 SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret)
1664 {
1665 /* there should be 3 params passed in
1666  (1) table (not the meta table)
1667  (2) string name of the attribute
1668  (3) any for the new value
1669  */
1670 
1671  int bases_search_result;
1672  int substack_start = lua_gettop(L) - 3;
1673  lua_checkstack(L,5);
1674  assert(lua_isuserdata(L,substack_start+1)); /* just in case */
1675  lua_getmetatable(L,substack_start+1); /* get the meta table */
1676  assert(lua_istable(L,-1)); /* just in case */
1677  if(ret)
1678  *ret = 0; /* it is setter - number of return values is always 0 */
1679 
1680  SWIG_Lua_get_table(L,".set"); /* find the .set table */
1681  if (lua_istable(L,-1))
1682  {
1683  /* look for the key in the .set table */
1684  lua_pushvalue(L,substack_start+2); /* key */
1685  lua_rawget(L,-2);
1686  lua_remove(L,-2); /* tidy stack, remove .set table */
1687  if (lua_iscfunction(L,-1))
1688  { /* found it so call the fn & return its value */
1689  lua_pushvalue(L,substack_start+1); /* userdata */
1690  lua_pushvalue(L,substack_start+3); /* value */
1691  lua_call(L,2,0);
1692  lua_remove(L,substack_start+4); /*remove metatable*/
1693  return SWIG_OK;
1694  }
1695  lua_pop(L,1); /* remove the value */
1696  } else {
1697  lua_pop(L,1); /* remove the answer for .set table request*/
1698  }
1699  /* NEW: looks for the __setitem() fn
1700  this is a user provided set fn */
1701  SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
1702  if (lua_iscfunction(L,-1)) /* if its there */
1703  { /* found it so call the fn & return its value */
1704  lua_pushvalue(L,substack_start+1); /* the userdata */
1705  lua_pushvalue(L,substack_start+2); /* the parameter */
1706  lua_pushvalue(L,substack_start+3); /* the value */
1707  lua_call(L,3,0); /* 3 values in ,0 out */
1708  lua_remove(L,-2); /* stack tidy, remove metatable */
1709  return SWIG_OK;
1710  }
1711  lua_pop(L,1); /* remove value */
1712 
1713  lua_pop(L,1); /* remove metatable */
1714  /* Search among bases */
1715  bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret);
1716  if(ret)
1717  assert(*ret == 0);
1718  assert(lua_gettop(L) == substack_start + 3);
1719  return bases_search_result;
1720 }
1721 
1722 /* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly
1723  * handles return values.
1724  */
1726 {
1727 /* There should be 3 params passed in
1728  (1) table (not the meta table)
1729  (2) string name of the attribute
1730  (3) any for the new value
1731  */
1732  int ret = 0;
1733  int result;
1734  swig_lua_userdata *usr;
1735  swig_type_info *type;
1736  assert(lua_isuserdata(L,1));
1737  usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1738  type = usr->type;
1739  result = SWIG_Lua_class_do_set(L,type,1,&ret);
1740  if(result != SWIG_OK) {
1741  SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method.");
1742  lua_error(L);
1743  } else {
1744  assert(ret==0);
1745  }
1746  return 0;
1747 }
1748 
1749 /* the class.destruct method called by the interpreter */
1751 {
1752 /* there should be 1 params passed in
1753  (1) userdata (not the meta table) */
1754  swig_lua_userdata *usr;
1755  swig_lua_class *clss;
1756  assert(lua_isuserdata(L,-1)); /* just in case */
1757  usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
1758  /* if must be destroyed & has a destructor */
1759  if (usr->own) /* if must be destroyed */
1760  {
1761  clss=(swig_lua_class*)usr->type->clientdata; /* get the class */
1762  if (clss && clss->destructor) /* there is a destroy fn */
1763  {
1764  clss->destructor(usr->ptr); /* bye bye */
1765  }
1766  }
1767  return 0;
1768 }
1769 
1770 /* the class.__tostring method called by the interpreter and print */
1772 {
1773 /* there should be 1 param passed in
1774  (1) userdata (not the metatable) */
1775  swig_lua_userdata* userData;
1776  assert(lua_isuserdata(L,1)); /* just in case */
1777  userData = (swig_lua_userdata*)lua_touserdata(L,1); /* get the userdata address */
1778 
1779  lua_pushfstring(L, "<userdata of type '%s' at %p>", userData->type->str, userData->ptr);
1780  return 1;
1781 }
1782 
1783 /* to manually disown some userdata */
1785 {
1786 /* there should be 1 params passed in
1787  (1) userdata (not the meta table) */
1788  swig_lua_userdata *usr;
1789  assert(lua_isuserdata(L,-1)); /* just in case */
1790  usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
1791 
1792  usr->own = 0; /* clear our ownership */
1793  return 0;
1794 }
1795 
1796 /* lua callable function to compare userdata's value
1797 the issue is that two userdata may point to the same thing
1798 but to lua, they are different objects */
1800 {
1801  int result;
1802  swig_lua_userdata *usr1,*usr2;
1803  if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */
1804  return 0; /* nil reply */
1805  usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1806  usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */
1807  /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
1808  result=(usr1->ptr==usr2->ptr);
1809  lua_pushboolean(L,result);
1810  return 1;
1811 }
1812 
1813 /* populate table at the top of the stack with metamethods that ought to be inherited */
1815 {
1816  SWIG_Lua_add_boolean(L, "__add", 1);
1817  SWIG_Lua_add_boolean(L, "__sub", 1);
1818  SWIG_Lua_add_boolean(L, "__mul", 1);
1819  SWIG_Lua_add_boolean(L, "__div", 1);
1820  SWIG_Lua_add_boolean(L, "__mod", 1);
1821  SWIG_Lua_add_boolean(L, "__pow", 1);
1822  SWIG_Lua_add_boolean(L, "__unm", 1);
1823  SWIG_Lua_add_boolean(L, "__len", 1 );
1824  SWIG_Lua_add_boolean(L, "__concat", 1 );
1825  SWIG_Lua_add_boolean(L, "__eq", 1);
1826  SWIG_Lua_add_boolean(L, "__lt", 1);
1827  SWIG_Lua_add_boolean(L, "__le", 1);
1828  SWIG_Lua_add_boolean(L, "__call", 1);
1829  SWIG_Lua_add_boolean(L, "__tostring", 1);
1830  SWIG_Lua_add_boolean(L, "__gc", 0);
1831 }
1832 
1833 /* creates the swig registry */
1835 {
1836  /* create main SWIG registry table */
1837  lua_pushstring(L,"SWIG");
1838  lua_newtable(L);
1839  /* populate it with some predefined data */
1840 
1841  /* .library table. Placeholder */
1842  lua_pushstring(L,".library");
1843  lua_newtable(L);
1844  {
1845  /* list of metamethods that class inherits from its bases */
1846  lua_pushstring(L,"inheritable_metamethods");
1847  lua_newtable(L);
1848  /* populate with list of metamethods */
1850  lua_rawset(L,-3);
1851  }
1852  lua_rawset(L,-3);
1853 
1854  lua_rawset(L,LUA_REGISTRYINDEX);
1855 }
1856 
1857 /* gets the swig registry (or creates it) */
1859 {
1860  /* add this all into the swig registry: */
1861  lua_pushstring(L,"SWIG");
1862  lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */
1863  if (!lua_istable(L,-1)) /* not there */
1864  { /* must be first time, so add it */
1865  lua_pop(L,1); /* remove the result */
1867  /* then get it */
1868  lua_pushstring(L,"SWIG");
1869  lua_rawget(L,LUA_REGISTRYINDEX);
1870  }
1871 }
1872 
1874 {
1876  lua_pushstring(L, ".library");
1877  lua_rawget(L,-2);
1878  assert( !lua_isnil(L,-1) );
1879  lua_pushstring(L, "inheritable_metamethods");
1880  lua_rawget(L,-2);
1881 
1882  /* Remove class registry and library table */
1883  lua_remove(L,-2);
1884  lua_remove(L,-2);
1885 }
1886 
1887 /* Helper function to get the classes metatable from the register */
1888 SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname)
1889 {
1890  SWIG_Lua_get_class_registry(L); /* get the registry */
1891  lua_pushstring(L,cname); /* get the name */
1892  lua_rawget(L,-2); /* get it */
1893  lua_remove(L,-2); /* tidy up (remove registry) */
1894 }
1895 
1896 /* Set up the base classes pointers.
1897 Each class structure has a list of pointers to the base class structures.
1898 This function fills them.
1899 It cannot be done at compile time, as this will not work with hireachies
1900 spread over more than one swig file.
1901 Therefore it must be done at runtime, querying the SWIG type system.
1902 */
1904 {
1905  int i=0;
1906  swig_module_info *module=SWIG_GetModule(L);
1907  for(i=0;clss->base_names[i];i++)
1908  {
1909  if (clss->bases[i]==0) /* not found yet */
1910  {
1911  /* lookup and cache the base class */
1912  swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
1913  if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
1914  }
1915  }
1916 }
1917 
1918 #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
1919 /* Merges two tables */
1920 SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
1921 {
1922  /* iterating */
1923  lua_pushnil(L);
1924  while (lua_next(L,source) != 0) {
1925  /* -1 - value, -2 - index */
1926  /* have to copy to assign */
1927  lua_pushvalue(L,-2); /* copy of index */
1928  lua_pushvalue(L,-2); /* copy of value */
1929  lua_rawset(L, target);
1930  lua_pop(L,1);
1931  /* only key is left */
1932  }
1933 }
1934 
1935 /* Merges two tables with given name. original - index of target metatable, base - index of source metatable */
1936 SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
1937 {
1938  /* push original[name], then base[name] */
1939  lua_pushstring(L,name);
1940  lua_rawget(L,original);
1941  int original_table = lua_gettop(L);
1942  lua_pushstring(L,name);
1943  lua_rawget(L,base);
1944  int base_table = lua_gettop(L);
1945  SWIG_Lua_merge_tables_by_index(L, original_table, base_table);
1946  /* clearing stack */
1947  lua_pop(L,2);
1948 }
1949 
1950 /* Function takes all symbols from base and adds it to derived class. It's just a helper. */
1951 SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
1952 {
1953  /* There is one parameter - original, i.e. 'derived' class metatable */
1954  assert(lua_istable(L,-1));
1955  int original = lua_gettop(L);
1956  SWIG_Lua_get_class_metatable(L,base_cls->fqname);
1957  int base = lua_gettop(L);
1958  SWIG_Lua_merge_tables(L, ".fn", original, base );
1959  SWIG_Lua_merge_tables(L, ".set", original, base );
1960  SWIG_Lua_merge_tables(L, ".get", original, base );
1961  lua_pop(L,1);
1962 }
1963 
1964 /* Function squashes all symbols from 'clss' bases into itself */
1965 SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
1966 {
1967  int i;
1969  for(i=0;clss->base_names[i];i++)
1970  {
1971  if (clss->bases[i]==0) /* Somehow it's not found. Skip it */
1972  continue;
1973  /* Thing is: all bases are already registered. Thus they have already executed
1974  * this function. So we just need to squash them into us, because their bases
1975  * are already squashed into them. No need for recursion here!
1976  */
1977  SWIG_Lua_class_squash_base(L, clss->bases[i]);
1978  }
1979  lua_pop(L,1); /*tidy stack*/
1980 }
1981 #endif
1982 
1983 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
1984 /* helper add a variable to a registered class */
1985 SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn)
1986 {
1987  assert(lua_istable(L,-1)); /* just in case */
1988  SWIG_Lua_get_table(L,".get"); /* find the .get table */
1989  assert(lua_istable(L,-1)); /* just in case */
1990  SWIG_Lua_add_function(L,name,getFn);
1991  lua_pop(L,1); /* tidy stack (remove table) */
1992  if (setFn)
1993  {
1994  SWIG_Lua_get_table(L,".set"); /* find the .set table */
1995  assert(lua_istable(L,-1)); /* just in case */
1996  SWIG_Lua_add_function(L,name,setFn);
1997  lua_pop(L,1); /* tidy stack (remove table) */
1998  }
1999 }
2000 
2001 /* helper to recursively add class static details (static attributes, operations and constants) */
2003 {
2004  int i = 0;
2005  /* The class namespace table must be on the top of the stack */
2006  assert(lua_istable(L,-1));
2007  /* call all the base classes first: we can then override these later: */
2008  for(i=0;clss->bases[i];i++)
2009  {
2011  }
2012 
2014 }
2015 
2016 SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */
2017 
2018 /* helper to recursively add class details (attributes & operations) */
2020 {
2021  int i;
2022  size_t bases_count = 0;
2023  /* Add bases to .bases table */
2024  SWIG_Lua_get_table(L,".bases");
2025  assert(lua_istable(L,-1)); /* just in case */
2026  for(i=0;clss->bases[i];i++)
2027  {
2029  /* Base class must be already registered */
2030  assert(lua_istable(L,-1));
2031  lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */
2032  bases_count++;
2033  }
2034  assert(lua_rawlen(L,-1) == bases_count);
2035  lua_pop(L,1); /* remove .bases table */
2036  /* add attributes */
2037  for(i=0;clss->attributes[i].name;i++){
2039  }
2040  /* add methods to the metatable */
2041  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
2042  assert(lua_istable(L,-1)); /* just in case */
2043  for(i=0;clss->methods[i].name;i++){
2044  SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func);
2045  }
2046  lua_pop(L,1); /* tidy stack (remove table) */
2047  /* add operator overloads
2048  This adds methods from metatable array to metatable. Can mess up garbage
2049  collectind if someone defines __gc method
2050  */
2051  if(clss->metatable) {
2052  for(i=0;clss->metatable[i].name;i++) {
2053  SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func);
2054  }
2055  }
2056 
2057 #if !defined(SWIG_LUA_SQUASH_BASES)
2058  /* Adding metamethods that are defined in base classes. If bases were squashed
2059  * then it is obviously unnecessary
2060  */
2062 #endif
2063 }
2064 
2065 /* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed
2066  for the following issue: Lua runtime checks for metamethod existence with rawget function
2067  ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method
2068  search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly
2069  in metatable and not in object).
2070  Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants
2071  are automatically given a special proxy __x that calls the real __x method.
2072  Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime,
2073  those changes must be reflected in all descendants.
2074 */
2075 
2076 SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/
2077 
2078 /* The real function that resolves a metamethod.
2079  * Function searches given class and all it's bases(recursively) for first instance of something that is
2080  * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation
2081  * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the
2082  * answer.
2083  * Returns 1 if found, 0 otherwise.
2084  * clss is class which metatable we will search for method
2085  * metamethod_name_idx is index in L where metamethod name (as string) lies
2086  * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check
2087  * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from
2088  * SWIG_Lua_resolve_metamethod
2089  * */
2090 SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx,
2091  int skip_check)
2092 {
2093  /* This function is called recursively */
2094  int result = 0;
2095  int i = 0;
2096 
2097  if (!skip_check) {
2099  lua_pushvalue(L, metamethod_name_idx);
2100  lua_rawget(L,-2);
2101  /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then
2102  * this isn't the function we are looking for :)
2103  * lua_tocfunction will return NULL if not cfunction
2104  */
2105  if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) {
2106  lua_remove(L,-2); /* removing class metatable */
2107  return 1;
2108  }
2109  lua_pop(L,2); /* remove class metatable and query result */
2110  }
2111 
2112  /* Forwarding calls to bases */
2113  for(i=0;clss->bases[i];i++)
2114  {
2115  result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0);
2116  if (result)
2117  break;
2118  }
2119 
2120  return result;
2121 }
2122 
2123 /* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method
2124  * and calls it */
2126 {
2127  int numargs;
2128  int metamethod_name_idx;
2129  const swig_lua_class* clss;
2130  int result;
2131 
2132  lua_checkstack(L,5);
2133  numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */
2134 
2135  /* Get upvalues from closure */
2136  lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/
2137  metamethod_name_idx = lua_gettop(L);
2138 
2139  lua_pushvalue(L, lua_upvalueindex(2));
2140  clss = (const swig_lua_class*)(lua_touserdata(L,-1));
2141  lua_pop(L,1); /* remove lightuserdata with clss from stack */
2142 
2143  /* Actual work */
2144  result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1);
2145  if (!result) {
2146  SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation.");
2147  lua_error(L);
2148  return 0;
2149  }
2150 
2151  lua_remove(L,-2); /* remove metamethod key */
2152  lua_insert(L,1); /* move function to correct position */
2153  lua_call(L, numargs, LUA_MULTRET);
2154  return lua_gettop(L); /* return all results */
2155 }
2156 
2157 
2158 /* If given metamethod must be present in given class, then creates appropriate proxy
2159  * Returns 1 if successfully added, 0 if not added because no base class has it, -1
2160  * if method is defined in the class metatable itself
2161  */
2162 SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index)
2163 {
2164  int key_index;
2165  int success = 0;
2166  int i = 0;
2167 
2168  /* metamethod name - on the top of the stack */
2169  assert(lua_isstring(L,-1));
2170 
2171  key_index = lua_gettop(L);
2172 
2173  /* Check whether method is already defined in metatable */
2174  lua_pushvalue(L,key_index); /* copy of the key */
2175  lua_gettable(L,metatable_index);
2176  if( !lua_isnil(L,-1) ) {
2177  lua_pop(L,1);
2178  return -1;
2179  }
2180  lua_pop(L,1);
2181 
2182  /* Iterating over immediate bases */
2183  for(i=0;clss->bases[i];i++)
2184  {
2185  const swig_lua_class *base = clss->bases[i];
2187  lua_pushvalue(L, key_index);
2188  lua_rawget(L, -2);
2189  if( !lua_isnil(L,-1) ) {
2190  lua_pushvalue(L, key_index);
2191 
2192  /* Add proxy function */
2193  lua_pushvalue(L, key_index); /* first closure value is function name */
2194  lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */
2195  lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2);
2196 
2197  lua_rawset(L, metatable_index);
2198  success = 1;
2199  }
2200  lua_pop(L,1); /* remove function or nil */
2201  lua_pop(L,1); /* remove base class metatable */
2202 
2203  if( success )
2204  break;
2205  }
2206 
2207  return success;
2208 }
2209 
2211 {
2212  int metatable_index;
2213  int metamethods_info_index;
2214  int tostring_undefined;
2215  int eq_undefined = 0;
2216 
2218  metatable_index = lua_gettop(L);
2220  assert(lua_istable(L,-1));
2221  metamethods_info_index = lua_gettop(L);
2222  lua_pushnil(L); /* first key */
2223  while(lua_next(L, metamethods_info_index) != 0 ) {
2224  /* key at index -2, value at index -1 */
2225  const int is_inheritable = lua_toboolean(L,-2);
2226  lua_pop(L,1); /* remove value - we don't need it anymore */
2227 
2228  if(is_inheritable) { /* if metamethod is inheritable */
2229  SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index);
2230  }
2231  }
2232 
2233  lua_pop(L,1); /* remove inheritable metatmethods table */
2234 
2235  /* Special handling for __tostring method */
2236  lua_pushstring(L, "__tostring");
2237  lua_pushvalue(L,-1);
2238  lua_rawget(L,metatable_index);
2239  tostring_undefined = lua_isnil(L,-1);
2240  lua_pop(L,1);
2241  if( tostring_undefined ) {
2242  lua_pushcfunction(L, SWIG_Lua_class_tostring);
2243  lua_rawset(L, metatable_index);
2244  } else {
2245  lua_pop(L,1); /* remove copy of the key */
2246  }
2247 
2248  /* Special handling for __eq method */
2249  lua_pushstring(L, "__eq");
2250  lua_pushvalue(L,-1);
2251  lua_rawget(L,metatable_index);
2252  eq_undefined = lua_isnil(L,-1);
2253  lua_pop(L,1);
2254  if( eq_undefined ) {
2255  lua_pushcfunction(L, SWIG_Lua_class_equal);
2256  lua_rawset(L, metatable_index);
2257  } else {
2258  lua_pop(L,1); /* remove copy of the key */
2259  }
2260  /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[]
2261  * a __getitem/__setitem method should be defined
2262  */
2263  lua_pop(L,1); /* pop class metatable */
2264 }
2265 
2266 /* Register class static methods,attributes etc as well as constructor proxy */
2268 {
2269  const int SWIGUNUSED begin = lua_gettop(L);
2270  lua_checkstack(L,5); /* just in case */
2271  assert(lua_istable(L,-1)); /* just in case */
2272  assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */
2273 
2275 
2276  assert(lua_istable(L,-1)); /* just in case */
2277 
2278  /* add its constructor to module with the name of the class
2279  so you can do MyClass(...) as well as new_MyClass(...)
2280  BUT only if a constructor is defined
2281  (this overcomes the problem of pure virtual classes without constructors)*/
2282  if (clss->constructor)
2283  {
2284  lua_getmetatable(L,-1);
2285  assert(lua_istable(L,-1)); /* just in case */
2286  SWIG_Lua_add_function(L,"__call", clss->constructor);
2287  lua_pop(L,1);
2288  }
2289 
2290  assert(lua_istable(L,-1)); /* just in case */
2292 
2293  /* clear stack */
2294  lua_pop(L,1);
2295  assert( lua_gettop(L) == begin );
2296 }
2297 
2298 /* Performs the instance (non-static) class registration process. Metatable for class is created
2299  * and added to the class registry.
2300  */
2302 {
2303  const int SWIGUNUSED begin = lua_gettop(L);
2304  int i;
2305  /* if name already there (class is already registered) then do nothing */
2306  SWIG_Lua_get_class_registry(L); /* get the registry */
2307  lua_pushstring(L,clss->fqname); /* get the name */
2308  lua_rawget(L,-2);
2309  if(!lua_isnil(L,-1)) {
2310  lua_pop(L,2);
2311  assert(lua_gettop(L)==begin);
2312  return;
2313  }
2314  lua_pop(L,2); /* tidy stack */
2315  /* Recursively initialize all bases */
2316  for(i=0;clss->bases[i];i++)
2317  {
2319  }
2320  /* Again, get registry and push name */
2321  SWIG_Lua_get_class_registry(L); /* get the registry */
2322  lua_pushstring(L,clss->fqname); /* get the name */
2323  lua_newtable(L); /* create the metatable */
2324 #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
2325  /* If squashing is requested, then merges all bases metatable into this one.
2326  * It would get us all special methods: __getitem, __add etc.
2327  * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away
2328  */
2329  {
2330  int new_metatable_index = lua_absindex(L,-1);
2331  for(i=0;clss->bases[i];i++)
2332  {
2333  int base_metatable;
2335  base_metatable = lua_absindex(L,-1);
2336  SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable);
2337  lua_pop(L,1);
2338  }
2339  }
2340  /* And now we will overwrite all incorrectly set data */
2341 #endif
2342  /* add string of class name called ".type" */
2343  lua_pushstring(L,".type");
2344  lua_pushstring(L,clss->fqname);
2345  lua_rawset(L,-3);
2346  /* add a table called bases */
2347  lua_pushstring(L,".bases");
2348  lua_newtable(L);
2349  lua_rawset(L,-3);
2350  /* add a table called ".get" */
2351  lua_pushstring(L,".get");
2352  lua_newtable(L);
2353  lua_rawset(L,-3);
2354  /* add a table called ".set" */
2355  lua_pushstring(L,".set");
2356  lua_newtable(L);
2357  lua_rawset(L,-3);
2358  /* add a table called ".fn" */
2359  lua_pushstring(L,".fn");
2360  lua_newtable(L);
2361  /* add manual disown method */
2363  lua_rawset(L,-3);
2364  /* add accessor fns for using the .get,.set&.fn */
2366  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
2368  /* add it */
2369  lua_rawset(L,-3); /* metatable into registry */
2370  lua_pop(L,1); /* tidy stack (remove registry) */
2371  assert(lua_gettop(L) == begin);
2372 
2373 #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
2374  /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */
2375  SWIG_Lua_class_squash_bases(L,clss);
2376 #endif
2378  SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */
2379  lua_pop(L,1); /* tidy stack (remove class metatable) */
2380  assert( lua_gettop(L) == begin );
2381 }
2382 
2384 {
2385  int SWIGUNUSED begin;
2386  assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */
2389 
2390  /* Add links from static part to instance part and vice versa */
2391  /* [SWIG registry] [Module]
2392  * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part]
2393  * ".get" ----> ... | | getmetatable()----|
2394  * ".set" ----> ... | | |
2395  * ".static" --------------)----------------/ [static part metatable]
2396  * | ".get" --> ...
2397  * | ".set" --> ....
2398  * |=============================== ".instance"
2399  */
2400  begin = lua_gettop(L);
2401  lua_pushstring(L,clss->cls_static->name);
2402  lua_rawget(L,-2); /* get class static table */
2403  assert(lua_istable(L,-1));
2404  lua_getmetatable(L,-1);
2405  assert(lua_istable(L,-1)); /* get class static metatable */
2406  lua_pushstring(L,".instance"); /* prepare key */
2407 
2408  SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */
2409  assert(lua_istable(L,-1));
2410  lua_pushstring(L,".static"); /* prepare key */
2411  lua_pushvalue(L, -4); /* push static class TABLE */
2412  assert(lua_istable(L,-1));
2413  lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */
2414  lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */
2415  lua_pop(L,2);
2416  assert(lua_gettop(L) == begin);
2417 }
2418 #endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
2419 
2420 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
2421 SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss)
2422 {
2423  const int SWIGUNUSED begin = lua_gettop(L);
2424  int i;
2425  /* if name already there (class is already registered) then do nothing */
2426  SWIG_Lua_get_class_registry(L); /* get the registry */
2427  lua_pushstring(L,clss->fqname); /* get the name */
2428  lua_rawget(L,-2);
2429  if(!lua_isnil(L,-1)) {
2430  lua_pop(L,2);
2431  assert(lua_gettop(L)==begin);
2432  return;
2433  }
2434  lua_pop(L,2); /* tidy stack */
2435  /* Recursively initialize all bases */
2436  for(i=0;clss->bases[i];i++)
2437  {
2438  SWIG_Lua_elua_class_register_instance(L,clss->bases[i]);
2439  }
2440  /* Again, get registry and push name */
2441  SWIG_Lua_get_class_registry(L); /* get the registry */
2442  lua_pushstring(L,clss->fqname); /* get the name */
2443  assert(clss->metatable);
2444  lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */
2445  lua_rawset(L,-3);
2446  lua_pop(L,1);
2447  assert(lua_gettop(L) == begin);
2448 }
2449 #endif /* elua && eluac */
2450 
2451 /* -----------------------------------------------------------------------------
2452  * Class/structure conversion fns
2453  * ----------------------------------------------------------------------------- */
2454 
2455 /* helper to add metatable to new lua object */
2457 {
2458  if (type->clientdata) /* there is clientdata: so add the metatable */
2459  {
2461  if (lua_istable(L,-1))
2462  {
2463  lua_setmetatable(L,-2);
2464  }
2465  else
2466  {
2467  lua_pop(L,1);
2468  }
2469  }
2470 }
2471 
2472 /* pushes a new object into the lua stack */
2473 SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own)
2474 {
2475  swig_lua_userdata *usr;
2476  if (!ptr){
2477  lua_pushnil(L);
2478  return;
2479  }
2480  usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */
2481  usr->ptr=ptr; /* set the ptr */
2482  usr->type=type;
2483  usr->own=own;
2484 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
2485  SWIG_Lua_AddMetatable(L,type); /* add metatable */
2486 #endif
2487 }
2488 
2489 /* takes a object from the lua stack & converts it into an object of the correct type
2490  (if possible) */
2491 SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
2492 {
2493  swig_lua_userdata *usr;
2494  swig_cast_info *cast;
2495  /* special case: lua nil => NULL pointer */
2496  if (lua_isnil(L,index))
2497  {
2498  *ptr=0;
2500  }
2501  usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */
2502  if (usr)
2503  {
2504  if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
2505  {
2506  usr->own=0;
2507  }
2508  if (!type) /* special cast void*, no casting fn */
2509  {
2510  *ptr=usr->ptr;
2511  return SWIG_OK; /* ok */
2512  }
2513  cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
2514  if (cast)
2515  {
2516  int newmemory = 0;
2517  *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
2518  assert(!newmemory); /* newmemory handling not yet implemented */
2519  return SWIG_OK; /* ok */
2520  }
2521  }
2522  return SWIG_ERROR; /* error */
2523 }
2524 
2525 SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,
2526  int argnum,const char *func_name){
2527  void *result;
2528  if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
2529  luaL_error (L,"Error in %s, expected a %s at argument number %d\n",
2530  func_name,(type && type->str)?type->str:"void*",argnum);
2531  }
2532  return result;
2533 }
2534 
2535 /* pushes a packed userdata. user for member fn pointers only */
2536 SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type)
2537 {
2538  swig_lua_rawdata *raw;
2539  assert(ptr); /* not acceptable to pass in a NULL value */
2540  raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */
2541  raw->type=type;
2542  raw->own=0;
2543  memcpy(raw->data,ptr,size); /* copy the data */
2544  SWIG_Lua_AddMetatable(L,type); /* add metatable */
2545 }
2546 
2547 /* converts a packed userdata. user for member fn pointers only */
2548 SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type)
2549 {
2550  swig_lua_rawdata *raw;
2551  raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */
2552  if (!raw) return SWIG_ERROR; /* error */
2553  if (type==0 || type==raw->type) /* void* or identical type */
2554  {
2555  memcpy(ptr,raw->data,size); /* copy it */
2556  return SWIG_OK; /* ok */
2557  }
2558  return SWIG_ERROR; /* error */
2559 }
2560 
2561 /* a function to get the typestring of a piece of data */
2562 SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
2563 {
2564  swig_lua_userdata *usr;
2565  if (lua_isuserdata(L,tp))
2566  {
2567  usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */
2568  if (usr && usr->type && usr->type->str)
2569  return usr->type->str;
2570  return "userdata (unknown type)";
2571  }
2572  return lua_typename(L,lua_type(L,tp));
2573 }
2574 
2575 /* lua callable function to get the userdata's type */
2576 SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
2577 {
2578  lua_pushstring(L,SWIG_Lua_typename(L,1));
2579  return 1;
2580 }
2581 
2582 /* -----------------------------------------------------------------------------
2583  * global variable support code: class/struct typemap functions
2584  * ----------------------------------------------------------------------------- */
2585 
2586 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
2587 /* Install Constants */
2588 SWIGINTERN void
2590  int i;
2591  for (i = 0; constants[i].type; i++) {
2592  switch(constants[i].type) {
2593  case SWIG_LUA_INT:
2594  lua_pushstring(L,constants[i].name);
2595  lua_pushinteger(L,(lua_Integer)constants[i].lvalue);
2596  lua_rawset(L,-3);
2597  break;
2598  case SWIG_LUA_FLOAT:
2599  lua_pushstring(L,constants[i].name);
2600  lua_pushnumber(L,(lua_Number)constants[i].dvalue);
2601  lua_rawset(L,-3);
2602  break;
2603  case SWIG_LUA_CHAR:
2604  lua_pushstring(L,constants[i].name);
2605  {
2606  char c = (char)constants[i].lvalue;
2607  lua_pushlstring(L,&c,1);
2608  }
2609  lua_rawset(L,-3);
2610  break;
2611  case SWIG_LUA_STRING:
2612  lua_pushstring(L,constants[i].name);
2613  lua_pushstring(L,(char *) constants[i].pvalue);
2614  lua_rawset(L,-3);
2615  break;
2616  case SWIG_LUA_POINTER:
2617  lua_pushstring(L,constants[i].name);
2618  SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
2619  lua_rawset(L,-3);
2620  break;
2621  case SWIG_LUA_BINARY:
2622  lua_pushstring(L,constants[i].name);
2623  SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
2624  lua_rawset(L,-3);
2625  break;
2626  default:
2627  break;
2628  }
2629  }
2630 }
2631 #endif
2632 
2633 /* -----------------------------------------------------------------------------
2634  * executing lua code from within the wrapper
2635  * ----------------------------------------------------------------------------- */
2636 
2637 #ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
2638 #define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
2639 #endif
2640 /* Executes a C string in Lua which is a really simple way of calling lua from C
2641 Unfortunately lua keeps changing its APIs, so we need a conditional compile
2642 In lua 5.0.X it's lua_dostring()
2643 In lua 5.1.X it's luaL_dostring()
2644 */
2645 SWIGINTERN int
2646 SWIG_Lua_dostring(lua_State *L, const char *str) {
2647  int ok,top;
2648  if (str==0 || str[0]==0) return 0; /* nothing to do */
2649  top=lua_gettop(L); /* save stack */
2650 #if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
2651  ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */
2652 #else
2653  ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */
2654 #endif
2655  if (ok!=0) {
2656  SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
2657  }
2658  lua_settop(L,top); /* restore the stack */
2659  return ok;
2660 }
2661 
2662 #ifdef __cplusplus
2663 }
2664 #endif
2665 
2666 /* ------------------------------ end luarun.swg ------------------------------ */
2667 
2668 
2669 /* -------- TYPES TABLE (BEGIN) -------- */
2670 
2671 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2672 #define SWIGTYPE_p_char swig_types[1]
2673 #define SWIGTYPE_p_double swig_types[2]
2674 #define SWIGTYPE_p_f_double_double__int swig_types[3]
2675 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[4]
2676 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[5]
2677 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[6]
2678 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[7]
2679 #define SWIGTYPE_p_int swig_types[8]
2680 #define SWIGTYPE_p_p_char swig_types[9]
2681 #define SWIGTYPE_p_p_double swig_types[10]
2682 #define SWIGTYPE_p_unsigned_int swig_types[11]
2684 static swig_module_info swig_module = {swig_types, 12, 0, 0, 0, 0};
2685 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2686 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2687 
2688 /* -------- TYPES TABLE (END) -------- */
2689 
2690 #define SWIG_name "plplotluac"
2691 #define SWIG_init luaopen_plplotluac
2692 #define SWIG_init_user luaopen_plplotluac_user
2693 
2694 #define SWIG_LUACODE luaopen_plplotluac_luacode
2695 
2696 #include "plplotP.h"
2697 
2698 
2699 #define LUA_ALLOC_ARRAY( TYPE, LEN ) (TYPE *) malloc( LEN * sizeof ( TYPE ) )
2700 #define LUA_FREE_ARRAY( PTR ) if ( PTR ) { free( PTR ); PTR = NULL;}
2701 
2702 // super macro to declare array typemap helper fns
2703  SWIGINTERN int SWIG_itable_size( lua_State* L, int index );
2704 #define LUA_DECLARE_TYPEMAP_ARR_FN( NAME, TYPE ) \
2705  SWIGINTERN int LUA_read_ ## NAME ## _num_array( lua_State * L, int index, TYPE * array, int size ){ \
2706  int i; \
2707  for ( i = 0; i < size; i++ ) { \
2708  lua_rawgeti( L, index, i + 1 ); \
2709  if ( lua_isnumber( L, -1 ) ) { \
2710  array[i] = (TYPE) lua_tonumber( L, -1 ); \
2711  } else { \
2712  lua_pop( L, 1 ); \
2713  return 0; \
2714  } \
2715  lua_pop( L, 1 ); \
2716  } \
2717  return 1; \
2718  } \
2719  SWIGINTERN TYPE* LUA_get_ ## NAME ## _num_array_var( lua_State * L, int index, int* size ) \
2720  { \
2721  TYPE *array; \
2722  if ( !lua_istable( L, index ) ) { \
2723  lua_pushstring( L, "expected a table" ); \
2724  return 0; \
2725  } \
2726  *size = SWIG_itable_size( L, index ); \
2727  if ( *size < 1 ) { \
2728  array = LUA_ALLOC_ARRAY( TYPE, 1 ); \
2729  array[0] = (TYPE) 0; \
2730  return array; \
2731  } \
2732  array = LUA_ALLOC_ARRAY( TYPE, *size ); \
2733  if ( !LUA_read_ ## NAME ## _num_array( L, index, array, *size ) ) { \
2734  lua_pushstring( L, "table must contain numbers" ); \
2735  LUA_FREE_ARRAY( array ); \
2736  return 0; \
2737  } \
2738  return array; \
2739  }
2740 
2741  LUA_DECLARE_TYPEMAP_ARR_FN( double, double );
2742  LUA_DECLARE_TYPEMAP_ARR_FN( int, int );
2743 
2744 
2745  static PLINT Alen = 0;
2746  static PLINT Xlen = 0, Ylen = 0;
2747 
2748 
2749 #ifdef __cplusplus /* generic alloc/dealloc fns*/
2750 #define SWIG_ALLOC_ARRAY(TYPE,LEN) new TYPE[LEN]
2751 #define SWIG_FREE_ARRAY(PTR) delete[] PTR
2752 #else
2753 #define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE))
2754 #define SWIG_FREE_ARRAY(PTR) free(PTR)
2755 #endif
2756 /* counting the size of arrays:*/
2757 SWIGINTERN int SWIG_itable_size(lua_State* L, int index)
2758 {
2759  int n=0;
2760  while(1){
2761  lua_rawgeti(L,index,n+1);
2762  if (lua_isnil(L,-1))break;
2763  ++n;
2764  lua_pop(L,1);
2765  }
2766  lua_pop(L,1);
2767  return n;
2768 }
2769 
2770 SWIGINTERN int SWIG_table_size(lua_State* L, int index)
2771 {
2772  int n=0;
2773  lua_pushnil(L); /* first key*/
2774  while (lua_next(L, index) != 0) {
2775  ++n;
2776  lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/
2777  }
2778  return n;
2779 }
2780 
2781 /* super macro to declare array typemap helper fns */
2782 #define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\
2783  SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\
2784  int i;\
2785  for (i = 0; i < size; i++) {\
2786  lua_rawgeti(L,index,i+1);\
2787  if (lua_isnumber(L,-1)){\
2788  array[i] = (TYPE)lua_tonumber(L,-1);\
2789  } else {\
2790  lua_pop(L,1);\
2791  return 0;\
2792  }\
2793  lua_pop(L,1);\
2794  }\
2795  return 1;\
2796  }\
2797  SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\
2798  TYPE *array;\
2799  if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\
2800  SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\
2801  return 0;\
2802  }\
2803  array=SWIG_ALLOC_ARRAY(TYPE,size);\
2804  if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\
2805  SWIG_Lua_pusherrstring(L,"table must contain numbers");\
2806  SWIG_FREE_ARRAY(array);\
2807  return 0;\
2808  }\
2809  return array;\
2810  }\
2811  SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\
2812  {\
2813  TYPE *array;\
2814  if (!lua_istable(L,index)) {\
2815  SWIG_Lua_pusherrstring(L,"expected a table");\
2816  return 0;\
2817  }\
2818  *size=SWIG_itable_size(L,index);\
2819  if (*size<1){\
2820  SWIG_Lua_pusherrstring(L,"table appears to be empty");\
2821  return 0;\
2822  }\
2823  array=SWIG_ALLOC_ARRAY(TYPE,*size);\
2824  if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\
2825  SWIG_Lua_pusherrstring(L,"table must contain numbers");\
2826  SWIG_FREE_ARRAY(array);\
2827  return 0;\
2828  }\
2829  return array;\
2830  }\
2831  SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\
2832  int i;\
2833  lua_newtable(L);\
2834  for (i = 0; i < size; i++){\
2835  lua_pushnumber(L,(lua_Number)array[i]);\
2836  lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \
2837  }\
2838  }
2839 
2840 SWIG_DECLARE_TYPEMAP_ARR_FN(schar,signed char)
2841 SWIG_DECLARE_TYPEMAP_ARR_FN(uchar,unsigned char)
2843 SWIG_DECLARE_TYPEMAP_ARR_FN(uint,unsigned int)
2844 SWIG_DECLARE_TYPEMAP_ARR_FN(short,short)
2845 SWIG_DECLARE_TYPEMAP_ARR_FN(ushort,unsigned short)
2846 SWIG_DECLARE_TYPEMAP_ARR_FN(long,long)
2847 SWIG_DECLARE_TYPEMAP_ARR_FN(ulong,unsigned long)
2848 SWIG_DECLARE_TYPEMAP_ARR_FN(float,float)
2849 SWIG_DECLARE_TYPEMAP_ARR_FN(double,double)
2850 
2851 SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){
2852  int i;
2853  for (i = 0; i < size; i++) {
2854  lua_rawgeti(L,index,i+1);
2855  if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){
2856  lua_pop(L,1);
2857  return 0;
2858  }
2859  lua_pop(L,1);
2860  }
2861  return 1;
2862 }
2863 SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){
2864  void **array;
2865  if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {
2866  SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);
2867  return 0;
2868  }
2869  array=SWIG_ALLOC_ARRAY(void*,size);
2870  if (!SWIG_read_ptr_array(L,index,array,size,type)){
2871  SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
2872  SWIG_FREE_ARRAY(array);
2873  return 0;
2874  }
2875  return array;
2876 }
2877 SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){
2878  void **array;
2879  if (!lua_istable(L,index)) {
2880  SWIG_Lua_pusherrstring(L,"expected a table");
2881  return 0;
2882  }
2883  *size=SWIG_itable_size(L,index);
2884  if (*size<1){
2885  SWIG_Lua_pusherrstring(L,"table appears to be empty");
2886  return 0;
2887  }
2888  array=SWIG_ALLOC_ARRAY(void*,*size);
2889  if (!SWIG_read_ptr_array(L,index,array,*size,type)){
2890  SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
2891  SWIG_FREE_ARRAY(array);
2892  return 0;
2893  }
2894  return array;
2895 }
2896 SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){
2897  int i;
2898  lua_newtable(L);
2899  for (i = 0; i < size; i++){
2900  SWIG_NewPointerObj(L,array[i],type,own);
2901  lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/
2902  }
2903 }
2904 
2905 
2906  PLFLT** read_double_Matrix( lua_State* L, int index, int* nx, int *ny );
2907 
2908  PLFLT** read_double_Matrix( lua_State* L, int index, int* nx, int *ny )
2909  {
2910  int i, j;
2911  PLFLT** matrix;
2912 
2913  *nx = 0;
2914  *ny = 0;
2915 
2916  if ( !lua_istable( L, index ) )
2917  {
2918  lua_pushstring( L, "expected a table" );
2919  return NULL;
2920  }
2921  *nx = SWIG_itable_size( L, index );
2922  if ( *nx < 1 )
2923  {
2924  lua_pushstring( L, "table appears to be empty" );
2925  return NULL;
2926  }
2927  matrix = LUA_ALLOC_ARRAY( PLFLT *, *nx );
2928  for ( i = 0; i < *nx; i++ )
2929  matrix[i] = NULL;
2930 
2931  lua_rawgeti( L, index, 1 );
2932  if ( !lua_istable( L, -1 ) )
2933  {
2934  lua_pop( L, 1 );
2935  lua_pushstring( L, "expected a table" );
2936  LUA_FREE_ARRAY( matrix );
2937  return NULL;
2938  }
2939  *ny = SWIG_itable_size( L, -1 );
2940  if ( *ny < 1 )
2941  {
2942  lua_pushstring( L, "table appears to be empty" );
2943  LUA_FREE_ARRAY( matrix );
2944  return NULL;
2945  }
2946  lua_pop( L, 1 );
2947 
2948  for ( i = 0; i < *nx; i++ )
2949  {
2950  lua_rawgeti( L, index, i + 1 );
2951  if ( !lua_istable( L, -1 ) )
2952  {
2953  lua_pop( L, 1 );
2954  lua_pushstring( L, "expected a table" );
2955  for ( j = 0; j < *ny; j++ )
2956  LUA_FREE_ARRAY( matrix[j] );
2957  LUA_FREE_ARRAY( matrix );
2958  return NULL;
2959  }
2960  if ( *ny != SWIG_itable_size( L, -1 ) )
2961  {
2962  lua_pop( L, 1 );
2963  lua_pushstring( L, "inconsistent table sizes" );
2964  for ( j = 0; j < i; j++ )
2965  LUA_FREE_ARRAY( matrix[j] );
2966  LUA_FREE_ARRAY( matrix );
2967  return NULL;
2968  }
2969  matrix[i] = LUA_ALLOC_ARRAY( PLFLT, *ny );
2970  for ( j = 0; j < *ny; j++ )
2971  {
2972  lua_rawgeti( L, -1, j + 1 );
2973  if ( lua_isnumber( L, -1 ) )
2974  {
2975  matrix[i][j] = (PLFLT) lua_tonumber( L, -1 );
2976  }
2977  else
2978  {
2979  lua_pop( L, 1 );
2980  lua_pushstring( L, "table must contain numbers" );
2981  for ( j = 0; j < i + 1; j++ )
2982  LUA_FREE_ARRAY( matrix[j] );
2983  LUA_FREE_ARRAY( matrix );
2984  return NULL;
2985  }
2986  lua_pop( L, 1 );
2987  }
2988  lua_pop( L, 1 );
2989  }
2990 
2991  return matrix;
2992  }
2993 
2994 
2995  void mapform( PLINT n, PLFLT* x, PLFLT* y );
2996 
2997  static lua_State* myL = NULL;
2998  static char mapform_funcstr[255];
2999 
3000  void mapform( PLINT n, PLFLT* x, PLFLT* y )
3001  {
3002  PLFLT *xtemp, *ytemp;
3003  int len, i;
3004 
3005  // check Lua state
3006  if ( myL == NULL )
3007  {
3008  fprintf( stderr, "Lua state is not set!" );
3009  return;
3010  }
3011 
3012  // push functions and arguments
3013  lua_getglobal( myL, mapform_funcstr ); // function to be called
3014  lua_pushnumber( myL, n ); // push 1st argument
3015  SWIG_write_double_num_array( myL, x, n ); // push 2nd argument
3016  SWIG_write_double_num_array( myL, y, n ); // push 3rd argument
3017 
3018  // do the call (3 arguments, 2 result)
3019  if ( lua_pcall( myL, 3, 2, 0 ) != 0 )
3020  fprintf( stderr, "error running function `%s':%s",
3021  mapform_funcstr, lua_tostring( myL, -1 ) );
3022 
3023  // retrieve results
3024  if ( !lua_istable( myL, -2 ) )
3025  {
3026  fprintf( stderr, "function `%s' must return a table as 1st result", mapform_funcstr );
3027  return;
3028  }
3029  if ( !lua_istable( myL, -1 ) )
3030  {
3031  fprintf( stderr, "function `%s' must return a table as 2nd result", mapform_funcstr );
3032  return;
3033  }
3034  xtemp = (PLFLT *) LUA_get_double_num_array_var( myL, -2, &len );
3035  if ( !xtemp || len != n )
3036  {
3037  fprintf( stderr, "function `%s' must return a table of length%d", mapform_funcstr, n );
3038  return;
3039  }
3040  for ( i = 0; i < n; i++ )
3041  x[i] = xtemp[i];
3042  LUA_FREE_ARRAY( xtemp );
3043 
3044  ytemp = (PLFLT *) LUA_get_double_num_array_var( myL, -1, &len );
3045  if ( !ytemp || len != n )
3046  {
3047  fprintf( stderr, "function `%s' must return a table of length%d", mapform_funcstr, n );
3048  return;
3049  }
3050  for ( i = 0; i < n; i++ )
3051  y[i] = ytemp[i];
3052  LUA_FREE_ARRAY( ytemp );
3053 
3054  lua_pop( myL, 2 ); // pop returned values
3055 
3056  return;
3057  }
3058 
3059 
3060  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3061  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3062  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3063  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3064  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3066  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
3067 
3068 // Function prototypes
3069  void mypltr( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void * pltr_data );
3070  void myct( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void * pltr_data );
3071  void mylabel( PLINT axis, PLFLT value, char* label, PLINT length, PLPointer data );
3072 
3073  static char mypltr_funcstr[255];
3074 
3075 // This is the callback that gets handed to the C code.
3076 // It, in turn, calls the Lua callback
3077  void mypltr( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void * PL_UNUSED( pltr_data ) )
3078  {
3079  *tx = 0;
3080  *ty = 0;
3081 
3082  // check Lua state
3083  if ( myL == NULL )
3084  {
3085  fprintf( stderr, "Lua state is not set!" );
3086  return;
3087  }
3088 
3089  // push functions and arguments
3090  lua_getglobal( myL, mypltr_funcstr ); // function to be called
3091  lua_pushnumber( myL, x ); // push 1st argument
3092  lua_pushnumber( myL, y ); // push 2nd argument
3093 
3094  // do the call (2 arguments, 2 result)
3095  if ( lua_pcall( myL, 2, 2, 0 ) != 0 )
3096  fprintf( stderr, "error running function `%s':%s",
3097  mypltr_funcstr, lua_tostring( myL, -1 ) );
3098 
3099  // retrieve results
3100  if ( !lua_isnumber( myL, -2 ) )
3101  {
3102  fprintf( stderr, "function `%s' must return a number as 1st result", mypltr_funcstr );
3103  return;
3104  }
3105  if ( !lua_isnumber( myL, -1 ) )
3106  {
3107  fprintf( stderr, "function `%s' must return a number as 2nd result", mypltr_funcstr );
3108  return;
3109  }
3110  *tx = lua_tonumber( myL, -2 );
3111  *ty = lua_tonumber( myL, -1 );
3112  lua_pop( myL, 2 ); // pop returned values
3113 
3114  return;
3115  }
3116 
3117  static char myct_funcstr[255];
3118 
3119 // This is the callback that gets handed to the C code.
3120 // It, in turn, calls the Lua callback
3121  void myct( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void * PL_UNUSED( pltr_data ) )
3122  {
3123  *tx = 0;
3124  *ty = 0;
3125 
3126  // check Lua state
3127  if ( myL == NULL )
3128  {
3129  fprintf( stderr, "Lua state is not set!" );
3130  return;
3131  }
3132 
3133  // push functions and arguments
3134  lua_getglobal( myL, myct_funcstr ); // function to be called
3135  lua_pushnumber( myL, x ); // push 1st argument
3136  lua_pushnumber( myL, y ); // push 2nd argument
3137 
3138  // do the call (2 arguments, 2 result)
3139  if ( lua_pcall( myL, 2, 2, 0 ) != 0 )
3140  fprintf( stderr, "error running function `%s':%s",
3141  myct_funcstr, lua_tostring( myL, -1 ) );
3142 
3143  // retrieve results
3144  if ( !lua_isnumber( myL, -2 ) )
3145  {
3146  fprintf( stderr, "function `%s' must return a number as 1st result", myct_funcstr );
3147  return;
3148  }
3149  if ( !lua_isnumber( myL, -1 ) )
3150  {
3151  fprintf( stderr, "function `%s' must return a number as 2nd result", myct_funcstr );
3152  return;
3153  }
3154  *tx = lua_tonumber( myL, -2 );
3155  *ty = lua_tonumber( myL, -1 );
3156  lua_pop( myL, 2 ); // pop returned values
3157 
3158  return;
3159  }
3160 
3161  static char mylabel_funcstr[255];
3162 
3163  void mylabel( PLINT axis, PLFLT value, char* label, PLINT length, PLPointer PL_UNUSED( data ) )
3164  {
3165  // check Lua state
3166  if ( myL == NULL )
3167  {
3168  fprintf( stderr, "Lua state is not set!" );
3169  return;
3170  }
3171 
3172  // push functions and arguments
3173  lua_getglobal( myL, mylabel_funcstr ); // function to be called
3174  lua_pushnumber( myL, axis ); // push 1st argument
3175  lua_pushnumber( myL, value ); // push 1st argument
3176 
3177  // do the call (2 arguments, 1 result)
3178  if ( lua_pcall( myL, 2, 1, 0 ) != 0 )
3179  fprintf( stderr, "error running function `%s':%s",
3180  mylabel_funcstr, lua_tostring( myL, -1 ) );
3181 
3182  // retrieve results
3183  if ( !lua_isstring( myL, -1 ) )
3184  {
3185  fprintf( stderr, "function `%s' must return a string as result", mylabel_funcstr );
3186  return;
3187  }
3188  strncpy( label, lua_tostring( myL, -1 ), length );
3189 
3190  lua_pop( myL, 1 ); // pop returned values
3191 
3192  return;
3193  }
3194 
3195 
3196 SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
3197  int ret = lua_isstring(L, idx);
3198  if (!ret)
3199  ret = lua_isnil(L, idx);
3200  return ret;
3201 }
3202 
3203 #ifdef __cplusplus
3204 extern "C" {
3205 #endif
3206 static int _wrap_PLGraphicsIn_type_set(lua_State* L) {
3207  int SWIG_arg = 0;
3208  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3209  int arg2 ;
3210 
3211  SWIG_check_num_args("PLGraphicsIn::type",2,2)
3212  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::type",1,"PLGraphicsIn *");
3213  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::type",2,"int");
3214 
3215  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3216  SWIG_fail_ptr("PLGraphicsIn_type_set",1,SWIGTYPE_p_PLGraphicsIn);
3217  }
3218 
3219  arg2 = (int)lua_tonumber(L, 2);
3220  if (arg1) (arg1)->type = arg2;
3221 
3222  return SWIG_arg;
3223 
3224  if(0) SWIG_fail;
3225 
3226 fail:
3227  lua_error(L);
3228  return SWIG_arg;
3229 }
3230 
3231 
3232 static int _wrap_PLGraphicsIn_type_get(lua_State* L) {
3233  int SWIG_arg = 0;
3234  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3235  int result;
3236 
3237  SWIG_check_num_args("PLGraphicsIn::type",1,1)
3238  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::type",1,"PLGraphicsIn *");
3239 
3240  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3241  SWIG_fail_ptr("PLGraphicsIn_type_get",1,SWIGTYPE_p_PLGraphicsIn);
3242  }
3243 
3244  result = (int) ((arg1)->type);
3245  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3246  return SWIG_arg;
3247 
3248  if(0) SWIG_fail;
3249 
3250 fail:
3251  lua_error(L);
3252  return SWIG_arg;
3253 }
3254 
3255 
3256 static int _wrap_PLGraphicsIn_state_set(lua_State* L) {
3257  int SWIG_arg = 0;
3258  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3259  unsigned int arg2 ;
3260 
3261  SWIG_check_num_args("PLGraphicsIn::state",2,2)
3262  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::state",1,"PLGraphicsIn *");
3263  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::state",2,"unsigned int");
3264 
3265  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3266  SWIG_fail_ptr("PLGraphicsIn_state_set",1,SWIGTYPE_p_PLGraphicsIn);
3267  }
3268 
3269  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
3270  arg2 = (unsigned int)lua_tonumber(L, 2);
3271  if (arg1) (arg1)->state = arg2;
3272 
3273  return SWIG_arg;
3274 
3275  if(0) SWIG_fail;
3276 
3277 fail:
3278  lua_error(L);
3279  return SWIG_arg;
3280 }
3281 
3282 
3283 static int _wrap_PLGraphicsIn_state_get(lua_State* L) {
3284  int SWIG_arg = 0;
3285  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3286  unsigned int result;
3287 
3288  SWIG_check_num_args("PLGraphicsIn::state",1,1)
3289  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::state",1,"PLGraphicsIn *");
3290 
3291  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3292  SWIG_fail_ptr("PLGraphicsIn_state_get",1,SWIGTYPE_p_PLGraphicsIn);
3293  }
3294 
3295  result = (unsigned int) ((arg1)->state);
3296  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3297  return SWIG_arg;
3298 
3299  if(0) SWIG_fail;
3300 
3301 fail:
3302  lua_error(L);
3303  return SWIG_arg;
3304 }
3305 
3306 
3307 static int _wrap_PLGraphicsIn_keysym_set(lua_State* L) {
3308  int SWIG_arg = 0;
3309  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3310  unsigned int arg2 ;
3311 
3312  SWIG_check_num_args("PLGraphicsIn::keysym",2,2)
3313  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::keysym",1,"PLGraphicsIn *");
3314  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::keysym",2,"unsigned int");
3315 
3316  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3317  SWIG_fail_ptr("PLGraphicsIn_keysym_set",1,SWIGTYPE_p_PLGraphicsIn);
3318  }
3319 
3320  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
3321  arg2 = (unsigned int)lua_tonumber(L, 2);
3322  if (arg1) (arg1)->keysym = arg2;
3323 
3324  return SWIG_arg;
3325 
3326  if(0) SWIG_fail;
3327 
3328 fail:
3329  lua_error(L);
3330  return SWIG_arg;
3331 }
3332 
3333 
3334 static int _wrap_PLGraphicsIn_keysym_get(lua_State* L) {
3335  int SWIG_arg = 0;
3336  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3337  unsigned int result;
3338 
3339  SWIG_check_num_args("PLGraphicsIn::keysym",1,1)
3340  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::keysym",1,"PLGraphicsIn *");
3341 
3342  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3343  SWIG_fail_ptr("PLGraphicsIn_keysym_get",1,SWIGTYPE_p_PLGraphicsIn);
3344  }
3345 
3346  result = (unsigned int) ((arg1)->keysym);
3347  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3348  return SWIG_arg;
3349 
3350  if(0) SWIG_fail;
3351 
3352 fail:
3353  lua_error(L);
3354  return SWIG_arg;
3355 }
3356 
3357 
3358 static int _wrap_PLGraphicsIn_button_set(lua_State* L) {
3359  int SWIG_arg = 0;
3360  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3361  unsigned int arg2 ;
3362 
3363  SWIG_check_num_args("PLGraphicsIn::button",2,2)
3364  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::button",1,"PLGraphicsIn *");
3365  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::button",2,"unsigned int");
3366 
3367  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3368  SWIG_fail_ptr("PLGraphicsIn_button_set",1,SWIGTYPE_p_PLGraphicsIn);
3369  }
3370 
3371  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
3372  arg2 = (unsigned int)lua_tonumber(L, 2);
3373  if (arg1) (arg1)->button = arg2;
3374 
3375  return SWIG_arg;
3376 
3377  if(0) SWIG_fail;
3378 
3379 fail:
3380  lua_error(L);
3381  return SWIG_arg;
3382 }
3383 
3384 
3385 static int _wrap_PLGraphicsIn_button_get(lua_State* L) {
3386  int SWIG_arg = 0;
3387  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3388  unsigned int result;
3389 
3390  SWIG_check_num_args("PLGraphicsIn::button",1,1)
3391  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::button",1,"PLGraphicsIn *");
3392 
3393  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3394  SWIG_fail_ptr("PLGraphicsIn_button_get",1,SWIGTYPE_p_PLGraphicsIn);
3395  }
3396 
3397  result = (unsigned int) ((arg1)->button);
3398  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3399  return SWIG_arg;
3400 
3401  if(0) SWIG_fail;
3402 
3403 fail:
3404  lua_error(L);
3405  return SWIG_arg;
3406 }
3407 
3408 
3409 static int _wrap_PLGraphicsIn_subwindow_set(lua_State* L) {
3410  int SWIG_arg = 0;
3411  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3412  PLINT arg2 ;
3413 
3414  SWIG_check_num_args("PLGraphicsIn::subwindow",2,2)
3415  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::subwindow",1,"PLGraphicsIn *");
3416  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::subwindow",2,"PLINT");
3417 
3418  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3419  SWIG_fail_ptr("PLGraphicsIn_subwindow_set",1,SWIGTYPE_p_PLGraphicsIn);
3420  }
3421 
3422  arg2 = (PLINT)lua_tonumber(L, 2);
3423  if (arg1) (arg1)->subwindow = arg2;
3424 
3425  return SWIG_arg;
3426 
3427  if(0) SWIG_fail;
3428 
3429 fail:
3430  lua_error(L);
3431  return SWIG_arg;
3432 }
3433 
3434 
3435 static int _wrap_PLGraphicsIn_subwindow_get(lua_State* L) {
3436  int SWIG_arg = 0;
3437  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3438  PLINT result;
3439 
3440  SWIG_check_num_args("PLGraphicsIn::subwindow",1,1)
3441  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::subwindow",1,"PLGraphicsIn *");
3442 
3443  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3444  SWIG_fail_ptr("PLGraphicsIn_subwindow_get",1,SWIGTYPE_p_PLGraphicsIn);
3445  }
3446 
3447  result = (PLINT) ((arg1)->subwindow);
3448  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3449  return SWIG_arg;
3450 
3451  if(0) SWIG_fail;
3452 
3453 fail:
3454  lua_error(L);
3455  return SWIG_arg;
3456 }
3457 
3458 
3459 static int _wrap_PLGraphicsIn_string_set(lua_State* L) {
3460  int SWIG_arg = 0;
3461  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3462  char *arg2 ;
3463 
3464  SWIG_check_num_args("PLGraphicsIn::string",2,2)
3465  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::string",1,"PLGraphicsIn *");
3466  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("PLGraphicsIn::string",2,"char [16]");
3467 
3468  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3469  SWIG_fail_ptr("PLGraphicsIn_string_set",1,SWIGTYPE_p_PLGraphicsIn);
3470  }
3471 
3472  arg2 = (char *)lua_tostring(L, 2);
3473  {
3474  if(arg2) {
3475  strncpy((char*)arg1->string, (const char *)arg2, 16-1);
3476  arg1->string[16-1] = 0;
3477  } else {
3478  arg1->string[0] = 0;
3479  }
3480  }
3481 
3482  return SWIG_arg;
3483 
3484  if(0) SWIG_fail;
3485 
3486 fail:
3487  lua_error(L);
3488  return SWIG_arg;
3489 }
3490 
3491 
3492 static int _wrap_PLGraphicsIn_string_get(lua_State* L) {
3493  int SWIG_arg = 0;
3494  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3495  char *result = 0 ;
3496 
3497  SWIG_check_num_args("PLGraphicsIn::string",1,1)
3498  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::string",1,"PLGraphicsIn *");
3499 
3500  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3501  SWIG_fail_ptr("PLGraphicsIn_string_get",1,SWIGTYPE_p_PLGraphicsIn);
3502  }
3503 
3504  result = (char *)(char *) ((arg1)->string);
3505  lua_pushstring(L,(const char *)result); SWIG_arg++;
3506  return SWIG_arg;
3507 
3508  if(0) SWIG_fail;
3509 
3510 fail:
3511  lua_error(L);
3512  return SWIG_arg;
3513 }
3514 
3515 
3516 static int _wrap_PLGraphicsIn_pX_set(lua_State* L) {
3517  int SWIG_arg = 0;
3518  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3519  int arg2 ;
3520 
3521  SWIG_check_num_args("PLGraphicsIn::pX",2,2)
3522  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::pX",1,"PLGraphicsIn *");
3523  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::pX",2,"int");
3524 
3525  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3526  SWIG_fail_ptr("PLGraphicsIn_pX_set",1,SWIGTYPE_p_PLGraphicsIn);
3527  }
3528 
3529  arg2 = (int)lua_tonumber(L, 2);
3530  if (arg1) (arg1)->pX = arg2;
3531 
3532  return SWIG_arg;
3533 
3534  if(0) SWIG_fail;
3535 
3536 fail:
3537  lua_error(L);
3538  return SWIG_arg;
3539 }
3540 
3541 
3542 static int _wrap_PLGraphicsIn_pX_get(lua_State* L) {
3543  int SWIG_arg = 0;
3544  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3545  int result;
3546 
3547  SWIG_check_num_args("PLGraphicsIn::pX",1,1)
3548  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::pX",1,"PLGraphicsIn *");
3549 
3550  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3551  SWIG_fail_ptr("PLGraphicsIn_pX_get",1,SWIGTYPE_p_PLGraphicsIn);
3552  }
3553 
3554  result = (int) ((arg1)->pX);
3555  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3556  return SWIG_arg;
3557 
3558  if(0) SWIG_fail;
3559 
3560 fail:
3561  lua_error(L);
3562  return SWIG_arg;
3563 }
3564 
3565 
3566 static int _wrap_PLGraphicsIn_pY_set(lua_State* L) {
3567  int SWIG_arg = 0;
3568  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3569  int arg2 ;
3570 
3571  SWIG_check_num_args("PLGraphicsIn::pY",2,2)
3572  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::pY",1,"PLGraphicsIn *");
3573  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::pY",2,"int");
3574 
3575  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3576  SWIG_fail_ptr("PLGraphicsIn_pY_set",1,SWIGTYPE_p_PLGraphicsIn);
3577  }
3578 
3579  arg2 = (int)lua_tonumber(L, 2);
3580  if (arg1) (arg1)->pY = arg2;
3581 
3582  return SWIG_arg;
3583 
3584  if(0) SWIG_fail;
3585 
3586 fail:
3587  lua_error(L);
3588  return SWIG_arg;
3589 }
3590 
3591 
3592 static int _wrap_PLGraphicsIn_pY_get(lua_State* L) {
3593  int SWIG_arg = 0;
3594  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3595  int result;
3596 
3597  SWIG_check_num_args("PLGraphicsIn::pY",1,1)
3598  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::pY",1,"PLGraphicsIn *");
3599 
3600  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3601  SWIG_fail_ptr("PLGraphicsIn_pY_get",1,SWIGTYPE_p_PLGraphicsIn);
3602  }
3603 
3604  result = (int) ((arg1)->pY);
3605  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3606  return SWIG_arg;
3607 
3608  if(0) SWIG_fail;
3609 
3610 fail:
3611  lua_error(L);
3612  return SWIG_arg;
3613 }
3614 
3615 
3616 static int _wrap_PLGraphicsIn_dX_set(lua_State* L) {
3617  int SWIG_arg = 0;
3618  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3619  PLFLT arg2 ;
3620 
3621  SWIG_check_num_args("PLGraphicsIn::dX",2,2)
3622  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::dX",1,"PLGraphicsIn *");
3623  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::dX",2,"PLFLT");
3624 
3625  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3626  SWIG_fail_ptr("PLGraphicsIn_dX_set",1,SWIGTYPE_p_PLGraphicsIn);
3627  }
3628 
3629  arg2 = (PLFLT)lua_tonumber(L, 2);
3630  if (arg1) (arg1)->dX = arg2;
3631 
3632  return SWIG_arg;
3633 
3634  if(0) SWIG_fail;
3635 
3636 fail:
3637  lua_error(L);
3638  return SWIG_arg;
3639 }
3640 
3641 
3642 static int _wrap_PLGraphicsIn_dX_get(lua_State* L) {
3643  int SWIG_arg = 0;
3644  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3645  PLFLT result;
3646 
3647  SWIG_check_num_args("PLGraphicsIn::dX",1,1)
3648  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::dX",1,"PLGraphicsIn *");
3649 
3650  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3651  SWIG_fail_ptr("PLGraphicsIn_dX_get",1,SWIGTYPE_p_PLGraphicsIn);
3652  }
3653 
3654  result = (PLFLT) ((arg1)->dX);
3655  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3656  return SWIG_arg;
3657 
3658  if(0) SWIG_fail;
3659 
3660 fail:
3661  lua_error(L);
3662  return SWIG_arg;
3663 }
3664 
3665 
3666 static int _wrap_PLGraphicsIn_dY_set(lua_State* L) {
3667  int SWIG_arg = 0;
3668  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3669  PLFLT arg2 ;
3670 
3671  SWIG_check_num_args("PLGraphicsIn::dY",2,2)
3672  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::dY",1,"PLGraphicsIn *");
3673  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::dY",2,"PLFLT");
3674 
3675  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3676  SWIG_fail_ptr("PLGraphicsIn_dY_set",1,SWIGTYPE_p_PLGraphicsIn);
3677  }
3678 
3679  arg2 = (PLFLT)lua_tonumber(L, 2);
3680  if (arg1) (arg1)->dY = arg2;
3681 
3682  return SWIG_arg;
3683 
3684  if(0) SWIG_fail;
3685 
3686 fail:
3687  lua_error(L);
3688  return SWIG_arg;
3689 }
3690 
3691 
3692 static int _wrap_PLGraphicsIn_dY_get(lua_State* L) {
3693  int SWIG_arg = 0;
3694  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3695  PLFLT result;
3696 
3697  SWIG_check_num_args("PLGraphicsIn::dY",1,1)
3698  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::dY",1,"PLGraphicsIn *");
3699 
3700  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3701  SWIG_fail_ptr("PLGraphicsIn_dY_get",1,SWIGTYPE_p_PLGraphicsIn);
3702  }
3703 
3704  result = (PLFLT) ((arg1)->dY);
3705  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3706  return SWIG_arg;
3707 
3708  if(0) SWIG_fail;
3709 
3710 fail:
3711  lua_error(L);
3712  return SWIG_arg;
3713 }
3714 
3715 
3716 static int _wrap_PLGraphicsIn_wX_set(lua_State* L) {
3717  int SWIG_arg = 0;
3718  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3719  PLFLT arg2 ;
3720 
3721  SWIG_check_num_args("PLGraphicsIn::wX",2,2)
3722  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::wX",1,"PLGraphicsIn *");
3723  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::wX",2,"PLFLT");
3724 
3725  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3726  SWIG_fail_ptr("PLGraphicsIn_wX_set",1,SWIGTYPE_p_PLGraphicsIn);
3727  }
3728 
3729  arg2 = (PLFLT)lua_tonumber(L, 2);
3730  if (arg1) (arg1)->wX = arg2;
3731 
3732  return SWIG_arg;
3733 
3734  if(0) SWIG_fail;
3735 
3736 fail:
3737  lua_error(L);
3738  return SWIG_arg;
3739 }
3740 
3741 
3742 static int _wrap_PLGraphicsIn_wX_get(lua_State* L) {
3743  int SWIG_arg = 0;
3744  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3745  PLFLT result;
3746 
3747  SWIG_check_num_args("PLGraphicsIn::wX",1,1)
3748  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::wX",1,"PLGraphicsIn *");
3749 
3750  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3751  SWIG_fail_ptr("PLGraphicsIn_wX_get",1,SWIGTYPE_p_PLGraphicsIn);
3752  }
3753 
3754  result = (PLFLT) ((arg1)->wX);
3755  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3756  return SWIG_arg;
3757 
3758  if(0) SWIG_fail;
3759 
3760 fail:
3761  lua_error(L);
3762  return SWIG_arg;
3763 }
3764 
3765 
3766 static int _wrap_PLGraphicsIn_wY_set(lua_State* L) {
3767  int SWIG_arg = 0;
3768  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3769  PLFLT arg2 ;
3770 
3771  SWIG_check_num_args("PLGraphicsIn::wY",2,2)
3772  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::wY",1,"PLGraphicsIn *");
3773  if(!lua_isnumber(L,2)) SWIG_fail_arg("PLGraphicsIn::wY",2,"PLFLT");
3774 
3775  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3776  SWIG_fail_ptr("PLGraphicsIn_wY_set",1,SWIGTYPE_p_PLGraphicsIn);
3777  }
3778 
3779  arg2 = (PLFLT)lua_tonumber(L, 2);
3780  if (arg1) (arg1)->wY = arg2;
3781 
3782  return SWIG_arg;
3783 
3784  if(0) SWIG_fail;
3785 
3786 fail:
3787  lua_error(L);
3788  return SWIG_arg;
3789 }
3790 
3791 
3792 static int _wrap_PLGraphicsIn_wY_get(lua_State* L) {
3793  int SWIG_arg = 0;
3794  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3795  PLFLT result;
3796 
3797  SWIG_check_num_args("PLGraphicsIn::wY",1,1)
3798  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("PLGraphicsIn::wY",1,"PLGraphicsIn *");
3799 
3800  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
3801  SWIG_fail_ptr("PLGraphicsIn_wY_get",1,SWIGTYPE_p_PLGraphicsIn);
3802  }
3803 
3804  result = (PLFLT) ((arg1)->wY);
3805  lua_pushnumber(L, (lua_Number) result); 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 int _wrap_new_PLGraphicsIn(lua_State* L) {
3817  int SWIG_arg = 0;
3818  PLGraphicsIn *result = 0 ;
3819 
3820  SWIG_check_num_args("PLGraphicsIn::PLGraphicsIn",0,0)
3821  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
3822  SWIG_NewPointerObj(L,result,SWIGTYPE_p_PLGraphicsIn,1); SWIG_arg++;
3823  return SWIG_arg;
3824 
3825  if(0) SWIG_fail;
3826 
3827 fail:
3828  lua_error(L);
3829  return SWIG_arg;
3830 }
3831 
3832 
3833 static void swig_delete_PLGraphicsIn(void *obj) {
3834 PLGraphicsIn *arg1 = (PLGraphicsIn *) obj;
3835 free((char *) arg1);
3836 }
3837 static int _proxy__wrap_new_PLGraphicsIn(lua_State *L) {
3838  assert(lua_istable(L,1));
3839  lua_pushcfunction(L,_wrap_new_PLGraphicsIn);
3840  assert(!lua_isnil(L,-1));
3841  lua_replace(L,1); /* replace our table with real constructor */
3842  lua_call(L,lua_gettop(L)-1,1);
3843  return 1;
3844 }
3858  {0,0,0}
3859 };
3861  {0,0}
3862 };
3864  {0,0}
3865 };
3866 
3868  {0,0,0}
3869 };
3871  {0,0,0,0,0,0}
3872 };
3874  {0,0}
3875 };
3877  0
3878 };
3879 
3881  "PLGraphicsIn",
3886  0
3887 };
3889 static const char *swig_PLGraphicsIn_base_names[] = {0};
3891 
3892 static int _wrap_setcontlabelformat(lua_State* L) {
3893  int SWIG_arg = 0;
3894  PLINT arg1 ;
3895  PLINT arg2 ;
3896 
3897  SWIG_check_num_args("pl_setcontlabelformat",2,2)
3898  if(!lua_isnumber(L,1)) SWIG_fail_arg("pl_setcontlabelformat",1,"PLINT");
3899  if(!lua_isnumber(L,2)) SWIG_fail_arg("pl_setcontlabelformat",2,"PLINT");
3900  arg1 = (PLINT)lua_tonumber(L, 1);
3901  arg2 = (PLINT)lua_tonumber(L, 2);
3902  pl_setcontlabelformat(arg1,arg2);
3903 
3904  return SWIG_arg;
3905 
3906  if(0) SWIG_fail;
3907 
3908 fail:
3909  lua_error(L);
3910  return SWIG_arg;
3911 }
3912 
3913 
3914 static int _wrap_setcontlabelparam(lua_State* L) {
3915  int SWIG_arg = 0;
3916  PLFLT arg1 ;
3917  PLFLT arg2 ;
3918  PLFLT arg3 ;
3919  PLINT arg4 ;
3920 
3921  SWIG_check_num_args("pl_setcontlabelparam",4,4)
3922  if(!lua_isnumber(L,1)) SWIG_fail_arg("pl_setcontlabelparam",1,"PLFLT");
3923  if(!lua_isnumber(L,2)) SWIG_fail_arg("pl_setcontlabelparam",2,"PLFLT");
3924  if(!lua_isnumber(L,3)) SWIG_fail_arg("pl_setcontlabelparam",3,"PLFLT");
3925  if(!lua_isnumber(L,4)) SWIG_fail_arg("pl_setcontlabelparam",4,"PLINT");
3926  arg1 = (PLFLT)lua_tonumber(L, 1);
3927  arg2 = (PLFLT)lua_tonumber(L, 2);
3928  arg3 = (PLFLT)lua_tonumber(L, 3);
3929  arg4 = (PLINT)lua_tonumber(L, 4);
3930  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
3931 
3932  return SWIG_arg;
3933 
3934  if(0) SWIG_fail;
3935 
3936 fail:
3937  lua_error(L);
3938  return SWIG_arg;
3939 }
3940 
3941 
3942 static int _wrap_adv(lua_State* L) {
3943  int SWIG_arg = 0;
3944  PLINT arg1 ;
3945 
3946  SWIG_check_num_args("pladv",1,1)
3947  if(!lua_isnumber(L,1)) SWIG_fail_arg("pladv",1,"PLINT");
3948  arg1 = (PLINT)lua_tonumber(L, 1);
3949  pladv(arg1);
3950 
3951  return SWIG_arg;
3952 
3953  if(0) SWIG_fail;
3954 
3955 fail:
3956  lua_error(L);
3957  return SWIG_arg;
3958 }
3959 
3960 
3961 static int _wrap_arc(lua_State* L) {
3962  int SWIG_arg = 0;
3963  PLFLT arg1 ;
3964  PLFLT arg2 ;
3965  PLFLT arg3 ;
3966  PLFLT arg4 ;
3967  PLFLT arg5 ;
3968  PLFLT arg6 ;
3969  PLFLT arg7 ;
3970  PLBOOL arg8 ;
3971 
3972  SWIG_check_num_args("plarc",8,8)
3973  if(!lua_isnumber(L,1)) SWIG_fail_arg("plarc",1,"PLFLT");
3974  if(!lua_isnumber(L,2)) SWIG_fail_arg("plarc",2,"PLFLT");
3975  if(!lua_isnumber(L,3)) SWIG_fail_arg("plarc",3,"PLFLT");
3976  if(!lua_isnumber(L,4)) SWIG_fail_arg("plarc",4,"PLFLT");
3977  if(!lua_isnumber(L,5)) SWIG_fail_arg("plarc",5,"PLFLT");
3978  if(!lua_isnumber(L,6)) SWIG_fail_arg("plarc",6,"PLFLT");
3979  if(!lua_isnumber(L,7)) SWIG_fail_arg("plarc",7,"PLFLT");
3980  if(!lua_isnumber(L,8)) SWIG_fail_arg("plarc",8,"PLBOOL");
3981  arg1 = (PLFLT)lua_tonumber(L, 1);
3982  arg2 = (PLFLT)lua_tonumber(L, 2);
3983  arg3 = (PLFLT)lua_tonumber(L, 3);
3984  arg4 = (PLFLT)lua_tonumber(L, 4);
3985  arg5 = (PLFLT)lua_tonumber(L, 5);
3986  arg6 = (PLFLT)lua_tonumber(L, 6);
3987  arg7 = (PLFLT)lua_tonumber(L, 7);
3988  arg8 = (PLBOOL)lua_tonumber(L, 8);
3989  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3990 
3991  return SWIG_arg;
3992 
3993  if(0) SWIG_fail;
3994 
3995 fail:
3996  lua_error(L);
3997  return SWIG_arg;
3998 }
3999 
4000 
4001 static int _wrap_axes(lua_State* L) {
4002  int SWIG_arg = 0;
4003  PLFLT arg1 ;
4004  PLFLT arg2 ;
4005  char *arg3 = (char *) 0 ;
4006  PLFLT arg4 ;
4007  PLINT arg5 ;
4008  char *arg6 = (char *) 0 ;
4009  PLFLT arg7 ;
4010  PLINT arg8 ;
4011 
4012  SWIG_check_num_args("plaxes",8,8)
4013  if(!lua_isnumber(L,1)) SWIG_fail_arg("plaxes",1,"PLFLT");
4014  if(!lua_isnumber(L,2)) SWIG_fail_arg("plaxes",2,"PLFLT");
4015  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("plaxes",3,"char const *");
4016  if(!lua_isnumber(L,4)) SWIG_fail_arg("plaxes",4,"PLFLT");
4017  if(!lua_isnumber(L,5)) SWIG_fail_arg("plaxes",5,"PLINT");
4018  if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("plaxes",6,"char const *");
4019  if(!lua_isnumber(L,7)) SWIG_fail_arg("plaxes",7,"PLFLT");
4020  if(!lua_isnumber(L,8)) SWIG_fail_arg("plaxes",8,"PLINT");
4021  arg1 = (PLFLT)lua_tonumber(L, 1);
4022  arg2 = (PLFLT)lua_tonumber(L, 2);
4023  arg3 = (char *)lua_tostring(L, 3);
4024  arg4 = (PLFLT)lua_tonumber(L, 4);
4025  arg5 = (PLINT)lua_tonumber(L, 5);
4026  arg6 = (char *)lua_tostring(L, 6);
4027  arg7 = (PLFLT)lua_tonumber(L, 7);
4028  arg8 = (PLINT)lua_tonumber(L, 8);
4029  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
4030 
4031  return SWIG_arg;
4032 
4033  if(0) SWIG_fail;
4034 
4035 fail:
4036  lua_error(L);
4037  return SWIG_arg;
4038 }
4039 
4040 
4041 static int _wrap_bin(lua_State* L) {
4042  int SWIG_arg = 0;
4043  PLINT arg1 ;
4044  PLFLT *arg2 = (PLFLT *) 0 ;
4045  PLFLT *arg3 = (PLFLT *) 0 ;
4046  PLINT arg4 ;
4047  int temp3 ;
4048 
4049  SWIG_check_num_args("plbin",3,3)
4050  if(!lua_isnumber(L,3)) SWIG_fail_arg("plbin",3,"PLINT");
4051  {
4052  int temp;
4053  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
4054  if ( !arg2 )
4055  SWIG_fail;
4056  arg1 = Alen = temp;
4057  }
4058  {
4059  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
4060  if ( !arg3 )
4061  SWIG_fail;
4062  if ( temp3 != Alen )
4063  {
4064  lua_pushfstring( L, "Tables must be of same length." );
4065  SWIG_fail;
4066  }
4067  }
4068  arg4 = (PLINT)lua_tonumber(L, 3);
4069  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
4070 
4071  {
4072  LUA_FREE_ARRAY( arg2 );
4073  }
4074  {
4075  LUA_FREE_ARRAY( arg3 );
4076  }
4077  return SWIG_arg;
4078 
4079  if(0) SWIG_fail;
4080 
4081 fail:
4082  {
4083  LUA_FREE_ARRAY( arg2 );
4084  }
4085  {
4086  LUA_FREE_ARRAY( arg3 );
4087  }
4088  lua_error(L);
4089  return SWIG_arg;
4090 }
4091 
4092 
4093 static int _wrap_btime(lua_State* L) {
4094  int SWIG_arg = 0;
4095  PLINT *arg1 = (PLINT *) 0 ;
4096  PLINT *arg2 = (PLINT *) 0 ;
4097  PLINT *arg3 = (PLINT *) 0 ;
4098  PLINT *arg4 = (PLINT *) 0 ;
4099  PLINT *arg5 = (PLINT *) 0 ;
4100  PLFLT *arg6 = (PLFLT *) 0 ;
4101  PLFLT arg7 ;
4102  PLINT temp1 ;
4103  PLINT temp2 ;
4104  PLINT temp3 ;
4105  PLINT temp4 ;
4106  PLINT temp5 ;
4107  PLFLT temp6 ;
4108 
4109  arg1 = &temp1;
4110  arg2 = &temp2;
4111  arg3 = &temp3;
4112  arg4 = &temp4;
4113  arg5 = &temp5;
4114  arg6 = &temp6;
4115  SWIG_check_num_args("plbtime",1,1)
4116  if(!lua_isnumber(L,1)) SWIG_fail_arg("plbtime",1,"PLFLT");
4117  arg7 = (PLFLT)lua_tonumber(L, 1);
4118  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4119 
4120  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
4121  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
4122  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
4123  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
4124  lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
4125  lua_pushnumber(L, (lua_Number) *arg6); SWIG_arg++;
4126  return SWIG_arg;
4127 
4128  if(0) SWIG_fail;
4129 
4130 fail:
4131  lua_error(L);
4132  return SWIG_arg;
4133 }
4134 
4135 
4136 static int _wrap_bop(lua_State* L) {
4137  int SWIG_arg = 0;
4138 
4139  SWIG_check_num_args("plbop",0,0)
4140  plbop();
4141 
4142  return SWIG_arg;
4143 
4144  if(0) SWIG_fail;
4145 
4146 fail:
4147  lua_error(L);
4148  return SWIG_arg;
4149 }
4150 
4151 
4152 static int _wrap_box(lua_State* L) {
4153  int SWIG_arg = 0;
4154  char *arg1 = (char *) 0 ;
4155  PLFLT arg2 ;
4156  PLINT arg3 ;
4157  char *arg4 = (char *) 0 ;
4158  PLFLT arg5 ;
4159  PLINT arg6 ;
4160 
4161  SWIG_check_num_args("plbox",6,6)
4162  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plbox",1,"char const *");
4163  if(!lua_isnumber(L,2)) SWIG_fail_arg("plbox",2,"PLFLT");
4164  if(!lua_isnumber(L,3)) SWIG_fail_arg("plbox",3,"PLINT");
4165  if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("plbox",4,"char const *");
4166  if(!lua_isnumber(L,5)) SWIG_fail_arg("plbox",5,"PLFLT");
4167  if(!lua_isnumber(L,6)) SWIG_fail_arg("plbox",6,"PLINT");
4168  arg1 = (char *)lua_tostring(L, 1);
4169  arg2 = (PLFLT)lua_tonumber(L, 2);
4170  arg3 = (PLINT)lua_tonumber(L, 3);
4171  arg4 = (char *)lua_tostring(L, 4);
4172  arg5 = (PLFLT)lua_tonumber(L, 5);
4173  arg6 = (PLINT)lua_tonumber(L, 6);
4174  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
4175 
4176  return SWIG_arg;
4177 
4178  if(0) SWIG_fail;
4179 
4180 fail:
4181  lua_error(L);
4182  return SWIG_arg;
4183 }
4184 
4185 
4186 static int _wrap_box3(lua_State* L) {
4187  int SWIG_arg = 0;
4188  char *arg1 = (char *) 0 ;
4189  char *arg2 = (char *) 0 ;
4190  PLFLT arg3 ;
4191  PLINT arg4 ;
4192  char *arg5 = (char *) 0 ;
4193  char *arg6 = (char *) 0 ;
4194  PLFLT arg7 ;
4195  PLINT arg8 ;
4196  char *arg9 = (char *) 0 ;
4197  char *arg10 = (char *) 0 ;
4198  PLFLT arg11 ;
4199  PLINT arg12 ;
4200 
4201  SWIG_check_num_args("plbox3",12,12)
4202  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plbox3",1,"char const *");
4203  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plbox3",2,"char const *");
4204  if(!lua_isnumber(L,3)) SWIG_fail_arg("plbox3",3,"PLFLT");
4205  if(!lua_isnumber(L,4)) SWIG_fail_arg("plbox3",4,"PLINT");
4206  if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("plbox3",5,"char const *");
4207  if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("plbox3",6,"char const *");
4208  if(!lua_isnumber(L,7)) SWIG_fail_arg("plbox3",7,"PLFLT");
4209  if(!lua_isnumber(L,8)) SWIG_fail_arg("plbox3",8,"PLINT");
4210  if(!SWIG_lua_isnilstring(L,9)) SWIG_fail_arg("plbox3",9,"char const *");
4211  if(!SWIG_lua_isnilstring(L,10)) SWIG_fail_arg("plbox3",10,"char const *");
4212  if(!lua_isnumber(L,11)) SWIG_fail_arg("plbox3",11,"PLFLT");
4213  if(!lua_isnumber(L,12)) SWIG_fail_arg("plbox3",12,"PLINT");
4214  arg1 = (char *)lua_tostring(L, 1);
4215  arg2 = (char *)lua_tostring(L, 2);
4216  arg3 = (PLFLT)lua_tonumber(L, 3);
4217  arg4 = (PLINT)lua_tonumber(L, 4);
4218  arg5 = (char *)lua_tostring(L, 5);
4219  arg6 = (char *)lua_tostring(L, 6);
4220  arg7 = (PLFLT)lua_tonumber(L, 7);
4221  arg8 = (PLINT)lua_tonumber(L, 8);
4222  arg9 = (char *)lua_tostring(L, 9);
4223  arg10 = (char *)lua_tostring(L, 10);
4224  arg11 = (PLFLT)lua_tonumber(L, 11);
4225  arg12 = (PLINT)lua_tonumber(L, 12);
4226  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);
4227 
4228  return SWIG_arg;
4229 
4230  if(0) SWIG_fail;
4231 
4232 fail:
4233  lua_error(L);
4234  return SWIG_arg;
4235 }
4236 
4237 
4238 static int _wrap_calc_world(lua_State* L) {
4239  int SWIG_arg = 0;
4240  PLFLT arg1 ;
4241  PLFLT arg2 ;
4242  PLFLT *arg3 = (PLFLT *) 0 ;
4243  PLFLT *arg4 = (PLFLT *) 0 ;
4244  PLINT *arg5 = (PLINT *) 0 ;
4245  PLFLT temp3 ;
4246  PLFLT temp4 ;
4247  PLINT temp5 ;
4248 
4249  arg3 = &temp3;
4250  arg4 = &temp4;
4251  arg5 = &temp5;
4252  SWIG_check_num_args("plcalc_world",2,2)
4253  if(!lua_isnumber(L,1)) SWIG_fail_arg("plcalc_world",1,"PLFLT");
4254  if(!lua_isnumber(L,2)) SWIG_fail_arg("plcalc_world",2,"PLFLT");
4255  arg1 = (PLFLT)lua_tonumber(L, 1);
4256  arg2 = (PLFLT)lua_tonumber(L, 2);
4257  plcalc_world(arg1,arg2,arg3,arg4,arg5);
4258 
4259  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
4260  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
4261  lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
4262  return SWIG_arg;
4263 
4264  if(0) SWIG_fail;
4265 
4266 fail:
4267  lua_error(L);
4268  return SWIG_arg;
4269 }
4270 
4271 
4272 static int _wrap_clear(lua_State* L) {
4273  int SWIG_arg = 0;
4274 
4275  SWIG_check_num_args("plclear",0,0)
4276  plclear();
4277 
4278  return SWIG_arg;
4279 
4280  if(0) SWIG_fail;
4281 
4282 fail:
4283  lua_error(L);
4284  return SWIG_arg;
4285 }
4286 
4287 
4288 static int _wrap_col0(lua_State* L) {
4289  int SWIG_arg = 0;
4290  PLINT arg1 ;
4291 
4292  SWIG_check_num_args("plcol0",1,1)
4293  if(!lua_isnumber(L,1)) SWIG_fail_arg("plcol0",1,"PLINT");
4294  arg1 = (PLINT)lua_tonumber(L, 1);
4295  plcol0(arg1);
4296 
4297  return SWIG_arg;
4298 
4299  if(0) SWIG_fail;
4300 
4301 fail:
4302  lua_error(L);
4303  return SWIG_arg;
4304 }
4305 
4306 
4307 static int _wrap_col1(lua_State* L) {
4308  int SWIG_arg = 0;
4309  PLFLT arg1 ;
4310 
4311  SWIG_check_num_args("plcol1",1,1)
4312  if(!lua_isnumber(L,1)) SWIG_fail_arg("plcol1",1,"PLFLT");
4313  arg1 = (PLFLT)lua_tonumber(L, 1);
4314  plcol1(arg1);
4315 
4316  return SWIG_arg;
4317 
4318  if(0) SWIG_fail;
4319 
4320 fail:
4321  lua_error(L);
4322  return SWIG_arg;
4323 }
4324 
4325 
4326 static int _wrap_configtime(lua_State* L) {
4327  int SWIG_arg = 0;
4328  PLFLT arg1 ;
4329  PLFLT arg2 ;
4330  PLFLT arg3 ;
4331  PLINT arg4 ;
4332  PLBOOL arg5 ;
4333  PLINT arg6 ;
4334  PLINT arg7 ;
4335  PLINT arg8 ;
4336  PLINT arg9 ;
4337  PLINT arg10 ;
4338  PLFLT arg11 ;
4339 
4340  SWIG_check_num_args("plconfigtime",11,11)
4341  if(!lua_isnumber(L,1)) SWIG_fail_arg("plconfigtime",1,"PLFLT");
4342  if(!lua_isnumber(L,2)) SWIG_fail_arg("plconfigtime",2,"PLFLT");
4343  if(!lua_isnumber(L,3)) SWIG_fail_arg("plconfigtime",3,"PLFLT");
4344  if(!lua_isnumber(L,4)) SWIG_fail_arg("plconfigtime",4,"PLINT");
4345  if(!lua_isnumber(L,5)) SWIG_fail_arg("plconfigtime",5,"PLBOOL");
4346  if(!lua_isnumber(L,6)) SWIG_fail_arg("plconfigtime",6,"PLINT");
4347  if(!lua_isnumber(L,7)) SWIG_fail_arg("plconfigtime",7,"PLINT");
4348  if(!lua_isnumber(L,8)) SWIG_fail_arg("plconfigtime",8,"PLINT");
4349  if(!lua_isnumber(L,9)) SWIG_fail_arg("plconfigtime",9,"PLINT");
4350  if(!lua_isnumber(L,10)) SWIG_fail_arg("plconfigtime",10,"PLINT");
4351  if(!lua_isnumber(L,11)) SWIG_fail_arg("plconfigtime",11,"PLFLT");
4352  arg1 = (PLFLT)lua_tonumber(L, 1);
4353  arg2 = (PLFLT)lua_tonumber(L, 2);
4354  arg3 = (PLFLT)lua_tonumber(L, 3);
4355  arg4 = (PLINT)lua_tonumber(L, 4);
4356  arg5 = (PLBOOL)lua_tonumber(L, 5);
4357  arg6 = (PLINT)lua_tonumber(L, 6);
4358  arg7 = (PLINT)lua_tonumber(L, 7);
4359  arg8 = (PLINT)lua_tonumber(L, 8);
4360  arg9 = (PLINT)lua_tonumber(L, 9);
4361  arg10 = (PLINT)lua_tonumber(L, 10);
4362  arg11 = (PLFLT)lua_tonumber(L, 11);
4363  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
4364 
4365  return SWIG_arg;
4366 
4367  if(0) SWIG_fail;
4368 
4369 fail:
4370  lua_error(L);
4371  return SWIG_arg;
4372 }
4373 
4374 
4375 static int _wrap_cont(lua_State* L) {
4376  int SWIG_arg = 0;
4377  PLFLT **arg1 = (PLFLT **) 0 ;
4378  PLINT arg2 ;
4379  PLINT arg3 ;
4380  PLINT arg4 ;
4381  PLINT arg5 ;
4382  PLINT arg6 ;
4383  PLINT arg7 ;
4384  PLFLT *arg8 = (PLFLT *) 0 ;
4385  PLINT arg9 ;
4386  pltr_func arg10 = (pltr_func) 0 ;
4387  PLPointer arg11 = (PLPointer) 0 ;
4388  int ii1 ;
4389  PLcGrid cgrid111 ;
4390  PLcGrid2 cgrid211 ;
4391 
4392  {
4393  cgrid111.xg = cgrid111.yg = cgrid111.zg = NULL;
4394  cgrid111.nx = cgrid111.ny = cgrid111.nz = 0;
4395  cgrid211.xg = cgrid211.yg = cgrid211.zg = NULL;
4396  cgrid211.nx = cgrid211.ny = 0;
4397  }
4398  {
4399  arg10 = NULL;
4400  }
4401  {
4402  arg11 = NULL;
4403  }
4404  SWIG_check_num_args("plcont",6,8)
4405  if(!lua_isnumber(L,2)) SWIG_fail_arg("plcont",2,"PLINT");
4406  if(!lua_isnumber(L,3)) SWIG_fail_arg("plcont",3,"PLINT");
4407  if(!lua_isnumber(L,4)) SWIG_fail_arg("plcont",4,"PLINT");
4408  if(!lua_isnumber(L,5)) SWIG_fail_arg("plcont",5,"PLINT");
4409  {
4410  int jj;
4411 
4412  arg1 = read_double_Matrix( L, 1, &ii1, &jj );
4413  if ( !arg1 )
4414  SWIG_fail;
4415  Xlen = arg2 = ii1;
4416  Ylen = arg3 = jj;
4417  }
4418  arg4 = (PLINT)lua_tonumber(L, 2);
4419  arg5 = (PLINT)lua_tonumber(L, 3);
4420  arg6 = (PLINT)lua_tonumber(L, 4);
4421  arg7 = (PLINT)lua_tonumber(L, 5);
4422  {
4423  int temp;
4424  arg8 = (PLFLT *) LUA_get_double_num_array_var( L, 6, &temp );
4425  if ( !arg8 )
4426  SWIG_fail;
4427  arg9 = Alen = temp;
4428  }
4429  if(lua_gettop(L)>=7){
4430  {
4431  arg10 = NULL;
4432  mypltr_funcstr[0] = '\0';
4433 
4434  if ( lua_isstring( L, 7 ) )
4435  {
4436  const char* funcstr = lua_tostring( L, 7 );
4437  if ( strcmp( "pltr0", funcstr ) == 0 )
4438  {
4439  arg10 = pltr0;
4440  }
4441  else if ( strcmp( "pltr1", funcstr ) == 0 )
4442  {
4443  arg10 = pltr1;
4444  }
4445  else if ( strcmp( "pltr2", funcstr ) == 0 )
4446  {
4447  arg10 = pltr2;
4448  }
4449  else
4450  {
4451  arg10 = mypltr;
4452  strncpy( mypltr_funcstr, funcstr, 255 );
4453  myL = L;
4454  }
4455  }
4456  else
4457  SWIG_fail_arg( "cont", 10, "pltr_func" );
4458  }
4459  }
4460  if(lua_gettop(L)>=8){
4461  {
4462  int nx, ny;
4463  int gridmode = 0;
4464 
4465  lua_pushstring( L, "xg" );
4466  lua_gettable( L, 8 );
4467  if ( !lua_istable( L, -1 ) )
4468  {
4469  lua_pop( L, 1 ); // pop "xg"
4470  lua_pushstring( L, "expected a table xg" );
4471  SWIG_fail;
4472  }
4473  lua_rawgeti( L, -1, 1 );
4474  if ( lua_istable( L, -1 ) )
4475  gridmode = 2; // two dimensional array
4476  else if ( lua_isnumber( L, -1 ) )
4477  gridmode = 1; // one dimensional array
4478  else
4479  {
4480  lua_pop( L, 1 ); // pop "1"
4481  lua_pop( L, 1 ); // pop "xg"
4482  lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
4483  SWIG_fail;
4484  }
4485  lua_pop( L, 1 ); // pop test element
4486  if ( gridmode == 1 )
4487  {
4488  cgrid111.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
4489  if ( !cgrid111.xg )
4490  {
4491  lua_pop( L, 1 ); // pop "xg"
4492  SWIG_fail;
4493  }
4494  if ( nx != Xlen )
4495  {
4496  lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
4497  SWIG_fail;
4498  }
4499  cgrid111.nx = nx;
4500  }
4501  else
4502  {
4503  cgrid211.xg = read_double_Matrix( L, -1, &nx, &ny );
4504  if ( !cgrid211.xg )
4505  {
4506  lua_pop( L, 1 ); // pop "xg"
4507  SWIG_fail;
4508  }
4509  if ( ( nx != Xlen ) || ( ny != Ylen ) )
4510  {
4511  lua_pop( L, 1 ); // pop "xg"
4512  lua_pushfstring( L, "Vectors must match matrix." );
4513  SWIG_fail;
4514  }
4515  cgrid211.nx = nx;
4516  cgrid211.ny = ny;
4517  }
4518  lua_pop( L, 1 ); // pop "xg"
4519 
4520  lua_pushstring( L, "yg" );
4521  lua_gettable( L, 8 );
4522  if ( !lua_istable( L, -1 ) )
4523  {
4524  lua_pop( L, 1 );
4525  lua_pushstring( L, "expected a table yg" );
4526  SWIG_fail;
4527  }
4528  lua_rawgeti( L, -1, 1 );
4529  if ( gridmode == 2 )
4530  {
4531  if ( !lua_istable( L, -1 ) )
4532  {
4533  lua_pop( L, 1 ); // pop "1"
4534  lua_pop( L, 1 ); // pop "yg"
4535  lua_pushstring( L, "expected a two dimensional array/table in yg" );
4536  SWIG_fail;
4537  }
4538  }
4539  else
4540  {
4541  if ( !lua_isnumber( L, -1 ) )
4542  {
4543  lua_pop( L, 1 ); // pop "1"
4544  lua_pop( L, 1 ); // pop "yg"
4545  lua_pushstring( L, "expected a one dimensional array/table in yg" );
4546  SWIG_fail;
4547  }
4548  }
4549  lua_pop( L, 1 ); // pop "1"
4550  if ( gridmode == 1 )
4551  {
4552  cgrid111.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
4553  if ( !cgrid111.yg )
4554  {
4555  lua_pop( L, 1 ); // pop "yg"
4556  SWIG_fail;
4557  }
4558  if ( ny != Ylen )
4559  {
4560  lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
4561  SWIG_fail;
4562  }
4563  cgrid111.ny = ny;
4564  }
4565  else
4566  {
4567  cgrid211.yg = read_double_Matrix( L, -1, &nx, &ny );
4568  if ( !cgrid211.yg )
4569  {
4570  lua_pop( L, 1 ); // pop "xg"
4571  SWIG_fail;
4572  }
4573  if ( ( nx != Xlen ) || ( ny != Ylen ) )
4574  {
4575  lua_pop( L, 1 ); // pop "xg"
4576  lua_pushfstring( L, "Vectors must match matrix." );
4577  SWIG_fail;
4578  }
4579  // cgrid211.nx/ny already set
4580  }
4581  lua_pop( L, 1 ); // pop "yg"
4582 
4583  if ( gridmode == 1 )
4584  arg11 = &cgrid111;
4585  else if ( gridmode == 2 )
4586  arg11 = &cgrid211;
4587  }
4588  }
4589  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
4590 
4591  {
4592  int i;
4593 
4594  if ( arg1 )
4595  {
4596  for ( i = 0; i < ii1; i++ )
4597  LUA_FREE_ARRAY( arg1[i] );
4598  LUA_FREE_ARRAY( arg1 );
4599  }
4600  }
4601  {
4602  LUA_FREE_ARRAY( arg8 );
4603  }
4604  {
4605  mypltr_funcstr[0] = '\0';
4606  }
4607  {
4608  int i;
4609 
4610  LUA_FREE_ARRAY( cgrid111.xg );
4611  LUA_FREE_ARRAY( cgrid111.yg );
4612 
4613  if ( cgrid211.xg )
4614  {
4615  for ( i = 0; i < Xlen; i++ )
4616  LUA_FREE_ARRAY( cgrid211.xg[i] );
4617  LUA_FREE_ARRAY( cgrid211.xg );
4618  }
4619  if ( cgrid211.yg )
4620  {
4621  for ( i = 0; i < Xlen; i++ )
4622  LUA_FREE_ARRAY( cgrid211.yg[i] );
4623  LUA_FREE_ARRAY( cgrid211.yg );
4624  }
4625  }
4626  return SWIG_arg;
4627 
4628  if(0) SWIG_fail;
4629 
4630 fail:
4631  {
4632  int i;
4633 
4634  if ( arg1 )
4635  {
4636  for ( i = 0; i < ii1; i++ )
4637  LUA_FREE_ARRAY( arg1[i] );
4638  LUA_FREE_ARRAY( arg1 );
4639  }
4640  }
4641  {
4642  LUA_FREE_ARRAY( arg8 );
4643  }
4644  {
4645  mypltr_funcstr[0] = '\0';
4646  }
4647  {
4648  int i;
4649 
4650  LUA_FREE_ARRAY( cgrid111.xg );
4651  LUA_FREE_ARRAY( cgrid111.yg );
4652 
4653  if ( cgrid211.xg )
4654  {
4655  for ( i = 0; i < Xlen; i++ )
4656  LUA_FREE_ARRAY( cgrid211.xg[i] );
4657  LUA_FREE_ARRAY( cgrid211.xg );
4658  }
4659  if ( cgrid211.yg )
4660  {
4661  for ( i = 0; i < Xlen; i++ )
4662  LUA_FREE_ARRAY( cgrid211.yg[i] );
4663  LUA_FREE_ARRAY( cgrid211.yg );
4664  }
4665  }
4666  lua_error(L);
4667  return SWIG_arg;
4668 }
4669 
4670 
4671 static int _wrap_ctime(lua_State* L) {
4672  int SWIG_arg = 0;
4673  PLINT arg1 ;
4674  PLINT arg2 ;
4675  PLINT arg3 ;
4676  PLINT arg4 ;
4677  PLINT arg5 ;
4678  PLFLT arg6 ;
4679  PLFLT *arg7 = (PLFLT *) 0 ;
4680  PLFLT temp7 ;
4681 
4682  arg7 = &temp7;
4683  SWIG_check_num_args("plctime",6,6)
4684  if(!lua_isnumber(L,1)) SWIG_fail_arg("plctime",1,"PLINT");
4685  if(!lua_isnumber(L,2)) SWIG_fail_arg("plctime",2,"PLINT");
4686  if(!lua_isnumber(L,3)) SWIG_fail_arg("plctime",3,"PLINT");
4687  if(!lua_isnumber(L,4)) SWIG_fail_arg("plctime",4,"PLINT");
4688  if(!lua_isnumber(L,5)) SWIG_fail_arg("plctime",5,"PLINT");
4689  if(!lua_isnumber(L,6)) SWIG_fail_arg("plctime",6,"PLFLT");
4690  arg1 = (PLINT)lua_tonumber(L, 1);
4691  arg2 = (PLINT)lua_tonumber(L, 2);
4692  arg3 = (PLINT)lua_tonumber(L, 3);
4693  arg4 = (PLINT)lua_tonumber(L, 4);
4694  arg5 = (PLINT)lua_tonumber(L, 5);
4695  arg6 = (PLFLT)lua_tonumber(L, 6);
4696  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4697 
4698  lua_pushnumber(L, (lua_Number) *arg7); SWIG_arg++;
4699  return SWIG_arg;
4700 
4701  if(0) SWIG_fail;
4702 
4703 fail:
4704  lua_error(L);
4705  return SWIG_arg;
4706 }
4707 
4708 
4709 static int _wrap_cpstrm(lua_State* L) {
4710  int SWIG_arg = 0;
4711  PLINT arg1 ;
4712  PLBOOL arg2 ;
4713 
4714  SWIG_check_num_args("plcpstrm",2,2)
4715  if(!lua_isnumber(L,1)) SWIG_fail_arg("plcpstrm",1,"PLINT");
4716  if(!lua_isnumber(L,2)) SWIG_fail_arg("plcpstrm",2,"PLBOOL");
4717  arg1 = (PLINT)lua_tonumber(L, 1);
4718  arg2 = (PLBOOL)lua_tonumber(L, 2);
4719  plcpstrm(arg1,arg2);
4720 
4721  return SWIG_arg;
4722 
4723  if(0) SWIG_fail;
4724 
4725 fail:
4726  lua_error(L);
4727  return SWIG_arg;
4728 }
4729 
4730 
4731 static int _wrap_plend(lua_State* L) {
4732  int SWIG_arg = 0;
4733 
4734  SWIG_check_num_args("plend",0,0)
4735  plend();
4736 
4737  return SWIG_arg;
4738 
4739  if(0) SWIG_fail;
4740 
4741 fail:
4742  lua_error(L);
4743  return SWIG_arg;
4744 }
4745 
4746 
4747 static int _wrap_plend1(lua_State* L) {
4748  int SWIG_arg = 0;
4749 
4750  SWIG_check_num_args("plend1",0,0)
4751  plend1();
4752 
4753  return SWIG_arg;
4754 
4755  if(0) SWIG_fail;
4756 
4757 fail:
4758  lua_error(L);
4759  return SWIG_arg;
4760 }
4761 
4762 
4763 static int _wrap_env(lua_State* L) {
4764  int SWIG_arg = 0;
4765  PLFLT arg1 ;
4766  PLFLT arg2 ;
4767  PLFLT arg3 ;
4768  PLFLT arg4 ;
4769  PLINT arg5 ;
4770  PLINT arg6 ;
4771 
4772  SWIG_check_num_args("plenv",6,6)
4773  if(!lua_isnumber(L,1)) SWIG_fail_arg("plenv",1,"PLFLT");
4774  if(!lua_isnumber(L,2)) SWIG_fail_arg("plenv",2,"PLFLT");
4775  if(!lua_isnumber(L,3)) SWIG_fail_arg("plenv",3,"PLFLT");
4776  if(!lua_isnumber(L,4)) SWIG_fail_arg("plenv",4,"PLFLT");
4777  if(!lua_isnumber(L,5)) SWIG_fail_arg("plenv",5,"PLINT");
4778  if(!lua_isnumber(L,6)) SWIG_fail_arg("plenv",6,"PLINT");
4779  arg1 = (PLFLT)lua_tonumber(L, 1);
4780  arg2 = (PLFLT)lua_tonumber(L, 2);
4781  arg3 = (PLFLT)lua_tonumber(L, 3);
4782  arg4 = (PLFLT)lua_tonumber(L, 4);
4783  arg5 = (PLINT)lua_tonumber(L, 5);
4784  arg6 = (PLINT)lua_tonumber(L, 6);
4785  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
4786 
4787  return SWIG_arg;
4788 
4789  if(0) SWIG_fail;
4790 
4791 fail:
4792  lua_error(L);
4793  return SWIG_arg;
4794 }
4795 
4796 
4797 static int _wrap_env0(lua_State* L) {
4798  int SWIG_arg = 0;
4799  PLFLT arg1 ;
4800  PLFLT arg2 ;
4801  PLFLT arg3 ;
4802  PLFLT arg4 ;
4803  PLINT arg5 ;
4804  PLINT arg6 ;
4805 
4806  SWIG_check_num_args("plenv0",6,6)
4807  if(!lua_isnumber(L,1)) SWIG_fail_arg("plenv0",1,"PLFLT");
4808  if(!lua_isnumber(L,2)) SWIG_fail_arg("plenv0",2,"PLFLT");
4809  if(!lua_isnumber(L,3)) SWIG_fail_arg("plenv0",3,"PLFLT");
4810  if(!lua_isnumber(L,4)) SWIG_fail_arg("plenv0",4,"PLFLT");
4811  if(!lua_isnumber(L,5)) SWIG_fail_arg("plenv0",5,"PLINT");
4812  if(!lua_isnumber(L,6)) SWIG_fail_arg("plenv0",6,"PLINT");
4813  arg1 = (PLFLT)lua_tonumber(L, 1);
4814  arg2 = (PLFLT)lua_tonumber(L, 2);
4815  arg3 = (PLFLT)lua_tonumber(L, 3);
4816  arg4 = (PLFLT)lua_tonumber(L, 4);
4817  arg5 = (PLINT)lua_tonumber(L, 5);
4818  arg6 = (PLINT)lua_tonumber(L, 6);
4819  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
4820 
4821  return SWIG_arg;
4822 
4823  if(0) SWIG_fail;
4824 
4825 fail:
4826  lua_error(L);
4827  return SWIG_arg;
4828 }
4829 
4830 
4831 static int _wrap_eop(lua_State* L) {
4832  int SWIG_arg = 0;
4833 
4834  SWIG_check_num_args("pleop",0,0)
4835  pleop();
4836 
4837  return SWIG_arg;
4838 
4839  if(0) SWIG_fail;
4840 
4841 fail:
4842  lua_error(L);
4843  return SWIG_arg;
4844 }
4845 
4846 
4847 static int _wrap_errx(lua_State* L) {
4848  int SWIG_arg = 0;
4849  PLINT arg1 ;
4850  PLFLT *arg2 = (PLFLT *) 0 ;
4851  PLFLT *arg3 = (PLFLT *) 0 ;
4852  PLFLT *arg4 = (PLFLT *) 0 ;
4853  int temp3 ;
4854  int temp4 ;
4855 
4856  SWIG_check_num_args("plerrx",3,3)
4857  {
4858  int temp;
4859  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
4860  if ( !arg2 )
4861  SWIG_fail;
4862  arg1 = Alen = temp;
4863  }
4864  {
4865  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
4866  if ( !arg3 )
4867  SWIG_fail;
4868  if ( temp3 != Alen )
4869  {
4870  lua_pushfstring( L, "Tables must be of same length." );
4871  SWIG_fail;
4872  }
4873  }
4874  {
4875  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
4876  if ( !arg4 )
4877  SWIG_fail;
4878  if ( temp4 != Alen )
4879  {
4880  lua_pushfstring( L, "Tables must be of same length." );
4881  SWIG_fail;
4882  }
4883  }
4884  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
4885 
4886  {
4887  LUA_FREE_ARRAY( arg2 );
4888  }
4889  {
4890  LUA_FREE_ARRAY( arg3 );
4891  }
4892  {
4893  LUA_FREE_ARRAY( arg4 );
4894  }
4895  return SWIG_arg;
4896 
4897  if(0) SWIG_fail;
4898 
4899 fail:
4900  {
4901  LUA_FREE_ARRAY( arg2 );
4902  }
4903  {
4904  LUA_FREE_ARRAY( arg3 );
4905  }
4906  {
4907  LUA_FREE_ARRAY( arg4 );
4908  }
4909  lua_error(L);
4910  return SWIG_arg;
4911 }
4912 
4913 
4914 static int _wrap_erry(lua_State* L) {
4915  int SWIG_arg = 0;
4916  PLINT arg1 ;
4917  PLFLT *arg2 = (PLFLT *) 0 ;
4918  PLFLT *arg3 = (PLFLT *) 0 ;
4919  PLFLT *arg4 = (PLFLT *) 0 ;
4920  int temp3 ;
4921  int temp4 ;
4922 
4923  SWIG_check_num_args("plerry",3,3)
4924  {
4925  int temp;
4926  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
4927  if ( !arg2 )
4928  SWIG_fail;
4929  arg1 = Alen = temp;
4930  }
4931  {
4932  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
4933  if ( !arg3 )
4934  SWIG_fail;
4935  if ( temp3 != Alen )
4936  {
4937  lua_pushfstring( L, "Tables must be of same length." );
4938  SWIG_fail;
4939  }
4940  }
4941  {
4942  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
4943  if ( !arg4 )
4944  SWIG_fail;
4945  if ( temp4 != Alen )
4946  {
4947  lua_pushfstring( L, "Tables must be of same length." );
4948  SWIG_fail;
4949  }
4950  }
4951  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
4952 
4953  {
4954  LUA_FREE_ARRAY( arg2 );
4955  }
4956  {
4957  LUA_FREE_ARRAY( arg3 );
4958  }
4959  {
4960  LUA_FREE_ARRAY( arg4 );
4961  }
4962  return SWIG_arg;
4963 
4964  if(0) SWIG_fail;
4965 
4966 fail:
4967  {
4968  LUA_FREE_ARRAY( arg2 );
4969  }
4970  {
4971  LUA_FREE_ARRAY( arg3 );
4972  }
4973  {
4974  LUA_FREE_ARRAY( arg4 );
4975  }
4976  lua_error(L);
4977  return SWIG_arg;
4978 }
4979 
4980 
4981 static int _wrap_famadv(lua_State* L) {
4982  int SWIG_arg = 0;
4983 
4984  SWIG_check_num_args("plfamadv",0,0)
4985  plfamadv();
4986 
4987  return SWIG_arg;
4988 
4989  if(0) SWIG_fail;
4990 
4991 fail:
4992  lua_error(L);
4993  return SWIG_arg;
4994 }
4995 
4996 
4997 static int _wrap_fill(lua_State* L) {
4998  int SWIG_arg = 0;
4999  PLINT arg1 ;
5000  PLFLT *arg2 = (PLFLT *) 0 ;
5001  PLFLT *arg3 = (PLFLT *) 0 ;
5002  int temp3 ;
5003 
5004  SWIG_check_num_args("plfill",2,2)
5005  {
5006  int temp;
5007  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
5008  if ( !arg2 )
5009  SWIG_fail;
5010  arg1 = Alen = temp;
5011  }
5012  {
5013  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
5014  if ( !arg3 )
5015  SWIG_fail;
5016  if ( temp3 != Alen )
5017  {
5018  lua_pushfstring( L, "Tables must be of same length." );
5019  SWIG_fail;
5020  }
5021  }
5022  plfill(arg1,(double const *)arg2,(double const *)arg3);
5023 
5024  {
5025  LUA_FREE_ARRAY( arg2 );
5026  }
5027  {
5028  LUA_FREE_ARRAY( arg3 );
5029  }
5030  return SWIG_arg;
5031 
5032  if(0) SWIG_fail;
5033 
5034 fail:
5035  {
5036  LUA_FREE_ARRAY( arg2 );
5037  }
5038  {
5039  LUA_FREE_ARRAY( arg3 );
5040  }
5041  lua_error(L);
5042  return SWIG_arg;
5043 }
5044 
5045 
5046 static int _wrap_fill3(lua_State* L) {
5047  int SWIG_arg = 0;
5048  PLINT arg1 ;
5049  PLFLT *arg2 = (PLFLT *) 0 ;
5050  PLFLT *arg3 = (PLFLT *) 0 ;
5051  PLFLT *arg4 = (PLFLT *) 0 ;
5052  int temp3 ;
5053  int temp4 ;
5054 
5055  SWIG_check_num_args("plfill3",3,3)
5056  {
5057  int temp;
5058  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
5059  if ( !arg2 )
5060  SWIG_fail;
5061  arg1 = Alen = temp;
5062  }
5063  {
5064  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
5065  if ( !arg3 )
5066  SWIG_fail;
5067  if ( temp3 != Alen )
5068  {
5069  lua_pushfstring( L, "Tables must be of same length." );
5070  SWIG_fail;
5071  }
5072  }
5073  {
5074  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
5075  if ( !arg4 )
5076  SWIG_fail;
5077  if ( temp4 != Alen )
5078  {
5079  lua_pushfstring( L, "Tables must be of same length." );
5080  SWIG_fail;
5081  }
5082  }
5083  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5084 
5085  {
5086  LUA_FREE_ARRAY( arg2 );
5087  }
5088  {
5089  LUA_FREE_ARRAY( arg3 );
5090  }
5091  {
5092  LUA_FREE_ARRAY( arg4 );
5093  }
5094  return SWIG_arg;
5095 
5096  if(0) SWIG_fail;
5097 
5098 fail:
5099  {
5100  LUA_FREE_ARRAY( arg2 );
5101  }
5102  {
5103  LUA_FREE_ARRAY( arg3 );
5104  }
5105  {
5106  LUA_FREE_ARRAY( arg4 );
5107  }
5108  lua_error(L);
5109  return SWIG_arg;
5110 }
5111 
5112 
5113 static int _wrap_gradient(lua_State* L) {
5114  int SWIG_arg = 0;
5115  PLINT arg1 ;
5116  PLFLT *arg2 = (PLFLT *) 0 ;
5117  PLFLT *arg3 = (PLFLT *) 0 ;
5118  PLFLT arg4 ;
5119  int temp3 ;
5120 
5121  SWIG_check_num_args("plgradient",3,3)
5122  if(!lua_isnumber(L,3)) SWIG_fail_arg("plgradient",3,"PLFLT");
5123  {
5124  int temp;
5125  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
5126  if ( !arg2 )
5127  SWIG_fail;
5128  arg1 = Alen = temp;
5129  }
5130  {
5131  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
5132  if ( !arg3 )
5133  SWIG_fail;
5134  if ( temp3 != Alen )
5135  {
5136  lua_pushfstring( L, "Tables must be of same length." );
5137  SWIG_fail;
5138  }
5139  }
5140  arg4 = (PLFLT)lua_tonumber(L, 3);
5141  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
5142 
5143  {
5144  LUA_FREE_ARRAY( arg2 );
5145  }
5146  {
5147  LUA_FREE_ARRAY( arg3 );
5148  }
5149  return SWIG_arg;
5150 
5151  if(0) SWIG_fail;
5152 
5153 fail:
5154  {
5155  LUA_FREE_ARRAY( arg2 );
5156  }
5157  {
5158  LUA_FREE_ARRAY( arg3 );
5159  }
5160  lua_error(L);
5161  return SWIG_arg;
5162 }
5163 
5164 
5165 static int _wrap_flush(lua_State* L) {
5166  int SWIG_arg = 0;
5167 
5168  SWIG_check_num_args("plflush",0,0)
5169  plflush();
5170 
5171  return SWIG_arg;
5172 
5173  if(0) SWIG_fail;
5174 
5175 fail:
5176  lua_error(L);
5177  return SWIG_arg;
5178 }
5179 
5180 
5181 static int _wrap_font(lua_State* L) {
5182  int SWIG_arg = 0;
5183  PLINT arg1 ;
5184 
5185  SWIG_check_num_args("plfont",1,1)
5186  if(!lua_isnumber(L,1)) SWIG_fail_arg("plfont",1,"PLINT");
5187  arg1 = (PLINT)lua_tonumber(L, 1);
5188  plfont(arg1);
5189 
5190  return SWIG_arg;
5191 
5192  if(0) SWIG_fail;
5193 
5194 fail:
5195  lua_error(L);
5196  return SWIG_arg;
5197 }
5198 
5199 
5200 static int _wrap_fontld(lua_State* L) {
5201  int SWIG_arg = 0;
5202  PLINT arg1 ;
5203 
5204  SWIG_check_num_args("plfontld",1,1)
5205  if(!lua_isnumber(L,1)) SWIG_fail_arg("plfontld",1,"PLINT");
5206  arg1 = (PLINT)lua_tonumber(L, 1);
5207  plfontld(arg1);
5208 
5209  return SWIG_arg;
5210 
5211  if(0) SWIG_fail;
5212 
5213 fail:
5214  lua_error(L);
5215  return SWIG_arg;
5216 }
5217 
5218 
5219 static int _wrap_gchr(lua_State* L) {
5220  int SWIG_arg = 0;
5221  PLFLT *arg1 = (PLFLT *) 0 ;
5222  PLFLT *arg2 = (PLFLT *) 0 ;
5223  PLFLT temp1 ;
5224  PLFLT temp2 ;
5225 
5226  arg1 = &temp1;
5227  arg2 = &temp2;
5228  SWIG_check_num_args("plgchr",0,0)
5229  plgchr(arg1,arg2);
5230 
5231  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5232  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5233  return SWIG_arg;
5234 
5235  if(0) SWIG_fail;
5236 
5237 fail:
5238  lua_error(L);
5239  return SWIG_arg;
5240 }
5241 
5242 
5243 static int _wrap_gcol0(lua_State* L) {
5244  int SWIG_arg = 0;
5245  PLINT arg1 ;
5246  PLINT *arg2 = (PLINT *) 0 ;
5247  PLINT *arg3 = (PLINT *) 0 ;
5248  PLINT *arg4 = (PLINT *) 0 ;
5249  PLINT temp2 ;
5250  PLINT temp3 ;
5251  PLINT temp4 ;
5252 
5253  arg2 = &temp2;
5254  arg3 = &temp3;
5255  arg4 = &temp4;
5256  SWIG_check_num_args("plgcol0",1,1)
5257  if(!lua_isnumber(L,1)) SWIG_fail_arg("plgcol0",1,"PLINT");
5258  arg1 = (PLINT)lua_tonumber(L, 1);
5259  plgcol0(arg1,arg2,arg3,arg4);
5260 
5261  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5262  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5263  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5264  return SWIG_arg;
5265 
5266  if(0) SWIG_fail;
5267 
5268 fail:
5269  lua_error(L);
5270  return SWIG_arg;
5271 }
5272 
5273 
5274 static int _wrap_gcol0a(lua_State* L) {
5275  int SWIG_arg = 0;
5276  PLINT arg1 ;
5277  PLINT *arg2 = (PLINT *) 0 ;
5278  PLINT *arg3 = (PLINT *) 0 ;
5279  PLINT *arg4 = (PLINT *) 0 ;
5280  PLFLT *arg5 = (PLFLT *) 0 ;
5281  PLINT temp2 ;
5282  PLINT temp3 ;
5283  PLINT temp4 ;
5284  PLFLT temp5 ;
5285 
5286  arg2 = &temp2;
5287  arg3 = &temp3;
5288  arg4 = &temp4;
5289  arg5 = &temp5;
5290  SWIG_check_num_args("plgcol0a",1,1)
5291  if(!lua_isnumber(L,1)) SWIG_fail_arg("plgcol0a",1,"PLINT");
5292  arg1 = (PLINT)lua_tonumber(L, 1);
5293  plgcol0a(arg1,arg2,arg3,arg4,arg5);
5294 
5295  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5296  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5297  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5298  lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
5299  return SWIG_arg;
5300 
5301  if(0) SWIG_fail;
5302 
5303 fail:
5304  lua_error(L);
5305  return SWIG_arg;
5306 }
5307 
5308 
5309 static int _wrap_gcolbg(lua_State* L) {
5310  int SWIG_arg = 0;
5311  PLINT *arg1 = (PLINT *) 0 ;
5312  PLINT *arg2 = (PLINT *) 0 ;
5313  PLINT *arg3 = (PLINT *) 0 ;
5314  PLINT temp1 ;
5315  PLINT temp2 ;
5316  PLINT temp3 ;
5317 
5318  arg1 = &temp1;
5319  arg2 = &temp2;
5320  arg3 = &temp3;
5321  SWIG_check_num_args("plgcolbg",0,0)
5322  plgcolbg(arg1,arg2,arg3);
5323 
5324  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5325  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5326  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5327  return SWIG_arg;
5328 
5329  if(0) SWIG_fail;
5330 
5331 fail:
5332  lua_error(L);
5333  return SWIG_arg;
5334 }
5335 
5336 
5337 static int _wrap_gcolbga(lua_State* L) {
5338  int SWIG_arg = 0;
5339  PLINT *arg1 = (PLINT *) 0 ;
5340  PLINT *arg2 = (PLINT *) 0 ;
5341  PLINT *arg3 = (PLINT *) 0 ;
5342  PLFLT *arg4 = (PLFLT *) 0 ;
5343  PLINT temp1 ;
5344  PLINT temp2 ;
5345  PLINT temp3 ;
5346  PLFLT temp4 ;
5347 
5348  arg1 = &temp1;
5349  arg2 = &temp2;
5350  arg3 = &temp3;
5351  arg4 = &temp4;
5352  SWIG_check_num_args("plgcolbga",0,0)
5353  plgcolbga(arg1,arg2,arg3,arg4);
5354 
5355  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5356  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5357  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5358  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5359  return SWIG_arg;
5360 
5361  if(0) SWIG_fail;
5362 
5363 fail:
5364  lua_error(L);
5365  return SWIG_arg;
5366 }
5367 
5368 
5369 static int _wrap_gcompression(lua_State* L) {
5370  int SWIG_arg = 0;
5371  PLINT *arg1 = (PLINT *) 0 ;
5372  PLINT temp1 ;
5373 
5374  arg1 = &temp1;
5375  SWIG_check_num_args("plgcompression",0,0)
5376  plgcompression(arg1);
5377 
5378  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5379  return SWIG_arg;
5380 
5381  if(0) SWIG_fail;
5382 
5383 fail:
5384  lua_error(L);
5385  return SWIG_arg;
5386 }
5387 
5388 
5389 static int _wrap_gdev(lua_State* L) {
5390  int SWIG_arg = 0;
5391  char *arg1 = (char *) 0 ;
5392  char buff1[1000] ;
5393 
5394  {
5395  arg1 = buff1;
5396  }
5397  SWIG_check_num_args("plgdev",0,0)
5398  plgdev(arg1);
5399 
5400  {
5401  lua_pushstring( L, arg1 );
5402  SWIG_arg++;
5403  }
5404  return SWIG_arg;
5405 
5406  if(0) SWIG_fail;
5407 
5408 fail:
5409  lua_error(L);
5410  return SWIG_arg;
5411 }
5412 
5413 
5414 static int _wrap_gdidev(lua_State* L) {
5415  int SWIG_arg = 0;
5416  PLFLT *arg1 = (PLFLT *) 0 ;
5417  PLFLT *arg2 = (PLFLT *) 0 ;
5418  PLFLT *arg3 = (PLFLT *) 0 ;
5419  PLFLT *arg4 = (PLFLT *) 0 ;
5420  PLFLT temp1 ;
5421  PLFLT temp2 ;
5422  PLFLT temp3 ;
5423  PLFLT temp4 ;
5424 
5425  arg1 = &temp1;
5426  arg2 = &temp2;
5427  arg3 = &temp3;
5428  arg4 = &temp4;
5429  SWIG_check_num_args("plgdidev",0,0)
5430  plgdidev(arg1,arg2,arg3,arg4);
5431 
5432  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5433  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5434  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5435  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5436  return SWIG_arg;
5437 
5438  if(0) SWIG_fail;
5439 
5440 fail:
5441  lua_error(L);
5442  return SWIG_arg;
5443 }
5444 
5445 
5446 static int _wrap_gdiori(lua_State* L) {
5447  int SWIG_arg = 0;
5448  PLFLT *arg1 = (PLFLT *) 0 ;
5449  PLFLT temp1 ;
5450 
5451  arg1 = &temp1;
5452  SWIG_check_num_args("plgdiori",0,0)
5453  plgdiori(arg1);
5454 
5455  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5456  return SWIG_arg;
5457 
5458  if(0) SWIG_fail;
5459 
5460 fail:
5461  lua_error(L);
5462  return SWIG_arg;
5463 }
5464 
5465 
5466 static int _wrap_gdiplt(lua_State* L) {
5467  int SWIG_arg = 0;
5468  PLFLT *arg1 = (PLFLT *) 0 ;
5469  PLFLT *arg2 = (PLFLT *) 0 ;
5470  PLFLT *arg3 = (PLFLT *) 0 ;
5471  PLFLT *arg4 = (PLFLT *) 0 ;
5472  PLFLT temp1 ;
5473  PLFLT temp2 ;
5474  PLFLT temp3 ;
5475  PLFLT temp4 ;
5476 
5477  arg1 = &temp1;
5478  arg2 = &temp2;
5479  arg3 = &temp3;
5480  arg4 = &temp4;
5481  SWIG_check_num_args("plgdiplt",0,0)
5482  plgdiplt(arg1,arg2,arg3,arg4);
5483 
5484  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5485  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5486  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5487  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5488  return SWIG_arg;
5489 
5490  if(0) SWIG_fail;
5491 
5492 fail:
5493  lua_error(L);
5494  return SWIG_arg;
5495 }
5496 
5497 
5498 static int _wrap_gfam(lua_State* L) {
5499  int SWIG_arg = 0;
5500  PLINT *arg1 = (PLINT *) 0 ;
5501  PLINT *arg2 = (PLINT *) 0 ;
5502  PLINT *arg3 = (PLINT *) 0 ;
5503  PLINT temp1 ;
5504  PLINT temp2 ;
5505  PLINT temp3 ;
5506 
5507  arg1 = &temp1;
5508  arg2 = &temp2;
5509  arg3 = &temp3;
5510  SWIG_check_num_args("plgfam",0,0)
5511  plgfam(arg1,arg2,arg3);
5512 
5513  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5514  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5515  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5516  return SWIG_arg;
5517 
5518  if(0) SWIG_fail;
5519 
5520 fail:
5521  lua_error(L);
5522  return SWIG_arg;
5523 }
5524 
5525 
5526 static int _wrap_gfci(lua_State* L) {
5527  int SWIG_arg = 0;
5528  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
5529  PLUNICODE temp1 ;
5530 
5531  arg1 = &temp1;
5532  SWIG_check_num_args("plgfci",0,0)
5533  plgfci(arg1);
5534 
5535  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5536  return SWIG_arg;
5537 
5538  if(0) SWIG_fail;
5539 
5540 fail:
5541  lua_error(L);
5542  return SWIG_arg;
5543 }
5544 
5545 
5546 static int _wrap_gfnam(lua_State* L) {
5547  int SWIG_arg = 0;
5548  char *arg1 = (char *) 0 ;
5549  char buff1[1000] ;
5550 
5551  {
5552  arg1 = buff1;
5553  }
5554  SWIG_check_num_args("plgfnam",0,0)
5555  plgfnam(arg1);
5556 
5557  {
5558  lua_pushstring( L, arg1 );
5559  SWIG_arg++;
5560  }
5561  return SWIG_arg;
5562 
5563  if(0) SWIG_fail;
5564 
5565 fail:
5566  lua_error(L);
5567  return SWIG_arg;
5568 }
5569 
5570 
5571 static int _wrap_gfont(lua_State* L) {
5572  int SWIG_arg = 0;
5573  PLINT *arg1 = (PLINT *) 0 ;
5574  PLINT *arg2 = (PLINT *) 0 ;
5575  PLINT *arg3 = (PLINT *) 0 ;
5576  PLINT temp1 ;
5577  PLINT temp2 ;
5578  PLINT temp3 ;
5579 
5580  arg1 = &temp1;
5581  arg2 = &temp2;
5582  arg3 = &temp3;
5583  SWIG_check_num_args("plgfont",0,0)
5584  plgfont(arg1,arg2,arg3);
5585 
5586  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5587  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5588  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5589  return SWIG_arg;
5590 
5591  if(0) SWIG_fail;
5592 
5593 fail:
5594  lua_error(L);
5595  return SWIG_arg;
5596 }
5597 
5598 
5599 static int _wrap_glevel(lua_State* L) {
5600  int SWIG_arg = 0;
5601  PLINT *arg1 = (PLINT *) 0 ;
5602  PLINT temp1 ;
5603 
5604  arg1 = &temp1;
5605  SWIG_check_num_args("plglevel",0,0)
5606  plglevel(arg1);
5607 
5608  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5609  return SWIG_arg;
5610 
5611  if(0) SWIG_fail;
5612 
5613 fail:
5614  lua_error(L);
5615  return SWIG_arg;
5616 }
5617 
5618 
5619 static int _wrap_gpage(lua_State* L) {
5620  int SWIG_arg = 0;
5621  PLFLT *arg1 = (PLFLT *) 0 ;
5622  PLFLT *arg2 = (PLFLT *) 0 ;
5623  PLINT *arg3 = (PLINT *) 0 ;
5624  PLINT *arg4 = (PLINT *) 0 ;
5625  PLINT *arg5 = (PLINT *) 0 ;
5626  PLINT *arg6 = (PLINT *) 0 ;
5627  PLFLT temp1 ;
5628  PLFLT temp2 ;
5629  PLINT temp3 ;
5630  PLINT temp4 ;
5631  PLINT temp5 ;
5632  PLINT temp6 ;
5633 
5634  arg1 = &temp1;
5635  arg2 = &temp2;
5636  arg3 = &temp3;
5637  arg4 = &temp4;
5638  arg5 = &temp5;
5639  arg6 = &temp6;
5640  SWIG_check_num_args("plgpage",0,0)
5641  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
5642 
5643  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5644  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5645  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5646  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5647  lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
5648  lua_pushnumber(L, (lua_Number) *arg6); SWIG_arg++;
5649  return SWIG_arg;
5650 
5651  if(0) SWIG_fail;
5652 
5653 fail:
5654  lua_error(L);
5655  return SWIG_arg;
5656 }
5657 
5658 
5659 static int _wrap_gra(lua_State* L) {
5660  int SWIG_arg = 0;
5661 
5662  SWIG_check_num_args("plgra",0,0)
5663  plgra();
5664 
5665  return SWIG_arg;
5666 
5667  if(0) SWIG_fail;
5668 
5669 fail:
5670  lua_error(L);
5671  return SWIG_arg;
5672 }
5673 
5674 
5675 static int _wrap_griddata(lua_State* L) {
5676  int SWIG_arg = 0;
5677  PLFLT *arg1 = (PLFLT *) 0 ;
5678  PLFLT *arg2 = (PLFLT *) 0 ;
5679  PLFLT *arg3 = (PLFLT *) 0 ;
5680  PLINT arg4 ;
5681  PLFLT *arg5 = (PLFLT *) 0 ;
5682  PLINT arg6 ;
5683  PLFLT *arg7 = (PLFLT *) 0 ;
5684  PLINT arg8 ;
5685  PLFLT **arg9 = (PLFLT **) 0 ;
5686  PLINT arg10 ;
5687  PLFLT arg11 ;
5688  int temp2 ;
5689 
5690  SWIG_check_num_args("plgriddata",7,7)
5691  if(!lua_isnumber(L,6)) SWIG_fail_arg("plgriddata",6,"PLINT");
5692  if(!lua_isnumber(L,7)) SWIG_fail_arg("plgriddata",7,"PLFLT");
5693  {
5694  int temp;
5695  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
5696  if ( !arg1 )
5697  SWIG_fail;
5698  Alen = temp;
5699  }
5700  {
5701  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp2 );
5702  if ( !arg2 )
5703  SWIG_fail;
5704  if ( temp2 != Alen )
5705  {
5706  lua_pushfstring( L, "Tables must be of same length." );
5707  SWIG_fail;
5708  }
5709  }
5710  {
5711  int temp;
5712  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp );
5713  if ( !arg3 )
5714  SWIG_fail;
5715  if ( temp != Alen )
5716  {
5717  lua_pushfstring( L, "Tables must be of same length." );
5718  SWIG_fail;
5719  }
5720  arg4 = temp;
5721  }
5722  {
5723  int temp;
5724  arg5 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp );
5725  if ( !arg5 )
5726  SWIG_fail;
5727  arg6 = Xlen = temp;
5728  }
5729  {
5730  int temp, i;
5731 
5732  arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
5733  if ( !arg7 )
5734  SWIG_fail;
5735  arg8 = Ylen = temp;
5736 
5737  arg9 = LUA_ALLOC_ARRAY( PLFLT *, Xlen );
5738  if ( !arg9 )
5739  SWIG_fail;
5740  for ( i = 0; i < Xlen; i++ )
5741  arg9[i] = NULL;
5742 
5743  for ( i = 0; i < Xlen; i++ )
5744  {
5745  arg9[i] = LUA_ALLOC_ARRAY( PLFLT, Ylen );
5746  if ( !arg9[i] )
5747  SWIG_fail;
5748  }
5749  }
5750  arg10 = (PLINT)lua_tonumber(L, 6);
5751  arg11 = (PLFLT)lua_tonumber(L, 7);
5752  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
5753 
5754  {
5755  int i;
5756 
5757  if ( arg9 )
5758  {
5759  lua_newtable( L );
5760  for ( i = 0; i < Xlen; i++ )
5761  {
5762  SWIG_write_double_num_array( L, arg9[i], Ylen );
5763  lua_rawseti( L, -2, i + 1 ); // -1 is the inner table, -2 is the outer table
5764  }
5765  SWIG_arg++;
5766  }
5767  }
5768  {
5769  LUA_FREE_ARRAY( arg1 );
5770  }
5771  {
5772  LUA_FREE_ARRAY( arg2 );
5773  }
5774  {
5775  LUA_FREE_ARRAY( arg3 );
5776  }
5777  {
5778  LUA_FREE_ARRAY( arg5 );
5779  }
5780  {
5781  int i;
5782 
5783  LUA_FREE_ARRAY( arg7 );
5784 
5785  if ( arg9 )
5786  {
5787  for ( i = 0; i < Xlen; i++ )
5788  LUA_FREE_ARRAY( arg9[i] );
5789  LUA_FREE_ARRAY( arg9 );
5790  }
5791  }
5792  return SWIG_arg;
5793 
5794  if(0) SWIG_fail;
5795 
5796 fail:
5797  {
5798  LUA_FREE_ARRAY( arg1 );
5799  }
5800  {
5801  LUA_FREE_ARRAY( arg2 );
5802  }
5803  {
5804  LUA_FREE_ARRAY( arg3 );
5805  }
5806  {
5807  LUA_FREE_ARRAY( arg5 );
5808  }
5809  {
5810  int i;
5811 
5812  LUA_FREE_ARRAY( arg7 );
5813 
5814  if ( arg9 )
5815  {
5816  for ( i = 0; i < Xlen; i++ )
5817  LUA_FREE_ARRAY( arg9[i] );
5818  LUA_FREE_ARRAY( arg9 );
5819  }
5820  }
5821  lua_error(L);
5822  return SWIG_arg;
5823 }
5824 
5825 
5826 static int _wrap_gspa(lua_State* L) {
5827  int SWIG_arg = 0;
5828  PLFLT *arg1 = (PLFLT *) 0 ;
5829  PLFLT *arg2 = (PLFLT *) 0 ;
5830  PLFLT *arg3 = (PLFLT *) 0 ;
5831  PLFLT *arg4 = (PLFLT *) 0 ;
5832  PLFLT temp1 ;
5833  PLFLT temp2 ;
5834  PLFLT temp3 ;
5835  PLFLT temp4 ;
5836 
5837  arg1 = &temp1;
5838  arg2 = &temp2;
5839  arg3 = &temp3;
5840  arg4 = &temp4;
5841  SWIG_check_num_args("plgspa",0,0)
5842  plgspa(arg1,arg2,arg3,arg4);
5843 
5844  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5845  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5846  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5847  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5848  return SWIG_arg;
5849 
5850  if(0) SWIG_fail;
5851 
5852 fail:
5853  lua_error(L);
5854  return SWIG_arg;
5855 }
5856 
5857 
5858 static int _wrap_gstrm(lua_State* L) {
5859  int SWIG_arg = 0;
5860  PLINT *arg1 = (PLINT *) 0 ;
5861  PLINT temp1 ;
5862 
5863  arg1 = &temp1;
5864  SWIG_check_num_args("plgstrm",0,0)
5865  plgstrm(arg1);
5866 
5867  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5868  return SWIG_arg;
5869 
5870  if(0) SWIG_fail;
5871 
5872 fail:
5873  lua_error(L);
5874  return SWIG_arg;
5875 }
5876 
5877 
5878 static int _wrap_gver(lua_State* L) {
5879  int SWIG_arg = 0;
5880  char *arg1 = (char *) 0 ;
5881  char buff1[1000] ;
5882 
5883  {
5884  arg1 = buff1;
5885  }
5886  SWIG_check_num_args("plgver",0,0)
5887  plgver(arg1);
5888 
5889  {
5890  lua_pushstring( L, arg1 );
5891  SWIG_arg++;
5892  }
5893  return SWIG_arg;
5894 
5895  if(0) SWIG_fail;
5896 
5897 fail:
5898  lua_error(L);
5899  return SWIG_arg;
5900 }
5901 
5902 
5903 static int _wrap_gvpd(lua_State* L) {
5904  int SWIG_arg = 0;
5905  PLFLT *arg1 = (PLFLT *) 0 ;
5906  PLFLT *arg2 = (PLFLT *) 0 ;
5907  PLFLT *arg3 = (PLFLT *) 0 ;
5908  PLFLT *arg4 = (PLFLT *) 0 ;
5909  PLFLT temp1 ;
5910  PLFLT temp2 ;
5911  PLFLT temp3 ;
5912  PLFLT temp4 ;
5913 
5914  arg1 = &temp1;
5915  arg2 = &temp2;
5916  arg3 = &temp3;
5917  arg4 = &temp4;
5918  SWIG_check_num_args("plgvpd",0,0)
5919  plgvpd(arg1,arg2,arg3,arg4);
5920 
5921  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5922  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5923  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5924  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5925  return SWIG_arg;
5926 
5927  if(0) SWIG_fail;
5928 
5929 fail:
5930  lua_error(L);
5931  return SWIG_arg;
5932 }
5933 
5934 
5935 static int _wrap_gvpw(lua_State* L) {
5936  int SWIG_arg = 0;
5937  PLFLT *arg1 = (PLFLT *) 0 ;
5938  PLFLT *arg2 = (PLFLT *) 0 ;
5939  PLFLT *arg3 = (PLFLT *) 0 ;
5940  PLFLT *arg4 = (PLFLT *) 0 ;
5941  PLFLT temp1 ;
5942  PLFLT temp2 ;
5943  PLFLT temp3 ;
5944  PLFLT temp4 ;
5945 
5946  arg1 = &temp1;
5947  arg2 = &temp2;
5948  arg3 = &temp3;
5949  arg4 = &temp4;
5950  SWIG_check_num_args("plgvpw",0,0)
5951  plgvpw(arg1,arg2,arg3,arg4);
5952 
5953  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5954  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5955  lua_pushnumber(L, (lua_Number) *arg3); SWIG_arg++;
5956  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
5957  return SWIG_arg;
5958 
5959  if(0) SWIG_fail;
5960 
5961 fail:
5962  lua_error(L);
5963  return SWIG_arg;
5964 }
5965 
5966 
5967 static int _wrap_gxax(lua_State* L) {
5968  int SWIG_arg = 0;
5969  PLINT *arg1 = (PLINT *) 0 ;
5970  PLINT *arg2 = (PLINT *) 0 ;
5971  PLINT temp1 ;
5972  PLINT temp2 ;
5973 
5974  arg1 = &temp1;
5975  arg2 = &temp2;
5976  SWIG_check_num_args("plgxax",0,0)
5977  plgxax(arg1,arg2);
5978 
5979  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
5980  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
5981  return SWIG_arg;
5982 
5983  if(0) SWIG_fail;
5984 
5985 fail:
5986  lua_error(L);
5987  return SWIG_arg;
5988 }
5989 
5990 
5991 static int _wrap_gyax(lua_State* L) {
5992  int SWIG_arg = 0;
5993  PLINT *arg1 = (PLINT *) 0 ;
5994  PLINT *arg2 = (PLINT *) 0 ;
5995  PLINT temp1 ;
5996  PLINT temp2 ;
5997 
5998  arg1 = &temp1;
5999  arg2 = &temp2;
6000  SWIG_check_num_args("plgyax",0,0)
6001  plgyax(arg1,arg2);
6002 
6003  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
6004  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
6005  return SWIG_arg;
6006 
6007  if(0) SWIG_fail;
6008 
6009 fail:
6010  lua_error(L);
6011  return SWIG_arg;
6012 }
6013 
6014 
6015 static int _wrap_gzax(lua_State* L) {
6016  int SWIG_arg = 0;
6017  PLINT *arg1 = (PLINT *) 0 ;
6018  PLINT *arg2 = (PLINT *) 0 ;
6019  PLINT temp1 ;
6020  PLINT temp2 ;
6021 
6022  arg1 = &temp1;
6023  arg2 = &temp2;
6024  SWIG_check_num_args("plgzax",0,0)
6025  plgzax(arg1,arg2);
6026 
6027  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
6028  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
6029  return SWIG_arg;
6030 
6031  if(0) SWIG_fail;
6032 
6033 fail:
6034  lua_error(L);
6035  return SWIG_arg;
6036 }
6037 
6038 
6039 static int _wrap_hist(lua_State* L) {
6040  int SWIG_arg = 0;
6041  PLINT arg1 ;
6042  PLFLT *arg2 = (PLFLT *) 0 ;
6043  PLFLT arg3 ;
6044  PLFLT arg4 ;
6045  PLINT arg5 ;
6046  PLINT arg6 ;
6047 
6048  SWIG_check_num_args("plhist",5,5)
6049  if(!lua_isnumber(L,2)) SWIG_fail_arg("plhist",2,"PLFLT");
6050  if(!lua_isnumber(L,3)) SWIG_fail_arg("plhist",3,"PLFLT");
6051  if(!lua_isnumber(L,4)) SWIG_fail_arg("plhist",4,"PLINT");
6052  if(!lua_isnumber(L,5)) SWIG_fail_arg("plhist",5,"PLINT");
6053  {
6054  int temp;
6055  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
6056  if ( !arg2 )
6057  SWIG_fail;
6058  arg1 = Alen = temp;
6059  }
6060  arg3 = (PLFLT)lua_tonumber(L, 2);
6061  arg4 = (PLFLT)lua_tonumber(L, 3);
6062  arg5 = (PLINT)lua_tonumber(L, 4);
6063  arg6 = (PLINT)lua_tonumber(L, 5);
6064  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
6065 
6066  {
6067  LUA_FREE_ARRAY( arg2 );
6068  }
6069  return SWIG_arg;
6070 
6071  if(0) SWIG_fail;
6072 
6073 fail:
6074  {
6075  LUA_FREE_ARRAY( arg2 );
6076  }
6077  lua_error(L);
6078  return SWIG_arg;
6079 }
6080 
6081 
6082 static int _wrap_hlsrgb(lua_State* L) {
6083  int SWIG_arg = 0;
6084  PLFLT arg1 ;
6085  PLFLT arg2 ;
6086  PLFLT arg3 ;
6087  PLFLT *arg4 = (PLFLT *) 0 ;
6088  PLFLT *arg5 = (PLFLT *) 0 ;
6089  PLFLT *arg6 = (PLFLT *) 0 ;
6090  PLFLT temp4 ;
6091  PLFLT temp5 ;
6092  PLFLT temp6 ;
6093 
6094  arg4 = &temp4;
6095  arg5 = &temp5;
6096  arg6 = &temp6;
6097  SWIG_check_num_args("plhlsrgb",3,3)
6098  if(!lua_isnumber(L,1)) SWIG_fail_arg("plhlsrgb",1,"PLFLT");
6099  if(!lua_isnumber(L,2)) SWIG_fail_arg("plhlsrgb",2,"PLFLT");
6100  if(!lua_isnumber(L,3)) SWIG_fail_arg("plhlsrgb",3,"PLFLT");
6101  arg1 = (PLFLT)lua_tonumber(L, 1);
6102  arg2 = (PLFLT)lua_tonumber(L, 2);
6103  arg3 = (PLFLT)lua_tonumber(L, 3);
6104  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
6105 
6106  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
6107  lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
6108  lua_pushnumber(L, (lua_Number) *arg6); SWIG_arg++;
6109  return SWIG_arg;
6110 
6111  if(0) SWIG_fail;
6112 
6113 fail:
6114  lua_error(L);
6115  return SWIG_arg;
6116 }
6117 
6118 
6119 static int _wrap_init(lua_State* L) {
6120  int SWIG_arg = 0;
6121 
6122  SWIG_check_num_args("plinit",0,0)
6123  plinit();
6124 
6125  return SWIG_arg;
6126 
6127  if(0) SWIG_fail;
6128 
6129 fail:
6130  lua_error(L);
6131  return SWIG_arg;
6132 }
6133 
6134 
6135 static int _wrap_join(lua_State* L) {
6136  int SWIG_arg = 0;
6137  PLFLT arg1 ;
6138  PLFLT arg2 ;
6139  PLFLT arg3 ;
6140  PLFLT arg4 ;
6141 
6142  SWIG_check_num_args("pljoin",4,4)
6143  if(!lua_isnumber(L,1)) SWIG_fail_arg("pljoin",1,"PLFLT");
6144  if(!lua_isnumber(L,2)) SWIG_fail_arg("pljoin",2,"PLFLT");
6145  if(!lua_isnumber(L,3)) SWIG_fail_arg("pljoin",3,"PLFLT");
6146  if(!lua_isnumber(L,4)) SWIG_fail_arg("pljoin",4,"PLFLT");
6147  arg1 = (PLFLT)lua_tonumber(L, 1);
6148  arg2 = (PLFLT)lua_tonumber(L, 2);
6149  arg3 = (PLFLT)lua_tonumber(L, 3);
6150  arg4 = (PLFLT)lua_tonumber(L, 4);
6151  pljoin(arg1,arg2,arg3,arg4);
6152 
6153  return SWIG_arg;
6154 
6155  if(0) SWIG_fail;
6156 
6157 fail:
6158  lua_error(L);
6159  return SWIG_arg;
6160 }
6161 
6162 
6163 static int _wrap_lab(lua_State* L) {
6164  int SWIG_arg = 0;
6165  char *arg1 = (char *) 0 ;
6166  char *arg2 = (char *) 0 ;
6167  char *arg3 = (char *) 0 ;
6168 
6169  SWIG_check_num_args("pllab",3,3)
6170  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("pllab",1,"char const *");
6171  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("pllab",2,"char const *");
6172  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("pllab",3,"char const *");
6173  arg1 = (char *)lua_tostring(L, 1);
6174  arg2 = (char *)lua_tostring(L, 2);
6175  arg3 = (char *)lua_tostring(L, 3);
6176  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
6177 
6178  return SWIG_arg;
6179 
6180  if(0) SWIG_fail;
6181 
6182 fail:
6183  lua_error(L);
6184  return SWIG_arg;
6185 }
6186 
6187 
6188 static int _wrap_legend(lua_State* L) {
6189  int SWIG_arg = 0;
6190  PLFLT *arg1 = (PLFLT *) 0 ;
6191  PLFLT *arg2 = (PLFLT *) 0 ;
6192  PLINT arg3 ;
6193  PLINT arg4 ;
6194  PLFLT arg5 ;
6195  PLFLT arg6 ;
6196  PLFLT arg7 ;
6197  PLINT arg8 ;
6198  PLINT arg9 ;
6199  PLINT arg10 ;
6200  PLINT arg11 ;
6201  PLINT arg12 ;
6202  PLINT arg13 ;
6203  PLINT *arg14 = (PLINT *) 0 ;
6204  PLFLT arg15 ;
6205  PLFLT arg16 ;
6206  PLFLT arg17 ;
6207  PLFLT arg18 ;
6208  PLINT *arg19 = (PLINT *) 0 ;
6209  char **arg20 = (char **) 0 ;
6210  PLINT *arg21 = (PLINT *) 0 ;
6211  PLINT *arg22 = (PLINT *) 0 ;
6212  PLFLT *arg23 = (PLFLT *) 0 ;
6213  PLFLT *arg24 = (PLFLT *) 0 ;
6214  PLINT *arg25 = (PLINT *) 0 ;
6215  PLINT *arg26 = (PLINT *) 0 ;
6216  PLFLT *arg27 = (PLFLT *) 0 ;
6217  PLINT *arg28 = (PLINT *) 0 ;
6218  PLFLT *arg29 = (PLFLT *) 0 ;
6219  PLINT *arg30 = (PLINT *) 0 ;
6220  char **arg31 = (char **) 0 ;
6221  PLFLT temp1 ;
6222  PLFLT temp2 ;
6223  int temp19 ;
6224  int temp21 ;
6225  int temp22 ;
6226  int temp23 ;
6227  int temp24 ;
6228  int temp25 ;
6229  int temp26 ;
6230  int temp27 ;
6231  int temp28 ;
6232  int temp29 ;
6233  int temp30 ;
6234 
6235  {
6236  arg21 = NULL;
6237  }
6238  {
6239  arg22 = NULL;
6240  }
6241  {
6242  arg23 = NULL;
6243  }
6244  {
6245  arg24 = NULL;
6246  }
6247  {
6248  arg25 = NULL;
6249  }
6250  {
6251  arg26 = NULL;
6252  }
6253  {
6254  arg27 = NULL;
6255  }
6256  {
6257  arg28 = NULL;
6258  }
6259  {
6260  arg29 = NULL;
6261  }
6262  {
6263  arg30 = NULL;
6264  }
6265  arg1 = &temp1;
6266  arg2 = &temp2;
6267  SWIG_check_num_args("pllegend",17,28)
6268  if(!lua_isnumber(L,1)) SWIG_fail_arg("pllegend",1,"PLINT");
6269  if(!lua_isnumber(L,2)) SWIG_fail_arg("pllegend",2,"PLINT");
6270  if(!lua_isnumber(L,3)) SWIG_fail_arg("pllegend",3,"PLFLT");
6271  if(!lua_isnumber(L,4)) SWIG_fail_arg("pllegend",4,"PLFLT");
6272  if(!lua_isnumber(L,5)) SWIG_fail_arg("pllegend",5,"PLFLT");
6273  if(!lua_isnumber(L,6)) SWIG_fail_arg("pllegend",6,"PLINT");
6274  if(!lua_isnumber(L,7)) SWIG_fail_arg("pllegend",7,"PLINT");
6275  if(!lua_isnumber(L,8)) SWIG_fail_arg("pllegend",8,"PLINT");
6276  if(!lua_isnumber(L,9)) SWIG_fail_arg("pllegend",9,"PLINT");
6277  if(!lua_isnumber(L,10)) SWIG_fail_arg("pllegend",10,"PLINT");
6278  if(!lua_isnumber(L,12)) SWIG_fail_arg("pllegend",12,"PLFLT");
6279  if(!lua_isnumber(L,13)) SWIG_fail_arg("pllegend",13,"PLFLT");
6280  if(!lua_isnumber(L,14)) SWIG_fail_arg("pllegend",14,"PLFLT");
6281  if(!lua_isnumber(L,15)) SWIG_fail_arg("pllegend",15,"PLFLT");
6282  if(!lua_istable(L,17)) SWIG_fail_arg("pllegend",17,"char const **");
6283  if(lua_gettop(L)>=28 && !lua_istable(L,28)) SWIG_fail_arg("pllegend",28,"char const **");
6284  arg3 = (PLINT)lua_tonumber(L, 1);
6285  arg4 = (PLINT)lua_tonumber(L, 2);
6286  arg5 = (PLFLT)lua_tonumber(L, 3);
6287  arg6 = (PLFLT)lua_tonumber(L, 4);
6288  arg7 = (PLFLT)lua_tonumber(L, 5);
6289  arg8 = (PLINT)lua_tonumber(L, 6);
6290  arg9 = (PLINT)lua_tonumber(L, 7);
6291  arg10 = (PLINT)lua_tonumber(L, 8);
6292  arg11 = (PLINT)lua_tonumber(L, 9);
6293  arg12 = (PLINT)lua_tonumber(L, 10);
6294  {
6295  arg14 = (PLINT *) LUA_get_int_num_array_var( L, 11, &arg13 );
6296  if ( !arg14 )
6297  SWIG_fail;
6298  Alen = arg13;
6299  }
6300  arg15 = (PLFLT)lua_tonumber(L, 12);
6301  arg16 = (PLFLT)lua_tonumber(L, 13);
6302  arg17 = (PLFLT)lua_tonumber(L, 14);
6303  arg18 = (PLFLT)lua_tonumber(L, 15);
6304  {
6305  arg19 = (PLINT *) LUA_get_int_num_array_var( L, 16, &temp19 );
6306  if ( !arg19 )
6307  SWIG_fail;
6308  if ( temp19 != Alen )
6309  {
6310  lua_pushfstring( L, "Tables must be of same length." );
6311  SWIG_fail;
6312  }
6313  }
6314  {
6315  int i;
6316  arg20 = NULL;
6317 
6318  if ( SWIG_table_size( L, 17 ) != Alen )
6319  {
6320  lua_pushfstring( L, "Tables must be of same length." );
6321  SWIG_fail;
6322  }
6323  arg20 = malloc( sizeof ( char* ) * Alen );
6324  for ( i = 1; i <= Alen; i++ )
6325  {
6326  lua_rawgeti( L, 17, i );
6327  if ( lua_isstring( L, -1 ) )
6328  {
6329  arg20[i - 1] = (char *) lua_tostring( L, -1 );
6330  }
6331  else
6332  {
6333  lua_pop( L, 1 );
6334  lua_pushfstring( L, "Requires a sequence of strings." );
6335  SWIG_fail;
6336  // arg20 array is freed after 'fail:'
6337  }
6338  lua_pop( L, 1 );
6339  }
6340  }
6341  if(lua_gettop(L)>=18){
6342  {
6343  if ( lua_isnil( L, 18 ) )
6344  {
6345  arg21 = NULL;
6346  }
6347  else
6348  {
6349  arg21 = (PLINT *) LUA_get_int_num_array_var( L, 18, &temp21 );
6350  if ( !arg21 )
6351  SWIG_fail;
6352  if ( temp21 != Alen )
6353  {
6354  lua_pushfstring( L, "Tables must be of same length." );
6355  SWIG_fail;
6356  }
6357  }
6358  }
6359  }
6360  if(lua_gettop(L)>=19){
6361  {
6362  if ( lua_isnil( L, 19 ) )
6363  {
6364  arg22 = NULL;
6365  }
6366  else
6367  {
6368  arg22 = (PLINT *) LUA_get_int_num_array_var( L, 19, &temp22 );
6369  if ( !arg22 )
6370  SWIG_fail;
6371  if ( temp22 != Alen )
6372  {
6373  lua_pushfstring( L, "Tables must be of same length." );
6374  SWIG_fail;
6375  }
6376  }
6377  }
6378  }
6379  if(lua_gettop(L)>=20){
6380  {
6381  if ( lua_isnil( L, 20 ) )
6382  {
6383  arg23 = NULL;
6384  }
6385  else
6386  {
6387  arg23 = (PLFLT *) LUA_get_double_num_array_var( L, 20, &temp23 );
6388  if ( !arg23 )
6389  SWIG_fail;
6390  if ( temp23 != Alen )
6391  {
6392  lua_pushfstring( L, "Tables must be of same length." );
6393  SWIG_fail;
6394  }
6395  }
6396  }
6397  }
6398  if(lua_gettop(L)>=21){
6399  {
6400  if ( lua_isnil( L, 21 ) )
6401  {
6402  arg24 = NULL;
6403  }
6404  else
6405  {
6406  arg24 = (PLFLT *) LUA_get_double_num_array_var( L, 21, &temp24 );
6407  if ( !arg24 )
6408  SWIG_fail;
6409  if ( temp24 != Alen )
6410  {
6411  lua_pushfstring( L, "Tables must be of same length." );
6412  SWIG_fail;
6413  }
6414  }
6415  }
6416  }
6417  if(lua_gettop(L)>=22){
6418  {
6419  if ( lua_isnil( L, 22 ) )
6420  {
6421  arg25 = NULL;
6422  }
6423  else
6424  {
6425  arg25 = (PLINT *) LUA_get_int_num_array_var( L, 22, &temp25 );
6426  if ( !arg25 )
6427  SWIG_fail;
6428  if ( temp25 != Alen )
6429  {
6430  lua_pushfstring( L, "Tables must be of same length." );
6431  SWIG_fail;
6432  }
6433  }
6434  }
6435  }
6436  if(lua_gettop(L)>=23){
6437  {
6438  if ( lua_isnil( L, 23 ) )
6439  {
6440  arg26 = NULL;
6441  }
6442  else
6443  {
6444  arg26 = (PLINT *) LUA_get_int_num_array_var( L, 23, &temp26 );
6445  if ( !arg26 )
6446  SWIG_fail;
6447  if ( temp26 != Alen )
6448  {
6449  lua_pushfstring( L, "Tables must be of same length." );
6450  SWIG_fail;
6451  }
6452  }
6453  }
6454  }
6455  if(lua_gettop(L)>=24){
6456  {
6457  if ( lua_isnil( L, 24 ) )
6458  {
6459  arg27 = NULL;
6460  }
6461  else
6462  {
6463  arg27 = (PLFLT *) LUA_get_double_num_array_var( L, 24, &temp27 );
6464  if ( !arg27 )
6465  SWIG_fail;
6466  if ( temp27 != Alen )
6467  {
6468  lua_pushfstring( L, "Tables must be of same length." );
6469  SWIG_fail;
6470  }
6471  }
6472  }
6473  }
6474  if(lua_gettop(L)>=25){
6475  {
6476  if ( lua_isnil( L, 25 ) )
6477  {
6478  arg28 = NULL;
6479  }
6480  else
6481  {
6482  arg28 = (PLINT *) LUA_get_int_num_array_var( L, 25, &temp28 );
6483  if ( !arg28 )
6484  SWIG_fail;
6485  if ( temp28 != Alen )
6486  {
6487  lua_pushfstring( L, "Tables must be of same length." );
6488  SWIG_fail;
6489  }
6490  }
6491  }
6492  }
6493  if(lua_gettop(L)>=26){
6494  {
6495  if ( lua_isnil( L, 26 ) )
6496  {
6497  arg29 = NULL;
6498  }
6499  else
6500  {
6501  arg29 = (PLFLT *) LUA_get_double_num_array_var( L, 26, &temp29 );
6502  if ( !arg29 )
6503  SWIG_fail;
6504  if ( temp29 != Alen )
6505  {
6506  lua_pushfstring( L, "Tables must be of same length." );
6507  SWIG_fail;
6508  }
6509  }
6510  }
6511  }
6512  if(lua_gettop(L)>=27){
6513  {
6514  if ( lua_isnil( L, 27 ) )
6515  {
6516  arg30 = NULL;
6517  }
6518  else
6519  {
6520  arg30 = (PLINT *) LUA_get_int_num_array_var( L, 27, &temp30 );
6521  if ( !arg30 )
6522  SWIG_fail;
6523  if ( temp30 != Alen )
6524  {
6525  lua_pushfstring( L, "Tables must be of same length." );
6526  SWIG_fail;
6527  }
6528  }
6529  }
6530  }
6531  if(lua_gettop(L)>=28){
6532  {
6533  int i;
6534  arg31 = NULL;
6535 
6536  if ( SWIG_table_size( L, 28 ) != Alen )
6537  {
6538  lua_pushfstring( L, "Tables must be of same length." );
6539  SWIG_fail;
6540  }
6541  arg31 = malloc( sizeof ( char* ) * Alen );
6542  for ( i = 1; i <= Alen; i++ )
6543  {
6544  lua_rawgeti( L, 28, i );
6545  if ( lua_isstring( L, -1 ) )
6546  {
6547  arg31[i - 1] = (char *) lua_tostring( L, -1 );
6548  }
6549  else
6550  {
6551  lua_pop( L, 1 );
6552  lua_pushfstring( L, "Requires a sequence of strings." );
6553  SWIG_fail;
6554  // arg31 array is freed after 'fail:'
6555  }
6556  lua_pop( L, 1 );
6557  }
6558  }
6559  }
6560  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);
6561 
6562  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
6563  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
6564  {
6565  LUA_FREE_ARRAY( arg14 );
6566  }
6567  {
6568  LUA_FREE_ARRAY( arg19 );
6569  }
6570  {
6571  if ( arg20 )
6572  {
6573  free( arg20 ); arg20 = NULL;
6574  }
6575  }
6576  {
6577  LUA_FREE_ARRAY( arg21 );
6578  }
6579  {
6580  LUA_FREE_ARRAY( arg22 );
6581  }
6582  {
6583  LUA_FREE_ARRAY( arg23 );
6584  }
6585  {
6586  LUA_FREE_ARRAY( arg24 );
6587  }
6588  {
6589  LUA_FREE_ARRAY( arg25 );
6590  }
6591  {
6592  LUA_FREE_ARRAY( arg26 );
6593  }
6594  {
6595  LUA_FREE_ARRAY( arg27 );
6596  }
6597  {
6598  LUA_FREE_ARRAY( arg28 );
6599  }
6600  {
6601  LUA_FREE_ARRAY( arg29 );
6602  }
6603  {
6604  LUA_FREE_ARRAY( arg30 );
6605  }
6606  {
6607  if ( arg31 )
6608  {
6609  free( arg31 ); arg31 = NULL;
6610  }
6611  }
6612  return SWIG_arg;
6613 
6614  if(0) SWIG_fail;
6615 
6616 fail:
6617  {
6618  LUA_FREE_ARRAY( arg14 );
6619  }
6620  {
6621  LUA_FREE_ARRAY( arg19 );
6622  }
6623  {
6624  if ( arg20 )
6625  {
6626  free( arg20 ); arg20 = NULL;
6627  }
6628  }
6629  {
6630  LUA_FREE_ARRAY( arg21 );
6631  }
6632  {
6633  LUA_FREE_ARRAY( arg22 );
6634  }
6635  {
6636  LUA_FREE_ARRAY( arg23 );
6637  }
6638  {
6639  LUA_FREE_ARRAY( arg24 );
6640  }
6641  {
6642  LUA_FREE_ARRAY( arg25 );
6643  }
6644  {
6645  LUA_FREE_ARRAY( arg26 );
6646  }
6647  {
6648  LUA_FREE_ARRAY( arg27 );
6649  }
6650  {
6651  LUA_FREE_ARRAY( arg28 );
6652  }
6653  {
6654  LUA_FREE_ARRAY( arg29 );
6655  }
6656  {
6657  LUA_FREE_ARRAY( arg30 );
6658  }
6659  {
6660  if ( arg31 )
6661  {
6662  free( arg31 ); arg31 = NULL;
6663  }
6664  }
6665  lua_error(L);
6666  return SWIG_arg;
6667 }
6668 
6669 
6670 static int _wrap_colorbar(lua_State* L) {
6671  int SWIG_arg = 0;
6672  PLFLT *arg1 = (PLFLT *) 0 ;
6673  PLFLT *arg2 = (PLFLT *) 0 ;
6674  PLINT arg3 ;
6675  PLINT arg4 ;
6676  PLFLT arg5 ;
6677  PLFLT arg6 ;
6678  PLFLT arg7 ;
6679  PLFLT arg8 ;
6680  PLINT arg9 ;
6681  PLINT arg10 ;
6682  PLINT arg11 ;
6683  PLFLT arg12 ;
6684  PLFLT arg13 ;
6685  PLINT arg14 ;
6686  PLFLT arg15 ;
6687  PLINT arg16 ;
6688  PLINT *arg17 = (PLINT *) 0 ;
6689  char **arg18 = (char **) 0 ;
6690  PLINT arg19 ;
6691  char **arg20 = (char **) 0 ;
6692  PLFLT *arg21 = (PLFLT *) 0 ;
6693  PLINT *arg22 = (PLINT *) 0 ;
6694  PLINT *arg23 = (PLINT *) 0 ;
6695  PLFLT **arg24 = (PLFLT **) 0 ;
6696  PLFLT temp1 ;
6697  PLFLT temp2 ;
6698  int temp21 ;
6699  int temp22 ;
6700  int temp23 ;
6701  int ii24 ;
6702 
6703  arg1 = &temp1;
6704  arg2 = &temp2;
6705  SWIG_check_num_args("plcolorbar",20,20)
6706  if(!lua_isnumber(L,1)) SWIG_fail_arg("plcolorbar",1,"PLINT");
6707  if(!lua_isnumber(L,2)) SWIG_fail_arg("plcolorbar",2,"PLINT");
6708  if(!lua_isnumber(L,3)) SWIG_fail_arg("plcolorbar",3,"PLFLT");
6709  if(!lua_isnumber(L,4)) SWIG_fail_arg("plcolorbar",4,"PLFLT");
6710  if(!lua_isnumber(L,5)) SWIG_fail_arg("plcolorbar",5,"PLFLT");
6711  if(!lua_isnumber(L,6)) SWIG_fail_arg("plcolorbar",6,"PLFLT");
6712  if(!lua_isnumber(L,7)) SWIG_fail_arg("plcolorbar",7,"PLINT");
6713  if(!lua_isnumber(L,8)) SWIG_fail_arg("plcolorbar",8,"PLINT");
6714  if(!lua_isnumber(L,9)) SWIG_fail_arg("plcolorbar",9,"PLINT");
6715  if(!lua_isnumber(L,10)) SWIG_fail_arg("plcolorbar",10,"PLFLT");
6716  if(!lua_isnumber(L,11)) SWIG_fail_arg("plcolorbar",11,"PLFLT");
6717  if(!lua_isnumber(L,12)) SWIG_fail_arg("plcolorbar",12,"PLINT");
6718  if(!lua_isnumber(L,13)) SWIG_fail_arg("plcolorbar",13,"PLFLT");
6719  if(!lua_istable(L,15)) SWIG_fail_arg("plcolorbar",15,"char const **");
6720  arg3 = (PLINT)lua_tonumber(L, 1);
6721  arg4 = (PLINT)lua_tonumber(L, 2);
6722  arg5 = (PLFLT)lua_tonumber(L, 3);
6723  arg6 = (PLFLT)lua_tonumber(L, 4);
6724  arg7 = (PLFLT)lua_tonumber(L, 5);
6725  arg8 = (PLFLT)lua_tonumber(L, 6);
6726  arg9 = (PLINT)lua_tonumber(L, 7);
6727  arg10 = (PLINT)lua_tonumber(L, 8);
6728  arg11 = (PLINT)lua_tonumber(L, 9);
6729  arg12 = (PLFLT)lua_tonumber(L, 10);
6730  arg13 = (PLFLT)lua_tonumber(L, 11);
6731  arg14 = (PLINT)lua_tonumber(L, 12);
6732  arg15 = (PLFLT)lua_tonumber(L, 13);
6733  {
6734  arg17 = (PLINT *) LUA_get_int_num_array_var( L, 14, &arg16 );
6735  if ( !arg17 )
6736  SWIG_fail;
6737  Alen = arg16;
6738  }
6739  {
6740  int i;
6741  arg18 = NULL;
6742 
6743  if ( SWIG_table_size( L, 15 ) != Alen )
6744  {
6745  lua_pushfstring( L, "Tables must be of same length." );
6746  SWIG_fail;
6747  }
6748  arg18 = malloc( sizeof ( char* ) * Alen );
6749  for ( i = 1; i <= Alen; i++ )
6750  {
6751  lua_rawgeti( L, 15, i );
6752  if ( lua_isstring( L, -1 ) )
6753  {
6754  arg18[i - 1] = (char *) lua_tostring( L, -1 );
6755  }
6756  else
6757  {
6758  lua_pop( L, 1 );
6759  lua_pushfstring( L, "Requires a sequence of strings." );
6760  SWIG_fail;
6761  // arg18 array is freed after 'fail:'
6762  }
6763  lua_pop( L, 1 );
6764  }
6765  }
6766  {
6767  int i;
6768  arg19 = SWIG_table_size( L, 16 );
6769  Alen = arg19;
6770 
6771  arg20 = malloc( sizeof ( char* ) * Alen );
6772  for ( i = 1; i <= Alen; i++ )
6773  {
6774  lua_rawgeti( L, 16, i );
6775  if ( lua_isstring( L, -1 ) )
6776  {
6777  arg20[i - 1] = (char *) lua_tostring( L, -1 );
6778  }
6779  else
6780  {
6781  lua_pop( L, 1 );
6782  lua_pushfstring( L, "Requires a sequence of strings." );
6783  SWIG_fail;
6784  }
6785  lua_pop( L, 1 );
6786  }
6787  }
6788  {
6789  arg21 = (PLFLT *) LUA_get_double_num_array_var( L, 17, &temp21 );
6790  if ( !arg21 )
6791  SWIG_fail;
6792  if ( temp21 != Alen )
6793  {
6794  lua_pushfstring( L, "Tables must be of same length." );
6795  SWIG_fail;
6796  }
6797  }
6798  {
6799  arg22 = (PLINT *) LUA_get_int_num_array_var( L, 18, &temp22 );
6800  if ( !arg22 )
6801  SWIG_fail;
6802  if ( temp22 != Alen )
6803  {
6804  lua_pushfstring( L, "Tables must be of same length." );
6805  SWIG_fail;
6806  }
6807  }
6808  {
6809  int i;
6810 
6811  arg23 = (PLINT *) LUA_get_int_num_array_var( L, 19, &temp23 );
6812  if ( !arg23 )
6813  SWIG_fail;
6814  if ( temp23 != Alen )
6815  {
6816  lua_pushfstring( L, "Tables must be of same length." );
6817  SWIG_fail;
6818  }
6819 
6820  Xlen = temp23;
6821  Ylen = -1;
6822  for ( i = 0; i < Xlen; i++ )
6823  if ( arg23[i] > Ylen )
6824  Ylen = arg23[i];
6825  }
6826  {
6827  int jj;
6828 
6829  arg24 = read_double_Matrix( L, 20, &ii24, &jj );
6830  if ( !arg24 )
6831  SWIG_fail;
6832  if ( ( ii24 != Xlen ) || ( jj != Ylen ) )
6833  {
6834  lua_pushfstring( L, "Vectors must match matrix." );
6835  SWIG_fail;
6836  }
6837  }
6838  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);
6839 
6840  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
6841  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
6842  {
6843  LUA_FREE_ARRAY( arg17 );
6844  }
6845  {
6846  if ( arg18 )
6847  {
6848  free( arg18 ); arg18 = NULL;
6849  }
6850  }
6851  {
6852  if ( arg20 )
6853  {
6854  free( arg20 ); arg20 = NULL;
6855  }
6856  }
6857  {
6858  LUA_FREE_ARRAY( arg21 );
6859  }
6860  {
6861  LUA_FREE_ARRAY( arg22 );
6862  }
6863  {
6864  LUA_FREE_ARRAY( arg23 );
6865  }
6866  {
6867  int i;
6868 
6869  if ( arg24 )
6870  {
6871  for ( i = 0; i < ii24; i++ )
6872  LUA_FREE_ARRAY( arg24[i] );
6873  LUA_FREE_ARRAY( arg24 );
6874  }
6875  }
6876  return SWIG_arg;
6877 
6878  if(0) SWIG_fail;
6879 
6880 fail:
6881  {
6882  LUA_FREE_ARRAY( arg17 );
6883  }
6884  {
6885  if ( arg18 )
6886  {
6887  free( arg18 ); arg18 = NULL;
6888  }
6889  }
6890  {
6891  if ( arg20 )
6892  {
6893  free( arg20 ); arg20 = NULL;
6894  }
6895  }
6896  {
6897  LUA_FREE_ARRAY( arg21 );
6898  }
6899  {
6900  LUA_FREE_ARRAY( arg22 );
6901  }
6902  {
6903  LUA_FREE_ARRAY( arg23 );
6904  }
6905  {
6906  int i;
6907 
6908  if ( arg24 )
6909  {
6910  for ( i = 0; i < ii24; i++ )
6911  LUA_FREE_ARRAY( arg24[i] );
6912  LUA_FREE_ARRAY( arg24 );
6913  }
6914  }
6915  lua_error(L);
6916  return SWIG_arg;
6917 }
6918 
6919 
6920 static int _wrap_lightsource(lua_State* L) {
6921  int SWIG_arg = 0;
6922  PLFLT arg1 ;
6923  PLFLT arg2 ;
6924  PLFLT arg3 ;
6925 
6926  SWIG_check_num_args("pllightsource",3,3)
6927  if(!lua_isnumber(L,1)) SWIG_fail_arg("pllightsource",1,"PLFLT");
6928  if(!lua_isnumber(L,2)) SWIG_fail_arg("pllightsource",2,"PLFLT");
6929  if(!lua_isnumber(L,3)) SWIG_fail_arg("pllightsource",3,"PLFLT");
6930  arg1 = (PLFLT)lua_tonumber(L, 1);
6931  arg2 = (PLFLT)lua_tonumber(L, 2);
6932  arg3 = (PLFLT)lua_tonumber(L, 3);
6933  pllightsource(arg1,arg2,arg3);
6934 
6935  return SWIG_arg;
6936 
6937  if(0) SWIG_fail;
6938 
6939 fail:
6940  lua_error(L);
6941  return SWIG_arg;
6942 }
6943 
6944 
6945 static int _wrap_line(lua_State* L) {
6946  int SWIG_arg = 0;
6947  PLINT arg1 ;
6948  PLFLT *arg2 = (PLFLT *) 0 ;
6949  PLFLT *arg3 = (PLFLT *) 0 ;
6950  int temp3 ;
6951 
6952  SWIG_check_num_args("plline",2,2)
6953  {
6954  int temp;
6955  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
6956  if ( !arg2 )
6957  SWIG_fail;
6958  arg1 = Alen = temp;
6959  }
6960  {
6961  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
6962  if ( !arg3 )
6963  SWIG_fail;
6964  if ( temp3 != Alen )
6965  {
6966  lua_pushfstring( L, "Tables must be of same length." );
6967  SWIG_fail;
6968  }
6969  }
6970  plline(arg1,(double const *)arg2,(double const *)arg3);
6971 
6972  {
6973  LUA_FREE_ARRAY( arg2 );
6974  }
6975  {
6976  LUA_FREE_ARRAY( arg3 );
6977  }
6978  return SWIG_arg;
6979 
6980  if(0) SWIG_fail;
6981 
6982 fail:
6983  {
6984  LUA_FREE_ARRAY( arg2 );
6985  }
6986  {
6987  LUA_FREE_ARRAY( arg3 );
6988  }
6989  lua_error(L);
6990  return SWIG_arg;
6991 }
6992 
6993 
6994 static int _wrap_line3(lua_State* L) {
6995  int SWIG_arg = 0;
6996  PLINT arg1 ;
6997  PLFLT *arg2 = (PLFLT *) 0 ;
6998  PLFLT *arg3 = (PLFLT *) 0 ;
6999  PLFLT *arg4 = (PLFLT *) 0 ;
7000  int temp3 ;
7001  int temp4 ;
7002 
7003  SWIG_check_num_args("plline3",3,3)
7004  {
7005  int temp;
7006  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7007  if ( !arg2 )
7008  SWIG_fail;
7009  arg1 = Alen = temp;
7010  }
7011  {
7012  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
7013  if ( !arg3 )
7014  SWIG_fail;
7015  if ( temp3 != Alen )
7016  {
7017  lua_pushfstring( L, "Tables must be of same length." );
7018  SWIG_fail;
7019  }
7020  }
7021  {
7022  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
7023  if ( !arg4 )
7024  SWIG_fail;
7025  if ( temp4 != Alen )
7026  {
7027  lua_pushfstring( L, "Tables must be of same length." );
7028  SWIG_fail;
7029  }
7030  }
7031  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
7032 
7033  {
7034  LUA_FREE_ARRAY( arg2 );
7035  }
7036  {
7037  LUA_FREE_ARRAY( arg3 );
7038  }
7039  {
7040  LUA_FREE_ARRAY( arg4 );
7041  }
7042  return SWIG_arg;
7043 
7044  if(0) SWIG_fail;
7045 
7046 fail:
7047  {
7048  LUA_FREE_ARRAY( arg2 );
7049  }
7050  {
7051  LUA_FREE_ARRAY( arg3 );
7052  }
7053  {
7054  LUA_FREE_ARRAY( arg4 );
7055  }
7056  lua_error(L);
7057  return SWIG_arg;
7058 }
7059 
7060 
7061 static int _wrap_lsty(lua_State* L) {
7062  int SWIG_arg = 0;
7063  PLINT arg1 ;
7064 
7065  SWIG_check_num_args("pllsty",1,1)
7066  if(!lua_isnumber(L,1)) SWIG_fail_arg("pllsty",1,"PLINT");
7067  arg1 = (PLINT)lua_tonumber(L, 1);
7068  pllsty(arg1);
7069 
7070  return SWIG_arg;
7071 
7072  if(0) SWIG_fail;
7073 
7074 fail:
7075  lua_error(L);
7076  return SWIG_arg;
7077 }
7078 
7079 
7080 static int _wrap_mesh(lua_State* L) {
7081  int SWIG_arg = 0;
7082  PLFLT *arg1 = (PLFLT *) 0 ;
7083  PLFLT *arg2 = (PLFLT *) 0 ;
7084  PLFLT **arg3 = (PLFLT **) 0 ;
7085  PLINT arg4 ;
7086  PLINT arg5 ;
7087  PLINT arg6 ;
7088  int ii3 ;
7089 
7090  SWIG_check_num_args("plmesh",4,4)
7091  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmesh",4,"PLINT");
7092  {
7093  int temp;
7094  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7095  if ( !arg1 )
7096  SWIG_fail;
7097  Xlen = temp;
7098  }
7099  {
7100  int temp;
7101  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7102  if ( !arg2 )
7103  SWIG_fail;
7104  Ylen = temp;
7105  }
7106  {
7107  int jj;
7108 
7109  arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7110  if ( !arg3 )
7111  SWIG_fail;
7112  arg4 = ii3;
7113  arg5 = jj;
7114  if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7115  {
7116  lua_pushfstring( L, "Vectors must match matrix." );
7117  SWIG_fail;
7118  }
7119  }
7120  arg6 = (PLINT)lua_tonumber(L, 4);
7121  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
7122 
7123  {
7124  LUA_FREE_ARRAY( arg1 );
7125  }
7126  {
7127  LUA_FREE_ARRAY( arg2 );
7128  }
7129  {
7130  int i;
7131 
7132  if ( arg3 )
7133  {
7134  for ( i = 0; i < ii3; i++ )
7135  LUA_FREE_ARRAY( arg3[i] );
7136  LUA_FREE_ARRAY( arg3 );
7137  }
7138  }
7139  return SWIG_arg;
7140 
7141  if(0) SWIG_fail;
7142 
7143 fail:
7144  {
7145  LUA_FREE_ARRAY( arg1 );
7146  }
7147  {
7148  LUA_FREE_ARRAY( arg2 );
7149  }
7150  {
7151  int i;
7152 
7153  if ( arg3 )
7154  {
7155  for ( i = 0; i < ii3; i++ )
7156  LUA_FREE_ARRAY( arg3[i] );
7157  LUA_FREE_ARRAY( arg3 );
7158  }
7159  }
7160  lua_error(L);
7161  return SWIG_arg;
7162 }
7163 
7164 
7165 static int _wrap_meshc(lua_State* L) {
7166  int SWIG_arg = 0;
7167  PLFLT *arg1 = (PLFLT *) 0 ;
7168  PLFLT *arg2 = (PLFLT *) 0 ;
7169  PLFLT **arg3 = (PLFLT **) 0 ;
7170  PLINT arg4 ;
7171  PLINT arg5 ;
7172  PLINT arg6 ;
7173  PLFLT *arg7 = (PLFLT *) 0 ;
7174  PLINT arg8 ;
7175  int ii3 ;
7176 
7177  SWIG_check_num_args("plmeshc",5,5)
7178  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmeshc",4,"PLINT");
7179  {
7180  int temp;
7181  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7182  if ( !arg1 )
7183  SWIG_fail;
7184  Xlen = temp;
7185  }
7186  {
7187  int temp;
7188  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7189  if ( !arg2 )
7190  SWIG_fail;
7191  Ylen = temp;
7192  }
7193  {
7194  int jj;
7195 
7196  arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7197  if ( !arg3 )
7198  SWIG_fail;
7199  arg4 = ii3;
7200  arg5 = jj;
7201  if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7202  {
7203  lua_pushfstring( L, "Vectors must match matrix." );
7204  SWIG_fail;
7205  }
7206  }
7207  arg6 = (PLINT)lua_tonumber(L, 4);
7208  {
7209  int temp;
7210  arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7211  if ( !arg7 )
7212  SWIG_fail;
7213  arg8 = Alen = temp;
7214  }
7215  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
7216 
7217  {
7218  LUA_FREE_ARRAY( arg1 );
7219  }
7220  {
7221  LUA_FREE_ARRAY( arg2 );
7222  }
7223  {
7224  int i;
7225 
7226  if ( arg3 )
7227  {
7228  for ( i = 0; i < ii3; i++ )
7229  LUA_FREE_ARRAY( arg3[i] );
7230  LUA_FREE_ARRAY( arg3 );
7231  }
7232  }
7233  {
7234  LUA_FREE_ARRAY( arg7 );
7235  }
7236  return SWIG_arg;
7237 
7238  if(0) SWIG_fail;
7239 
7240 fail:
7241  {
7242  LUA_FREE_ARRAY( arg1 );
7243  }
7244  {
7245  LUA_FREE_ARRAY( arg2 );
7246  }
7247  {
7248  int i;
7249 
7250  if ( arg3 )
7251  {
7252  for ( i = 0; i < ii3; i++ )
7253  LUA_FREE_ARRAY( arg3[i] );
7254  LUA_FREE_ARRAY( arg3 );
7255  }
7256  }
7257  {
7258  LUA_FREE_ARRAY( arg7 );
7259  }
7260  lua_error(L);
7261  return SWIG_arg;
7262 }
7263 
7264 
7265 static int _wrap_mkstrm(lua_State* L) {
7266  int SWIG_arg = 0;
7267  PLINT *arg1 = (PLINT *) 0 ;
7268  PLINT temp1 ;
7269 
7270  arg1 = &temp1;
7271  SWIG_check_num_args("plmkstrm",0,0)
7272  plmkstrm(arg1);
7273 
7274  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
7275  return SWIG_arg;
7276 
7277  if(0) SWIG_fail;
7278 
7279 fail:
7280  lua_error(L);
7281  return SWIG_arg;
7282 }
7283 
7284 
7285 static int _wrap_mtex(lua_State* L) {
7286  int SWIG_arg = 0;
7287  char *arg1 = (char *) 0 ;
7288  PLFLT arg2 ;
7289  PLFLT arg3 ;
7290  PLFLT arg4 ;
7291  char *arg5 = (char *) 0 ;
7292 
7293  SWIG_check_num_args("plmtex",5,5)
7294  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plmtex",1,"char const *");
7295  if(!lua_isnumber(L,2)) SWIG_fail_arg("plmtex",2,"PLFLT");
7296  if(!lua_isnumber(L,3)) SWIG_fail_arg("plmtex",3,"PLFLT");
7297  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmtex",4,"PLFLT");
7298  if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("plmtex",5,"char const *");
7299  arg1 = (char *)lua_tostring(L, 1);
7300  arg2 = (PLFLT)lua_tonumber(L, 2);
7301  arg3 = (PLFLT)lua_tonumber(L, 3);
7302  arg4 = (PLFLT)lua_tonumber(L, 4);
7303  arg5 = (char *)lua_tostring(L, 5);
7304  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
7305 
7306  return SWIG_arg;
7307 
7308  if(0) SWIG_fail;
7309 
7310 fail:
7311  lua_error(L);
7312  return SWIG_arg;
7313 }
7314 
7315 
7316 static int _wrap_mtex3(lua_State* L) {
7317  int SWIG_arg = 0;
7318  char *arg1 = (char *) 0 ;
7319  PLFLT arg2 ;
7320  PLFLT arg3 ;
7321  PLFLT arg4 ;
7322  char *arg5 = (char *) 0 ;
7323 
7324  SWIG_check_num_args("plmtex3",5,5)
7325  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plmtex3",1,"char const *");
7326  if(!lua_isnumber(L,2)) SWIG_fail_arg("plmtex3",2,"PLFLT");
7327  if(!lua_isnumber(L,3)) SWIG_fail_arg("plmtex3",3,"PLFLT");
7328  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmtex3",4,"PLFLT");
7329  if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("plmtex3",5,"char const *");
7330  arg1 = (char *)lua_tostring(L, 1);
7331  arg2 = (PLFLT)lua_tonumber(L, 2);
7332  arg3 = (PLFLT)lua_tonumber(L, 3);
7333  arg4 = (PLFLT)lua_tonumber(L, 4);
7334  arg5 = (char *)lua_tostring(L, 5);
7335  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
7336 
7337  return SWIG_arg;
7338 
7339  if(0) SWIG_fail;
7340 
7341 fail:
7342  lua_error(L);
7343  return SWIG_arg;
7344 }
7345 
7346 
7347 static int _wrap_plot3d(lua_State* L) {
7348  int SWIG_arg = 0;
7349  PLFLT *arg1 = (PLFLT *) 0 ;
7350  PLFLT *arg2 = (PLFLT *) 0 ;
7351  PLFLT **arg3 = (PLFLT **) 0 ;
7352  PLINT arg4 ;
7353  PLINT arg5 ;
7354  PLINT arg6 ;
7355  PLBOOL arg7 ;
7356  int ii3 ;
7357 
7358  SWIG_check_num_args("plot3d",5,5)
7359  if(!lua_isnumber(L,4)) SWIG_fail_arg("plot3d",4,"PLINT");
7360  if(!lua_isnumber(L,5)) SWIG_fail_arg("plot3d",5,"PLBOOL");
7361  {
7362  int temp;
7363  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7364  if ( !arg1 )
7365  SWIG_fail;
7366  Xlen = temp;
7367  }
7368  {
7369  int temp;
7370  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7371  if ( !arg2 )
7372  SWIG_fail;
7373  Ylen = temp;
7374  }
7375  {
7376  int jj;
7377 
7378  arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7379  if ( !arg3 )
7380  SWIG_fail;
7381  arg4 = ii3;
7382  arg5 = jj;
7383  if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7384  {
7385  lua_pushfstring( L, "Vectors must match matrix." );
7386  SWIG_fail;
7387  }
7388  }
7389  arg6 = (PLINT)lua_tonumber(L, 4);
7390  arg7 = (PLBOOL)lua_tonumber(L, 5);
7391  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
7392 
7393  {
7394  LUA_FREE_ARRAY( arg1 );
7395  }
7396  {
7397  LUA_FREE_ARRAY( arg2 );
7398  }
7399  {
7400  int i;
7401 
7402  if ( arg3 )
7403  {
7404  for ( i = 0; i < ii3; i++ )
7405  LUA_FREE_ARRAY( arg3[i] );
7406  LUA_FREE_ARRAY( arg3 );
7407  }
7408  }
7409  return SWIG_arg;
7410 
7411  if(0) SWIG_fail;
7412 
7413 fail:
7414  {
7415  LUA_FREE_ARRAY( arg1 );
7416  }
7417  {
7418  LUA_FREE_ARRAY( arg2 );
7419  }
7420  {
7421  int i;
7422 
7423  if ( arg3 )
7424  {
7425  for ( i = 0; i < ii3; i++ )
7426  LUA_FREE_ARRAY( arg3[i] );
7427  LUA_FREE_ARRAY( arg3 );
7428  }
7429  }
7430  lua_error(L);
7431  return SWIG_arg;
7432 }
7433 
7434 
7435 static int _wrap_plot3dc(lua_State* L) {
7436  int SWIG_arg = 0;
7437  PLFLT *arg1 = (PLFLT *) 0 ;
7438  PLFLT *arg2 = (PLFLT *) 0 ;
7439  PLFLT **arg3 = (PLFLT **) 0 ;
7440  PLINT arg4 ;
7441  PLINT arg5 ;
7442  PLINT arg6 ;
7443  PLFLT *arg7 = (PLFLT *) 0 ;
7444  PLINT arg8 ;
7445  int ii3 ;
7446 
7447  SWIG_check_num_args("plot3dc",5,5)
7448  if(!lua_isnumber(L,4)) SWIG_fail_arg("plot3dc",4,"PLINT");
7449  {
7450  int temp;
7451  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7452  if ( !arg1 )
7453  SWIG_fail;
7454  Xlen = temp;
7455  }
7456  {
7457  int temp;
7458  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7459  if ( !arg2 )
7460  SWIG_fail;
7461  Ylen = temp;
7462  }
7463  {
7464  int jj;
7465 
7466  arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7467  if ( !arg3 )
7468  SWIG_fail;
7469  arg4 = ii3;
7470  arg5 = jj;
7471  if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7472  {
7473  lua_pushfstring( L, "Vectors must match matrix." );
7474  SWIG_fail;
7475  }
7476  }
7477  arg6 = (PLINT)lua_tonumber(L, 4);
7478  {
7479  int temp;
7480  arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7481  if ( !arg7 )
7482  SWIG_fail;
7483  arg8 = Alen = temp;
7484  }
7485  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
7486 
7487  {
7488  LUA_FREE_ARRAY( arg1 );
7489  }
7490  {
7491  LUA_FREE_ARRAY( arg2 );
7492  }
7493  {
7494  int i;
7495 
7496  if ( arg3 )
7497  {
7498  for ( i = 0; i < ii3; i++ )
7499  LUA_FREE_ARRAY( arg3[i] );
7500  LUA_FREE_ARRAY( arg3 );
7501  }
7502  }
7503  {
7504  LUA_FREE_ARRAY( arg7 );
7505  }
7506  return SWIG_arg;
7507 
7508  if(0) SWIG_fail;
7509 
7510 fail:
7511  {
7512  LUA_FREE_ARRAY( arg1 );
7513  }
7514  {
7515  LUA_FREE_ARRAY( arg2 );
7516  }
7517  {
7518  int i;
7519 
7520  if ( arg3 )
7521  {
7522  for ( i = 0; i < ii3; i++ )
7523  LUA_FREE_ARRAY( arg3[i] );
7524  LUA_FREE_ARRAY( arg3 );
7525  }
7526  }
7527  {
7528  LUA_FREE_ARRAY( arg7 );
7529  }
7530  lua_error(L);
7531  return SWIG_arg;
7532 }
7533 
7534 
7535 static int _wrap_plot3dcl(lua_State* L) {
7536  int SWIG_arg = 0;
7537  PLFLT *arg1 = (PLFLT *) 0 ;
7538  PLFLT *arg2 = (PLFLT *) 0 ;
7539  PLFLT **arg3 = (PLFLT **) 0 ;
7540  PLINT arg4 ;
7541  PLINT arg5 ;
7542  PLINT arg6 ;
7543  PLFLT *arg7 = (PLFLT *) 0 ;
7544  PLINT arg8 ;
7545  PLINT arg9 ;
7546  PLINT arg10 ;
7547  PLINT *arg11 = (PLINT *) 0 ;
7548  PLINT *arg12 = (PLINT *) 0 ;
7549  int ii3 ;
7550  int temp12 ;
7551 
7552  SWIG_check_num_args("plot3dcl",8,8)
7553  if(!lua_isnumber(L,4)) SWIG_fail_arg("plot3dcl",4,"PLINT");
7554  if(!lua_isnumber(L,6)) SWIG_fail_arg("plot3dcl",6,"PLINT");
7555  {
7556  int temp;
7557  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7558  if ( !arg1 )
7559  SWIG_fail;
7560  Xlen = temp;
7561  }
7562  {
7563  int temp;
7564  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7565  if ( !arg2 )
7566  SWIG_fail;
7567  Ylen = temp;
7568  }
7569  {
7570  int jj;
7571 
7572  arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7573  if ( !arg3 )
7574  SWIG_fail;
7575  arg4 = ii3;
7576  arg5 = jj;
7577  if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7578  {
7579  lua_pushfstring( L, "Vectors must match matrix." );
7580  SWIG_fail;
7581  }
7582  }
7583  arg6 = (PLINT)lua_tonumber(L, 4);
7584  {
7585  int temp;
7586  arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7587  if ( !arg7 )
7588  SWIG_fail;
7589  arg8 = Alen = temp;
7590  }
7591  arg9 = (PLINT)lua_tonumber(L, 6);
7592  {
7593  arg11 = (PLINT *) LUA_get_int_num_array_var( L, 7, &arg10 );
7594  if ( !arg11 )
7595  SWIG_fail;
7596  Alen = arg10;
7597  }
7598  {
7599  arg12 = (PLINT *) LUA_get_int_num_array_var( L, 8, &temp12 );
7600  if ( !arg12 )
7601  SWIG_fail;
7602  if ( temp12 != Alen )
7603  {
7604  lua_pushfstring( L, "Tables must be of same length." );
7605  SWIG_fail;
7606  }
7607  }
7608  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);
7609 
7610  {
7611  LUA_FREE_ARRAY( arg1 );
7612  }
7613  {
7614  LUA_FREE_ARRAY( arg2 );
7615  }
7616  {
7617  int i;
7618 
7619  if ( arg3 )
7620  {
7621  for ( i = 0; i < ii3; i++ )
7622  LUA_FREE_ARRAY( arg3[i] );
7623  LUA_FREE_ARRAY( arg3 );
7624  }
7625  }
7626  {
7627  LUA_FREE_ARRAY( arg7 );
7628  }
7629  {
7630  LUA_FREE_ARRAY( arg11 );
7631  }
7632  {
7633  LUA_FREE_ARRAY( arg12 );
7634  }
7635  return SWIG_arg;
7636 
7637  if(0) SWIG_fail;
7638 
7639 fail:
7640  {
7641  LUA_FREE_ARRAY( arg1 );
7642  }
7643  {
7644  LUA_FREE_ARRAY( arg2 );
7645  }
7646  {
7647  int i;
7648 
7649  if ( arg3 )
7650  {
7651  for ( i = 0; i < ii3; i++ )
7652  LUA_FREE_ARRAY( arg3[i] );
7653  LUA_FREE_ARRAY( arg3 );
7654  }
7655  }
7656  {
7657  LUA_FREE_ARRAY( arg7 );
7658  }
7659  {
7660  LUA_FREE_ARRAY( arg11 );
7661  }
7662  {
7663  LUA_FREE_ARRAY( arg12 );
7664  }
7665  lua_error(L);
7666  return SWIG_arg;
7667 }
7668 
7669 
7670 static int _wrap_surf3d(lua_State* L) {
7671  int SWIG_arg = 0;
7672  PLFLT *arg1 = (PLFLT *) 0 ;
7673  PLFLT *arg2 = (PLFLT *) 0 ;
7674  PLFLT **arg3 = (PLFLT **) 0 ;
7675  PLINT arg4 ;
7676  PLINT arg5 ;
7677  PLINT arg6 ;
7678  PLFLT *arg7 = (PLFLT *) 0 ;
7679  PLINT arg8 ;
7680  int ii3 ;
7681 
7682  SWIG_check_num_args("plsurf3d",5,5)
7683  if(!lua_isnumber(L,4)) SWIG_fail_arg("plsurf3d",4,"PLINT");
7684  {
7685  int temp;
7686  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7687  if ( !arg1 )
7688  SWIG_fail;
7689  Xlen = temp;
7690  }
7691  {
7692  int temp;
7693  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7694  if ( !arg2 )
7695  SWIG_fail;
7696  Ylen = temp;
7697  }
7698  {
7699  int jj;
7700 
7701  arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7702  if ( !arg3 )
7703  SWIG_fail;
7704  arg4 = ii3;
7705  arg5 = jj;
7706  if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7707  {
7708  lua_pushfstring( L, "Vectors must match matrix." );
7709  SWIG_fail;
7710  }
7711  }
7712  arg6 = (PLINT)lua_tonumber(L, 4);
7713  {
7714  int temp;
7715  arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7716  if ( !arg7 )
7717  SWIG_fail;
7718  arg8 = Alen = temp;
7719  }
7720  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
7721 
7722  {
7723  LUA_FREE_ARRAY( arg1 );
7724  }
7725  {
7726  LUA_FREE_ARRAY( arg2 );
7727  }
7728  {
7729  int i;
7730 
7731  if ( arg3 )
7732  {
7733  for ( i = 0; i < ii3; i++ )
7734  LUA_FREE_ARRAY( arg3[i] );
7735  LUA_FREE_ARRAY( arg3 );
7736  }
7737  }
7738  {
7739  LUA_FREE_ARRAY( arg7 );
7740  }
7741  return SWIG_arg;
7742 
7743  if(0) SWIG_fail;
7744 
7745 fail:
7746  {
7747  LUA_FREE_ARRAY( arg1 );
7748  }
7749  {
7750  LUA_FREE_ARRAY( arg2 );
7751  }
7752  {
7753  int i;
7754 
7755  if ( arg3 )
7756  {
7757  for ( i = 0; i < ii3; i++ )
7758  LUA_FREE_ARRAY( arg3[i] );
7759  LUA_FREE_ARRAY( arg3 );
7760  }
7761  }
7762  {
7763  LUA_FREE_ARRAY( arg7 );
7764  }
7765  lua_error(L);
7766  return SWIG_arg;
7767 }
7768 
7769 
7770 static int _wrap_surf3dl(lua_State* L) {
7771  int SWIG_arg = 0;
7772  PLFLT *arg1 = (PLFLT *) 0 ;
7773  PLFLT *arg2 = (PLFLT *) 0 ;
7774  PLFLT **arg3 = (PLFLT **) 0 ;
7775  PLINT arg4 ;
7776  PLINT arg5 ;
7777  PLINT arg6 ;
7778  PLFLT *arg7 = (PLFLT *) 0 ;
7779  PLINT arg8 ;
7780  PLINT arg9 ;
7781  PLINT arg10 ;
7782  PLINT *arg11 = (PLINT *) 0 ;
7783  PLINT *arg12 = (PLINT *) 0 ;
7784  int ii3 ;
7785  int temp12 ;
7786 
7787  SWIG_check_num_args("plsurf3dl",8,8)
7788  if(!lua_isnumber(L,4)) SWIG_fail_arg("plsurf3dl",4,"PLINT");
7789  if(!lua_isnumber(L,6)) SWIG_fail_arg("plsurf3dl",6,"PLINT");
7790  {
7791  int temp;
7792  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
7793  if ( !arg1 )
7794  SWIG_fail;
7795  Xlen = temp;
7796  }
7797  {
7798  int temp;
7799  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
7800  if ( !arg2 )
7801  SWIG_fail;
7802  Ylen = temp;
7803  }
7804  {
7805  int jj;
7806 
7807  arg3 = read_double_Matrix( L, 3, &ii3, &jj );
7808  if ( !arg3 )
7809  SWIG_fail;
7810  arg4 = ii3;
7811  arg5 = jj;
7812  if ( ( arg4 != Xlen ) || ( arg5 != Ylen ) )
7813  {
7814  lua_pushfstring( L, "Vectors must match matrix." );
7815  SWIG_fail;
7816  }
7817  }
7818  arg6 = (PLINT)lua_tonumber(L, 4);
7819  {
7820  int temp;
7821  arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp );
7822  if ( !arg7 )
7823  SWIG_fail;
7824  arg8 = Alen = temp;
7825  }
7826  arg9 = (PLINT)lua_tonumber(L, 6);
7827  {
7828  arg11 = (PLINT *) LUA_get_int_num_array_var( L, 7, &arg10 );
7829  if ( !arg11 )
7830  SWIG_fail;
7831  Alen = arg10;
7832  }
7833  {
7834  arg12 = (PLINT *) LUA_get_int_num_array_var( L, 8, &temp12 );
7835  if ( !arg12 )
7836  SWIG_fail;
7837  if ( temp12 != Alen )
7838  {
7839  lua_pushfstring( L, "Tables must be of same length." );
7840  SWIG_fail;
7841  }
7842  }
7843  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);
7844 
7845  {
7846  LUA_FREE_ARRAY( arg1 );
7847  }
7848  {
7849  LUA_FREE_ARRAY( arg2 );
7850  }
7851  {
7852  int i;
7853 
7854  if ( arg3 )
7855  {
7856  for ( i = 0; i < ii3; i++ )
7857  LUA_FREE_ARRAY( arg3[i] );
7858  LUA_FREE_ARRAY( arg3 );
7859  }
7860  }
7861  {
7862  LUA_FREE_ARRAY( arg7 );
7863  }
7864  {
7865  LUA_FREE_ARRAY( arg11 );
7866  }
7867  {
7868  LUA_FREE_ARRAY( arg12 );
7869  }
7870  return SWIG_arg;
7871 
7872  if(0) SWIG_fail;
7873 
7874 fail:
7875  {
7876  LUA_FREE_ARRAY( arg1 );
7877  }
7878  {
7879  LUA_FREE_ARRAY( arg2 );
7880  }
7881  {
7882  int i;
7883 
7884  if ( arg3 )
7885  {
7886  for ( i = 0; i < ii3; i++ )
7887  LUA_FREE_ARRAY( arg3[i] );
7888  LUA_FREE_ARRAY( arg3 );
7889  }
7890  }
7891  {
7892  LUA_FREE_ARRAY( arg7 );
7893  }
7894  {
7895  LUA_FREE_ARRAY( arg11 );
7896  }
7897  {
7898  LUA_FREE_ARRAY( arg12 );
7899  }
7900  lua_error(L);
7901  return SWIG_arg;
7902 }
7903 
7904 
7905 static int _wrap_parseopts(lua_State* L) {
7906  int SWIG_arg = 0;
7907  int *arg1 = (int *) 0 ;
7908  char **arg2 = (char **) 0 ;
7909  PLINT arg3 ;
7910  PLINT result;
7911 
7912  SWIG_check_num_args("plparseopts",2,2)
7913  if(!lua_istable(L,1)) SWIG_fail_arg("plparseopts",1,"int *");
7914  if(!lua_isnumber(L,2)) SWIG_fail_arg("plparseopts",2,"PLINT");
7915  {
7916  int i, n;
7917 
7918  // from lua 5.1 on there is no element "n" anymore,
7919  // so we need to find out the number of command line
7920  // options manually
7921  for ( i = 1;; i++ )
7922  {
7923  lua_rawgeti( L, 1, i );
7924  if ( lua_isnil( L, -1 ) )
7925  {
7926  // ok, this index doesn't exist anymore, we have i-1
7927  // command line options
7928  lua_pop( L, 1 );
7929  break;
7930  }
7931  }
7932  n = i;
7933  arg1 = &n;
7934 
7935  arg2 = LUA_ALLOC_ARRAY( char*, ( n + 1 ) );
7936 
7937  for ( i = 0; i < n; i++ )
7938  {
7939  lua_rawgeti( L, 1, i );
7940  if ( lua_isstring( L, -1 ) )
7941  {
7942  arg2[i] = (char *) lua_tostring( L, -1 );
7943  }
7944  else
7945  {
7946  lua_pop( L, 1 );
7947  lua_pushfstring( L, "List items must be strings" );
7948  SWIG_fail;
7949  // arg2 array is freed after 'fail:'
7950  }
7951  lua_pop( L, 1 );
7952  }
7953  arg2[n] = NULL;
7954  }
7955  arg3 = (PLINT)lua_tonumber(L, 2);
7956  result = (PLINT)plparseopts(arg1,arg2,arg3);
7957  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
7958  {
7959  LUA_FREE_ARRAY( arg2 );
7960  }
7961  return SWIG_arg;
7962 
7963  if(0) SWIG_fail;
7964 
7965 fail:
7966  {
7967  LUA_FREE_ARRAY( arg2 );
7968  }
7969  lua_error(L);
7970  return SWIG_arg;
7971 }
7972 
7973 
7974 static int _wrap_pat(lua_State* L) {
7975  int SWIG_arg = 0;
7976  PLINT arg1 ;
7977  PLINT *arg2 = (PLINT *) 0 ;
7978  PLINT *arg3 = (PLINT *) 0 ;
7979  int temp3 ;
7980 
7981  SWIG_check_num_args("plpat",2,2)
7982  {
7983  arg2 = (PLINT *) LUA_get_int_num_array_var( L, 1, &arg1 );
7984  if ( !arg2 )
7985  SWIG_fail;
7986  Alen = arg1;
7987  }
7988  {
7989  arg3 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp3 );
7990  if ( !arg3 )
7991  SWIG_fail;
7992  if ( temp3 != Alen )
7993  {
7994  lua_pushfstring( L, "Tables must be of same length." );
7995  SWIG_fail;
7996  }
7997  }
7998  plpat(arg1,(int const *)arg2,(int const *)arg3);
7999 
8000  {
8001  LUA_FREE_ARRAY( arg2 );
8002  }
8003  {
8004  LUA_FREE_ARRAY( arg3 );
8005  }
8006  return SWIG_arg;
8007 
8008  if(0) SWIG_fail;
8009 
8010 fail:
8011  {
8012  LUA_FREE_ARRAY( arg2 );
8013  }
8014  {
8015  LUA_FREE_ARRAY( arg3 );
8016  }
8017  lua_error(L);
8018  return SWIG_arg;
8019 }
8020 
8021 
8022 static int _wrap_path(lua_State* L) {
8023  int SWIG_arg = 0;
8024  PLINT arg1 ;
8025  PLFLT arg2 ;
8026  PLFLT arg3 ;
8027  PLFLT arg4 ;
8028  PLFLT arg5 ;
8029 
8030  SWIG_check_num_args("plpath",5,5)
8031  if(!lua_isnumber(L,1)) SWIG_fail_arg("plpath",1,"PLINT");
8032  if(!lua_isnumber(L,2)) SWIG_fail_arg("plpath",2,"PLFLT");
8033  if(!lua_isnumber(L,3)) SWIG_fail_arg("plpath",3,"PLFLT");
8034  if(!lua_isnumber(L,4)) SWIG_fail_arg("plpath",4,"PLFLT");
8035  if(!lua_isnumber(L,5)) SWIG_fail_arg("plpath",5,"PLFLT");
8036  arg1 = (PLINT)lua_tonumber(L, 1);
8037  arg2 = (PLFLT)lua_tonumber(L, 2);
8038  arg3 = (PLFLT)lua_tonumber(L, 3);
8039  arg4 = (PLFLT)lua_tonumber(L, 4);
8040  arg5 = (PLFLT)lua_tonumber(L, 5);
8041  plpath(arg1,arg2,arg3,arg4,arg5);
8042 
8043  return SWIG_arg;
8044 
8045  if(0) SWIG_fail;
8046 
8047 fail:
8048  lua_error(L);
8049  return SWIG_arg;
8050 }
8051 
8052 
8053 static int _wrap_poin(lua_State* L) {
8054  int SWIG_arg = 0;
8055  PLINT arg1 ;
8056  PLFLT *arg2 = (PLFLT *) 0 ;
8057  PLFLT *arg3 = (PLFLT *) 0 ;
8058  PLINT arg4 ;
8059  int temp3 ;
8060 
8061  SWIG_check_num_args("plpoin",3,3)
8062  if(!lua_isnumber(L,3)) SWIG_fail_arg("plpoin",3,"PLINT");
8063  {
8064  int temp;
8065  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
8066  if ( !arg2 )
8067  SWIG_fail;
8068  arg1 = Alen = temp;
8069  }
8070  {
8071  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
8072  if ( !arg3 )
8073  SWIG_fail;
8074  if ( temp3 != Alen )
8075  {
8076  lua_pushfstring( L, "Tables must be of same length." );
8077  SWIG_fail;
8078  }
8079  }
8080  arg4 = (PLINT)lua_tonumber(L, 3);
8081  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
8082 
8083  {
8084  LUA_FREE_ARRAY( arg2 );
8085  }
8086  {
8087  LUA_FREE_ARRAY( arg3 );
8088  }
8089  return SWIG_arg;
8090 
8091  if(0) SWIG_fail;
8092 
8093 fail:
8094  {
8095  LUA_FREE_ARRAY( arg2 );
8096  }
8097  {
8098  LUA_FREE_ARRAY( arg3 );
8099  }
8100  lua_error(L);
8101  return SWIG_arg;
8102 }
8103 
8104 
8105 static int _wrap_poin3(lua_State* L) {
8106  int SWIG_arg = 0;
8107  PLINT arg1 ;
8108  PLFLT *arg2 = (PLFLT *) 0 ;
8109  PLFLT *arg3 = (PLFLT *) 0 ;
8110  PLFLT *arg4 = (PLFLT *) 0 ;
8111  PLINT arg5 ;
8112  int temp3 ;
8113  int temp4 ;
8114 
8115  SWIG_check_num_args("plpoin3",4,4)
8116  if(!lua_isnumber(L,4)) SWIG_fail_arg("plpoin3",4,"PLINT");
8117  {
8118  int temp;
8119  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
8120  if ( !arg2 )
8121  SWIG_fail;
8122  arg1 = Alen = temp;
8123  }
8124  {
8125  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
8126  if ( !arg3 )
8127  SWIG_fail;
8128  if ( temp3 != Alen )
8129  {
8130  lua_pushfstring( L, "Tables must be of same length." );
8131  SWIG_fail;
8132  }
8133  }
8134  {
8135  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
8136  if ( !arg4 )
8137  SWIG_fail;
8138  if ( temp4 != Alen )
8139  {
8140  lua_pushfstring( L, "Tables must be of same length." );
8141  SWIG_fail;
8142  }
8143  }
8144  arg5 = (PLINT)lua_tonumber(L, 4);
8145  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
8146 
8147  {
8148  LUA_FREE_ARRAY( arg2 );
8149  }
8150  {
8151  LUA_FREE_ARRAY( arg3 );
8152  }
8153  {
8154  LUA_FREE_ARRAY( arg4 );
8155  }
8156  return SWIG_arg;
8157 
8158  if(0) SWIG_fail;
8159 
8160 fail:
8161  {
8162  LUA_FREE_ARRAY( arg2 );
8163  }
8164  {
8165  LUA_FREE_ARRAY( arg3 );
8166  }
8167  {
8168  LUA_FREE_ARRAY( arg4 );
8169  }
8170  lua_error(L);
8171  return SWIG_arg;
8172 }
8173 
8174 
8175 static int _wrap_poly3(lua_State* L) {
8176  int SWIG_arg = 0;
8177  PLINT arg1 ;
8178  PLFLT *arg2 = (PLFLT *) 0 ;
8179  PLFLT *arg3 = (PLFLT *) 0 ;
8180  PLFLT *arg4 = (PLFLT *) 0 ;
8181  PLBOOL *arg5 = (PLBOOL *) 0 ;
8182  PLBOOL arg6 ;
8183  int temp3 ;
8184  int temp4 ;
8185  int temp5 ;
8186 
8187  SWIG_check_num_args("plpoly3",5,5)
8188  if(!lua_isnumber(L,5)) SWIG_fail_arg("plpoly3",5,"PLBOOL");
8189  {
8190  int temp;
8191  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
8192  if ( !arg2 )
8193  SWIG_fail;
8194  arg1 = Alen = temp;
8195  }
8196  {
8197  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
8198  if ( !arg3 )
8199  SWIG_fail;
8200  if ( temp3 != Alen )
8201  {
8202  lua_pushfstring( L, "Tables must be of same length." );
8203  SWIG_fail;
8204  }
8205  }
8206  {
8207  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
8208  if ( !arg4 )
8209  SWIG_fail;
8210  if ( temp4 != Alen )
8211  {
8212  lua_pushfstring( L, "Tables must be of same length." );
8213  SWIG_fail;
8214  }
8215  }
8216  {
8217  arg5 = (PLINT *) LUA_get_int_num_array_var( L, 4, &temp5 );
8218  if ( !arg5 )
8219  SWIG_fail;
8220  if ( temp5 < Alen - 1 )
8221  {
8222  lua_pushfstring( L, "Tables must be at least length of others minus 1." );
8223  SWIG_fail;
8224  }
8225  }
8226  arg6 = (PLBOOL)lua_tonumber(L, 5);
8227  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
8228 
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  return SWIG_arg;
8242 
8243  if(0) SWIG_fail;
8244 
8245 fail:
8246  {
8247  LUA_FREE_ARRAY( arg2 );
8248  }
8249  {
8250  LUA_FREE_ARRAY( arg3 );
8251  }
8252  {
8253  LUA_FREE_ARRAY( arg4 );
8254  }
8255  {
8256  LUA_FREE_ARRAY( arg5 );
8257  }
8258  lua_error(L);
8259  return SWIG_arg;
8260 }
8261 
8262 
8263 static int _wrap_prec(lua_State* L) {
8264  int SWIG_arg = 0;
8265  PLINT arg1 ;
8266  PLINT arg2 ;
8267 
8268  SWIG_check_num_args("plprec",2,2)
8269  if(!lua_isnumber(L,1)) SWIG_fail_arg("plprec",1,"PLINT");
8270  if(!lua_isnumber(L,2)) SWIG_fail_arg("plprec",2,"PLINT");
8271  arg1 = (PLINT)lua_tonumber(L, 1);
8272  arg2 = (PLINT)lua_tonumber(L, 2);
8273  plprec(arg1,arg2);
8274 
8275  return SWIG_arg;
8276 
8277  if(0) SWIG_fail;
8278 
8279 fail:
8280  lua_error(L);
8281  return SWIG_arg;
8282 }
8283 
8284 
8285 static int _wrap_psty(lua_State* L) {
8286  int SWIG_arg = 0;
8287  PLINT arg1 ;
8288 
8289  SWIG_check_num_args("plpsty",1,1)
8290  if(!lua_isnumber(L,1)) SWIG_fail_arg("plpsty",1,"PLINT");
8291  arg1 = (PLINT)lua_tonumber(L, 1);
8292  plpsty(arg1);
8293 
8294  return SWIG_arg;
8295 
8296  if(0) SWIG_fail;
8297 
8298 fail:
8299  lua_error(L);
8300  return SWIG_arg;
8301 }
8302 
8303 
8304 static int _wrap_ptex(lua_State* L) {
8305  int SWIG_arg = 0;
8306  PLFLT arg1 ;
8307  PLFLT arg2 ;
8308  PLFLT arg3 ;
8309  PLFLT arg4 ;
8310  PLFLT arg5 ;
8311  char *arg6 = (char *) 0 ;
8312 
8313  SWIG_check_num_args("plptex",6,6)
8314  if(!lua_isnumber(L,1)) SWIG_fail_arg("plptex",1,"PLFLT");
8315  if(!lua_isnumber(L,2)) SWIG_fail_arg("plptex",2,"PLFLT");
8316  if(!lua_isnumber(L,3)) SWIG_fail_arg("plptex",3,"PLFLT");
8317  if(!lua_isnumber(L,4)) SWIG_fail_arg("plptex",4,"PLFLT");
8318  if(!lua_isnumber(L,5)) SWIG_fail_arg("plptex",5,"PLFLT");
8319  if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("plptex",6,"char const *");
8320  arg1 = (PLFLT)lua_tonumber(L, 1);
8321  arg2 = (PLFLT)lua_tonumber(L, 2);
8322  arg3 = (PLFLT)lua_tonumber(L, 3);
8323  arg4 = (PLFLT)lua_tonumber(L, 4);
8324  arg5 = (PLFLT)lua_tonumber(L, 5);
8325  arg6 = (char *)lua_tostring(L, 6);
8326  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
8327 
8328  return SWIG_arg;
8329 
8330  if(0) SWIG_fail;
8331 
8332 fail:
8333  lua_error(L);
8334  return SWIG_arg;
8335 }
8336 
8337 
8338 static int _wrap_ptex3(lua_State* L) {
8339  int SWIG_arg = 0;
8340  PLFLT arg1 ;
8341  PLFLT arg2 ;
8342  PLFLT arg3 ;
8343  PLFLT arg4 ;
8344  PLFLT arg5 ;
8345  PLFLT arg6 ;
8346  PLFLT arg7 ;
8347  PLFLT arg8 ;
8348  PLFLT arg9 ;
8349  PLFLT arg10 ;
8350  char *arg11 = (char *) 0 ;
8351 
8352  SWIG_check_num_args("plptex3",11,11)
8353  if(!lua_isnumber(L,1)) SWIG_fail_arg("plptex3",1,"PLFLT");
8354  if(!lua_isnumber(L,2)) SWIG_fail_arg("plptex3",2,"PLFLT");
8355  if(!lua_isnumber(L,3)) SWIG_fail_arg("plptex3",3,"PLFLT");
8356  if(!lua_isnumber(L,4)) SWIG_fail_arg("plptex3",4,"PLFLT");
8357  if(!lua_isnumber(L,5)) SWIG_fail_arg("plptex3",5,"PLFLT");
8358  if(!lua_isnumber(L,6)) SWIG_fail_arg("plptex3",6,"PLFLT");
8359  if(!lua_isnumber(L,7)) SWIG_fail_arg("plptex3",7,"PLFLT");
8360  if(!lua_isnumber(L,8)) SWIG_fail_arg("plptex3",8,"PLFLT");
8361  if(!lua_isnumber(L,9)) SWIG_fail_arg("plptex3",9,"PLFLT");
8362  if(!lua_isnumber(L,10)) SWIG_fail_arg("plptex3",10,"PLFLT");
8363  if(!SWIG_lua_isnilstring(L,11)) SWIG_fail_arg("plptex3",11,"char const *");
8364  arg1 = (PLFLT)lua_tonumber(L, 1);
8365  arg2 = (PLFLT)lua_tonumber(L, 2);
8366  arg3 = (PLFLT)lua_tonumber(L, 3);
8367  arg4 = (PLFLT)lua_tonumber(L, 4);
8368  arg5 = (PLFLT)lua_tonumber(L, 5);
8369  arg6 = (PLFLT)lua_tonumber(L, 6);
8370  arg7 = (PLFLT)lua_tonumber(L, 7);
8371  arg8 = (PLFLT)lua_tonumber(L, 8);
8372  arg9 = (PLFLT)lua_tonumber(L, 9);
8373  arg10 = (PLFLT)lua_tonumber(L, 10);
8374  arg11 = (char *)lua_tostring(L, 11);
8375  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
8376 
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_randd(lua_State* L) {
8388  int SWIG_arg = 0;
8389  PLFLT result;
8390 
8391  SWIG_check_num_args("plrandd",0,0)
8392  result = (PLFLT)plrandd();
8393  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8394  return SWIG_arg;
8395 
8396  if(0) SWIG_fail;
8397 
8398 fail:
8399  lua_error(L);
8400  return SWIG_arg;
8401 }
8402 
8403 
8404 static int _wrap_replot(lua_State* L) {
8405  int SWIG_arg = 0;
8406 
8407  SWIG_check_num_args("plreplot",0,0)
8408  plreplot();
8409 
8410  return SWIG_arg;
8411 
8412  if(0) SWIG_fail;
8413 
8414 fail:
8415  lua_error(L);
8416  return SWIG_arg;
8417 }
8418 
8419 
8420 static int _wrap_rgbhls(lua_State* L) {
8421  int SWIG_arg = 0;
8422  PLFLT arg1 ;
8423  PLFLT arg2 ;
8424  PLFLT arg3 ;
8425  PLFLT *arg4 = (PLFLT *) 0 ;
8426  PLFLT *arg5 = (PLFLT *) 0 ;
8427  PLFLT *arg6 = (PLFLT *) 0 ;
8428  PLFLT temp4 ;
8429  PLFLT temp5 ;
8430  PLFLT temp6 ;
8431 
8432  arg4 = &temp4;
8433  arg5 = &temp5;
8434  arg6 = &temp6;
8435  SWIG_check_num_args("plrgbhls",3,3)
8436  if(!lua_isnumber(L,1)) SWIG_fail_arg("plrgbhls",1,"PLFLT");
8437  if(!lua_isnumber(L,2)) SWIG_fail_arg("plrgbhls",2,"PLFLT");
8438  if(!lua_isnumber(L,3)) SWIG_fail_arg("plrgbhls",3,"PLFLT");
8439  arg1 = (PLFLT)lua_tonumber(L, 1);
8440  arg2 = (PLFLT)lua_tonumber(L, 2);
8441  arg3 = (PLFLT)lua_tonumber(L, 3);
8442  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
8443 
8444  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
8445  lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
8446  lua_pushnumber(L, (lua_Number) *arg6); SWIG_arg++;
8447  return SWIG_arg;
8448 
8449  if(0) SWIG_fail;
8450 
8451 fail:
8452  lua_error(L);
8453  return SWIG_arg;
8454 }
8455 
8456 
8457 static int _wrap_schr(lua_State* L) {
8458  int SWIG_arg = 0;
8459  PLFLT arg1 ;
8460  PLFLT arg2 ;
8461 
8462  SWIG_check_num_args("plschr",2,2)
8463  if(!lua_isnumber(L,1)) SWIG_fail_arg("plschr",1,"PLFLT");
8464  if(!lua_isnumber(L,2)) SWIG_fail_arg("plschr",2,"PLFLT");
8465  arg1 = (PLFLT)lua_tonumber(L, 1);
8466  arg2 = (PLFLT)lua_tonumber(L, 2);
8467  plschr(arg1,arg2);
8468 
8469  return SWIG_arg;
8470 
8471  if(0) SWIG_fail;
8472 
8473 fail:
8474  lua_error(L);
8475  return SWIG_arg;
8476 }
8477 
8478 
8479 static int _wrap_scmap0(lua_State* L) {
8480  int SWIG_arg = 0;
8481  PLINT *arg1 = (PLINT *) 0 ;
8482  PLINT *arg2 = (PLINT *) 0 ;
8483  PLINT *arg3 = (PLINT *) 0 ;
8484  PLINT arg4 ;
8485  int temp1 ;
8486  int temp2 ;
8487  int temp3 ;
8488 
8489  SWIG_check_num_args("plscmap0",3,3)
8490  {
8491  arg1 = (PLINT *) LUA_get_int_num_array_var( L, 1, &temp1 );
8492  if ( !arg1 )
8493  SWIG_fail;
8494  Alen = temp1;
8495  }
8496  {
8497  arg2 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp2 );
8498  if ( !arg2 )
8499  SWIG_fail;
8500  if ( temp2 != Alen )
8501  {
8502  lua_pushfstring( L, "Tables must be of same length." );
8503  SWIG_fail;
8504  }
8505  }
8506  {
8507  arg3 = (PLINT *) LUA_get_int_num_array_var( L, 3, &temp3 );
8508  if ( !arg3 )
8509  SWIG_fail;
8510  if ( temp3 != Alen )
8511  {
8512  lua_pushfstring( L, "Tables must be of same length." );
8513  SWIG_fail;
8514  }
8515  arg4 = temp3;
8516  }
8517  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
8518 
8519  {
8520  LUA_FREE_ARRAY( arg1 );
8521  }
8522  {
8523  LUA_FREE_ARRAY( arg2 );
8524  }
8525  {
8526  LUA_FREE_ARRAY( arg3 );
8527  }
8528  return SWIG_arg;
8529 
8530  if(0) SWIG_fail;
8531 
8532 fail:
8533  {
8534  LUA_FREE_ARRAY( arg1 );
8535  }
8536  {
8537  LUA_FREE_ARRAY( arg2 );
8538  }
8539  {
8540  LUA_FREE_ARRAY( arg3 );
8541  }
8542  lua_error(L);
8543  return SWIG_arg;
8544 }
8545 
8546 
8547 static int _wrap_scmap0a(lua_State* L) {
8548  int SWIG_arg = 0;
8549  PLINT *arg1 = (PLINT *) 0 ;
8550  PLINT *arg2 = (PLINT *) 0 ;
8551  PLINT *arg3 = (PLINT *) 0 ;
8552  PLFLT *arg4 = (PLFLT *) 0 ;
8553  PLINT arg5 ;
8554  int temp1 ;
8555  int temp2 ;
8556  int temp3 ;
8557 
8558  SWIG_check_num_args("plscmap0a",4,4)
8559  {
8560  arg1 = (PLINT *) LUA_get_int_num_array_var( L, 1, &temp1 );
8561  if ( !arg1 )
8562  SWIG_fail;
8563  Alen = temp1;
8564  }
8565  {
8566  arg2 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp2 );
8567  if ( !arg2 )
8568  SWIG_fail;
8569  if ( temp2 != Alen )
8570  {
8571  lua_pushfstring( L, "Tables must be of same length." );
8572  SWIG_fail;
8573  }
8574  }
8575  {
8576  arg3 = (PLINT *) LUA_get_int_num_array_var( L, 3, &temp3 );
8577  if ( !arg3 )
8578  SWIG_fail;
8579  if ( temp3 != Alen )
8580  {
8581  lua_pushfstring( L, "Tables must be of same length." );
8582  SWIG_fail;
8583  }
8584  }
8585  {
8586  int temp;
8587  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp );
8588  if ( !arg4 )
8589  SWIG_fail;
8590  if ( temp != Alen )
8591  {
8592  lua_pushfstring( L, "Tables must be of same length." );
8593  SWIG_fail;
8594  }
8595  arg5 = temp;
8596  }
8597  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
8598 
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  return SWIG_arg;
8612 
8613  if(0) SWIG_fail;
8614 
8615 fail:
8616  {
8617  LUA_FREE_ARRAY( arg1 );
8618  }
8619  {
8620  LUA_FREE_ARRAY( arg2 );
8621  }
8622  {
8623  LUA_FREE_ARRAY( arg3 );
8624  }
8625  {
8626  LUA_FREE_ARRAY( arg4 );
8627  }
8628  lua_error(L);
8629  return SWIG_arg;
8630 }
8631 
8632 
8633 static int _wrap_scmap0n(lua_State* L) {
8634  int SWIG_arg = 0;
8635  PLINT arg1 ;
8636 
8637  SWIG_check_num_args("plscmap0n",1,1)
8638  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap0n",1,"PLINT");
8639  arg1 = (PLINT)lua_tonumber(L, 1);
8640  plscmap0n(arg1);
8641 
8642  return SWIG_arg;
8643 
8644  if(0) SWIG_fail;
8645 
8646 fail:
8647  lua_error(L);
8648  return SWIG_arg;
8649 }
8650 
8651 
8652 static int _wrap_scmap1(lua_State* L) {
8653  int SWIG_arg = 0;
8654  PLINT *arg1 = (PLINT *) 0 ;
8655  PLINT *arg2 = (PLINT *) 0 ;
8656  PLINT *arg3 = (PLINT *) 0 ;
8657  PLINT arg4 ;
8658  int temp1 ;
8659  int temp2 ;
8660  int temp3 ;
8661 
8662  SWIG_check_num_args("plscmap1",3,3)
8663  {
8664  arg1 = (PLINT *) LUA_get_int_num_array_var( L, 1, &temp1 );
8665  if ( !arg1 )
8666  SWIG_fail;
8667  Alen = temp1;
8668  }
8669  {
8670  arg2 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp2 );
8671  if ( !arg2 )
8672  SWIG_fail;
8673  if ( temp2 != Alen )
8674  {
8675  lua_pushfstring( L, "Tables must be of same length." );
8676  SWIG_fail;
8677  }
8678  }
8679  {
8680  arg3 = (PLINT *) LUA_get_int_num_array_var( L, 3, &temp3 );
8681  if ( !arg3 )
8682  SWIG_fail;
8683  if ( temp3 != Alen )
8684  {
8685  lua_pushfstring( L, "Tables must be of same length." );
8686  SWIG_fail;
8687  }
8688  arg4 = temp3;
8689  }
8690  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
8691 
8692  {
8693  LUA_FREE_ARRAY( arg1 );
8694  }
8695  {
8696  LUA_FREE_ARRAY( arg2 );
8697  }
8698  {
8699  LUA_FREE_ARRAY( arg3 );
8700  }
8701  return SWIG_arg;
8702 
8703  if(0) SWIG_fail;
8704 
8705 fail:
8706  {
8707  LUA_FREE_ARRAY( arg1 );
8708  }
8709  {
8710  LUA_FREE_ARRAY( arg2 );
8711  }
8712  {
8713  LUA_FREE_ARRAY( arg3 );
8714  }
8715  lua_error(L);
8716  return SWIG_arg;
8717 }
8718 
8719 
8720 static int _wrap_scmap1a(lua_State* L) {
8721  int SWIG_arg = 0;
8722  PLINT *arg1 = (PLINT *) 0 ;
8723  PLINT *arg2 = (PLINT *) 0 ;
8724  PLINT *arg3 = (PLINT *) 0 ;
8725  PLFLT *arg4 = (PLFLT *) 0 ;
8726  PLINT arg5 ;
8727  int temp1 ;
8728  int temp2 ;
8729  int temp3 ;
8730 
8731  SWIG_check_num_args("plscmap1a",4,4)
8732  {
8733  arg1 = (PLINT *) LUA_get_int_num_array_var( L, 1, &temp1 );
8734  if ( !arg1 )
8735  SWIG_fail;
8736  Alen = temp1;
8737  }
8738  {
8739  arg2 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp2 );
8740  if ( !arg2 )
8741  SWIG_fail;
8742  if ( temp2 != Alen )
8743  {
8744  lua_pushfstring( L, "Tables must be of same length." );
8745  SWIG_fail;
8746  }
8747  }
8748  {
8749  arg3 = (PLINT *) LUA_get_int_num_array_var( L, 3, &temp3 );
8750  if ( !arg3 )
8751  SWIG_fail;
8752  if ( temp3 != Alen )
8753  {
8754  lua_pushfstring( L, "Tables must be of same length." );
8755  SWIG_fail;
8756  }
8757  }
8758  {
8759  int temp;
8760  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp );
8761  if ( !arg4 )
8762  SWIG_fail;
8763  if ( temp != Alen )
8764  {
8765  lua_pushfstring( L, "Tables must be of same length." );
8766  SWIG_fail;
8767  }
8768  arg5 = temp;
8769  }
8770  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
8771 
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  return SWIG_arg;
8785 
8786  if(0) SWIG_fail;
8787 
8788 fail:
8789  {
8790  LUA_FREE_ARRAY( arg1 );
8791  }
8792  {
8793  LUA_FREE_ARRAY( arg2 );
8794  }
8795  {
8796  LUA_FREE_ARRAY( arg3 );
8797  }
8798  {
8799  LUA_FREE_ARRAY( arg4 );
8800  }
8801  lua_error(L);
8802  return SWIG_arg;
8803 }
8804 
8805 
8806 static int _wrap_scmap1l(lua_State* L) {
8807  int SWIG_arg = 0;
8808  PLBOOL arg1 ;
8809  PLINT arg2 ;
8810  PLFLT *arg3 = (PLFLT *) 0 ;
8811  PLFLT *arg4 = (PLFLT *) 0 ;
8812  PLFLT *arg5 = (PLFLT *) 0 ;
8813  PLFLT *arg6 = (PLFLT *) 0 ;
8814  PLBOOL *arg7 = (PLBOOL *) 0 ;
8815  int temp4 ;
8816  int temp5 ;
8817  int temp6 ;
8818  int temp7 ;
8819 
8820  {
8821  arg7 = NULL;
8822  }
8823  SWIG_check_num_args("plscmap1l",5,6)
8824  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap1l",1,"PLBOOL");
8825  arg1 = (PLBOOL)lua_tonumber(L, 1);
8826  {
8827  int temp;
8828  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
8829  if ( !arg3 )
8830  SWIG_fail;
8831  arg2 = Alen = temp;
8832  }
8833  {
8834  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
8835  if ( !arg4 )
8836  SWIG_fail;
8837  if ( temp4 != Alen )
8838  {
8839  lua_pushfstring( L, "Tables must be of same length." );
8840  SWIG_fail;
8841  }
8842  }
8843  {
8844  arg5 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp5 );
8845  if ( !arg5 )
8846  SWIG_fail;
8847  if ( temp5 != Alen )
8848  {
8849  lua_pushfstring( L, "Tables must be of same length." );
8850  SWIG_fail;
8851  }
8852  }
8853  {
8854  arg6 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp6 );
8855  if ( !arg6 )
8856  SWIG_fail;
8857  if ( temp6 != Alen )
8858  {
8859  lua_pushfstring( L, "Tables must be of same length." );
8860  SWIG_fail;
8861  }
8862  }
8863  if(lua_gettop(L)>=6){
8864  {
8865  if ( lua_isnil( L, 6 ) )
8866  {
8867  arg7 = NULL;
8868  }
8869  else
8870  {
8871  arg7 = (PLINT *) LUA_get_int_num_array_var( L, 6, &temp7 );
8872  if ( !arg7 )
8873  SWIG_fail;
8874  if ( temp7 < Alen - 1 )
8875  {
8876  lua_pushfstring( L, "Tables must be at least length of others minus 1." );
8877  SWIG_fail;
8878  }
8879  }
8880  }
8881  }
8882  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
8883 
8884  {
8885  LUA_FREE_ARRAY( arg3 );
8886  }
8887  {
8888  LUA_FREE_ARRAY( arg4 );
8889  }
8890  {
8891  LUA_FREE_ARRAY( arg5 );
8892  }
8893  {
8894  LUA_FREE_ARRAY( arg6 );
8895  }
8896  {
8897  LUA_FREE_ARRAY( arg7 );
8898  }
8899  return SWIG_arg;
8900 
8901  if(0) SWIG_fail;
8902 
8903 fail:
8904  {
8905  LUA_FREE_ARRAY( arg3 );
8906  }
8907  {
8908  LUA_FREE_ARRAY( arg4 );
8909  }
8910  {
8911  LUA_FREE_ARRAY( arg5 );
8912  }
8913  {
8914  LUA_FREE_ARRAY( arg6 );
8915  }
8916  {
8917  LUA_FREE_ARRAY( arg7 );
8918  }
8919  lua_error(L);
8920  return SWIG_arg;
8921 }
8922 
8923 
8924 static int _wrap_scmap1la(lua_State* L) {
8925  int SWIG_arg = 0;
8926  PLBOOL arg1 ;
8927  PLINT arg2 ;
8928  PLFLT *arg3 = (PLFLT *) 0 ;
8929  PLFLT *arg4 = (PLFLT *) 0 ;
8930  PLFLT *arg5 = (PLFLT *) 0 ;
8931  PLFLT *arg6 = (PLFLT *) 0 ;
8932  PLFLT *arg7 = (PLFLT *) 0 ;
8933  PLBOOL *arg8 = (PLBOOL *) 0 ;
8934  int temp4 ;
8935  int temp5 ;
8936  int temp6 ;
8937  int temp7 ;
8938  int temp8 ;
8939 
8940  {
8941  arg8 = NULL;
8942  }
8943  SWIG_check_num_args("plscmap1la",6,7)
8944  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap1la",1,"PLBOOL");
8945  arg1 = (PLBOOL)lua_tonumber(L, 1);
8946  {
8947  int temp;
8948  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
8949  if ( !arg3 )
8950  SWIG_fail;
8951  arg2 = Alen = temp;
8952  }
8953  {
8954  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
8955  if ( !arg4 )
8956  SWIG_fail;
8957  if ( temp4 != Alen )
8958  {
8959  lua_pushfstring( L, "Tables must be of same length." );
8960  SWIG_fail;
8961  }
8962  }
8963  {
8964  arg5 = (PLFLT *) LUA_get_double_num_array_var( L, 4, &temp5 );
8965  if ( !arg5 )
8966  SWIG_fail;
8967  if ( temp5 != Alen )
8968  {
8969  lua_pushfstring( L, "Tables must be of same length." );
8970  SWIG_fail;
8971  }
8972  }
8973  {
8974  arg6 = (PLFLT *) LUA_get_double_num_array_var( L, 5, &temp6 );
8975  if ( !arg6 )
8976  SWIG_fail;
8977  if ( temp6 != Alen )
8978  {
8979  lua_pushfstring( L, "Tables must be of same length." );
8980  SWIG_fail;
8981  }
8982  }
8983  {
8984  arg7 = (PLFLT *) LUA_get_double_num_array_var( L, 6, &temp7 );
8985  if ( !arg7 )
8986  SWIG_fail;
8987  if ( temp7 != Alen )
8988  {
8989  lua_pushfstring( L, "Tables must be of same length." );
8990  SWIG_fail;
8991  }
8992  }
8993  if(lua_gettop(L)>=7){
8994  {
8995  if ( lua_isnil( L, 7 ) )
8996  {
8997  arg8 = NULL;
8998  }
8999  else
9000  {
9001  arg8 = (PLINT *) LUA_get_int_num_array_var( L, 7, &temp8 );
9002  if ( !arg8 )
9003  SWIG_fail;
9004  if ( temp8 < Alen - 1 )
9005  {
9006  lua_pushfstring( L, "Tables must be at least length of others minus 1." );
9007  SWIG_fail;
9008  }
9009  }
9010  }
9011  }
9012  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
9013 
9014  {
9015  LUA_FREE_ARRAY( arg3 );
9016  }
9017  {
9018  LUA_FREE_ARRAY( arg4 );
9019  }
9020  {
9021  LUA_FREE_ARRAY( arg5 );
9022  }
9023  {
9024  LUA_FREE_ARRAY( arg6 );
9025  }
9026  {
9027  LUA_FREE_ARRAY( arg7 );
9028  }
9029  {
9030  LUA_FREE_ARRAY( arg8 );
9031  }
9032  return SWIG_arg;
9033 
9034  if(0) SWIG_fail;
9035 
9036 fail:
9037  {
9038  LUA_FREE_ARRAY( arg3 );
9039  }
9040  {
9041  LUA_FREE_ARRAY( arg4 );
9042  }
9043  {
9044  LUA_FREE_ARRAY( arg5 );
9045  }
9046  {
9047  LUA_FREE_ARRAY( arg6 );
9048  }
9049  {
9050  LUA_FREE_ARRAY( arg7 );
9051  }
9052  {
9053  LUA_FREE_ARRAY( arg8 );
9054  }
9055  lua_error(L);
9056  return SWIG_arg;
9057 }
9058 
9059 
9060 static int _wrap_scmap1n(lua_State* L) {
9061  int SWIG_arg = 0;
9062  PLINT arg1 ;
9063 
9064  SWIG_check_num_args("plscmap1n",1,1)
9065  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap1n",1,"PLINT");
9066  arg1 = (PLINT)lua_tonumber(L, 1);
9067  plscmap1n(arg1);
9068 
9069  return SWIG_arg;
9070 
9071  if(0) SWIG_fail;
9072 
9073 fail:
9074  lua_error(L);
9075  return SWIG_arg;
9076 }
9077 
9078 
9079 static int _wrap_scmap1_range(lua_State* L) {
9080  int SWIG_arg = 0;
9081  PLFLT arg1 ;
9082  PLFLT arg2 ;
9083 
9084  SWIG_check_num_args("plscmap1_range",2,2)
9085  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscmap1_range",1,"PLFLT");
9086  if(!lua_isnumber(L,2)) SWIG_fail_arg("plscmap1_range",2,"PLFLT");
9087  arg1 = (PLFLT)lua_tonumber(L, 1);
9088  arg2 = (PLFLT)lua_tonumber(L, 2);
9089  plscmap1_range(arg1,arg2);
9090 
9091  return SWIG_arg;
9092 
9093  if(0) SWIG_fail;
9094 
9095 fail:
9096  lua_error(L);
9097  return SWIG_arg;
9098 }
9099 
9100 
9101 static int _wrap_gcmap1_range(lua_State* L) {
9102  int SWIG_arg = 0;
9103  PLFLT *arg1 = (PLFLT *) 0 ;
9104  PLFLT *arg2 = (PLFLT *) 0 ;
9105  PLFLT temp1 ;
9106  PLFLT temp2 ;
9107 
9108  arg1 = &temp1;
9109  arg2 = &temp2;
9110  SWIG_check_num_args("plgcmap1_range",0,0)
9111  plgcmap1_range(arg1,arg2);
9112 
9113  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
9114  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
9115  return SWIG_arg;
9116 
9117  if(0) SWIG_fail;
9118 
9119 fail:
9120  lua_error(L);
9121  return SWIG_arg;
9122 }
9123 
9124 
9125 static int _wrap_scol0(lua_State* L) {
9126  int SWIG_arg = 0;
9127  PLINT arg1 ;
9128  PLINT arg2 ;
9129  PLINT arg3 ;
9130  PLINT arg4 ;
9131 
9132  SWIG_check_num_args("plscol0",4,4)
9133  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscol0",1,"PLINT");
9134  if(!lua_isnumber(L,2)) SWIG_fail_arg("plscol0",2,"PLINT");
9135  if(!lua_isnumber(L,3)) SWIG_fail_arg("plscol0",3,"PLINT");
9136  if(!lua_isnumber(L,4)) SWIG_fail_arg("plscol0",4,"PLINT");
9137  arg1 = (PLINT)lua_tonumber(L, 1);
9138  arg2 = (PLINT)lua_tonumber(L, 2);
9139  arg3 = (PLINT)lua_tonumber(L, 3);
9140  arg4 = (PLINT)lua_tonumber(L, 4);
9141  plscol0(arg1,arg2,arg3,arg4);
9142 
9143  return SWIG_arg;
9144 
9145  if(0) SWIG_fail;
9146 
9147 fail:
9148  lua_error(L);
9149  return SWIG_arg;
9150 }
9151 
9152 
9153 static int _wrap_scol0a(lua_State* L) {
9154  int SWIG_arg = 0;
9155  PLINT arg1 ;
9156  PLINT arg2 ;
9157  PLINT arg3 ;
9158  PLINT arg4 ;
9159  PLFLT arg5 ;
9160 
9161  SWIG_check_num_args("plscol0a",5,5)
9162  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscol0a",1,"PLINT");
9163  if(!lua_isnumber(L,2)) SWIG_fail_arg("plscol0a",2,"PLINT");
9164  if(!lua_isnumber(L,3)) SWIG_fail_arg("plscol0a",3,"PLINT");
9165  if(!lua_isnumber(L,4)) SWIG_fail_arg("plscol0a",4,"PLINT");
9166  if(!lua_isnumber(L,5)) SWIG_fail_arg("plscol0a",5,"PLFLT");
9167  arg1 = (PLINT)lua_tonumber(L, 1);
9168  arg2 = (PLINT)lua_tonumber(L, 2);
9169  arg3 = (PLINT)lua_tonumber(L, 3);
9170  arg4 = (PLINT)lua_tonumber(L, 4);
9171  arg5 = (PLFLT)lua_tonumber(L, 5);
9172  plscol0a(arg1,arg2,arg3,arg4,arg5);
9173 
9174  return SWIG_arg;
9175 
9176  if(0) SWIG_fail;
9177 
9178 fail:
9179  lua_error(L);
9180  return SWIG_arg;
9181 }
9182 
9183 
9184 static int _wrap_scolbg(lua_State* L) {
9185  int SWIG_arg = 0;
9186  PLINT arg1 ;
9187  PLINT arg2 ;
9188  PLINT arg3 ;
9189 
9190  SWIG_check_num_args("plscolbg",3,3)
9191  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscolbg",1,"PLINT");
9192  if(!lua_isnumber(L,2)) SWIG_fail_arg("plscolbg",2,"PLINT");
9193  if(!lua_isnumber(L,3)) SWIG_fail_arg("plscolbg",3,"PLINT");
9194  arg1 = (PLINT)lua_tonumber(L, 1);
9195  arg2 = (PLINT)lua_tonumber(L, 2);
9196  arg3 = (PLINT)lua_tonumber(L, 3);
9197  plscolbg(arg1,arg2,arg3);
9198 
9199  return SWIG_arg;
9200 
9201  if(0) SWIG_fail;
9202 
9203 fail:
9204  lua_error(L);
9205  return SWIG_arg;
9206 }
9207 
9208 
9209 static int _wrap_scolbga(lua_State* L) {
9210  int SWIG_arg = 0;
9211  PLINT arg1 ;
9212  PLINT arg2 ;
9213  PLINT arg3 ;
9214  PLFLT arg4 ;
9215 
9216  SWIG_check_num_args("plscolbga",4,4)
9217  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscolbga",1,"PLINT");
9218  if(!lua_isnumber(L,2)) SWIG_fail_arg("plscolbga",2,"PLINT");
9219  if(!lua_isnumber(L,3)) SWIG_fail_arg("plscolbga",3,"PLINT");
9220  if(!lua_isnumber(L,4)) SWIG_fail_arg("plscolbga",4,"PLFLT");
9221  arg1 = (PLINT)lua_tonumber(L, 1);
9222  arg2 = (PLINT)lua_tonumber(L, 2);
9223  arg3 = (PLINT)lua_tonumber(L, 3);
9224  arg4 = (PLFLT)lua_tonumber(L, 4);
9225  plscolbga(arg1,arg2,arg3,arg4);
9226 
9227  return SWIG_arg;
9228 
9229  if(0) SWIG_fail;
9230 
9231 fail:
9232  lua_error(L);
9233  return SWIG_arg;
9234 }
9235 
9236 
9237 static int _wrap_scolor(lua_State* L) {
9238  int SWIG_arg = 0;
9239  PLINT arg1 ;
9240 
9241  SWIG_check_num_args("plscolor",1,1)
9242  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscolor",1,"PLINT");
9243  arg1 = (PLINT)lua_tonumber(L, 1);
9244  plscolor(arg1);
9245 
9246  return SWIG_arg;
9247 
9248  if(0) SWIG_fail;
9249 
9250 fail:
9251  lua_error(L);
9252  return SWIG_arg;
9253 }
9254 
9255 
9256 static int _wrap_scompression(lua_State* L) {
9257  int SWIG_arg = 0;
9258  PLINT arg1 ;
9259 
9260  SWIG_check_num_args("plscompression",1,1)
9261  if(!lua_isnumber(L,1)) SWIG_fail_arg("plscompression",1,"PLINT");
9262  arg1 = (PLINT)lua_tonumber(L, 1);
9263  plscompression(arg1);
9264 
9265  return SWIG_arg;
9266 
9267  if(0) SWIG_fail;
9268 
9269 fail:
9270  lua_error(L);
9271  return SWIG_arg;
9272 }
9273 
9274 
9275 static int _wrap_sdev(lua_State* L) {
9276  int SWIG_arg = 0;
9277  char *arg1 = (char *) 0 ;
9278 
9279  SWIG_check_num_args("plsdev",1,1)
9280  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plsdev",1,"char const *");
9281  arg1 = (char *)lua_tostring(L, 1);
9282  plsdev((char const *)arg1);
9283 
9284  return SWIG_arg;
9285 
9286  if(0) SWIG_fail;
9287 
9288 fail:
9289  lua_error(L);
9290  return SWIG_arg;
9291 }
9292 
9293 
9294 static int _wrap_sdidev(lua_State* L) {
9295  int SWIG_arg = 0;
9296  PLFLT arg1 ;
9297  PLFLT arg2 ;
9298  PLFLT arg3 ;
9299  PLFLT arg4 ;
9300 
9301  SWIG_check_num_args("plsdidev",4,4)
9302  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdidev",1,"PLFLT");
9303  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsdidev",2,"PLFLT");
9304  if(!lua_isnumber(L,3)) SWIG_fail_arg("plsdidev",3,"PLFLT");
9305  if(!lua_isnumber(L,4)) SWIG_fail_arg("plsdidev",4,"PLFLT");
9306  arg1 = (PLFLT)lua_tonumber(L, 1);
9307  arg2 = (PLFLT)lua_tonumber(L, 2);
9308  arg3 = (PLFLT)lua_tonumber(L, 3);
9309  arg4 = (PLFLT)lua_tonumber(L, 4);
9310  plsdidev(arg1,arg2,arg3,arg4);
9311 
9312  return SWIG_arg;
9313 
9314  if(0) SWIG_fail;
9315 
9316 fail:
9317  lua_error(L);
9318  return SWIG_arg;
9319 }
9320 
9321 
9322 static int _wrap_sdimap(lua_State* L) {
9323  int SWIG_arg = 0;
9324  PLINT arg1 ;
9325  PLINT arg2 ;
9326  PLINT arg3 ;
9327  PLINT arg4 ;
9328  PLFLT arg5 ;
9329  PLFLT arg6 ;
9330 
9331  SWIG_check_num_args("plsdimap",6,6)
9332  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdimap",1,"PLINT");
9333  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsdimap",2,"PLINT");
9334  if(!lua_isnumber(L,3)) SWIG_fail_arg("plsdimap",3,"PLINT");
9335  if(!lua_isnumber(L,4)) SWIG_fail_arg("plsdimap",4,"PLINT");
9336  if(!lua_isnumber(L,5)) SWIG_fail_arg("plsdimap",5,"PLFLT");
9337  if(!lua_isnumber(L,6)) SWIG_fail_arg("plsdimap",6,"PLFLT");
9338  arg1 = (PLINT)lua_tonumber(L, 1);
9339  arg2 = (PLINT)lua_tonumber(L, 2);
9340  arg3 = (PLINT)lua_tonumber(L, 3);
9341  arg4 = (PLINT)lua_tonumber(L, 4);
9342  arg5 = (PLFLT)lua_tonumber(L, 5);
9343  arg6 = (PLFLT)lua_tonumber(L, 6);
9344  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
9345 
9346  return SWIG_arg;
9347 
9348  if(0) SWIG_fail;
9349 
9350 fail:
9351  lua_error(L);
9352  return SWIG_arg;
9353 }
9354 
9355 
9356 static int _wrap_sdiori(lua_State* L) {
9357  int SWIG_arg = 0;
9358  PLFLT arg1 ;
9359 
9360  SWIG_check_num_args("plsdiori",1,1)
9361  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdiori",1,"PLFLT");
9362  arg1 = (PLFLT)lua_tonumber(L, 1);
9363  plsdiori(arg1);
9364 
9365  return SWIG_arg;
9366 
9367  if(0) SWIG_fail;
9368 
9369 fail:
9370  lua_error(L);
9371  return SWIG_arg;
9372 }
9373 
9374 
9375 static int _wrap_sdiplt(lua_State* L) {
9376  int SWIG_arg = 0;
9377  PLFLT arg1 ;
9378  PLFLT arg2 ;
9379  PLFLT arg3 ;
9380  PLFLT arg4 ;
9381 
9382  SWIG_check_num_args("plsdiplt",4,4)
9383  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdiplt",1,"PLFLT");
9384  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsdiplt",2,"PLFLT");
9385  if(!lua_isnumber(L,3)) SWIG_fail_arg("plsdiplt",3,"PLFLT");
9386  if(!lua_isnumber(L,4)) SWIG_fail_arg("plsdiplt",4,"PLFLT");
9387  arg1 = (PLFLT)lua_tonumber(L, 1);
9388  arg2 = (PLFLT)lua_tonumber(L, 2);
9389  arg3 = (PLFLT)lua_tonumber(L, 3);
9390  arg4 = (PLFLT)lua_tonumber(L, 4);
9391  plsdiplt(arg1,arg2,arg3,arg4);
9392 
9393  return SWIG_arg;
9394 
9395  if(0) SWIG_fail;
9396 
9397 fail:
9398  lua_error(L);
9399  return SWIG_arg;
9400 }
9401 
9402 
9403 static int _wrap_sdiplz(lua_State* L) {
9404  int SWIG_arg = 0;
9405  PLFLT arg1 ;
9406  PLFLT arg2 ;
9407  PLFLT arg3 ;
9408  PLFLT arg4 ;
9409 
9410  SWIG_check_num_args("plsdiplz",4,4)
9411  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsdiplz",1,"PLFLT");
9412  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsdiplz",2,"PLFLT");
9413  if(!lua_isnumber(L,3)) SWIG_fail_arg("plsdiplz",3,"PLFLT");
9414  if(!lua_isnumber(L,4)) SWIG_fail_arg("plsdiplz",4,"PLFLT");
9415  arg1 = (PLFLT)lua_tonumber(L, 1);
9416  arg2 = (PLFLT)lua_tonumber(L, 2);
9417  arg3 = (PLFLT)lua_tonumber(L, 3);
9418  arg4 = (PLFLT)lua_tonumber(L, 4);
9419  plsdiplz(arg1,arg2,arg3,arg4);
9420 
9421  return SWIG_arg;
9422 
9423  if(0) SWIG_fail;
9424 
9425 fail:
9426  lua_error(L);
9427  return SWIG_arg;
9428 }
9429 
9430 
9431 static int _wrap_seed(lua_State* L) {
9432  int SWIG_arg = 0;
9433  unsigned int arg1 ;
9434 
9435  SWIG_check_num_args("plseed",1,1)
9436  if(!lua_isnumber(L,1)) SWIG_fail_arg("plseed",1,"unsigned int");
9437  SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative")
9438  arg1 = (unsigned int)lua_tonumber(L, 1);
9439  plseed(arg1);
9440 
9441  return SWIG_arg;
9442 
9443  if(0) SWIG_fail;
9444 
9445 fail:
9446  lua_error(L);
9447  return SWIG_arg;
9448 }
9449 
9450 
9451 static int _wrap_sesc(lua_State* L) {
9452  int SWIG_arg = 0;
9453  char arg1 ;
9454 
9455  SWIG_check_num_args("plsesc",1,1)
9456  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plsesc",1,"char");
9457  arg1 = (lua_tostring(L, 1))[0];
9458  plsesc(arg1);
9459 
9460  return SWIG_arg;
9461 
9462  if(0) SWIG_fail;
9463 
9464 fail:
9465  lua_error(L);
9466  return SWIG_arg;
9467 }
9468 
9469 
9470 static int _wrap_setopt(lua_State* L) {
9471  int SWIG_arg = 0;
9472  char *arg1 = (char *) 0 ;
9473  char *arg2 = (char *) 0 ;
9474  PLINT result;
9475 
9476  SWIG_check_num_args("plsetopt",2,2)
9477  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plsetopt",1,"char const *");
9478  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plsetopt",2,"char const *");
9479  arg1 = (char *)lua_tostring(L, 1);
9480  arg2 = (char *)lua_tostring(L, 2);
9481  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
9482  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9483  return SWIG_arg;
9484 
9485  if(0) SWIG_fail;
9486 
9487 fail:
9488  lua_error(L);
9489  return SWIG_arg;
9490 }
9491 
9492 
9493 static int _wrap_sfam(lua_State* L) {
9494  int SWIG_arg = 0;
9495  PLINT arg1 ;
9496  PLINT arg2 ;
9497  PLINT arg3 ;
9498 
9499  SWIG_check_num_args("plsfam",3,3)
9500  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsfam",1,"PLINT");
9501  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsfam",2,"PLINT");
9502  if(!lua_isnumber(L,3)) SWIG_fail_arg("plsfam",3,"PLINT");
9503  arg1 = (PLINT)lua_tonumber(L, 1);
9504  arg2 = (PLINT)lua_tonumber(L, 2);
9505  arg3 = (PLINT)lua_tonumber(L, 3);
9506  plsfam(arg1,arg2,arg3);
9507 
9508  return SWIG_arg;
9509 
9510  if(0) SWIG_fail;
9511 
9512 fail:
9513  lua_error(L);
9514  return SWIG_arg;
9515 }
9516 
9517 
9518 static int _wrap_sfci(lua_State* L) {
9519  int SWIG_arg = 0;
9520  PLUNICODE arg1 ;
9521 
9522  SWIG_check_num_args("plsfci",1,1)
9523  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsfci",1,"PLUNICODE");
9524  SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative")
9525  arg1 = (PLUNICODE)lua_tonumber(L, 1);
9526  plsfci(arg1);
9527 
9528  return SWIG_arg;
9529 
9530  if(0) SWIG_fail;
9531 
9532 fail:
9533  lua_error(L);
9534  return SWIG_arg;
9535 }
9536 
9537 
9538 static int _wrap_sfnam(lua_State* L) {
9539  int SWIG_arg = 0;
9540  char *arg1 = (char *) 0 ;
9541 
9542  SWIG_check_num_args("plsfnam",1,1)
9543  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plsfnam",1,"char const *");
9544  arg1 = (char *)lua_tostring(L, 1);
9545  plsfnam((char const *)arg1);
9546 
9547  return SWIG_arg;
9548 
9549  if(0) SWIG_fail;
9550 
9551 fail:
9552  lua_error(L);
9553  return SWIG_arg;
9554 }
9555 
9556 
9557 static int _wrap_sfont(lua_State* L) {
9558  int SWIG_arg = 0;
9559  PLINT arg1 ;
9560  PLINT arg2 ;
9561  PLINT arg3 ;
9562 
9563  SWIG_check_num_args("plsfont",3,3)
9564  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsfont",1,"PLINT");
9565  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsfont",2,"PLINT");
9566  if(!lua_isnumber(L,3)) SWIG_fail_arg("plsfont",3,"PLINT");
9567  arg1 = (PLINT)lua_tonumber(L, 1);
9568  arg2 = (PLINT)lua_tonumber(L, 2);
9569  arg3 = (PLINT)lua_tonumber(L, 3);
9570  plsfont(arg1,arg2,arg3);
9571 
9572  return SWIG_arg;
9573 
9574  if(0) SWIG_fail;
9575 
9576 fail:
9577  lua_error(L);
9578  return SWIG_arg;
9579 }
9580 
9581 
9582 static int _wrap_shades(lua_State* L) {
9583  int SWIG_arg = 0;
9584  PLFLT **arg1 = (PLFLT **) 0 ;
9585  PLINT arg2 ;
9586  PLINT arg3 ;
9587  defined_func arg4 = (defined_func) 0 ;
9588  PLFLT arg5 ;
9589  PLFLT arg6 ;
9590  PLFLT arg7 ;
9591  PLFLT arg8 ;
9592  PLFLT *arg9 = (PLFLT *) 0 ;
9593  PLINT arg10 ;
9594  PLFLT arg11 ;
9595  PLINT arg12 ;
9596  PLFLT arg13 ;
9597  fill_func arg14 = (fill_func) 0 ;
9598  PLBOOL arg15 ;
9599  pltr_func arg16 = (pltr_func) 0 ;
9600  PLPointer arg17 = (PLPointer) 0 ;
9601  int ii1 ;
9602  PLcGrid cgrid117 ;
9603  PLcGrid2 cgrid217 ;
9604 
9605  {
9606  cgrid117.xg = cgrid117.yg = cgrid117.zg = NULL;
9607  cgrid117.nx = cgrid117.ny = cgrid117.nz = 0;
9608  cgrid217.xg = cgrid217.yg = cgrid217.zg = NULL;
9609  cgrid217.nx = cgrid217.ny = 0;
9610  }
9611  {
9612  arg16 = NULL;
9613  }
9614  {
9615  arg17 = NULL;
9616  }
9617  {
9618  arg4 = NULL;
9619  }
9620  {
9621  arg14 = plfill;
9622  }
9623  SWIG_check_num_args("plshades",10,12)
9624  if(!lua_isnumber(L,2)) SWIG_fail_arg("plshades",2,"PLFLT");
9625  if(!lua_isnumber(L,3)) SWIG_fail_arg("plshades",3,"PLFLT");
9626  if(!lua_isnumber(L,4)) SWIG_fail_arg("plshades",4,"PLFLT");
9627  if(!lua_isnumber(L,5)) SWIG_fail_arg("plshades",5,"PLFLT");
9628  if(!lua_isnumber(L,7)) SWIG_fail_arg("plshades",7,"PLFLT");
9629  if(!lua_isnumber(L,8)) SWIG_fail_arg("plshades",8,"PLINT");
9630  if(!lua_isnumber(L,9)) SWIG_fail_arg("plshades",9,"PLFLT");
9631  if(!lua_isnumber(L,10)) SWIG_fail_arg("plshades",10,"PLBOOL");
9632  {
9633  int jj;
9634 
9635  arg1 = read_double_Matrix( L, 1, &ii1, &jj );
9636  if ( !arg1 )
9637  SWIG_fail;
9638  Xlen = arg2 = ii1;
9639  Ylen = arg3 = jj;
9640  }
9641  arg5 = (PLFLT)lua_tonumber(L, 2);
9642  arg6 = (PLFLT)lua_tonumber(L, 3);
9643  arg7 = (PLFLT)lua_tonumber(L, 4);
9644  arg8 = (PLFLT)lua_tonumber(L, 5);
9645  {
9646  int temp;
9647  arg9 = (PLFLT *) LUA_get_double_num_array_var( L, 6, &temp );
9648  if ( !arg9 )
9649  SWIG_fail;
9650  arg10 = Alen = temp;
9651  }
9652  arg11 = (PLFLT)lua_tonumber(L, 7);
9653  arg12 = (PLINT)lua_tonumber(L, 8);
9654  arg13 = (PLFLT)lua_tonumber(L, 9);
9655  arg15 = (PLBOOL)lua_tonumber(L, 10);
9656  if(lua_gettop(L)>=11){
9657  {
9658  arg16 = NULL;
9659  mypltr_funcstr[0] = '\0';
9660 
9661  if ( lua_isstring( L, 11 ) )
9662  {
9663  const char* funcstr = lua_tostring( L, 11 );
9664  if ( strcmp( "pltr0", funcstr ) == 0 )
9665  {
9666  arg16 = pltr0;
9667  }
9668  else if ( strcmp( "pltr1", funcstr ) == 0 )
9669  {
9670  arg16 = pltr1;
9671  }
9672  else if ( strcmp( "pltr2", funcstr ) == 0 )
9673  {
9674  arg16 = pltr2;
9675  }
9676  else
9677  {
9678  arg16 = mypltr;
9679  strncpy( mypltr_funcstr, funcstr, 255 );
9680  myL = L;
9681  }
9682  }
9683  else
9684  SWIG_fail_arg( "shades", 16, "pltr_func" );
9685  }
9686  }
9687  if(lua_gettop(L)>=12){
9688  {
9689  int nx, ny;
9690  int gridmode = 0;
9691 
9692  lua_pushstring( L, "xg" );
9693  lua_gettable( L, 12 );
9694  if ( !lua_istable( L, -1 ) )
9695  {
9696  lua_pop( L, 1 ); // pop "xg"
9697  lua_pushstring( L, "expected a table xg" );
9698  SWIG_fail;
9699  }
9700  lua_rawgeti( L, -1, 1 );
9701  if ( lua_istable( L, -1 ) )
9702  gridmode = 2; // two dimensional array
9703  else if ( lua_isnumber( L, -1 ) )
9704  gridmode = 1; // one dimensional array
9705  else
9706  {
9707  lua_pop( L, 1 ); // pop "1"
9708  lua_pop( L, 1 ); // pop "xg"
9709  lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
9710  SWIG_fail;
9711  }
9712  lua_pop( L, 1 ); // pop test element
9713  if ( gridmode == 1 )
9714  {
9715  cgrid117.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
9716  if ( !cgrid117.xg )
9717  {
9718  lua_pop( L, 1 ); // pop "xg"
9719  SWIG_fail;
9720  }
9721  if ( nx != Xlen )
9722  {
9723  lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
9724  SWIG_fail;
9725  }
9726  cgrid117.nx = nx;
9727  }
9728  else
9729  {
9730  cgrid217.xg = read_double_Matrix( L, -1, &nx, &ny );
9731  if ( !cgrid217.xg )
9732  {
9733  lua_pop( L, 1 ); // pop "xg"
9734  SWIG_fail;
9735  }
9736  if ( ( nx != Xlen ) || ( ny != Ylen ) )
9737  {
9738  lua_pop( L, 1 ); // pop "xg"
9739  lua_pushfstring( L, "Vectors must match matrix." );
9740  SWIG_fail;
9741  }
9742  cgrid217.nx = nx;
9743  cgrid217.ny = ny;
9744  }
9745  lua_pop( L, 1 ); // pop "xg"
9746 
9747  lua_pushstring( L, "yg" );
9748  lua_gettable( L, 12 );
9749  if ( !lua_istable( L, -1 ) )
9750  {
9751  lua_pop( L, 1 );
9752  lua_pushstring( L, "expected a table yg" );
9753  SWIG_fail;
9754  }
9755  lua_rawgeti( L, -1, 1 );
9756  if ( gridmode == 2 )
9757  {
9758  if ( !lua_istable( L, -1 ) )
9759  {
9760  lua_pop( L, 1 ); // pop "1"
9761  lua_pop( L, 1 ); // pop "yg"
9762  lua_pushstring( L, "expected a two dimensional array/table in yg" );
9763  SWIG_fail;
9764  }
9765  }
9766  else
9767  {
9768  if ( !lua_isnumber( L, -1 ) )
9769  {
9770  lua_pop( L, 1 ); // pop "1"
9771  lua_pop( L, 1 ); // pop "yg"
9772  lua_pushstring( L, "expected a one dimensional array/table in yg" );
9773  SWIG_fail;
9774  }
9775  }
9776  lua_pop( L, 1 ); // pop "1"
9777  if ( gridmode == 1 )
9778  {
9779  cgrid117.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
9780  if ( !cgrid117.yg )
9781  {
9782  lua_pop( L, 1 ); // pop "yg"
9783  SWIG_fail;
9784  }
9785  if ( ny != Ylen )
9786  {
9787  lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
9788  SWIG_fail;
9789  }
9790  cgrid117.ny = ny;
9791  }
9792  else
9793  {
9794  cgrid217.yg = read_double_Matrix( L, -1, &nx, &ny );
9795  if ( !cgrid217.yg )
9796  {
9797  lua_pop( L, 1 ); // pop "xg"
9798  SWIG_fail;
9799  }
9800  if ( ( nx != Xlen ) || ( ny != Ylen ) )
9801  {
9802  lua_pop( L, 1 ); // pop "xg"
9803  lua_pushfstring( L, "Vectors must match matrix." );
9804  SWIG_fail;
9805  }
9806  // cgrid217.nx/ny already set
9807  }
9808  lua_pop( L, 1 ); // pop "yg"
9809 
9810  if ( gridmode == 1 )
9811  arg17 = &cgrid117;
9812  else if ( gridmode == 2 )
9813  arg17 = &cgrid217;
9814  }
9815  }
9816  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
9817 
9818  {
9819  int i;
9820 
9821  if ( arg1 )
9822  {
9823  for ( i = 0; i < ii1; i++ )
9824  LUA_FREE_ARRAY( arg1[i] );
9825  LUA_FREE_ARRAY( arg1 );
9826  }
9827  }
9828  {
9829  LUA_FREE_ARRAY( arg9 );
9830  }
9831  {
9832  mypltr_funcstr[0] = '\0';
9833  }
9834  {
9835  int i;
9836 
9837  LUA_FREE_ARRAY( cgrid117.xg );
9838  LUA_FREE_ARRAY( cgrid117.yg );
9839 
9840  if ( cgrid217.xg )
9841  {
9842  for ( i = 0; i < Xlen; i++ )
9843  LUA_FREE_ARRAY( cgrid217.xg[i] );
9844  LUA_FREE_ARRAY( cgrid217.xg );
9845  }
9846  if ( cgrid217.yg )
9847  {
9848  for ( i = 0; i < Xlen; i++ )
9849  LUA_FREE_ARRAY( cgrid217.yg[i] );
9850  LUA_FREE_ARRAY( cgrid217.yg );
9851  }
9852  }
9853  return SWIG_arg;
9854 
9855  if(0) SWIG_fail;
9856 
9857 fail:
9858  {
9859  int i;
9860 
9861  if ( arg1 )
9862  {
9863  for ( i = 0; i < ii1; i++ )
9864  LUA_FREE_ARRAY( arg1[i] );
9865  LUA_FREE_ARRAY( arg1 );
9866  }
9867  }
9868  {
9869  LUA_FREE_ARRAY( arg9 );
9870  }
9871  {
9872  mypltr_funcstr[0] = '\0';
9873  }
9874  {
9875  int i;
9876 
9877  LUA_FREE_ARRAY( cgrid117.xg );
9878  LUA_FREE_ARRAY( cgrid117.yg );
9879 
9880  if ( cgrid217.xg )
9881  {
9882  for ( i = 0; i < Xlen; i++ )
9883  LUA_FREE_ARRAY( cgrid217.xg[i] );
9884  LUA_FREE_ARRAY( cgrid217.xg );
9885  }
9886  if ( cgrid217.yg )
9887  {
9888  for ( i = 0; i < Xlen; i++ )
9889  LUA_FREE_ARRAY( cgrid217.yg[i] );
9890  LUA_FREE_ARRAY( cgrid217.yg );
9891  }
9892  }
9893  lua_error(L);
9894  return SWIG_arg;
9895 }
9896 
9897 
9898 static int _wrap_shade(lua_State* L) {
9899  int SWIG_arg = 0;
9900  PLFLT **arg1 = (PLFLT **) 0 ;
9901  PLINT arg2 ;
9902  PLINT arg3 ;
9903  defined_func arg4 = (defined_func) 0 ;
9904  PLFLT arg5 ;
9905  PLFLT arg6 ;
9906  PLFLT arg7 ;
9907  PLFLT arg8 ;
9908  PLFLT arg9 ;
9909  PLFLT arg10 ;
9910  PLINT arg11 ;
9911  PLFLT arg12 ;
9912  PLFLT arg13 ;
9913  PLINT arg14 ;
9914  PLFLT arg15 ;
9915  PLINT arg16 ;
9916  PLFLT arg17 ;
9917  fill_func arg18 = (fill_func) 0 ;
9918  PLBOOL arg19 ;
9919  pltr_func arg20 = (pltr_func) 0 ;
9920  PLPointer arg21 = (PLPointer) 0 ;
9921  int ii1 ;
9922  PLcGrid cgrid121 ;
9923  PLcGrid2 cgrid221 ;
9924 
9925  {
9926  cgrid121.xg = cgrid121.yg = cgrid121.zg = NULL;
9927  cgrid121.nx = cgrid121.ny = cgrid121.nz = 0;
9928  cgrid221.xg = cgrid221.yg = cgrid221.zg = NULL;
9929  cgrid221.nx = cgrid221.ny = 0;
9930  }
9931  {
9932  arg20 = NULL;
9933  }
9934  {
9935  arg21 = NULL;
9936  }
9937  {
9938  arg4 = NULL;
9939  }
9940  {
9941  arg18 = plfill;
9942  }
9943  SWIG_check_num_args("plshade",15,17)
9944  if(!lua_isnumber(L,2)) SWIG_fail_arg("plshade",2,"PLFLT");
9945  if(!lua_isnumber(L,3)) SWIG_fail_arg("plshade",3,"PLFLT");
9946  if(!lua_isnumber(L,4)) SWIG_fail_arg("plshade",4,"PLFLT");
9947  if(!lua_isnumber(L,5)) SWIG_fail_arg("plshade",5,"PLFLT");
9948  if(!lua_isnumber(L,6)) SWIG_fail_arg("plshade",6,"PLFLT");
9949  if(!lua_isnumber(L,7)) SWIG_fail_arg("plshade",7,"PLFLT");
9950  if(!lua_isnumber(L,8)) SWIG_fail_arg("plshade",8,"PLINT");
9951  if(!lua_isnumber(L,9)) SWIG_fail_arg("plshade",9,"PLFLT");
9952  if(!lua_isnumber(L,10)) SWIG_fail_arg("plshade",10,"PLFLT");
9953  if(!lua_isnumber(L,11)) SWIG_fail_arg("plshade",11,"PLINT");
9954  if(!lua_isnumber(L,12)) SWIG_fail_arg("plshade",12,"PLFLT");
9955  if(!lua_isnumber(L,13)) SWIG_fail_arg("plshade",13,"PLINT");
9956  if(!lua_isnumber(L,14)) SWIG_fail_arg("plshade",14,"PLFLT");
9957  if(!lua_isnumber(L,15)) SWIG_fail_arg("plshade",15,"PLBOOL");
9958  {
9959  int jj;
9960 
9961  arg1 = read_double_Matrix( L, 1, &ii1, &jj );
9962  if ( !arg1 )
9963  SWIG_fail;
9964  Xlen = arg2 = ii1;
9965  Ylen = arg3 = jj;
9966  }
9967  arg5 = (PLFLT)lua_tonumber(L, 2);
9968  arg6 = (PLFLT)lua_tonumber(L, 3);
9969  arg7 = (PLFLT)lua_tonumber(L, 4);
9970  arg8 = (PLFLT)lua_tonumber(L, 5);
9971  arg9 = (PLFLT)lua_tonumber(L, 6);
9972  arg10 = (PLFLT)lua_tonumber(L, 7);
9973  arg11 = (PLINT)lua_tonumber(L, 8);
9974  arg12 = (PLFLT)lua_tonumber(L, 9);
9975  arg13 = (PLFLT)lua_tonumber(L, 10);
9976  arg14 = (PLINT)lua_tonumber(L, 11);
9977  arg15 = (PLFLT)lua_tonumber(L, 12);
9978  arg16 = (PLINT)lua_tonumber(L, 13);
9979  arg17 = (PLFLT)lua_tonumber(L, 14);
9980  arg19 = (PLBOOL)lua_tonumber(L, 15);
9981  if(lua_gettop(L)>=16){
9982  {
9983  arg20 = NULL;
9984  mypltr_funcstr[0] = '\0';
9985 
9986  if ( lua_isstring( L, 16 ) )
9987  {
9988  const char* funcstr = lua_tostring( L, 16 );
9989  if ( strcmp( "pltr0", funcstr ) == 0 )
9990  {
9991  arg20 = pltr0;
9992  }
9993  else if ( strcmp( "pltr1", funcstr ) == 0 )
9994  {
9995  arg20 = pltr1;
9996  }
9997  else if ( strcmp( "pltr2", funcstr ) == 0 )
9998  {
9999  arg20 = pltr2;
10000  }
10001  else
10002  {
10003  arg20 = mypltr;
10004  strncpy( mypltr_funcstr, funcstr, 255 );
10005  myL = L;
10006  }
10007  }
10008  else
10009  SWIG_fail_arg( "shade", 20, "pltr_func" );
10010  }
10011  }
10012  if(lua_gettop(L)>=17){
10013  {
10014  int nx, ny;
10015  int gridmode = 0;
10016 
10017  lua_pushstring( L, "xg" );
10018  lua_gettable( L, 17 );
10019  if ( !lua_istable( L, -1 ) )
10020  {
10021  lua_pop( L, 1 ); // pop "xg"
10022  lua_pushstring( L, "expected a table xg" );
10023  SWIG_fail;
10024  }
10025  lua_rawgeti( L, -1, 1 );
10026  if ( lua_istable( L, -1 ) )
10027  gridmode = 2; // two dimensional array
10028  else if ( lua_isnumber( L, -1 ) )
10029  gridmode = 1; // one dimensional array
10030  else
10031  {
10032  lua_pop( L, 1 ); // pop "1"
10033  lua_pop( L, 1 ); // pop "xg"
10034  lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
10035  SWIG_fail;
10036  }
10037  lua_pop( L, 1 ); // pop test element
10038  if ( gridmode == 1 )
10039  {
10040  cgrid121.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
10041  if ( !cgrid121.xg )
10042  {
10043  lua_pop( L, 1 ); // pop "xg"
10044  SWIG_fail;
10045  }
10046  if ( nx != Xlen )
10047  {
10048  lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
10049  SWIG_fail;
10050  }
10051  cgrid121.nx = nx;
10052  }
10053  else
10054  {
10055  cgrid221.xg = read_double_Matrix( L, -1, &nx, &ny );
10056  if ( !cgrid221.xg )
10057  {
10058  lua_pop( L, 1 ); // pop "xg"
10059  SWIG_fail;
10060  }
10061  if ( ( nx != Xlen ) || ( ny != Ylen ) )
10062  {
10063  lua_pop( L, 1 ); // pop "xg"
10064  lua_pushfstring( L, "Vectors must match matrix." );
10065  SWIG_fail;
10066  }
10067  cgrid221.nx = nx;
10068  cgrid221.ny = ny;
10069  }
10070  lua_pop( L, 1 ); // pop "xg"
10071 
10072  lua_pushstring( L, "yg" );
10073  lua_gettable( L, 17 );
10074  if ( !lua_istable( L, -1 ) )
10075  {
10076  lua_pop( L, 1 );
10077  lua_pushstring( L, "expected a table yg" );
10078  SWIG_fail;
10079  }
10080  lua_rawgeti( L, -1, 1 );
10081  if ( gridmode == 2 )
10082  {
10083  if ( !lua_istable( L, -1 ) )
10084  {
10085  lua_pop( L, 1 ); // pop "1"
10086  lua_pop( L, 1 ); // pop "yg"
10087  lua_pushstring( L, "expected a two dimensional array/table in yg" );
10088  SWIG_fail;
10089  }
10090  }
10091  else
10092  {
10093  if ( !lua_isnumber( L, -1 ) )
10094  {
10095  lua_pop( L, 1 ); // pop "1"
10096  lua_pop( L, 1 ); // pop "yg"
10097  lua_pushstring( L, "expected a one dimensional array/table in yg" );
10098  SWIG_fail;
10099  }
10100  }
10101  lua_pop( L, 1 ); // pop "1"
10102  if ( gridmode == 1 )
10103  {
10104  cgrid121.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
10105  if ( !cgrid121.yg )
10106  {
10107  lua_pop( L, 1 ); // pop "yg"
10108  SWIG_fail;
10109  }
10110  if ( ny != Ylen )
10111  {
10112  lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
10113  SWIG_fail;
10114  }
10115  cgrid121.ny = ny;
10116  }
10117  else
10118  {
10119  cgrid221.yg = read_double_Matrix( L, -1, &nx, &ny );
10120  if ( !cgrid221.yg )
10121  {
10122  lua_pop( L, 1 ); // pop "xg"
10123  SWIG_fail;
10124  }
10125  if ( ( nx != Xlen ) || ( ny != Ylen ) )
10126  {
10127  lua_pop( L, 1 ); // pop "xg"
10128  lua_pushfstring( L, "Vectors must match matrix." );
10129  SWIG_fail;
10130  }
10131  // cgrid221.nx/ny already set
10132  }
10133  lua_pop( L, 1 ); // pop "yg"
10134 
10135  if ( gridmode == 1 )
10136  arg21 = &cgrid121;
10137  else if ( gridmode == 2 )
10138  arg21 = &cgrid221;
10139  }
10140  }
10141  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
10142 
10143  {
10144  int i;
10145 
10146  if ( arg1 )
10147  {
10148  for ( i = 0; i < ii1; i++ )
10149  LUA_FREE_ARRAY( arg1[i] );
10150  LUA_FREE_ARRAY( arg1 );
10151  }
10152  }
10153  {
10154  mypltr_funcstr[0] = '\0';
10155  }
10156  {
10157  int i;
10158 
10159  LUA_FREE_ARRAY( cgrid121.xg );
10160  LUA_FREE_ARRAY( cgrid121.yg );
10161 
10162  if ( cgrid221.xg )
10163  {
10164  for ( i = 0; i < Xlen; i++ )
10165  LUA_FREE_ARRAY( cgrid221.xg[i] );
10166  LUA_FREE_ARRAY( cgrid221.xg );
10167  }
10168  if ( cgrid221.yg )
10169  {
10170  for ( i = 0; i < Xlen; i++ )
10171  LUA_FREE_ARRAY( cgrid221.yg[i] );
10172  LUA_FREE_ARRAY( cgrid221.yg );
10173  }
10174  }
10175  return SWIG_arg;
10176 
10177  if(0) SWIG_fail;
10178 
10179 fail:
10180  {
10181  int i;
10182 
10183  if ( arg1 )
10184  {
10185  for ( i = 0; i < ii1; i++ )
10186  LUA_FREE_ARRAY( arg1[i] );
10187  LUA_FREE_ARRAY( arg1 );
10188  }
10189  }
10190  {
10191  mypltr_funcstr[0] = '\0';
10192  }
10193  {
10194  int i;
10195 
10196  LUA_FREE_ARRAY( cgrid121.xg );
10197  LUA_FREE_ARRAY( cgrid121.yg );
10198 
10199  if ( cgrid221.xg )
10200  {
10201  for ( i = 0; i < Xlen; i++ )
10202  LUA_FREE_ARRAY( cgrid221.xg[i] );
10203  LUA_FREE_ARRAY( cgrid221.xg );
10204  }
10205  if ( cgrid221.yg )
10206  {
10207  for ( i = 0; i < Xlen; i++ )
10208  LUA_FREE_ARRAY( cgrid221.yg[i] );
10209  LUA_FREE_ARRAY( cgrid221.yg );
10210  }
10211  }
10212  lua_error(L);
10213  return SWIG_arg;
10214 }
10215 
10216 
10217 static int _wrap_slabelfunc(lua_State* L) {
10218  int SWIG_arg = 0;
10219  label_func arg1 = (label_func) 0 ;
10220  PLPointer arg2 = (PLPointer) 0 ;
10221 
10222  {
10223  arg2 = NULL;
10224  }
10225  SWIG_check_num_args("plslabelfunc",1,1)
10226  {
10227  arg1 = NULL;
10228  mylabel_funcstr[0] = '\0';
10229 
10230  if ( lua_isnil( L, 1 ) )
10231  {
10232  arg1 = NULL;
10233  }
10234  else if ( lua_isstring( L, 1 ) )
10235  {
10236  arg1 = mylabel;
10237  strncpy( mylabel_funcstr, lua_tostring( L, 1 ), 255 );
10238  myL = L;
10239  }
10240  else
10241  SWIG_fail_arg( "slabelfunc", 1, "label_func" );
10242  }
10243  plslabelfunc(arg1,arg2);
10244 
10245  {
10246 
10247  }
10248  return SWIG_arg;
10249 
10250  if(0) SWIG_fail;
10251 
10252 fail:
10253  {
10254 
10255  }
10256  lua_error(L);
10257  return SWIG_arg;
10258 }
10259 
10260 
10261 static int _wrap_smaj(lua_State* L) {
10262  int SWIG_arg = 0;
10263  PLFLT arg1 ;
10264  PLFLT arg2 ;
10265 
10266  SWIG_check_num_args("plsmaj",2,2)
10267  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsmaj",1,"PLFLT");
10268  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsmaj",2,"PLFLT");
10269  arg1 = (PLFLT)lua_tonumber(L, 1);
10270  arg2 = (PLFLT)lua_tonumber(L, 2);
10271  plsmaj(arg1,arg2);
10272 
10273  return SWIG_arg;
10274 
10275  if(0) SWIG_fail;
10276 
10277 fail:
10278  lua_error(L);
10279  return SWIG_arg;
10280 }
10281 
10282 
10283 static int _wrap_smin(lua_State* L) {
10284  int SWIG_arg = 0;
10285  PLFLT arg1 ;
10286  PLFLT arg2 ;
10287 
10288  SWIG_check_num_args("plsmin",2,2)
10289  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsmin",1,"PLFLT");
10290  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsmin",2,"PLFLT");
10291  arg1 = (PLFLT)lua_tonumber(L, 1);
10292  arg2 = (PLFLT)lua_tonumber(L, 2);
10293  plsmin(arg1,arg2);
10294 
10295  return SWIG_arg;
10296 
10297  if(0) SWIG_fail;
10298 
10299 fail:
10300  lua_error(L);
10301  return SWIG_arg;
10302 }
10303 
10304 
10305 static int _wrap_sori(lua_State* L) {
10306  int SWIG_arg = 0;
10307  PLINT arg1 ;
10308 
10309  SWIG_check_num_args("plsori",1,1)
10310  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsori",1,"PLINT");
10311  arg1 = (PLINT)lua_tonumber(L, 1);
10312  plsori(arg1);
10313 
10314  return SWIG_arg;
10315 
10316  if(0) SWIG_fail;
10317 
10318 fail:
10319  lua_error(L);
10320  return SWIG_arg;
10321 }
10322 
10323 
10324 static int _wrap_spage(lua_State* L) {
10325  int SWIG_arg = 0;
10326  PLFLT arg1 ;
10327  PLFLT arg2 ;
10328  PLINT arg3 ;
10329  PLINT arg4 ;
10330  PLINT arg5 ;
10331  PLINT arg6 ;
10332 
10333  SWIG_check_num_args("plspage",6,6)
10334  if(!lua_isnumber(L,1)) SWIG_fail_arg("plspage",1,"PLFLT");
10335  if(!lua_isnumber(L,2)) SWIG_fail_arg("plspage",2,"PLFLT");
10336  if(!lua_isnumber(L,3)) SWIG_fail_arg("plspage",3,"PLINT");
10337  if(!lua_isnumber(L,4)) SWIG_fail_arg("plspage",4,"PLINT");
10338  if(!lua_isnumber(L,5)) SWIG_fail_arg("plspage",5,"PLINT");
10339  if(!lua_isnumber(L,6)) SWIG_fail_arg("plspage",6,"PLINT");
10340  arg1 = (PLFLT)lua_tonumber(L, 1);
10341  arg2 = (PLFLT)lua_tonumber(L, 2);
10342  arg3 = (PLINT)lua_tonumber(L, 3);
10343  arg4 = (PLINT)lua_tonumber(L, 4);
10344  arg5 = (PLINT)lua_tonumber(L, 5);
10345  arg6 = (PLINT)lua_tonumber(L, 6);
10346  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
10347 
10348  return SWIG_arg;
10349 
10350  if(0) SWIG_fail;
10351 
10352 fail:
10353  lua_error(L);
10354  return SWIG_arg;
10355 }
10356 
10357 
10358 static int _wrap_spal0(lua_State* L) {
10359  int SWIG_arg = 0;
10360  char *arg1 = (char *) 0 ;
10361 
10362  SWIG_check_num_args("plspal0",1,1)
10363  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plspal0",1,"char const *");
10364  arg1 = (char *)lua_tostring(L, 1);
10365  plspal0((char const *)arg1);
10366 
10367  return SWIG_arg;
10368 
10369  if(0) SWIG_fail;
10370 
10371 fail:
10372  lua_error(L);
10373  return SWIG_arg;
10374 }
10375 
10376 
10377 static int _wrap_spal1(lua_State* L) {
10378  int SWIG_arg = 0;
10379  char *arg1 = (char *) 0 ;
10380  PLBOOL arg2 ;
10381 
10382  SWIG_check_num_args("plspal1",2,2)
10383  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plspal1",1,"char const *");
10384  if(!lua_isnumber(L,2)) SWIG_fail_arg("plspal1",2,"PLBOOL");
10385  arg1 = (char *)lua_tostring(L, 1);
10386  arg2 = (PLBOOL)lua_tonumber(L, 2);
10387  plspal1((char const *)arg1,arg2);
10388 
10389  return SWIG_arg;
10390 
10391  if(0) SWIG_fail;
10392 
10393 fail:
10394  lua_error(L);
10395  return SWIG_arg;
10396 }
10397 
10398 
10399 static int _wrap_spause(lua_State* L) {
10400  int SWIG_arg = 0;
10401  PLBOOL arg1 ;
10402 
10403  SWIG_check_num_args("plspause",1,1)
10404  if(!lua_isnumber(L,1)) SWIG_fail_arg("plspause",1,"PLBOOL");
10405  arg1 = (PLBOOL)lua_tonumber(L, 1);
10406  plspause(arg1);
10407 
10408  return SWIG_arg;
10409 
10410  if(0) SWIG_fail;
10411 
10412 fail:
10413  lua_error(L);
10414  return SWIG_arg;
10415 }
10416 
10417 
10418 static int _wrap_sstrm(lua_State* L) {
10419  int SWIG_arg = 0;
10420  PLINT arg1 ;
10421 
10422  SWIG_check_num_args("plsstrm",1,1)
10423  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsstrm",1,"PLINT");
10424  arg1 = (PLINT)lua_tonumber(L, 1);
10425  plsstrm(arg1);
10426 
10427  return SWIG_arg;
10428 
10429  if(0) SWIG_fail;
10430 
10431 fail:
10432  lua_error(L);
10433  return SWIG_arg;
10434 }
10435 
10436 
10437 static int _wrap_ssub(lua_State* L) {
10438  int SWIG_arg = 0;
10439  PLINT arg1 ;
10440  PLINT arg2 ;
10441 
10442  SWIG_check_num_args("plssub",2,2)
10443  if(!lua_isnumber(L,1)) SWIG_fail_arg("plssub",1,"PLINT");
10444  if(!lua_isnumber(L,2)) SWIG_fail_arg("plssub",2,"PLINT");
10445  arg1 = (PLINT)lua_tonumber(L, 1);
10446  arg2 = (PLINT)lua_tonumber(L, 2);
10447  plssub(arg1,arg2);
10448 
10449  return SWIG_arg;
10450 
10451  if(0) SWIG_fail;
10452 
10453 fail:
10454  lua_error(L);
10455  return SWIG_arg;
10456 }
10457 
10458 
10459 static int _wrap_ssym(lua_State* L) {
10460  int SWIG_arg = 0;
10461  PLFLT arg1 ;
10462  PLFLT arg2 ;
10463 
10464  SWIG_check_num_args("plssym",2,2)
10465  if(!lua_isnumber(L,1)) SWIG_fail_arg("plssym",1,"PLFLT");
10466  if(!lua_isnumber(L,2)) SWIG_fail_arg("plssym",2,"PLFLT");
10467  arg1 = (PLFLT)lua_tonumber(L, 1);
10468  arg2 = (PLFLT)lua_tonumber(L, 2);
10469  plssym(arg1,arg2);
10470 
10471  return SWIG_arg;
10472 
10473  if(0) SWIG_fail;
10474 
10475 fail:
10476  lua_error(L);
10477  return SWIG_arg;
10478 }
10479 
10480 
10481 static int _wrap_star(lua_State* L) {
10482  int SWIG_arg = 0;
10483  PLINT arg1 ;
10484  PLINT arg2 ;
10485 
10486  SWIG_check_num_args("plstar",2,2)
10487  if(!lua_isnumber(L,1)) SWIG_fail_arg("plstar",1,"PLINT");
10488  if(!lua_isnumber(L,2)) SWIG_fail_arg("plstar",2,"PLINT");
10489  arg1 = (PLINT)lua_tonumber(L, 1);
10490  arg2 = (PLINT)lua_tonumber(L, 2);
10491  plstar(arg1,arg2);
10492 
10493  return SWIG_arg;
10494 
10495  if(0) SWIG_fail;
10496 
10497 fail:
10498  lua_error(L);
10499  return SWIG_arg;
10500 }
10501 
10502 
10503 static int _wrap_start(lua_State* L) {
10504  int SWIG_arg = 0;
10505  char *arg1 = (char *) 0 ;
10506  PLINT arg2 ;
10507  PLINT arg3 ;
10508 
10509  SWIG_check_num_args("plstart",3,3)
10510  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plstart",1,"char const *");
10511  if(!lua_isnumber(L,2)) SWIG_fail_arg("plstart",2,"PLINT");
10512  if(!lua_isnumber(L,3)) SWIG_fail_arg("plstart",3,"PLINT");
10513  arg1 = (char *)lua_tostring(L, 1);
10514  arg2 = (PLINT)lua_tonumber(L, 2);
10515  arg3 = (PLINT)lua_tonumber(L, 3);
10516  plstart((char const *)arg1,arg2,arg3);
10517 
10518  return SWIG_arg;
10519 
10520  if(0) SWIG_fail;
10521 
10522 fail:
10523  lua_error(L);
10524  return SWIG_arg;
10525 }
10526 
10527 
10528 static int _wrap_stransform(lua_State* L) {
10529  int SWIG_arg = 0;
10530  ct_func arg1 = (ct_func) 0 ;
10531  PLPointer arg2 = (PLPointer) 0 ;
10532 
10533  {
10534  arg1 = NULL;
10535  myct_funcstr[0] = '\0';
10536  }
10537  {
10538  arg2 = NULL;
10539  }
10540  SWIG_check_num_args("plstransform",0,1)
10541  if(lua_gettop(L)>=1){
10542  {
10543  arg1 = NULL;
10544  myct_funcstr[0] = '\0';
10545 
10546  if ( lua_isstring( L, 1 ) )
10547  {
10548  const char* funcstr = lua_tostring( L, 1 );
10549  arg1 = myct;
10550  strncpy( myct_funcstr, funcstr, 255 );
10551  myL = L;
10552  }
10553  else
10554  SWIG_fail_arg( "stransform", 1, "ct_func" );
10555  }
10556  }
10557  plstransform(arg1,arg2);
10558 
10559  return SWIG_arg;
10560 
10561  if(0) SWIG_fail;
10562 
10563 fail:
10564  lua_error(L);
10565  return SWIG_arg;
10566 }
10567 
10568 
10569 static int _wrap_string(lua_State* L) {
10570  int SWIG_arg = 0;
10571  PLINT arg1 ;
10572  PLFLT *arg2 = (PLFLT *) 0 ;
10573  PLFLT *arg3 = (PLFLT *) 0 ;
10574  char *arg4 = (char *) 0 ;
10575  int temp3 ;
10576 
10577  SWIG_check_num_args("plstring",3,3)
10578  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("plstring",3,"char const *");
10579  {
10580  int temp;
10581  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
10582  if ( !arg2 )
10583  SWIG_fail;
10584  arg1 = Alen = temp;
10585  }
10586  {
10587  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
10588  if ( !arg3 )
10589  SWIG_fail;
10590  if ( temp3 != Alen )
10591  {
10592  lua_pushfstring( L, "Tables must be of same length." );
10593  SWIG_fail;
10594  }
10595  }
10596  arg4 = (char *)lua_tostring(L, 3);
10597  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
10598 
10599  {
10600  LUA_FREE_ARRAY( arg2 );
10601  }
10602  {
10603  LUA_FREE_ARRAY( arg3 );
10604  }
10605  return SWIG_arg;
10606 
10607  if(0) SWIG_fail;
10608 
10609 fail:
10610  {
10611  LUA_FREE_ARRAY( arg2 );
10612  }
10613  {
10614  LUA_FREE_ARRAY( arg3 );
10615  }
10616  lua_error(L);
10617  return SWIG_arg;
10618 }
10619 
10620 
10621 static int _wrap_string3(lua_State* L) {
10622  int SWIG_arg = 0;
10623  PLINT arg1 ;
10624  PLFLT *arg2 = (PLFLT *) 0 ;
10625  PLFLT *arg3 = (PLFLT *) 0 ;
10626  PLFLT *arg4 = (PLFLT *) 0 ;
10627  char *arg5 = (char *) 0 ;
10628  int temp3 ;
10629  int temp4 ;
10630 
10631  SWIG_check_num_args("plstring3",4,4)
10632  if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("plstring3",4,"char const *");
10633  {
10634  int temp;
10635  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
10636  if ( !arg2 )
10637  SWIG_fail;
10638  arg1 = Alen = temp;
10639  }
10640  {
10641  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
10642  if ( !arg3 )
10643  SWIG_fail;
10644  if ( temp3 != Alen )
10645  {
10646  lua_pushfstring( L, "Tables must be of same length." );
10647  SWIG_fail;
10648  }
10649  }
10650  {
10651  arg4 = (PLFLT *) LUA_get_double_num_array_var( L, 3, &temp4 );
10652  if ( !arg4 )
10653  SWIG_fail;
10654  if ( temp4 != Alen )
10655  {
10656  lua_pushfstring( L, "Tables must be of same length." );
10657  SWIG_fail;
10658  }
10659  }
10660  arg5 = (char *)lua_tostring(L, 4);
10661  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
10662 
10663  {
10664  LUA_FREE_ARRAY( arg2 );
10665  }
10666  {
10667  LUA_FREE_ARRAY( arg3 );
10668  }
10669  {
10670  LUA_FREE_ARRAY( arg4 );
10671  }
10672  return SWIG_arg;
10673 
10674  if(0) SWIG_fail;
10675 
10676 fail:
10677  {
10678  LUA_FREE_ARRAY( arg2 );
10679  }
10680  {
10681  LUA_FREE_ARRAY( arg3 );
10682  }
10683  {
10684  LUA_FREE_ARRAY( arg4 );
10685  }
10686  lua_error(L);
10687  return SWIG_arg;
10688 }
10689 
10690 
10691 static int _wrap_stripa(lua_State* L) {
10692  int SWIG_arg = 0;
10693  PLINT arg1 ;
10694  PLINT arg2 ;
10695  PLFLT arg3 ;
10696  PLFLT arg4 ;
10697 
10698  SWIG_check_num_args("plstripa",4,4)
10699  if(!lua_isnumber(L,1)) SWIG_fail_arg("plstripa",1,"PLINT");
10700  if(!lua_isnumber(L,2)) SWIG_fail_arg("plstripa",2,"PLINT");
10701  if(!lua_isnumber(L,3)) SWIG_fail_arg("plstripa",3,"PLFLT");
10702  if(!lua_isnumber(L,4)) SWIG_fail_arg("plstripa",4,"PLFLT");
10703  arg1 = (PLINT)lua_tonumber(L, 1);
10704  arg2 = (PLINT)lua_tonumber(L, 2);
10705  arg3 = (PLFLT)lua_tonumber(L, 3);
10706  arg4 = (PLFLT)lua_tonumber(L, 4);
10707  plstripa(arg1,arg2,arg3,arg4);
10708 
10709  return SWIG_arg;
10710 
10711  if(0) SWIG_fail;
10712 
10713 fail:
10714  lua_error(L);
10715  return SWIG_arg;
10716 }
10717 
10718 
10719 static int _wrap_stripc(lua_State* L) {
10720  int SWIG_arg = 0;
10721  PLINT *arg1 = (PLINT *) 0 ;
10722  char *arg2 = (char *) 0 ;
10723  char *arg3 = (char *) 0 ;
10724  PLFLT arg4 ;
10725  PLFLT arg5 ;
10726  PLFLT arg6 ;
10727  PLFLT arg7 ;
10728  PLFLT arg8 ;
10729  PLFLT arg9 ;
10730  PLFLT arg10 ;
10731  PLBOOL arg11 ;
10732  PLBOOL arg12 ;
10733  PLINT arg13 ;
10734  PLINT arg14 ;
10735  PLINT *arg15 = (PLINT *) 0 ;
10736  PLINT *arg16 = (PLINT *) 0 ;
10737  char **arg17 ;
10738  char *arg18 = (char *) 0 ;
10739  char *arg19 = (char *) 0 ;
10740  char *arg20 = (char *) 0 ;
10741  PLINT temp1 ;
10742  int temp15 ;
10743  int temp16 ;
10744 
10745  {
10746  arg17 = NULL;
10747  }
10748  arg1 = &temp1;
10749  SWIG_check_num_args("plstripc",15,19)
10750  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plstripc",1,"char const *");
10751  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plstripc",2,"char const *");
10752  if(!lua_isnumber(L,3)) SWIG_fail_arg("plstripc",3,"PLFLT");
10753  if(!lua_isnumber(L,4)) SWIG_fail_arg("plstripc",4,"PLFLT");
10754  if(!lua_isnumber(L,5)) SWIG_fail_arg("plstripc",5,"PLFLT");
10755  if(!lua_isnumber(L,6)) SWIG_fail_arg("plstripc",6,"PLFLT");
10756  if(!lua_isnumber(L,7)) SWIG_fail_arg("plstripc",7,"PLFLT");
10757  if(!lua_isnumber(L,8)) SWIG_fail_arg("plstripc",8,"PLFLT");
10758  if(!lua_isnumber(L,9)) SWIG_fail_arg("plstripc",9,"PLFLT");
10759  if(!lua_isnumber(L,10)) SWIG_fail_arg("plstripc",10,"PLBOOL");
10760  if(!lua_isnumber(L,11)) SWIG_fail_arg("plstripc",11,"PLBOOL");
10761  if(!lua_isnumber(L,12)) SWIG_fail_arg("plstripc",12,"PLINT");
10762  if(!lua_isnumber(L,13)) SWIG_fail_arg("plstripc",13,"PLINT");
10763  if(lua_gettop(L)>=16 && !lua_istable(L,16)) SWIG_fail_arg("plstripc",16,"char const *[4]");
10764  if(lua_gettop(L)>=17 && !SWIG_lua_isnilstring(L,17)) SWIG_fail_arg("plstripc",17,"char const *");
10765  if(lua_gettop(L)>=18 && !SWIG_lua_isnilstring(L,18)) SWIG_fail_arg("plstripc",18,"char const *");
10766  if(lua_gettop(L)>=19 && !SWIG_lua_isnilstring(L,19)) SWIG_fail_arg("plstripc",19,"char const *");
10767  arg2 = (char *)lua_tostring(L, 1);
10768  arg3 = (char *)lua_tostring(L, 2);
10769  arg4 = (PLFLT)lua_tonumber(L, 3);
10770  arg5 = (PLFLT)lua_tonumber(L, 4);
10771  arg6 = (PLFLT)lua_tonumber(L, 5);
10772  arg7 = (PLFLT)lua_tonumber(L, 6);
10773  arg8 = (PLFLT)lua_tonumber(L, 7);
10774  arg9 = (PLFLT)lua_tonumber(L, 8);
10775  arg10 = (PLFLT)lua_tonumber(L, 9);
10776  arg11 = (PLBOOL)lua_tonumber(L, 10);
10777  arg12 = (PLBOOL)lua_tonumber(L, 11);
10778  arg13 = (PLINT)lua_tonumber(L, 12);
10779  arg14 = (PLINT)lua_tonumber(L, 13);
10780  {
10781  arg15 = (PLINT *) LUA_get_int_num_array_var( L, 14, &temp15 );
10782  if ( !arg15 )
10783  SWIG_fail;
10784  Alen = temp15;
10785  }
10786  {
10787  arg16 = (PLINT *) LUA_get_int_num_array_var( L, 15, &temp16 );
10788  if ( !arg16 )
10789  SWIG_fail;
10790  if ( temp16 != Alen )
10791  {
10792  lua_pushfstring( L, "Tables must be of same length." );
10793  SWIG_fail;
10794  }
10795  }
10796  if(lua_gettop(L)>=16){
10797  {
10798  int i;
10799  arg17 = NULL;
10800 
10801  if ( SWIG_table_size( L, 16 ) != 4 )
10802  {
10803  lua_pushfstring( L, "Requires a sequence of 4 strings." );
10804  SWIG_fail;
10805  }
10806  if ( Alen != 4 )
10807  {
10808  lua_pushfstring( L, "colline and styline args must be length 4." );
10809  SWIG_fail;
10810  }
10811 
10812  arg17 = malloc( sizeof ( char* ) * 4 );
10813  for ( i = 1; i <= 4; i++ )
10814  {
10815  lua_rawgeti( L, 16, i );
10816  if ( lua_isstring( L, -1 ) )
10817  {
10818  arg17[i - 1] = (char *) lua_tostring( L, -1 );
10819  }
10820  else
10821  {
10822  lua_pop( L, 1 );
10823  lua_pushfstring( L, "Requires a sequence of 4 strings." );
10824  SWIG_fail;
10825  // arg17 array is freed after 'fail:'
10826  }
10827  lua_pop( L, 1 );
10828  }
10829  }
10830  }
10831  if(lua_gettop(L)>=17){
10832  arg18 = (char *)lua_tostring(L, 17);
10833  }
10834  if(lua_gettop(L)>=18){
10835  arg19 = (char *)lua_tostring(L, 18);
10836  }
10837  if(lua_gettop(L)>=19){
10838  arg20 = (char *)lua_tostring(L, 19);
10839  }
10840  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);
10841 
10842  lua_pushnumber(L, (lua_Number) *arg1); SWIG_arg++;
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  return SWIG_arg;
10856 
10857  if(0) SWIG_fail;
10858 
10859 fail:
10860  {
10861  LUA_FREE_ARRAY( arg15 );
10862  }
10863  {
10864  LUA_FREE_ARRAY( arg16 );
10865  }
10866  {
10867  if ( arg17 )
10868  {
10869  free( arg17 ); arg17 = NULL;
10870  }
10871  }
10872  lua_error(L);
10873  return SWIG_arg;
10874 }
10875 
10876 
10877 static int _wrap_stripd(lua_State* L) {
10878  int SWIG_arg = 0;
10879  PLINT arg1 ;
10880 
10881  SWIG_check_num_args("plstripd",1,1)
10882  if(!lua_isnumber(L,1)) SWIG_fail_arg("plstripd",1,"PLINT");
10883  arg1 = (PLINT)lua_tonumber(L, 1);
10884  plstripd(arg1);
10885 
10886  return SWIG_arg;
10887 
10888  if(0) SWIG_fail;
10889 
10890 fail:
10891  lua_error(L);
10892  return SWIG_arg;
10893 }
10894 
10895 
10896 static int _wrap_styl(lua_State* L) {
10897  int SWIG_arg = 0;
10898  PLINT arg1 ;
10899  PLINT *arg2 = (PLINT *) 0 ;
10900  PLINT *arg3 = (PLINT *) 0 ;
10901  int temp3 ;
10902 
10903  SWIG_check_num_args("plstyl",2,2)
10904  {
10905  arg2 = (PLINT *) LUA_get_int_num_array_var( L, 1, &arg1 );
10906  if ( !arg2 )
10907  SWIG_fail;
10908  Alen = arg1;
10909  }
10910  {
10911  arg3 = (PLINT *) LUA_get_int_num_array_var( L, 2, &temp3 );
10912  if ( !arg3 )
10913  SWIG_fail;
10914  if ( temp3 != Alen )
10915  {
10916  lua_pushfstring( L, "Tables must be of same length." );
10917  SWIG_fail;
10918  }
10919  }
10920  plstyl(arg1,(int const *)arg2,(int const *)arg3);
10921 
10922  {
10923  LUA_FREE_ARRAY( arg2 );
10924  }
10925  {
10926  LUA_FREE_ARRAY( arg3 );
10927  }
10928  return SWIG_arg;
10929 
10930  if(0) SWIG_fail;
10931 
10932 fail:
10933  {
10934  LUA_FREE_ARRAY( arg2 );
10935  }
10936  {
10937  LUA_FREE_ARRAY( arg3 );
10938  }
10939  lua_error(L);
10940  return SWIG_arg;
10941 }
10942 
10943 
10944 static int _wrap_svect(lua_State* L) {
10945  int SWIG_arg = 0;
10946  PLFLT *arg1 = (PLFLT *) 0 ;
10947  PLFLT *arg2 = (PLFLT *) 0 ;
10948  PLINT arg3 ;
10949  PLBOOL arg4 ;
10950 
10951  {
10952  arg2 = NULL; arg3 = 0;
10953  }
10954  {
10955  arg4 = 0;
10956  }
10957  SWIG_check_num_args("plsvect",1,3)
10958  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("plsvect",3,"PLBOOL");
10959  {
10960  int temp;
10961  if ( lua_isnil( L, 1 ) )
10962  {
10963  arg1 = NULL;
10964  Alen = 0;
10965  }
10966  else
10967  {
10968  arg1 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
10969  if ( !arg1 )
10970  SWIG_fail;
10971  Alen = temp;
10972  }
10973  }
10974  if(lua_gettop(L)>=2){
10975  {
10976  int temp = 0;
10977  if ( lua_isnil( L, 2 ) )
10978  {
10979  arg2 = NULL;
10980  }
10981  else
10982  {
10983  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp );
10984  if ( !arg2 )
10985  SWIG_fail;
10986  if ( temp != Alen )
10987  {
10988  lua_pushfstring( L, "Tables must be of same length." );
10989  SWIG_fail;
10990  }
10991  }
10992  arg3 = temp;
10993  }
10994  }
10995  if(lua_gettop(L)>=3){
10996  arg4 = (PLBOOL)lua_tonumber(L, 3);
10997  }
10998  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
10999 
11000  {
11001  LUA_FREE_ARRAY( arg2 );
11002  }
11003  return SWIG_arg;
11004 
11005  if(0) SWIG_fail;
11006 
11007 fail:
11008  {
11009  LUA_FREE_ARRAY( arg2 );
11010  }
11011  lua_error(L);
11012  return SWIG_arg;
11013 }
11014 
11015 
11016 static int _wrap_svpa(lua_State* L) {
11017  int SWIG_arg = 0;
11018  PLFLT arg1 ;
11019  PLFLT arg2 ;
11020  PLFLT arg3 ;
11021  PLFLT arg4 ;
11022 
11023  SWIG_check_num_args("plsvpa",4,4)
11024  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsvpa",1,"PLFLT");
11025  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsvpa",2,"PLFLT");
11026  if(!lua_isnumber(L,3)) SWIG_fail_arg("plsvpa",3,"PLFLT");
11027  if(!lua_isnumber(L,4)) SWIG_fail_arg("plsvpa",4,"PLFLT");
11028  arg1 = (PLFLT)lua_tonumber(L, 1);
11029  arg2 = (PLFLT)lua_tonumber(L, 2);
11030  arg3 = (PLFLT)lua_tonumber(L, 3);
11031  arg4 = (PLFLT)lua_tonumber(L, 4);
11032  plsvpa(arg1,arg2,arg3,arg4);
11033 
11034  return SWIG_arg;
11035 
11036  if(0) SWIG_fail;
11037 
11038 fail:
11039  lua_error(L);
11040  return SWIG_arg;
11041 }
11042 
11043 
11044 static int _wrap_sxax(lua_State* L) {
11045  int SWIG_arg = 0;
11046  PLINT arg1 ;
11047  PLINT arg2 ;
11048 
11049  SWIG_check_num_args("plsxax",2,2)
11050  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsxax",1,"PLINT");
11051  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsxax",2,"PLINT");
11052  arg1 = (PLINT)lua_tonumber(L, 1);
11053  arg2 = (PLINT)lua_tonumber(L, 2);
11054  plsxax(arg1,arg2);
11055 
11056  return SWIG_arg;
11057 
11058  if(0) SWIG_fail;
11059 
11060 fail:
11061  lua_error(L);
11062  return SWIG_arg;
11063 }
11064 
11065 
11066 static int _wrap_syax(lua_State* L) {
11067  int SWIG_arg = 0;
11068  PLINT arg1 ;
11069  PLINT arg2 ;
11070 
11071  SWIG_check_num_args("plsyax",2,2)
11072  if(!lua_isnumber(L,1)) SWIG_fail_arg("plsyax",1,"PLINT");
11073  if(!lua_isnumber(L,2)) SWIG_fail_arg("plsyax",2,"PLINT");
11074  arg1 = (PLINT)lua_tonumber(L, 1);
11075  arg2 = (PLINT)lua_tonumber(L, 2);
11076  plsyax(arg1,arg2);
11077 
11078  return SWIG_arg;
11079 
11080  if(0) SWIG_fail;
11081 
11082 fail:
11083  lua_error(L);
11084  return SWIG_arg;
11085 }
11086 
11087 
11088 static int _wrap_sym(lua_State* L) {
11089  int SWIG_arg = 0;
11090  PLINT arg1 ;
11091  PLFLT *arg2 = (PLFLT *) 0 ;
11092  PLFLT *arg3 = (PLFLT *) 0 ;
11093  PLINT arg4 ;
11094  int temp3 ;
11095 
11096  SWIG_check_num_args("plsym",3,3)
11097  if(!lua_isnumber(L,3)) SWIG_fail_arg("plsym",3,"PLINT");
11098  {
11099  int temp;
11100  arg2 = (PLFLT *) LUA_get_double_num_array_var( L, 1, &temp );
11101  if ( !arg2 )
11102  SWIG_fail;
11103  arg1 = Alen = temp;
11104  }
11105  {
11106  arg3 = (PLFLT *) LUA_get_double_num_array_var( L, 2, &temp3 );
11107  if ( !arg3 )
11108  SWIG_fail;
11109  if ( temp3 != Alen )
11110  {
11111  lua_pushfstring( L, "Tables must be of same length." );
11112  SWIG_fail;
11113  }
11114  }
11115  arg4 = (PLINT)lua_tonumber(L, 3);
11116  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
11117 
11118  {
11119  LUA_FREE_ARRAY( arg2 );
11120  }
11121  {
11122  LUA_FREE_ARRAY( arg3 );
11123  }
11124  return SWIG_arg;
11125 
11126  if(0) SWIG_fail;
11127 
11128 fail:
11129  {
11130  LUA_FREE_ARRAY( arg2 );
11131  }
11132  {
11133  LUA_FREE_ARRAY( arg3 );
11134  }
11135  lua_error(L);
11136  return SWIG_arg;
11137 }
11138 
11139 
11140 static int _wrap_szax(lua_State* L) {
11141  int SWIG_arg = 0;
11142  PLINT arg1 ;
11143  PLINT arg2 ;
11144 
11145  SWIG_check_num_args("plszax",2,2)
11146  if(!lua_isnumber(L,1)) SWIG_fail_arg("plszax",1,"PLINT");
11147  if(!lua_isnumber(L,2)) SWIG_fail_arg("plszax",2,"PLINT");
11148  arg1 = (PLINT)lua_tonumber(L, 1);
11149  arg2 = (PLINT)lua_tonumber(L, 2);
11150  plszax(arg1,arg2);
11151 
11152  return SWIG_arg;
11153 
11154  if(0) SWIG_fail;
11155 
11156 fail:
11157  lua_error(L);
11158  return SWIG_arg;
11159 }
11160 
11161 
11162 static int _wrap_text(lua_State* L) {
11163  int SWIG_arg = 0;
11164 
11165  SWIG_check_num_args("pltext",0,0)
11166  pltext();
11167 
11168  return SWIG_arg;
11169 
11170  if(0) SWIG_fail;
11171 
11172 fail:
11173  lua_error(L);
11174  return SWIG_arg;
11175 }
11176 
11177 
11178 static int _wrap_timefmt(lua_State* L) {
11179  int SWIG_arg = 0;
11180  char *arg1 = (char *) 0 ;
11181 
11182  SWIG_check_num_args("pltimefmt",1,1)
11183  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("pltimefmt",1,"char const *");
11184  arg1 = (char *)lua_tostring(L, 1);
11185  pltimefmt((char const *)arg1);
11186 
11187  return SWIG_arg;
11188 
11189  if(0) SWIG_fail;
11190 
11191 fail:
11192  lua_error(L);
11193  return SWIG_arg;
11194 }
11195 
11196 
11197 static int _wrap_vasp(lua_State* L) {
11198  int SWIG_arg = 0;
11199  PLFLT arg1 ;
11200 
11201  SWIG_check_num_args("plvasp",1,1)
11202  if(!lua_isnumber(L,1)) SWIG_fail_arg("plvasp",1,"PLFLT");
11203  arg1 = (PLFLT)lua_tonumber(L, 1);
11204  plvasp(arg1);
11205 
11206  return SWIG_arg;
11207 
11208  if(0) SWIG_fail;
11209 
11210 fail:
11211  lua_error(L);
11212  return SWIG_arg;
11213 }
11214 
11215 
11216 static int _wrap_vect(lua_State* L) {
11217  int SWIG_arg = 0;
11218  PLFLT **arg1 = (PLFLT **) 0 ;
11219  PLFLT **arg2 = (PLFLT **) 0 ;
11220  PLINT arg3 ;
11221  PLINT arg4 ;
11222  PLFLT arg5 ;
11223  pltr_func arg6 = (pltr_func) 0 ;
11224  PLPointer arg7 = (PLPointer) 0 ;
11225  int ii1 ;
11226  int ii2 ;
11227  PLcGrid cgrid17 ;
11228  PLcGrid2 cgrid27 ;
11229 
11230  {
11231  cgrid17.xg = cgrid17.yg = cgrid17.zg = NULL;
11232  cgrid17.nx = cgrid17.ny = cgrid17.nz = 0;
11233  cgrid27.xg = cgrid27.yg = cgrid27.zg = NULL;
11234  cgrid27.nx = cgrid27.ny = 0;
11235  }
11236  {
11237  arg6 = NULL;
11238  }
11239  {
11240  arg7 = NULL;
11241  }
11242  SWIG_check_num_args("plvect",3,5)
11243  if(!lua_isnumber(L,3)) SWIG_fail_arg("plvect",3,"PLFLT");
11244  {
11245  int jj;
11246 
11247  arg1 = read_double_Matrix( L, 1, &ii1, &jj );
11248  if ( !arg1 )
11249  SWIG_fail;
11250  Xlen = ii1;
11251  Ylen = jj;
11252  }
11253  {
11254  int jj;
11255 
11256  arg2 = read_double_Matrix( L, 2, &ii2, &jj );
11257  if ( !arg2 )
11258  SWIG_fail;
11259  arg3 = ii2;
11260  arg4 = jj;
11261  if ( ( arg3 != Xlen ) || ( arg4 != Ylen ) )
11262  {
11263  lua_pushfstring( L, "Vectors must match matrix." );
11264  SWIG_fail;
11265  }
11266  }
11267  arg5 = (PLFLT)lua_tonumber(L, 3);
11268  if(lua_gettop(L)>=4){
11269  {
11270  arg6 = NULL;
11271  mypltr_funcstr[0] = '\0';
11272 
11273  if ( lua_isstring( L, 4 ) )
11274  {
11275  const char* funcstr = lua_tostring( L, 4 );
11276  if ( strcmp( "pltr0", funcstr ) == 0 )
11277  {
11278  arg6 = pltr0;
11279  }
11280  else if ( strcmp( "pltr1", funcstr ) == 0 )
11281  {
11282  arg6 = pltr1;
11283  }
11284  else if ( strcmp( "pltr2", funcstr ) == 0 )
11285  {
11286  arg6 = pltr2;
11287  }
11288  else
11289  {
11290  arg6 = mypltr;
11291  strncpy( mypltr_funcstr, funcstr, 255 );
11292  myL = L;
11293  }
11294  }
11295  else
11296  SWIG_fail_arg( "vect", 6, "pltr_func" );
11297  }
11298  }
11299  if(lua_gettop(L)>=5){
11300  {
11301  int nx, ny;
11302  int gridmode = 0;
11303 
11304  lua_pushstring( L, "xg" );
11305  lua_gettable( L, 5 );
11306  if ( !lua_istable( L, -1 ) )
11307  {
11308  lua_pop( L, 1 ); // pop "xg"
11309  lua_pushstring( L, "expected a table xg" );
11310  SWIG_fail;
11311  }
11312  lua_rawgeti( L, -1, 1 );
11313  if ( lua_istable( L, -1 ) )
11314  gridmode = 2; // two dimensional array
11315  else if ( lua_isnumber( L, -1 ) )
11316  gridmode = 1; // one dimensional array
11317  else
11318  {
11319  lua_pop( L, 1 ); // pop "1"
11320  lua_pop( L, 1 ); // pop "xg"
11321  lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
11322  SWIG_fail;
11323  }
11324  lua_pop( L, 1 ); // pop test element
11325  if ( gridmode == 1 )
11326  {
11327  cgrid17.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
11328  if ( !cgrid17.xg )
11329  {
11330  lua_pop( L, 1 ); // pop "xg"
11331  SWIG_fail;
11332  }
11333  if ( nx != Xlen )
11334  {
11335  lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
11336  SWIG_fail;
11337  }
11338  cgrid17.nx = nx;
11339  }
11340  else
11341  {
11342  cgrid27.xg = read_double_Matrix( L, -1, &nx, &ny );
11343  if ( !cgrid27.xg )
11344  {
11345  lua_pop( L, 1 ); // pop "xg"
11346  SWIG_fail;
11347  }
11348  if ( ( nx != Xlen ) || ( ny != Ylen ) )
11349  {
11350  lua_pop( L, 1 ); // pop "xg"
11351  lua_pushfstring( L, "Vectors must match matrix." );
11352  SWIG_fail;
11353  }
11354  cgrid27.nx = nx;
11355  cgrid27.ny = ny;
11356  }
11357  lua_pop( L, 1 ); // pop "xg"
11358 
11359  lua_pushstring( L, "yg" );
11360  lua_gettable( L, 5 );
11361  if ( !lua_istable( L, -1 ) )
11362  {
11363  lua_pop( L, 1 );
11364  lua_pushstring( L, "expected a table yg" );
11365  SWIG_fail;
11366  }
11367  lua_rawgeti( L, -1, 1 );
11368  if ( gridmode == 2 )
11369  {
11370  if ( !lua_istable( L, -1 ) )
11371  {
11372  lua_pop( L, 1 ); // pop "1"
11373  lua_pop( L, 1 ); // pop "yg"
11374  lua_pushstring( L, "expected a two dimensional array/table in yg" );
11375  SWIG_fail;
11376  }
11377  }
11378  else
11379  {
11380  if ( !lua_isnumber( L, -1 ) )
11381  {
11382  lua_pop( L, 1 ); // pop "1"
11383  lua_pop( L, 1 ); // pop "yg"
11384  lua_pushstring( L, "expected a one dimensional array/table in yg" );
11385  SWIG_fail;
11386  }
11387  }
11388  lua_pop( L, 1 ); // pop "1"
11389  if ( gridmode == 1 )
11390  {
11391  cgrid17.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
11392  if ( !cgrid17.yg )
11393  {
11394  lua_pop( L, 1 ); // pop "yg"
11395  SWIG_fail;
11396  }
11397  if ( ny != Ylen )
11398  {
11399  lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
11400  SWIG_fail;
11401  }
11402  cgrid17.ny = ny;
11403  }
11404  else
11405  {
11406  cgrid27.yg = read_double_Matrix( L, -1, &nx, &ny );
11407  if ( !cgrid27.yg )
11408  {
11409  lua_pop( L, 1 ); // pop "xg"
11410  SWIG_fail;
11411  }
11412  if ( ( nx != Xlen ) || ( ny != Ylen ) )
11413  {
11414  lua_pop( L, 1 ); // pop "xg"
11415  lua_pushfstring( L, "Vectors must match matrix." );
11416  SWIG_fail;
11417  }
11418  // cgrid27.nx/ny already set
11419  }
11420  lua_pop( L, 1 ); // pop "yg"
11421 
11422  if ( gridmode == 1 )
11423  arg7 = &cgrid17;
11424  else if ( gridmode == 2 )
11425  arg7 = &cgrid27;
11426  }
11427  }
11428  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
11429 
11430  {
11431  int i;
11432 
11433  if ( arg1 )
11434  {
11435  for ( i = 0; i < ii1; i++ )
11436  LUA_FREE_ARRAY( arg1[i] );
11437  LUA_FREE_ARRAY( arg1 );
11438  }
11439  }
11440  {
11441  int i;
11442 
11443  if ( arg2 )
11444  {
11445  for ( i = 0; i < ii2; i++ )
11446  LUA_FREE_ARRAY( arg2[i] );
11447  LUA_FREE_ARRAY( arg2 );
11448  }
11449  }
11450  {
11451  mypltr_funcstr[0] = '\0';
11452  }
11453  {
11454  int i;
11455 
11456  LUA_FREE_ARRAY( cgrid17.xg );
11457  LUA_FREE_ARRAY( cgrid17.yg );
11458 
11459  if ( cgrid27.xg )
11460  {
11461  for ( i = 0; i < Xlen; i++ )
11462  LUA_FREE_ARRAY( cgrid27.xg[i] );
11463  LUA_FREE_ARRAY( cgrid27.xg );
11464  }
11465  if ( cgrid27.yg )
11466  {
11467  for ( i = 0; i < Xlen; i++ )
11468  LUA_FREE_ARRAY( cgrid27.yg[i] );
11469  LUA_FREE_ARRAY( cgrid27.yg );
11470  }
11471  }
11472  return SWIG_arg;
11473 
11474  if(0) SWIG_fail;
11475 
11476 fail:
11477  {
11478  int i;
11479 
11480  if ( arg1 )
11481  {
11482  for ( i = 0; i < ii1; i++ )
11483  LUA_FREE_ARRAY( arg1[i] );
11484  LUA_FREE_ARRAY( arg1 );
11485  }
11486  }
11487  {
11488  int i;
11489 
11490  if ( arg2 )
11491  {
11492  for ( i = 0; i < ii2; i++ )
11493  LUA_FREE_ARRAY( arg2[i] );
11494  LUA_FREE_ARRAY( arg2 );
11495  }
11496  }
11497  {
11498  mypltr_funcstr[0] = '\0';
11499  }
11500  {
11501  int i;
11502 
11503  LUA_FREE_ARRAY( cgrid17.xg );
11504  LUA_FREE_ARRAY( cgrid17.yg );
11505 
11506  if ( cgrid27.xg )
11507  {
11508  for ( i = 0; i < Xlen; i++ )
11509  LUA_FREE_ARRAY( cgrid27.xg[i] );
11510  LUA_FREE_ARRAY( cgrid27.xg );
11511  }
11512  if ( cgrid27.yg )
11513  {
11514  for ( i = 0; i < Xlen; i++ )
11515  LUA_FREE_ARRAY( cgrid27.yg[i] );
11516  LUA_FREE_ARRAY( cgrid27.yg );
11517  }
11518  }
11519  lua_error(L);
11520  return SWIG_arg;
11521 }
11522 
11523 
11524 static int _wrap_vpas(lua_State* L) {
11525  int SWIG_arg = 0;
11526  PLFLT arg1 ;
11527  PLFLT arg2 ;
11528  PLFLT arg3 ;
11529  PLFLT arg4 ;
11530  PLFLT arg5 ;
11531 
11532  SWIG_check_num_args("plvpas",5,5)
11533  if(!lua_isnumber(L,1)) SWIG_fail_arg("plvpas",1,"PLFLT");
11534  if(!lua_isnumber(L,2)) SWIG_fail_arg("plvpas",2,"PLFLT");
11535  if(!lua_isnumber(L,3)) SWIG_fail_arg("plvpas",3,"PLFLT");
11536  if(!lua_isnumber(L,4)) SWIG_fail_arg("plvpas",4,"PLFLT");
11537  if(!lua_isnumber(L,5)) SWIG_fail_arg("plvpas",5,"PLFLT");
11538  arg1 = (PLFLT)lua_tonumber(L, 1);
11539  arg2 = (PLFLT)lua_tonumber(L, 2);
11540  arg3 = (PLFLT)lua_tonumber(L, 3);
11541  arg4 = (PLFLT)lua_tonumber(L, 4);
11542  arg5 = (PLFLT)lua_tonumber(L, 5);
11543  plvpas(arg1,arg2,arg3,arg4,arg5);
11544 
11545  return SWIG_arg;
11546 
11547  if(0) SWIG_fail;
11548 
11549 fail:
11550  lua_error(L);
11551  return SWIG_arg;
11552 }
11553 
11554 
11555 static int _wrap_vpor(lua_State* L) {
11556  int SWIG_arg = 0;
11557  PLFLT arg1 ;
11558  PLFLT arg2 ;
11559  PLFLT arg3 ;
11560  PLFLT arg4 ;
11561 
11562  SWIG_check_num_args("plvpor",4,4)
11563  if(!lua_isnumber(L,1)) SWIG_fail_arg("plvpor",1,"PLFLT");
11564  if(!lua_isnumber(L,2)) SWIG_fail_arg("plvpor",2,"PLFLT");
11565  if(!lua_isnumber(L,3)) SWIG_fail_arg("plvpor",3,"PLFLT");
11566  if(!lua_isnumber(L,4)) SWIG_fail_arg("plvpor",4,"PLFLT");
11567  arg1 = (PLFLT)lua_tonumber(L, 1);
11568  arg2 = (PLFLT)lua_tonumber(L, 2);
11569  arg3 = (PLFLT)lua_tonumber(L, 3);
11570  arg4 = (PLFLT)lua_tonumber(L, 4);
11571  plvpor(arg1,arg2,arg3,arg4);
11572 
11573  return SWIG_arg;
11574 
11575  if(0) SWIG_fail;
11576 
11577 fail:
11578  lua_error(L);
11579  return SWIG_arg;
11580 }
11581 
11582 
11583 static int _wrap_vsta(lua_State* L) {
11584  int SWIG_arg = 0;
11585 
11586  SWIG_check_num_args("plvsta",0,0)
11587  plvsta();
11588 
11589  return SWIG_arg;
11590 
11591  if(0) SWIG_fail;
11592 
11593 fail:
11594  lua_error(L);
11595  return SWIG_arg;
11596 }
11597 
11598 
11599 static int _wrap_w3d(lua_State* L) {
11600  int SWIG_arg = 0;
11601  PLFLT arg1 ;
11602  PLFLT arg2 ;
11603  PLFLT arg3 ;
11604  PLFLT arg4 ;
11605  PLFLT arg5 ;
11606  PLFLT arg6 ;
11607  PLFLT arg7 ;
11608  PLFLT arg8 ;
11609  PLFLT arg9 ;
11610  PLFLT arg10 ;
11611  PLFLT arg11 ;
11612 
11613  SWIG_check_num_args("plw3d",11,11)
11614  if(!lua_isnumber(L,1)) SWIG_fail_arg("plw3d",1,"PLFLT");
11615  if(!lua_isnumber(L,2)) SWIG_fail_arg("plw3d",2,"PLFLT");
11616  if(!lua_isnumber(L,3)) SWIG_fail_arg("plw3d",3,"PLFLT");
11617  if(!lua_isnumber(L,4)) SWIG_fail_arg("plw3d",4,"PLFLT");
11618  if(!lua_isnumber(L,5)) SWIG_fail_arg("plw3d",5,"PLFLT");
11619  if(!lua_isnumber(L,6)) SWIG_fail_arg("plw3d",6,"PLFLT");
11620  if(!lua_isnumber(L,7)) SWIG_fail_arg("plw3d",7,"PLFLT");
11621  if(!lua_isnumber(L,8)) SWIG_fail_arg("plw3d",8,"PLFLT");
11622  if(!lua_isnumber(L,9)) SWIG_fail_arg("plw3d",9,"PLFLT");
11623  if(!lua_isnumber(L,10)) SWIG_fail_arg("plw3d",10,"PLFLT");
11624  if(!lua_isnumber(L,11)) SWIG_fail_arg("plw3d",11,"PLFLT");
11625  arg1 = (PLFLT)lua_tonumber(L, 1);
11626  arg2 = (PLFLT)lua_tonumber(L, 2);
11627  arg3 = (PLFLT)lua_tonumber(L, 3);
11628  arg4 = (PLFLT)lua_tonumber(L, 4);
11629  arg5 = (PLFLT)lua_tonumber(L, 5);
11630  arg6 = (PLFLT)lua_tonumber(L, 6);
11631  arg7 = (PLFLT)lua_tonumber(L, 7);
11632  arg8 = (PLFLT)lua_tonumber(L, 8);
11633  arg9 = (PLFLT)lua_tonumber(L, 9);
11634  arg10 = (PLFLT)lua_tonumber(L, 10);
11635  arg11 = (PLFLT)lua_tonumber(L, 11);
11636  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11637 
11638  return SWIG_arg;
11639 
11640  if(0) SWIG_fail;
11641 
11642 fail:
11643  lua_error(L);
11644  return SWIG_arg;
11645 }
11646 
11647 
11648 static int _wrap_width(lua_State* L) {
11649  int SWIG_arg = 0;
11650  PLFLT arg1 ;
11651 
11652  SWIG_check_num_args("plwidth",1,1)
11653  if(!lua_isnumber(L,1)) SWIG_fail_arg("plwidth",1,"PLFLT");
11654  arg1 = (PLFLT)lua_tonumber(L, 1);
11655  plwidth(arg1);
11656 
11657  return SWIG_arg;
11658 
11659  if(0) SWIG_fail;
11660 
11661 fail:
11662  lua_error(L);
11663  return SWIG_arg;
11664 }
11665 
11666 
11667 static int _wrap_wind(lua_State* L) {
11668  int SWIG_arg = 0;
11669  PLFLT arg1 ;
11670  PLFLT arg2 ;
11671  PLFLT arg3 ;
11672  PLFLT arg4 ;
11673 
11674  SWIG_check_num_args("plwind",4,4)
11675  if(!lua_isnumber(L,1)) SWIG_fail_arg("plwind",1,"PLFLT");
11676  if(!lua_isnumber(L,2)) SWIG_fail_arg("plwind",2,"PLFLT");
11677  if(!lua_isnumber(L,3)) SWIG_fail_arg("plwind",3,"PLFLT");
11678  if(!lua_isnumber(L,4)) SWIG_fail_arg("plwind",4,"PLFLT");
11679  arg1 = (PLFLT)lua_tonumber(L, 1);
11680  arg2 = (PLFLT)lua_tonumber(L, 2);
11681  arg3 = (PLFLT)lua_tonumber(L, 3);
11682  arg4 = (PLFLT)lua_tonumber(L, 4);
11683  plwind(arg1,arg2,arg3,arg4);
11684 
11685  return SWIG_arg;
11686 
11687  if(0) SWIG_fail;
11688 
11689 fail:
11690  lua_error(L);
11691  return SWIG_arg;
11692 }
11693 
11694 
11695 static int _wrap_xormod(lua_State* L) {
11696  int SWIG_arg = 0;
11697  PLBOOL arg1 ;
11698  PLBOOL *arg2 = (PLBOOL *) 0 ;
11699  PLBOOL temp2 ;
11700 
11701  arg2 = &temp2;
11702  SWIG_check_num_args("plxormod",1,1)
11703  if(!lua_isnumber(L,1)) SWIG_fail_arg("plxormod",1,"PLBOOL");
11704  arg1 = (PLBOOL)lua_tonumber(L, 1);
11705  plxormod(arg1,arg2);
11706 
11707  lua_pushnumber(L, (lua_Number) *arg2); SWIG_arg++;
11708  return SWIG_arg;
11709 
11710  if(0) SWIG_fail;
11711 
11712 fail:
11713  lua_error(L);
11714  return SWIG_arg;
11715 }
11716 
11717 
11718 static int _wrap_map(lua_State* L) {
11719  int SWIG_arg = 0;
11720  mapform_func arg1 = (mapform_func) 0 ;
11721  char *arg2 = (char *) 0 ;
11722  PLFLT arg3 ;
11723  PLFLT arg4 ;
11724  PLFLT arg5 ;
11725  PLFLT arg6 ;
11726 
11727  SWIG_check_num_args("plmap",6,6)
11728  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmap",2,"char const *");
11729  if(!lua_isnumber(L,3)) SWIG_fail_arg("plmap",3,"PLFLT");
11730  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmap",4,"PLFLT");
11731  if(!lua_isnumber(L,5)) SWIG_fail_arg("plmap",5,"PLFLT");
11732  if(!lua_isnumber(L,6)) SWIG_fail_arg("plmap",6,"PLFLT");
11733  {
11734  arg1 = NULL;
11735  mapform_funcstr[0] = '\0';
11736 
11737  if ( lua_isnil( L, 1 ) )
11738  {
11739  arg1 = NULL;
11740  }
11741  else if ( lua_isstring( L, 1 ) )
11742  {
11743  arg1 = mapform;
11744  strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
11745  myL = L;
11746  }
11747  else
11748  SWIG_fail_arg( "map", 1, "mapform_func" );
11749  }
11750  arg2 = (char *)lua_tostring(L, 2);
11751  arg3 = (PLFLT)lua_tonumber(L, 3);
11752  arg4 = (PLFLT)lua_tonumber(L, 4);
11753  arg5 = (PLFLT)lua_tonumber(L, 5);
11754  arg6 = (PLFLT)lua_tonumber(L, 6);
11755  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
11756 
11757  {
11758  mapform_funcstr[0] = '\0';
11759  }
11760  return SWIG_arg;
11761 
11762  if(0) SWIG_fail;
11763 
11764 fail:
11765  {
11766  mapform_funcstr[0] = '\0';
11767  }
11768  lua_error(L);
11769  return SWIG_arg;
11770 }
11771 
11772 
11773 static int _wrap_mapline(lua_State* L) {
11774  int SWIG_arg = 0;
11775  mapform_func arg1 = (mapform_func) 0 ;
11776  char *arg2 = (char *) 0 ;
11777  PLFLT arg3 ;
11778  PLFLT arg4 ;
11779  PLFLT arg5 ;
11780  PLFLT arg6 ;
11781  PLINT *arg7 = (PLINT *) 0 ;
11782  PLINT arg8 ;
11783  int temp7 ;
11784 
11785  SWIG_check_num_args("plmapline",7,7)
11786  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmapline",2,"char const *");
11787  if(!lua_isnumber(L,3)) SWIG_fail_arg("plmapline",3,"PLFLT");
11788  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmapline",4,"PLFLT");
11789  if(!lua_isnumber(L,5)) SWIG_fail_arg("plmapline",5,"PLFLT");
11790  if(!lua_isnumber(L,6)) SWIG_fail_arg("plmapline",6,"PLFLT");
11791  {
11792  arg1 = NULL;
11793  mapform_funcstr[0] = '\0';
11794 
11795  if ( lua_isnil( L, 1 ) )
11796  {
11797  arg1 = NULL;
11798  }
11799  else if ( lua_isstring( L, 1 ) )
11800  {
11801  arg1 = mapform;
11802  strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
11803  myL = L;
11804  }
11805  else
11806  SWIG_fail_arg( "mapline", 1, "mapform_func" );
11807  }
11808  arg2 = (char *)lua_tostring(L, 2);
11809  arg3 = (PLFLT)lua_tonumber(L, 3);
11810  arg4 = (PLFLT)lua_tonumber(L, 4);
11811  arg5 = (PLFLT)lua_tonumber(L, 5);
11812  arg6 = (PLFLT)lua_tonumber(L, 6);
11813  {
11814  if ( lua_isnil( L, 7 ) )
11815  {
11816  arg7 = NULL;
11817  arg8 = 0;
11818  }
11819  else
11820  {
11821  arg7 = (PLINT *) LUA_get_int_num_array_var( L, 7, &temp7 );
11822  if ( !arg7 )
11823  SWIG_fail;
11824  arg8 = temp7;
11825  }
11826  }
11827  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
11828 
11829  {
11830  mapform_funcstr[0] = '\0';
11831  }
11832  {
11833  LUA_FREE_ARRAY( arg7 );
11834  }
11835  return SWIG_arg;
11836 
11837  if(0) SWIG_fail;
11838 
11839 fail:
11840  {
11841  mapform_funcstr[0] = '\0';
11842  }
11843  {
11844  LUA_FREE_ARRAY( arg7 );
11845  }
11846  lua_error(L);
11847  return SWIG_arg;
11848 }
11849 
11850 
11851 static int _wrap_mapstring(lua_State* L) {
11852  int SWIG_arg = 0;
11853  mapform_func arg1 = (mapform_func) 0 ;
11854  char *arg2 = (char *) 0 ;
11855  char *arg3 = (char *) 0 ;
11856  PLFLT arg4 ;
11857  PLFLT arg5 ;
11858  PLFLT arg6 ;
11859  PLFLT arg7 ;
11860  PLINT *arg8 = (PLINT *) 0 ;
11861  PLINT arg9 ;
11862  int temp8 ;
11863 
11864  SWIG_check_num_args("plmapstring",8,8)
11865  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmapstring",2,"char const *");
11866  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("plmapstring",3,"char const *");
11867  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmapstring",4,"PLFLT");
11868  if(!lua_isnumber(L,5)) SWIG_fail_arg("plmapstring",5,"PLFLT");
11869  if(!lua_isnumber(L,6)) SWIG_fail_arg("plmapstring",6,"PLFLT");
11870  if(!lua_isnumber(L,7)) SWIG_fail_arg("plmapstring",7,"PLFLT");
11871  {
11872  arg1 = NULL;
11873  mapform_funcstr[0] = '\0';
11874 
11875  if ( lua_isnil( L, 1 ) )
11876  {
11877  arg1 = NULL;
11878  }
11879  else if ( lua_isstring( L, 1 ) )
11880  {
11881  arg1 = mapform;
11882  strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
11883  myL = L;
11884  }
11885  else
11886  SWIG_fail_arg( "mapstring", 1, "mapform_func" );
11887  }
11888  arg2 = (char *)lua_tostring(L, 2);
11889  arg3 = (char *)lua_tostring(L, 3);
11890  arg4 = (PLFLT)lua_tonumber(L, 4);
11891  arg5 = (PLFLT)lua_tonumber(L, 5);
11892  arg6 = (PLFLT)lua_tonumber(L, 6);
11893  arg7 = (PLFLT)lua_tonumber(L, 7);
11894  {
11895  if ( lua_isnil( L, 8 ) )
11896  {
11897  arg8 = NULL;
11898  arg9 = 0;
11899  }
11900  else
11901  {
11902  arg8 = (PLINT *) LUA_get_int_num_array_var( L, 8, &temp8 );
11903  if ( !arg8 )
11904  SWIG_fail;
11905  arg9 = temp8;
11906  }
11907  }
11908  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
11909 
11910  {
11911  mapform_funcstr[0] = '\0';
11912  }
11913  {
11914  LUA_FREE_ARRAY( arg8 );
11915  }
11916  return SWIG_arg;
11917 
11918  if(0) SWIG_fail;
11919 
11920 fail:
11921  {
11922  mapform_funcstr[0] = '\0';
11923  }
11924  {
11925  LUA_FREE_ARRAY( arg8 );
11926  }
11927  lua_error(L);
11928  return SWIG_arg;
11929 }
11930 
11931 
11932 static int _wrap_maptex(lua_State* L) {
11933  int SWIG_arg = 0;
11934  mapform_func arg1 = (mapform_func) 0 ;
11935  char *arg2 = (char *) 0 ;
11936  PLFLT arg3 ;
11937  PLFLT arg4 ;
11938  PLFLT arg5 ;
11939  char *arg6 = (char *) 0 ;
11940  PLFLT arg7 ;
11941  PLFLT arg8 ;
11942  PLFLT arg9 ;
11943  PLFLT arg10 ;
11944  PLINT arg11 ;
11945 
11946  SWIG_check_num_args("plmaptex",11,11)
11947  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmaptex",2,"char const *");
11948  if(!lua_isnumber(L,3)) SWIG_fail_arg("plmaptex",3,"PLFLT");
11949  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmaptex",4,"PLFLT");
11950  if(!lua_isnumber(L,5)) SWIG_fail_arg("plmaptex",5,"PLFLT");
11951  if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("plmaptex",6,"char const *");
11952  if(!lua_isnumber(L,7)) SWIG_fail_arg("plmaptex",7,"PLFLT");
11953  if(!lua_isnumber(L,8)) SWIG_fail_arg("plmaptex",8,"PLFLT");
11954  if(!lua_isnumber(L,9)) SWIG_fail_arg("plmaptex",9,"PLFLT");
11955  if(!lua_isnumber(L,10)) SWIG_fail_arg("plmaptex",10,"PLFLT");
11956  if(!lua_isnumber(L,11)) SWIG_fail_arg("plmaptex",11,"PLINT");
11957  {
11958  arg1 = NULL;
11959  mapform_funcstr[0] = '\0';
11960 
11961  if ( lua_isnil( L, 1 ) )
11962  {
11963  arg1 = NULL;
11964  }
11965  else if ( lua_isstring( L, 1 ) )
11966  {
11967  arg1 = mapform;
11968  strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
11969  myL = L;
11970  }
11971  else
11972  SWIG_fail_arg( "maptex", 1, "mapform_func" );
11973  }
11974  arg2 = (char *)lua_tostring(L, 2);
11975  arg3 = (PLFLT)lua_tonumber(L, 3);
11976  arg4 = (PLFLT)lua_tonumber(L, 4);
11977  arg5 = (PLFLT)lua_tonumber(L, 5);
11978  arg6 = (char *)lua_tostring(L, 6);
11979  arg7 = (PLFLT)lua_tonumber(L, 7);
11980  arg8 = (PLFLT)lua_tonumber(L, 8);
11981  arg9 = (PLFLT)lua_tonumber(L, 9);
11982  arg10 = (PLFLT)lua_tonumber(L, 10);
11983  arg11 = (PLINT)lua_tonumber(L, 11);
11984  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
11985 
11986  {
11987  mapform_funcstr[0] = '\0';
11988  }
11989  return SWIG_arg;
11990 
11991  if(0) SWIG_fail;
11992 
11993 fail:
11994  {
11995  mapform_funcstr[0] = '\0';
11996  }
11997  lua_error(L);
11998  return SWIG_arg;
11999 }
12000 
12001 
12002 static int _wrap_mapfill(lua_State* L) {
12003  int SWIG_arg = 0;
12004  mapform_func arg1 = (mapform_func) 0 ;
12005  char *arg2 = (char *) 0 ;
12006  PLFLT arg3 ;
12007  PLFLT arg4 ;
12008  PLFLT arg5 ;
12009  PLFLT arg6 ;
12010  PLINT *arg7 = (PLINT *) 0 ;
12011  PLINT arg8 ;
12012  int temp7 ;
12013 
12014  SWIG_check_num_args("plmapfill",7,7)
12015  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plmapfill",2,"char const *");
12016  if(!lua_isnumber(L,3)) SWIG_fail_arg("plmapfill",3,"PLFLT");
12017  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmapfill",4,"PLFLT");
12018  if(!lua_isnumber(L,5)) SWIG_fail_arg("plmapfill",5,"PLFLT");
12019  if(!lua_isnumber(L,6)) SWIG_fail_arg("plmapfill",6,"PLFLT");
12020  {
12021  arg1 = NULL;
12022  mapform_funcstr[0] = '\0';
12023 
12024  if ( lua_isnil( L, 1 ) )
12025  {
12026  arg1 = NULL;
12027  }
12028  else if ( lua_isstring( L, 1 ) )
12029  {
12030  arg1 = mapform;
12031  strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
12032  myL = L;
12033  }
12034  else
12035  SWIG_fail_arg( "mapfill", 1, "mapform_func" );
12036  }
12037  arg2 = (char *)lua_tostring(L, 2);
12038  arg3 = (PLFLT)lua_tonumber(L, 3);
12039  arg4 = (PLFLT)lua_tonumber(L, 4);
12040  arg5 = (PLFLT)lua_tonumber(L, 5);
12041  arg6 = (PLFLT)lua_tonumber(L, 6);
12042  {
12043  if ( lua_isnil( L, 7 ) )
12044  {
12045  arg7 = NULL;
12046  arg8 = 0;
12047  }
12048  else
12049  {
12050  arg7 = (PLINT *) LUA_get_int_num_array_var( L, 7, &temp7 );
12051  if ( !arg7 )
12052  SWIG_fail;
12053  arg8 = temp7;
12054  }
12055  }
12056  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
12057 
12058  {
12059  mapform_funcstr[0] = '\0';
12060  }
12061  {
12062  LUA_FREE_ARRAY( arg7 );
12063  }
12064  return SWIG_arg;
12065 
12066  if(0) SWIG_fail;
12067 
12068 fail:
12069  {
12070  mapform_funcstr[0] = '\0';
12071  }
12072  {
12073  LUA_FREE_ARRAY( arg7 );
12074  }
12075  lua_error(L);
12076  return SWIG_arg;
12077 }
12078 
12079 
12080 static int _wrap_meridians(lua_State* L) {
12081  int SWIG_arg = 0;
12082  mapform_func arg1 = (mapform_func) 0 ;
12083  PLFLT arg2 ;
12084  PLFLT arg3 ;
12085  PLFLT arg4 ;
12086  PLFLT arg5 ;
12087  PLFLT arg6 ;
12088  PLFLT arg7 ;
12089 
12090  SWIG_check_num_args("plmeridians",7,7)
12091  if(!lua_isnumber(L,2)) SWIG_fail_arg("plmeridians",2,"PLFLT");
12092  if(!lua_isnumber(L,3)) SWIG_fail_arg("plmeridians",3,"PLFLT");
12093  if(!lua_isnumber(L,4)) SWIG_fail_arg("plmeridians",4,"PLFLT");
12094  if(!lua_isnumber(L,5)) SWIG_fail_arg("plmeridians",5,"PLFLT");
12095  if(!lua_isnumber(L,6)) SWIG_fail_arg("plmeridians",6,"PLFLT");
12096  if(!lua_isnumber(L,7)) SWIG_fail_arg("plmeridians",7,"PLFLT");
12097  {
12098  arg1 = NULL;
12099  mapform_funcstr[0] = '\0';
12100 
12101  if ( lua_isnil( L, 1 ) )
12102  {
12103  arg1 = NULL;
12104  }
12105  else if ( lua_isstring( L, 1 ) )
12106  {
12107  arg1 = mapform;
12108  strncpy( mapform_funcstr, lua_tostring( L, 1 ), 255 );
12109  myL = L;
12110  }
12111  else
12112  SWIG_fail_arg( "meridians", 1, "mapform_func" );
12113  }
12114  arg2 = (PLFLT)lua_tonumber(L, 2);
12115  arg3 = (PLFLT)lua_tonumber(L, 3);
12116  arg4 = (PLFLT)lua_tonumber(L, 4);
12117  arg5 = (PLFLT)lua_tonumber(L, 5);
12118  arg6 = (PLFLT)lua_tonumber(L, 6);
12119  arg7 = (PLFLT)lua_tonumber(L, 7);
12120  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
12121 
12122  {
12123  mapform_funcstr[0] = '\0';
12124  }
12125  return SWIG_arg;
12126 
12127  if(0) SWIG_fail;
12128 
12129 fail:
12130  {
12131  mapform_funcstr[0] = '\0';
12132  }
12133  lua_error(L);
12134  return SWIG_arg;
12135 }
12136 
12137 
12138 static int _wrap_image(lua_State* L) {
12139  int SWIG_arg = 0;
12140  PLFLT **arg1 = (PLFLT **) 0 ;
12141  PLINT arg2 ;
12142  PLINT arg3 ;
12143  PLFLT arg4 ;
12144  PLFLT arg5 ;
12145  PLFLT arg6 ;
12146  PLFLT arg7 ;
12147  PLFLT arg8 ;
12148  PLFLT arg9 ;
12149  PLFLT arg10 ;
12150  PLFLT arg11 ;
12151  PLFLT arg12 ;
12152  PLFLT arg13 ;
12153  int ii1 ;
12154 
12155  SWIG_check_num_args("plimage",11,11)
12156  if(!lua_isnumber(L,2)) SWIG_fail_arg("plimage",2,"PLFLT");
12157  if(!lua_isnumber(L,3)) SWIG_fail_arg("plimage",3,"PLFLT");
12158  if(!lua_isnumber(L,4)) SWIG_fail_arg("plimage",4,"PLFLT");
12159  if(!lua_isnumber(L,5)) SWIG_fail_arg("plimage",5,"PLFLT");
12160  if(!lua_isnumber(L,6)) SWIG_fail_arg("plimage",6,"PLFLT");
12161  if(!lua_isnumber(L,7)) SWIG_fail_arg("plimage",7,"PLFLT");
12162  if(!lua_isnumber(L,8)) SWIG_fail_arg("plimage",8,"PLFLT");
12163  if(!lua_isnumber(L,9)) SWIG_fail_arg("plimage",9,"PLFLT");
12164  if(!lua_isnumber(L,10)) SWIG_fail_arg("plimage",10,"PLFLT");
12165  if(!lua_isnumber(L,11)) SWIG_fail_arg("plimage",11,"PLFLT");
12166  {
12167  int jj;
12168 
12169  arg1 = read_double_Matrix( L, 1, &ii1, &jj );
12170  if ( !arg1 )
12171  SWIG_fail;
12172  Xlen = arg2 = ii1;
12173  Ylen = arg3 = jj;
12174  }
12175  arg4 = (PLFLT)lua_tonumber(L, 2);
12176  arg5 = (PLFLT)lua_tonumber(L, 3);
12177  arg6 = (PLFLT)lua_tonumber(L, 4);
12178  arg7 = (PLFLT)lua_tonumber(L, 5);
12179  arg8 = (PLFLT)lua_tonumber(L, 6);
12180  arg9 = (PLFLT)lua_tonumber(L, 7);
12181  arg10 = (PLFLT)lua_tonumber(L, 8);
12182  arg11 = (PLFLT)lua_tonumber(L, 9);
12183  arg12 = (PLFLT)lua_tonumber(L, 10);
12184  arg13 = (PLFLT)lua_tonumber(L, 11);
12185  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
12186 
12187  {
12188  int i;
12189 
12190  if ( arg1 )
12191  {
12192  for ( i = 0; i < ii1; i++ )
12193  LUA_FREE_ARRAY( arg1[i] );
12194  LUA_FREE_ARRAY( arg1 );
12195  }
12196  }
12197  return SWIG_arg;
12198 
12199  if(0) SWIG_fail;
12200 
12201 fail:
12202  {
12203  int i;
12204 
12205  if ( arg1 )
12206  {
12207  for ( i = 0; i < ii1; i++ )
12208  LUA_FREE_ARRAY( arg1[i] );
12209  LUA_FREE_ARRAY( arg1 );
12210  }
12211  }
12212  lua_error(L);
12213  return SWIG_arg;
12214 }
12215 
12216 
12217 static int _wrap_imagefr(lua_State* L) {
12218  int SWIG_arg = 0;
12219  PLFLT **arg1 = (PLFLT **) 0 ;
12220  PLINT arg2 ;
12221  PLINT arg3 ;
12222  PLFLT arg4 ;
12223  PLFLT arg5 ;
12224  PLFLT arg6 ;
12225  PLFLT arg7 ;
12226  PLFLT arg8 ;
12227  PLFLT arg9 ;
12228  PLFLT arg10 ;
12229  PLFLT arg11 ;
12230  pltr_func arg12 = (pltr_func) 0 ;
12231  PLPointer arg13 = (PLPointer) 0 ;
12232  int ii1 ;
12233  PLcGrid cgrid113 ;
12234  PLcGrid2 cgrid213 ;
12235 
12236  {
12237  cgrid113.xg = cgrid113.yg = cgrid113.zg = NULL;
12238  cgrid113.nx = cgrid113.ny = cgrid113.nz = 0;
12239  cgrid213.xg = cgrid213.yg = cgrid213.zg = NULL;
12240  cgrid213.nx = cgrid213.ny = 0;
12241  }
12242  {
12243  arg12 = NULL;
12244  }
12245  {
12246  arg13 = NULL;
12247  }
12248  SWIG_check_num_args("plimagefr",9,11)
12249  if(!lua_isnumber(L,2)) SWIG_fail_arg("plimagefr",2,"PLFLT");
12250  if(!lua_isnumber(L,3)) SWIG_fail_arg("plimagefr",3,"PLFLT");
12251  if(!lua_isnumber(L,4)) SWIG_fail_arg("plimagefr",4,"PLFLT");
12252  if(!lua_isnumber(L,5)) SWIG_fail_arg("plimagefr",5,"PLFLT");
12253  if(!lua_isnumber(L,6)) SWIG_fail_arg("plimagefr",6,"PLFLT");
12254  if(!lua_isnumber(L,7)) SWIG_fail_arg("plimagefr",7,"PLFLT");
12255  if(!lua_isnumber(L,8)) SWIG_fail_arg("plimagefr",8,"PLFLT");
12256  if(!lua_isnumber(L,9)) SWIG_fail_arg("plimagefr",9,"PLFLT");
12257  {
12258  int jj;
12259 
12260  arg1 = read_double_Matrix( L, 1, &ii1, &jj );
12261  if ( !arg1 )
12262  SWIG_fail;
12263  Xlen = arg2 = ii1;
12264  Ylen = arg3 = jj;
12265  }
12266  arg4 = (PLFLT)lua_tonumber(L, 2);
12267  arg5 = (PLFLT)lua_tonumber(L, 3);
12268  arg6 = (PLFLT)lua_tonumber(L, 4);
12269  arg7 = (PLFLT)lua_tonumber(L, 5);
12270  arg8 = (PLFLT)lua_tonumber(L, 6);
12271  arg9 = (PLFLT)lua_tonumber(L, 7);
12272  arg10 = (PLFLT)lua_tonumber(L, 8);
12273  arg11 = (PLFLT)lua_tonumber(L, 9);
12274  if(lua_gettop(L)>=10){
12275  {
12276  arg12 = NULL;
12277  mypltr_funcstr[0] = '\0';
12278 
12279  if ( lua_isstring( L, 10 ) )
12280  {
12281  const char* funcstr = lua_tostring( L, 10 );
12282  if ( strcmp( "pltr0", funcstr ) == 0 )
12283  {
12284  arg12 = pltr0;
12285  }
12286  else if ( strcmp( "pltr1", funcstr ) == 0 )
12287  {
12288  arg12 = pltr1;
12289  }
12290  else if ( strcmp( "pltr2", funcstr ) == 0 )
12291  {
12292  arg12 = pltr2;
12293  }
12294  else
12295  {
12296  arg12 = mypltr;
12297  strncpy( mypltr_funcstr, funcstr, 255 );
12298  myL = L;
12299  }
12300  }
12301  else
12302  SWIG_fail_arg( "imagefr", 12, "pltr_func" );
12303  }
12304  }
12305  if(lua_gettop(L)>=11){
12306  {
12307  int nx, ny;
12308  int gridmode = 0;
12309 
12310  lua_pushstring( L, "xg" );
12311  lua_gettable( L, 11 );
12312  if ( !lua_istable( L, -1 ) )
12313  {
12314  lua_pop( L, 1 ); // pop "xg"
12315  lua_pushstring( L, "expected a table xg" );
12316  SWIG_fail;
12317  }
12318  lua_rawgeti( L, -1, 1 );
12319  if ( lua_istable( L, -1 ) )
12320  gridmode = 2; // two dimensional array
12321  else if ( lua_isnumber( L, -1 ) )
12322  gridmode = 1; // one dimensional array
12323  else
12324  {
12325  lua_pop( L, 1 ); // pop "1"
12326  lua_pop( L, 1 ); // pop "xg"
12327  lua_pushstring( L, "expected a one or two dimensional array/table in xg" );
12328  SWIG_fail;
12329  }
12330  lua_pop( L, 1 ); // pop test element
12331  if ( gridmode == 1 )
12332  {
12333  cgrid113.xg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &nx );
12334  if ( !cgrid113.xg )
12335  {
12336  lua_pop( L, 1 ); // pop "xg"
12337  SWIG_fail;
12338  }
12339  if ( nx != Xlen )
12340  {
12341  lua_pushfstring( L, "Table xg must be of length%d.", Xlen );
12342  SWIG_fail;
12343  }
12344  cgrid113.nx = nx;
12345  }
12346  else
12347  {
12348  cgrid213.xg = read_double_Matrix( L, -1, &nx, &ny );
12349  if ( !cgrid213.xg )
12350  {
12351  lua_pop( L, 1 ); // pop "xg"
12352  SWIG_fail;
12353  }
12354  if ( ( nx != Xlen ) || ( ny != Ylen ) )
12355  {
12356  lua_pop( L, 1 ); // pop "xg"
12357  lua_pushfstring( L, "Vectors must match matrix." );
12358  SWIG_fail;
12359  }
12360  cgrid213.nx = nx;
12361  cgrid213.ny = ny;
12362  }
12363  lua_pop( L, 1 ); // pop "xg"
12364 
12365  lua_pushstring( L, "yg" );
12366  lua_gettable( L, 11 );
12367  if ( !lua_istable( L, -1 ) )
12368  {
12369  lua_pop( L, 1 );
12370  lua_pushstring( L, "expected a table yg" );
12371  SWIG_fail;
12372  }
12373  lua_rawgeti( L, -1, 1 );
12374  if ( gridmode == 2 )
12375  {
12376  if ( !lua_istable( L, -1 ) )
12377  {
12378  lua_pop( L, 1 ); // pop "1"
12379  lua_pop( L, 1 ); // pop "yg"
12380  lua_pushstring( L, "expected a two dimensional array/table in yg" );
12381  SWIG_fail;
12382  }
12383  }
12384  else
12385  {
12386  if ( !lua_isnumber( L, -1 ) )
12387  {
12388  lua_pop( L, 1 ); // pop "1"
12389  lua_pop( L, 1 ); // pop "yg"
12390  lua_pushstring( L, "expected a one dimensional array/table in yg" );
12391  SWIG_fail;
12392  }
12393  }
12394  lua_pop( L, 1 ); // pop "1"
12395  if ( gridmode == 1 )
12396  {
12397  cgrid113.yg = (PLFLT *) LUA_get_double_num_array_var( L, -1, &ny );
12398  if ( !cgrid113.yg )
12399  {
12400  lua_pop( L, 1 ); // pop "yg"
12401  SWIG_fail;
12402  }
12403  if ( ny != Ylen )
12404  {
12405  lua_pushfstring( L, "Table yg must be of length%d.", Ylen );
12406  SWIG_fail;
12407  }
12408  cgrid113.ny = ny;
12409  }
12410  else
12411  {
12412  cgrid213.yg = read_double_Matrix( L, -1, &nx, &ny );
12413  if ( !cgrid213.yg )
12414  {
12415  lua_pop( L, 1 ); // pop "xg"
12416  SWIG_fail;
12417  }
12418  if ( ( nx != Xlen ) || ( ny != Ylen ) )
12419  {
12420  lua_pop( L, 1 ); // pop "xg"
12421  lua_pushfstring( L, "Vectors must match matrix." );
12422  SWIG_fail;
12423  }
12424  // cgrid213.nx/ny already set
12425  }
12426  lua_pop( L, 1 ); // pop "yg"
12427 
12428  if ( gridmode == 1 )
12429  arg13 = &cgrid113;
12430  else if ( gridmode == 2 )
12431  arg13 = &cgrid213;
12432  }
12433  }
12434  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
12435 
12436  {
12437  int i;
12438 
12439  if ( arg1 )
12440  {
12441  for ( i = 0; i < ii1; i++ )
12442  LUA_FREE_ARRAY( arg1[i] );
12443  LUA_FREE_ARRAY( arg1 );
12444  }
12445  }
12446  {
12447  mypltr_funcstr[0] = '\0';
12448  }
12449  {
12450  int i;
12451 
12452  LUA_FREE_ARRAY( cgrid113.xg );
12453  LUA_FREE_ARRAY( cgrid113.yg );
12454 
12455  if ( cgrid213.xg )
12456  {
12457  for ( i = 0; i < Xlen; i++ )
12458  LUA_FREE_ARRAY( cgrid213.xg[i] );
12459  LUA_FREE_ARRAY( cgrid213.xg );
12460  }
12461  if ( cgrid213.yg )
12462  {
12463  for ( i = 0; i < Xlen; i++ )
12464  LUA_FREE_ARRAY( cgrid213.yg[i] );
12465  LUA_FREE_ARRAY( cgrid213.yg );
12466  }
12467  }
12468  return SWIG_arg;
12469 
12470  if(0) SWIG_fail;
12471 
12472 fail:
12473  {
12474  int i;
12475 
12476  if ( arg1 )
12477  {
12478  for ( i = 0; i < ii1; i++ )
12479  LUA_FREE_ARRAY( arg1[i] );
12480  LUA_FREE_ARRAY( arg1 );
12481  }
12482  }
12483  {
12484  mypltr_funcstr[0] = '\0';
12485  }
12486  {
12487  int i;
12488 
12489  LUA_FREE_ARRAY( cgrid113.xg );
12490  LUA_FREE_ARRAY( cgrid113.yg );
12491 
12492  if ( cgrid213.xg )
12493  {
12494  for ( i = 0; i < Xlen; i++ )
12495  LUA_FREE_ARRAY( cgrid213.xg[i] );
12496  LUA_FREE_ARRAY( cgrid213.xg );
12497  }
12498  if ( cgrid213.yg )
12499  {
12500  for ( i = 0; i < Xlen; i++ )
12501  LUA_FREE_ARRAY( cgrid213.yg[i] );
12502  LUA_FREE_ARRAY( cgrid213.yg );
12503  }
12504  }
12505  lua_error(L);
12506  return SWIG_arg;
12507 }
12508 
12509 
12510 static int _wrap_plClearOpts(lua_State* L) {
12511  int SWIG_arg = 0;
12512 
12513  SWIG_check_num_args("plClearOpts",0,0)
12514  plClearOpts();
12515 
12516  return SWIG_arg;
12517 
12518  if(0) SWIG_fail;
12519 
12520 fail:
12521  lua_error(L);
12522  return SWIG_arg;
12523 }
12524 
12525 
12526 static int _wrap_plResetOpts(lua_State* L) {
12527  int SWIG_arg = 0;
12528 
12529  SWIG_check_num_args("plResetOpts",0,0)
12530  plResetOpts();
12531 
12532  return SWIG_arg;
12533 
12534  if(0) SWIG_fail;
12535 
12536 fail:
12537  lua_error(L);
12538  return SWIG_arg;
12539 }
12540 
12541 
12542 static int _wrap_plSetUsage(lua_State* L) {
12543  int SWIG_arg = 0;
12544  char *arg1 = (char *) 0 ;
12545  char *arg2 = (char *) 0 ;
12546 
12547  SWIG_check_num_args("plSetUsage",2,2)
12548  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("plSetUsage",1,"char const *");
12549  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("plSetUsage",2,"char const *");
12550  arg1 = (char *)lua_tostring(L, 1);
12551  arg2 = (char *)lua_tostring(L, 2);
12552  plSetUsage((char const *)arg1,(char const *)arg2);
12553 
12554  return SWIG_arg;
12555 
12556  if(0) SWIG_fail;
12557 
12558 fail:
12559  lua_error(L);
12560  return SWIG_arg;
12561 }
12562 
12563 
12564 static int _wrap_plOptUsage(lua_State* L) {
12565  int SWIG_arg = 0;
12566 
12567  SWIG_check_num_args("plOptUsage",0,0)
12568  plOptUsage();
12569 
12570  return SWIG_arg;
12571 
12572  if(0) SWIG_fail;
12573 
12574 fail:
12575  lua_error(L);
12576  return SWIG_arg;
12577 }
12578 
12579 
12580 static int _wrap_MinMax2dGrid(lua_State* L) {
12581  int SWIG_arg = 0;
12582  PLFLT **arg1 = (PLFLT **) 0 ;
12583  PLINT arg2 ;
12584  PLINT arg3 ;
12585  PLFLT *arg4 = (PLFLT *) 0 ;
12586  PLFLT *arg5 = (PLFLT *) 0 ;
12587  int ii1 ;
12588  PLFLT temp4 ;
12589  PLFLT temp5 ;
12590 
12591  arg4 = &temp4;
12592  arg5 = &temp5;
12593  SWIG_check_num_args("plMinMax2dGrid",1,1)
12594  {
12595  int jj;
12596 
12597  arg1 = read_double_Matrix( L, 1, &ii1, &jj );
12598  if ( !arg1 )
12599  SWIG_fail;
12600  Xlen = arg2 = ii1;
12601  Ylen = arg3 = jj;
12602  }
12603  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
12604 
12605  lua_pushnumber(L, (lua_Number) *arg4); SWIG_arg++;
12606  lua_pushnumber(L, (lua_Number) *arg5); SWIG_arg++;
12607  {
12608  int i;
12609 
12610  if ( arg1 )
12611  {
12612  for ( i = 0; i < ii1; i++ )
12613  LUA_FREE_ARRAY( arg1[i] );
12614  LUA_FREE_ARRAY( arg1 );
12615  }
12616  }
12617  return SWIG_arg;
12618 
12619  if(0) SWIG_fail;
12620 
12621 fail:
12622  {
12623  int i;
12624 
12625  if ( arg1 )
12626  {
12627  for ( i = 0; i < ii1; i++ )
12628  LUA_FREE_ARRAY( arg1[i] );
12629  LUA_FREE_ARRAY( arg1 );
12630  }
12631  }
12632  lua_error(L);
12633  return SWIG_arg;
12634 }
12635 
12636 
12637 static int _wrap_plGetCursor(lua_State* L) {
12638  int SWIG_arg = 0;
12639  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12640  PLINT result;
12641 
12642  SWIG_check_num_args("plGetCursor",1,1)
12643  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("plGetCursor",1,"PLGraphicsIn *");
12644 
12645  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_PLGraphicsIn,0))){
12646  SWIG_fail_ptr("plGetCursor",1,SWIGTYPE_p_PLGraphicsIn);
12647  }
12648 
12649  result = (PLINT)plGetCursor(arg1);
12650  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
12651  return SWIG_arg;
12652 
12653  if(0) SWIG_fail;
12654 
12655 fail:
12656  lua_error(L);
12657  return SWIG_arg;
12658 }
12659 
12660 
12661 static int _wrap_warn(lua_State* L) {
12662  int SWIG_arg = 0;
12663  char *arg1 = (char *) 0 ;
12664 
12665  SWIG_check_num_args("plwarn",1,1)
12666  if(!lua_isstring(L,1)) SWIG_fail_arg("plwarn",1,"char const *");
12667  {
12668  arg1 = (char *) lua_tostring( L, 1 );
12669  }
12670  plwarn((char const *)arg1);
12671 
12672  return SWIG_arg;
12673 
12674  if(0) SWIG_fail;
12675 
12676 fail:
12677  lua_error(L);
12678  return SWIG_arg;
12679 }
12680 
12681 
12682 static int _wrap_abort(lua_State* L) {
12683  int SWIG_arg = 0;
12684  char *arg1 = (char *) 0 ;
12685 
12686  SWIG_check_num_args("plabort",1,1)
12687  if(!lua_isstring(L,1)) SWIG_fail_arg("plabort",1,"char const *");
12688  {
12689  arg1 = (char *) lua_tostring( L, 1 );
12690  }
12691  plabort((char const *)arg1);
12692 
12693  return SWIG_arg;
12694 
12695  if(0) SWIG_fail;
12696 
12697 fail:
12698  lua_error(L);
12699  return SWIG_arg;
12700 }
12701 
12702 
12704  {0,0,0}
12705 };
12707  {SWIG_LUA_CONSTTAB_INT("PLESC_SET_RGB", 1)},
12708  {SWIG_LUA_CONSTTAB_INT("PLESC_ALLOC_NCOL", 2)},
12709  {SWIG_LUA_CONSTTAB_INT("PLESC_SET_LPB", 3)},
12710  {SWIG_LUA_CONSTTAB_INT("PLESC_EXPOSE", 4)},
12711  {SWIG_LUA_CONSTTAB_INT("PLESC_RESIZE", 5)},
12712  {SWIG_LUA_CONSTTAB_INT("PLESC_REDRAW", 6)},
12713  {SWIG_LUA_CONSTTAB_INT("PLESC_TEXT", 7)},
12714  {SWIG_LUA_CONSTTAB_INT("PLESC_GRAPH", 8)},
12715  {SWIG_LUA_CONSTTAB_INT("PLESC_FILL", 9)},
12716  {SWIG_LUA_CONSTTAB_INT("PLESC_DI", 10)},
12717  {SWIG_LUA_CONSTTAB_INT("PLESC_FLUSH", 11)},
12718  {SWIG_LUA_CONSTTAB_INT("PLESC_EH", 12)},
12719  {SWIG_LUA_CONSTTAB_INT("PLESC_GETC", 13)},
12720  {SWIG_LUA_CONSTTAB_INT("PLESC_SWIN", 14)},
12721  {SWIG_LUA_CONSTTAB_INT("PLESC_DOUBLEBUFFERING", 15)},
12722  {SWIG_LUA_CONSTTAB_INT("PLESC_XORMOD", 16)},
12723  {SWIG_LUA_CONSTTAB_INT("PLESC_SET_COMPRESSION", 17)},
12724  {SWIG_LUA_CONSTTAB_INT("PLESC_CLEAR", 18)},
12725  {SWIG_LUA_CONSTTAB_INT("PLESC_DASH", 19)},
12726  {SWIG_LUA_CONSTTAB_INT("PLESC_HAS_TEXT", 20)},
12727  {SWIG_LUA_CONSTTAB_INT("PLESC_IMAGE", 21)},
12728  {SWIG_LUA_CONSTTAB_INT("PLESC_IMAGEOPS", 22)},
12729  {SWIG_LUA_CONSTTAB_INT("PLESC_PL2DEVCOL", 23)},
12730  {SWIG_LUA_CONSTTAB_INT("PLESC_DEV2PLCOL", 24)},
12731  {SWIG_LUA_CONSTTAB_INT("PLESC_SETBGFG", 25)},
12732  {SWIG_LUA_CONSTTAB_INT("PLESC_DEVINIT", 26)},
12733  {SWIG_LUA_CONSTTAB_INT("PLESC_GETBACKEND", 27)},
12734  {SWIG_LUA_CONSTTAB_INT("PLESC_BEGIN_TEXT", 28)},
12735  {SWIG_LUA_CONSTTAB_INT("PLESC_TEXT_CHAR", 29)},
12736  {SWIG_LUA_CONSTTAB_INT("PLESC_CONTROL_CHAR", 30)},
12737  {SWIG_LUA_CONSTTAB_INT("PLESC_END_TEXT", 31)},
12738  {SWIG_LUA_CONSTTAB_INT("PLESC_START_RASTERIZE", 32)},
12739  {SWIG_LUA_CONSTTAB_INT("PLESC_END_RASTERIZE", 33)},
12740  {SWIG_LUA_CONSTTAB_INT("PLESC_ARC", 34)},
12741  {SWIG_LUA_CONSTTAB_INT("PLESC_GRADIENT", 35)},
12742  {SWIG_LUA_CONSTTAB_INT("PLESC_MODESET", 36)},
12743  {SWIG_LUA_CONSTTAB_INT("PLESC_MODEGET", 37)},
12744  {SWIG_LUA_CONSTTAB_INT("PLESC_FIXASPECT", 38)},
12745  {SWIG_LUA_CONSTTAB_INT("PLESC_IMPORT_BUFFER", 39)},
12746  {SWIG_LUA_CONSTTAB_INT("PLESC_APPEND_BUFFER", 40)},
12747  {SWIG_LUA_CONSTTAB_INT("PLESC_FLUSH_REMAINING_BUFFER", 41)},
12748  {SWIG_LUA_CONSTTAB_INT("PLTEXT_FONTCHANGE", 0)},
12749  {SWIG_LUA_CONSTTAB_INT("PLTEXT_SUPERSCRIPT", 1)},
12750  {SWIG_LUA_CONSTTAB_INT("PLTEXT_SUBSCRIPT", 2)},
12751  {SWIG_LUA_CONSTTAB_INT("PLTEXT_BACKCHAR", 3)},
12752  {SWIG_LUA_CONSTTAB_INT("PLTEXT_OVERLINE", 4)},
12753  {SWIG_LUA_CONSTTAB_INT("PLTEXT_UNDERLINE", 5)},
12754  {SWIG_LUA_CONSTTAB_INT("ZEROW2B", 1)},
12755  {SWIG_LUA_CONSTTAB_INT("ZEROW2D", 2)},
12756  {SWIG_LUA_CONSTTAB_INT("ONEW2B", 3)},
12757  {SWIG_LUA_CONSTTAB_INT("ONEW2D", 4)},
12758  {SWIG_LUA_CONSTTAB_INT("PLSWIN_DEVICE", 1)},
12759  {SWIG_LUA_CONSTTAB_INT("PLSWIN_WORLD", 2)},
12760  {SWIG_LUA_CONSTTAB_INT("PL_X_AXIS", 1)},
12761  {SWIG_LUA_CONSTTAB_INT("PL_Y_AXIS", 2)},
12762  {SWIG_LUA_CONSTTAB_INT("PL_Z_AXIS", 3)},
12763  {SWIG_LUA_CONSTTAB_INT("PL_OPT_ENABLED", 0x0001)},
12764  {SWIG_LUA_CONSTTAB_INT("PL_OPT_ARG", 0x0002)},
12765  {SWIG_LUA_CONSTTAB_INT("PL_OPT_NODELETE", 0x0004)},
12766  {SWIG_LUA_CONSTTAB_INT("PL_OPT_INVISIBLE", 0x0008)},
12767  {SWIG_LUA_CONSTTAB_INT("PL_OPT_DISABLED", 0x0010)},
12768  {SWIG_LUA_CONSTTAB_INT("PL_OPT_FUNC", 0x0100)},
12769  {SWIG_LUA_CONSTTAB_INT("PL_OPT_BOOL", 0x0200)},
12770  {SWIG_LUA_CONSTTAB_INT("PL_OPT_INT", 0x0400)},
12771  {SWIG_LUA_CONSTTAB_INT("PL_OPT_FLOAT", 0x0800)},
12772  {SWIG_LUA_CONSTTAB_INT("PL_OPT_STRING", 0x1000)},
12773  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_PARTIAL", 0x0000)},
12774  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_FULL", 0x0001)},
12775  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_QUIET", 0x0002)},
12776  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_NODELETE", 0x0004)},
12777  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_SHOWALL", 0x0008)},
12778  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_OVERRIDE", 0x0010)},
12779  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_NOPROGRAM", 0x0020)},
12780  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_NODASH", 0x0040)},
12781  {SWIG_LUA_CONSTTAB_INT("PL_PARSE_SKIP", 0x0080)},
12782  {SWIG_LUA_CONSTTAB_INT("PL_FCI_MARK", 0x80000000)},
12783  {SWIG_LUA_CONSTTAB_INT("PL_FCI_IMPOSSIBLE", 0x00000000)},
12784  {SWIG_LUA_CONSTTAB_INT("PL_FCI_HEXDIGIT_MASK", 0xf)},
12785  {SWIG_LUA_CONSTTAB_INT("PL_FCI_HEXPOWER_MASK", 0x7)},
12786  {SWIG_LUA_CONSTTAB_INT("PL_FCI_HEXPOWER_IMPOSSIBLE", 0xf)},
12787  {SWIG_LUA_CONSTTAB_INT("PL_FCI_FAMILY", 0x0)},
12788  {SWIG_LUA_CONSTTAB_INT("PL_FCI_STYLE", 0x1)},
12789  {SWIG_LUA_CONSTTAB_INT("PL_FCI_WEIGHT", 0x2)},
12790  {SWIG_LUA_CONSTTAB_INT("PL_FCI_SANS", 0x0)},
12791  {SWIG_LUA_CONSTTAB_INT("PL_FCI_SERIF", 0x1)},
12792  {SWIG_LUA_CONSTTAB_INT("PL_FCI_MONO", 0x2)},
12793  {SWIG_LUA_CONSTTAB_INT("PL_FCI_SCRIPT", 0x3)},
12794  {SWIG_LUA_CONSTTAB_INT("PL_FCI_SYMBOL", 0x4)},
12795  {SWIG_LUA_CONSTTAB_INT("PL_FCI_UPRIGHT", 0x0)},
12796  {SWIG_LUA_CONSTTAB_INT("PL_FCI_ITALIC", 0x1)},
12797  {SWIG_LUA_CONSTTAB_INT("PL_FCI_OBLIQUE", 0x2)},
12798  {SWIG_LUA_CONSTTAB_INT("PL_FCI_MEDIUM", 0x0)},
12799  {SWIG_LUA_CONSTTAB_INT("PL_FCI_BOLD", 0x1)},
12800  {SWIG_LUA_CONSTTAB_INT("PL_MAXKEY", 16)},
12801  {SWIG_LUA_CONSTTAB_INT("PL_MASK_SHIFT", 0x1)},
12802  {SWIG_LUA_CONSTTAB_INT("PL_MASK_CAPS", 0x2)},
12803  {SWIG_LUA_CONSTTAB_INT("PL_MASK_CONTROL", 0x4)},
12804  {SWIG_LUA_CONSTTAB_INT("PL_MASK_ALT", 0x8)},
12805  {SWIG_LUA_CONSTTAB_INT("PL_MASK_NUM", 0x10)},
12806  {SWIG_LUA_CONSTTAB_INT("PL_MASK_ALTGR", 0x20)},
12807  {SWIG_LUA_CONSTTAB_INT("PL_MASK_WIN", 0x40)},
12808  {SWIG_LUA_CONSTTAB_INT("PL_MASK_SCROLL", 0x80)},
12809  {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON1", 0x100)},
12810  {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON2", 0x200)},
12811  {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON3", 0x400)},
12812  {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON4", 0x800)},
12813  {SWIG_LUA_CONSTTAB_INT("PL_MASK_BUTTON5", 0x1000)},
12814  {SWIG_LUA_CONSTTAB_INT("PL_MAXWINDOWS", 64)},
12815  {SWIG_LUA_CONSTTAB_INT("PL_NOTSET", (-42))},
12816  {SWIG_LUA_CONSTTAB_INT("PL_DEFAULT_NCOL0", 16)},
12817  {SWIG_LUA_CONSTTAB_INT("PL_DEFAULT_NCOL1", 128)},
12818  {SWIG_LUA_CONSTTAB_INT("MIN_PLINT_RGB", 0)},
12819  {SWIG_LUA_CONSTTAB_INT("MAX_PLINT_RGB", 255)},
12820  {SWIG_LUA_CONSTTAB_FLOAT("MIN_PLFLT_CMAP1", 0.)},
12821  {SWIG_LUA_CONSTTAB_FLOAT("MAX_PLFLT_CMAP1", 1.)},
12822  {SWIG_LUA_CONSTTAB_FLOAT("MIN_PLFLT_ALPHA", 0.)},
12823  {SWIG_LUA_CONSTTAB_FLOAT("MAX_PLFLT_ALPHA", 1.)},
12824  {SWIG_LUA_CONSTTAB_INT("PLESC_DOUBLEBUFFERING_ENABLE", 1)},
12825  {SWIG_LUA_CONSTTAB_INT("PLESC_DOUBLEBUFFERING_DISABLE", 2)},
12826  {SWIG_LUA_CONSTTAB_INT("PLESC_DOUBLEBUFFERING_QUERY", 3)},
12827  {SWIG_LUA_CONSTTAB_INT("PL_BIN_DEFAULT", 0x0)},
12828  {SWIG_LUA_CONSTTAB_INT("PL_BIN_CENTRED", 0x1)},
12829  {SWIG_LUA_CONSTTAB_INT("PL_BIN_NOEXPAND", 0x2)},
12830  {SWIG_LUA_CONSTTAB_INT("PL_BIN_NOEMPTY", 0x4)},
12831  {SWIG_LUA_CONSTTAB_INT("GRID_CSA", 1)},
12832  {SWIG_LUA_CONSTTAB_INT("GRID_DTLI", 2)},
12833  {SWIG_LUA_CONSTTAB_INT("GRID_NNI", 3)},
12834  {SWIG_LUA_CONSTTAB_INT("GRID_NNIDW", 4)},
12835  {SWIG_LUA_CONSTTAB_INT("GRID_NNLI", 5)},
12836  {SWIG_LUA_CONSTTAB_INT("GRID_NNAIDW", 6)},
12837  {SWIG_LUA_CONSTTAB_INT("PL_HIST_DEFAULT", 0x00)},
12838  {SWIG_LUA_CONSTTAB_INT("PL_HIST_NOSCALING", 0x01)},
12839  {SWIG_LUA_CONSTTAB_INT("PL_HIST_IGNORE_OUTLIERS", 0x02)},
12840  {SWIG_LUA_CONSTTAB_INT("PL_HIST_NOEXPAND", 0x08)},
12841  {SWIG_LUA_CONSTTAB_INT("PL_HIST_NOEMPTY", 0x10)},
12842  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_NULL", 0x0)},
12843  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_LEFT", 0x1)},
12844  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_RIGHT", 0x2)},
12845  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_TOP", 0x4)},
12846  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_BOTTOM", 0x8)},
12847  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_INSIDE", 0x10)},
12848  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_OUTSIDE", 0x20)},
12849  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_VIEWPORT", 0x40)},
12850  {SWIG_LUA_CONSTTAB_INT("PL_POSITION_SUBPAGE", 0x80)},
12851  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_NULL", 0x0)},
12852  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_NONE", 0x1)},
12853  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_COLOR_BOX", 0x2)},
12854  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_LINE", 0x4)},
12855  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_SYMBOL", 0x8)},
12856  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_TEXT_LEFT", 0x10)},
12857  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_BACKGROUND", 0x20)},
12858  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_BOUNDING_BOX", 0x40)},
12859  {SWIG_LUA_CONSTTAB_INT("PL_LEGEND_ROW_MAJOR", 0x80)},
12860  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_NULL", 0x0)},
12861  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_LABEL_LEFT", 0x1)},
12862  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_LABEL_RIGHT", 0x2)},
12863  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_LABEL_TOP", 0x4)},
12864  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_LABEL_BOTTOM", 0x8)},
12865  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_IMAGE", 0x10)},
12866  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_SHADE", 0x20)},
12867  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_GRADIENT", 0x40)},
12868  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_CAP_NONE", 0x80)},
12869  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_CAP_LOW", 0x100)},
12870  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_CAP_HIGH", 0x200)},
12871  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_SHADE_LABEL", 0x400)},
12872  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_ORIENT_RIGHT", 0x800)},
12873  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_ORIENT_TOP", 0x1000)},
12874  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_ORIENT_LEFT", 0x2000)},
12875  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_ORIENT_BOTTOM", 0x4000)},
12876  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_BACKGROUND", 0x8000)},
12877  {SWIG_LUA_CONSTTAB_INT("PL_COLORBAR_BOUNDING_BOX", 0x10000)},
12878  {SWIG_LUA_CONSTTAB_INT("PL_DRAWMODE_UNKNOWN", 0x0)},
12879  {SWIG_LUA_CONSTTAB_INT("PL_DRAWMODE_DEFAULT", 0x1)},
12880  {SWIG_LUA_CONSTTAB_INT("PL_DRAWMODE_REPLACE", 0x2)},
12881  {SWIG_LUA_CONSTTAB_INT("PL_DRAWMODE_XOR", 0x4)},
12882  {SWIG_LUA_CONSTTAB_INT("DRAW_LINEX", 0x001)},
12883  {SWIG_LUA_CONSTTAB_INT("DRAW_LINEY", 0x002)},
12884  {SWIG_LUA_CONSTTAB_INT("DRAW_LINEXY", 0x003)},
12885  {SWIG_LUA_CONSTTAB_INT("MAG_COLOR", 0x004)},
12886  {SWIG_LUA_CONSTTAB_INT("BASE_CONT", 0x008)},
12887  {SWIG_LUA_CONSTTAB_INT("TOP_CONT", 0x010)},
12888  {SWIG_LUA_CONSTTAB_INT("SURF_CONT", 0x020)},
12889  {SWIG_LUA_CONSTTAB_INT("DRAW_SIDES", 0x040)},
12890  {SWIG_LUA_CONSTTAB_INT("FACETED", 0x080)},
12891  {SWIG_LUA_CONSTTAB_INT("MESH", 0x100)},
12892  {0,0,0,0,0,0}
12893 };
12895  { "setcontlabelformat", _wrap_setcontlabelformat},
12896  { "setcontlabelparam", _wrap_setcontlabelparam},
12897  { "adv", _wrap_adv},
12898  { "arc", _wrap_arc},
12899  { "axes", _wrap_axes},
12900  { "bin", _wrap_bin},
12901  { "btime", _wrap_btime},
12902  { "bop", _wrap_bop},
12903  { "box", _wrap_box},
12904  { "box3", _wrap_box3},
12905  { "calc_world", _wrap_calc_world},
12906  { "clear", _wrap_clear},
12907  { "col0", _wrap_col0},
12908  { "col1", _wrap_col1},
12909  { "configtime", _wrap_configtime},
12910  { "cont", _wrap_cont},
12911  { "ctime", _wrap_ctime},
12912  { "cpstrm", _wrap_cpstrm},
12913  { "plend", _wrap_plend},
12914  { "plend1", _wrap_plend1},
12915  { "env", _wrap_env},
12916  { "env0", _wrap_env0},
12917  { "eop", _wrap_eop},
12918  { "errx", _wrap_errx},
12919  { "erry", _wrap_erry},
12920  { "famadv", _wrap_famadv},
12921  { "fill", _wrap_fill},
12922  { "fill3", _wrap_fill3},
12923  { "gradient", _wrap_gradient},
12924  { "flush", _wrap_flush},
12925  { "font", _wrap_font},
12926  { "fontld", _wrap_fontld},
12927  { "gchr", _wrap_gchr},
12928  { "gcol0", _wrap_gcol0},
12929  { "gcol0a", _wrap_gcol0a},
12930  { "gcolbg", _wrap_gcolbg},
12931  { "gcolbga", _wrap_gcolbga},
12932  { "gcompression", _wrap_gcompression},
12933  { "gdev", _wrap_gdev},
12934  { "gdidev", _wrap_gdidev},
12935  { "gdiori", _wrap_gdiori},
12936  { "gdiplt", _wrap_gdiplt},
12937  { "gfam", _wrap_gfam},
12938  { "gfci", _wrap_gfci},
12939  { "gfnam", _wrap_gfnam},
12940  { "gfont", _wrap_gfont},
12941  { "glevel", _wrap_glevel},
12942  { "gpage", _wrap_gpage},
12943  { "gra", _wrap_gra},
12944  { "griddata", _wrap_griddata},
12945  { "gspa", _wrap_gspa},
12946  { "gstrm", _wrap_gstrm},
12947  { "gver", _wrap_gver},
12948  { "gvpd", _wrap_gvpd},
12949  { "gvpw", _wrap_gvpw},
12950  { "gxax", _wrap_gxax},
12951  { "gyax", _wrap_gyax},
12952  { "gzax", _wrap_gzax},
12953  { "hist", _wrap_hist},
12954  { "hlsrgb", _wrap_hlsrgb},
12955  { "init", _wrap_init},
12956  { "join", _wrap_join},
12957  { "lab", _wrap_lab},
12958  { "legend", _wrap_legend},
12959  { "colorbar", _wrap_colorbar},
12960  { "lightsource", _wrap_lightsource},
12961  { "line", _wrap_line},
12962  { "line3", _wrap_line3},
12963  { "lsty", _wrap_lsty},
12964  { "mesh", _wrap_mesh},
12965  { "meshc", _wrap_meshc},
12966  { "mkstrm", _wrap_mkstrm},
12967  { "mtex", _wrap_mtex},
12968  { "mtex3", _wrap_mtex3},
12969  { "plot3d", _wrap_plot3d},
12970  { "plot3dc", _wrap_plot3dc},
12971  { "plot3dcl", _wrap_plot3dcl},
12972  { "surf3d", _wrap_surf3d},
12973  { "surf3dl", _wrap_surf3dl},
12974  { "parseopts", _wrap_parseopts},
12975  { "pat", _wrap_pat},
12976  { "path", _wrap_path},
12977  { "poin", _wrap_poin},
12978  { "poin3", _wrap_poin3},
12979  { "poly3", _wrap_poly3},
12980  { "prec", _wrap_prec},
12981  { "psty", _wrap_psty},
12982  { "ptex", _wrap_ptex},
12983  { "ptex3", _wrap_ptex3},
12984  { "randd", _wrap_randd},
12985  { "replot", _wrap_replot},
12986  { "rgbhls", _wrap_rgbhls},
12987  { "schr", _wrap_schr},
12988  { "scmap0", _wrap_scmap0},
12989  { "scmap0a", _wrap_scmap0a},
12990  { "scmap0n", _wrap_scmap0n},
12991  { "scmap1", _wrap_scmap1},
12992  { "scmap1a", _wrap_scmap1a},
12993  { "scmap1l", _wrap_scmap1l},
12994  { "scmap1la", _wrap_scmap1la},
12995  { "scmap1n", _wrap_scmap1n},
12996  { "scmap1_range", _wrap_scmap1_range},
12997  { "gcmap1_range", _wrap_gcmap1_range},
12998  { "scol0", _wrap_scol0},
12999  { "scol0a", _wrap_scol0a},
13000  { "scolbg", _wrap_scolbg},
13001  { "scolbga", _wrap_scolbga},
13002  { "scolor", _wrap_scolor},
13003  { "scompression", _wrap_scompression},
13004  { "sdev", _wrap_sdev},
13005  { "sdidev", _wrap_sdidev},
13006  { "sdimap", _wrap_sdimap},
13007  { "sdiori", _wrap_sdiori},
13008  { "sdiplt", _wrap_sdiplt},
13009  { "sdiplz", _wrap_sdiplz},
13010  { "seed", _wrap_seed},
13011  { "sesc", _wrap_sesc},
13012  { "setopt", _wrap_setopt},
13013  { "sfam", _wrap_sfam},
13014  { "sfci", _wrap_sfci},
13015  { "sfnam", _wrap_sfnam},
13016  { "sfont", _wrap_sfont},
13017  { "shades", _wrap_shades},
13018  { "shade", _wrap_shade},
13019  { "slabelfunc", _wrap_slabelfunc},
13020  { "smaj", _wrap_smaj},
13021  { "smin", _wrap_smin},
13022  { "sori", _wrap_sori},
13023  { "spage", _wrap_spage},
13024  { "spal0", _wrap_spal0},
13025  { "spal1", _wrap_spal1},
13026  { "spause", _wrap_spause},
13027  { "sstrm", _wrap_sstrm},
13028  { "ssub", _wrap_ssub},
13029  { "ssym", _wrap_ssym},
13030  { "star", _wrap_star},
13031  { "start", _wrap_start},
13032  { "stransform", _wrap_stransform},
13033  { "string", _wrap_string},
13034  { "string3", _wrap_string3},
13035  { "stripa", _wrap_stripa},
13036  { "stripc", _wrap_stripc},
13037  { "stripd", _wrap_stripd},
13038  { "styl", _wrap_styl},
13039  { "svect", _wrap_svect},
13040  { "svpa", _wrap_svpa},
13041  { "sxax", _wrap_sxax},
13042  { "syax", _wrap_syax},
13043  { "sym", _wrap_sym},
13044  { "szax", _wrap_szax},
13045  { "text", _wrap_text},
13046  { "timefmt", _wrap_timefmt},
13047  { "vasp", _wrap_vasp},
13048  { "vect", _wrap_vect},
13049  { "vpas", _wrap_vpas},
13050  { "vpor", _wrap_vpor},
13051  { "vsta", _wrap_vsta},
13052  { "w3d", _wrap_w3d},
13053  { "width", _wrap_width},
13054  { "wind", _wrap_wind},
13055  { "xormod", _wrap_xormod},
13056  { "map", _wrap_map},
13057  { "mapline", _wrap_mapline},
13058  { "mapstring", _wrap_mapstring},
13059  { "maptex", _wrap_maptex},
13060  { "mapfill", _wrap_mapfill},
13061  { "meridians", _wrap_meridians},
13062  { "image", _wrap_image},
13063  { "imagefr", _wrap_imagefr},
13064  { "plClearOpts", _wrap_plClearOpts},
13065  { "plResetOpts", _wrap_plResetOpts},
13066  { "plSetUsage", _wrap_plSetUsage},
13067  { "plOptUsage", _wrap_plOptUsage},
13068  { "MinMax2dGrid", _wrap_MinMax2dGrid},
13069  { "plGetCursor", _wrap_plGetCursor},
13070  { "warn", _wrap_warn},
13071  { "abort", _wrap_abort},
13072  {0,0}
13073 };
13076  0
13077 };
13079  0
13080 };
13081 
13083  "plplotluac",
13089 };
13090 #ifdef __cplusplus
13091 }
13092 #endif
13093 
13094 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
13095 
13096 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
13097 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
13098 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
13099 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};
13100 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};
13101 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};
13102 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};
13103 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};
13104 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
13105 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
13106 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
13107 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
13108 
13111  &_swigt__p_char,
13118  &_swigt__p_int,
13122 };
13123 
13124 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
13125 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
13126 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
13132 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
13133 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
13134 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
13135 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
13136 
13146  _swigc__p_int,
13150 };
13151 
13152 
13153 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
13154 
13155 /* -----------------------------------------------------------------------------
13156  * Type initialization:
13157  * This problem is tough by the requirement that no dynamic
13158  * memory is used. Also, since swig_type_info structures store pointers to
13159  * swig_cast_info structures and swig_cast_info structures store pointers back
13160  * to swig_type_info structures, we need some lookup code at initialization.
13161  * The idea is that swig generates all the structures that are needed.
13162  * The runtime then collects these partially filled structures.
13163  * The SWIG_InitializeModule function takes these initial arrays out of
13164  * swig_module, and does all the lookup, filling in the swig_module.types
13165  * array with the correct data and linking the correct swig_cast_info
13166  * structures together.
13167  *
13168  * The generated swig_type_info structures are assigned statically to an initial
13169  * array. We just loop through that array, and handle each type individually.
13170  * First we lookup if this type has been already loaded, and if so, use the
13171  * loaded structure instead of the generated one. Then we have to fill in the
13172  * cast linked list. The cast data is initially stored in something like a
13173  * two-dimensional array. Each row corresponds to a type (there are the same
13174  * number of rows as there are in the swig_type_initial array). Each entry in
13175  * a column is one of the swig_cast_info structures for that type.
13176  * The cast_initial array is actually an array of arrays, because each row has
13177  * a variable number of columns. So to actually build the cast linked list,
13178  * we find the array of casts associated with the type, and loop through it
13179  * adding the casts to the list. The one last trick we need to do is making
13180  * sure the type pointer in the swig_cast_info struct is correct.
13181  *
13182  * First off, we lookup the cast->type name to see if it is already loaded.
13183  * There are three cases to handle:
13184  * 1) If the cast->type has already been loaded AND the type we are adding
13185  * casting info to has not been loaded (it is in this module), THEN we
13186  * replace the cast->type pointer with the type pointer that has already
13187  * been loaded.
13188  * 2) If BOTH types (the one we are adding casting info to, and the
13189  * cast->type) are loaded, THEN the cast info has already been loaded by
13190  * the previous module so we just ignore it.
13191  * 3) Finally, if cast->type has not already been loaded, then we add that
13192  * swig_cast_info to the linked list (because the cast->type) pointer will
13193  * be correct.
13194  * ----------------------------------------------------------------------------- */
13195 
13196 #ifdef __cplusplus
13197 extern "C" {
13198 #if 0
13199 } /* c-mode */
13200 #endif
13201 #endif
13202 
13203 #if 0
13204 #define SWIGRUNTIME_DEBUG
13205 #endif
13206 
13207 
13208 SWIGRUNTIME void
13209 SWIG_InitializeModule(void *clientdata) {
13210  size_t i;
13211  swig_module_info *module_head, *iter;
13212  int init;
13213 
13214  /* check to see if the circular list has been setup, if not, set it up */
13215  if (swig_module.next==0) {
13216  /* Initialize the swig_module */
13220  init = 1;
13221  } else {
13222  init = 0;
13223  }
13224 
13225  /* Try and load any already created modules */
13226  module_head = SWIG_GetModule(clientdata);
13227  if (!module_head) {
13228  /* This is the first module loaded for this interpreter */
13229  /* so set the swig module into the interpreter */
13230  SWIG_SetModule(clientdata, &swig_module);
13231  } else {
13232  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
13233  iter=module_head;
13234  do {
13235  if (iter==&swig_module) {
13236  /* Our module is already in the list, so there's nothing more to do. */
13237  return;
13238  }
13239  iter=iter->next;
13240  } while (iter!= module_head);
13241 
13242  /* otherwise we must add our module into the list */
13243  swig_module.next = module_head->next;
13244  module_head->next = &swig_module;
13245  }
13246 
13247  /* When multiple interpreters are used, a module could have already been initialized in
13248  a different interpreter, but not yet have a pointer in this interpreter.
13249  In this case, we do not want to continue adding types... everything should be
13250  set up already */
13251  if (init == 0) return;
13252 
13253  /* Now work on filling in swig_module.types */
13254 #ifdef SWIGRUNTIME_DEBUG
13255  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
13256 #endif
13257  for (i = 0; i < swig_module.size; ++i) {
13258  swig_type_info *type = 0;
13259  swig_type_info *ret;
13260  swig_cast_info *cast;
13261 
13262 #ifdef SWIGRUNTIME_DEBUG
13263  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
13264 #endif
13265 
13266  /* if there is another module already loaded */
13267  if (swig_module.next != &swig_module) {
13269  }
13270  if (type) {
13271  /* Overwrite clientdata field */
13272 #ifdef SWIGRUNTIME_DEBUG
13273  printf("SWIG_InitializeModule: found type %s\n", type->name);
13274 #endif
13277 #ifdef SWIGRUNTIME_DEBUG
13278  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
13279 #endif
13280  }
13281  } else {
13282  type = swig_module.type_initial[i];
13283  }
13284 
13285  /* Insert casting types */
13286  cast = swig_module.cast_initial[i];
13287  while (cast->type) {
13288 
13289  /* Don't need to add information already in the list */
13290  ret = 0;
13291 #ifdef SWIGRUNTIME_DEBUG
13292  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
13293 #endif
13294  if (swig_module.next != &swig_module) {
13296 #ifdef SWIGRUNTIME_DEBUG
13297  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
13298 #endif
13299  }
13300  if (ret) {
13301  if (type == swig_module.type_initial[i]) {
13302 #ifdef SWIGRUNTIME_DEBUG
13303  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
13304 #endif
13305  cast->type = ret;
13306  ret = 0;
13307  } else {
13308  /* Check for casting already in the list */
13309  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
13310 #ifdef SWIGRUNTIME_DEBUG
13311  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
13312 #endif
13313  if (!ocast) ret = 0;
13314  }
13315  }
13316 
13317  if (!ret) {
13318 #ifdef SWIGRUNTIME_DEBUG
13319  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
13320 #endif
13321  if (type->cast) {
13322  type->cast->prev = cast;
13323  cast->next = type->cast;
13324  }
13325  type->cast = cast;
13326  }
13327  cast++;
13328  }
13329  /* Set entry in modules->types array equal to the type */
13330  swig_module.types[i] = type;
13331  }
13332  swig_module.types[i] = 0;
13333 
13334 #ifdef SWIGRUNTIME_DEBUG
13335  printf("**** SWIG_InitializeModule: Cast List ******\n");
13336  for (i = 0; i < swig_module.size; ++i) {
13337  int j = 0;
13339  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
13340  while (cast->type) {
13341  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
13342  cast++;
13343  ++j;
13344  }
13345  printf("---- Total casts: %d\n",j);
13346  }
13347  printf("**** SWIG_InitializeModule: Cast List ******\n");
13348 #endif
13349 }
13350 
13351 /* This function will propagate the clientdata field of type to
13352 * any new swig_type_info structures that have been added into the list
13353 * of equivalent types. It is like calling
13354 * SWIG_TypeClientData(type, clientdata) a second time.
13355 */
13356 SWIGRUNTIME void
13358  size_t i;
13359  swig_cast_info *equiv;
13360  static int init_run = 0;
13361 
13362  if (init_run) return;
13363  init_run = 1;
13364 
13365  for (i = 0; i < swig_module.size; i++) {
13366  if (swig_module.types[i]->clientdata) {
13367  equiv = swig_module.types[i]->cast;
13368  while (equiv) {
13369  if (!equiv->converter) {
13370  if (equiv->type && !equiv->type->clientdata)
13372  }
13373  equiv = equiv->next;
13374  }
13375  }
13376  }
13377 }
13378 
13379 #ifdef __cplusplus
13380 #if 0
13381 { /* c-mode */
13382 #endif
13383 }
13384 #endif
13385 
13386 
13387 
13388 /* Forward declaration of where the user's %init{} gets inserted */
13389 void SWIG_init_user(lua_State* L );
13390 
13391 #ifdef __cplusplus
13392 extern "C" {
13393 #endif
13394 /* this is the initialization function
13395  added at the very end of the code
13396  the function is always called SWIG_init, but an earlier #define will rename it
13397 */
13398 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
13399 LUALIB_API int SWIG_init(lua_State* L)
13400 #else
13401 SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
13402 #endif
13403 {
13404 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */
13405  int i;
13406  int globalRegister = 0;
13407  /* start with global table */
13408  lua_pushglobaltable (L);
13409  /* SWIG's internal initialisation */
13410  SWIG_InitializeModule((void*)L);
13412 #endif
13413 
13414 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE)
13415  /* add a global fn */
13416  SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
13418 #endif
13419 
13420 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
13421  /* set up base class pointers (the hierarchy) */
13422  for (i = 0; swig_types[i]; i++){
13423  if (swig_types[i]->clientdata){
13424  SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
13425  }
13426  }
13427 #ifdef SWIG_LUA_MODULE_GLOBAL
13428  globalRegister = 1;
13429 #endif
13430 
13431 
13432 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
13433  SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister);
13434 #endif
13435 
13436 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
13437  for (i = 0; swig_types[i]; i++){
13438  if (swig_types[i]->clientdata){
13439  SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata));
13440  }
13441  }
13442 #endif
13443 
13444 #if defined(SWIG_LUA_ELUA_EMULATE)
13445  lua_newtable(L);
13446  SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods);
13447  SWIG_Lua_elua_emulate_register_clear(L);
13448  if(globalRegister) {
13449  lua_pushstring(L,swig_SwigModule.name);
13450  lua_pushvalue(L,-2);
13451  lua_rawset(L,-4);
13452  }
13453 #endif
13454 
13455 #endif
13456 
13457 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
13458  /* invoke user-specific initialization */
13459  SWIG_init_user(L);
13460  /* end module */
13461  /* Note: We do not clean up the stack here (Lua will do this for us). At this
13462  point, we have the globals table and out module table on the stack. Returning
13463  one value makes the module table the result of the require command. */
13464  return 1;
13465 #else
13466  return 0;
13467 #endif
13468 }
13469 
13470 #ifdef __cplusplus
13471 }
13472 #endif
13473 
13474 
13475 const char* SWIG_LUACODE=
13476  "\n"
13477  " pl = plplotluac";
13478 
13479 void SWIG_init_user(lua_State* L)
13480 {
13481  /* exec Lua code if applicable */
13483 }
13484 
pllsty
#define pllsty
Definition: plplot.h:763
_wrap_sdiplt
static int _wrap_sdiplt(lua_State *L)
Definition: plplotluacLUA_wrap.c:9375
_wrap_vpor
static int _wrap_vpor(lua_State *L)
Definition: plplotluacLUA_wrap.c:11555
_wrap_scmap0a
static int _wrap_scmap0a(lua_State *L)
Definition: plplotluacLUA_wrap.c:8547
swig_lua_rawdata::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:1023
SWIG_DOSTRING_FAIL
#define SWIG_DOSTRING_FAIL(S)
Definition: plplotluacLUA_wrap.c:2638
SWIG_check_num_args
#define SWIG_check_num_args(func_name, a, b)
Definition: plplotluacLUA_wrap.c:1054
swig_lua_class::destructor
void(* destructor)(void *)
Definition: plplotluacLUA_wrap.c:1000
plsstrm
#define plsstrm
Definition: plplot.h:835
plsdidev
#define plsdidev
Definition: plplot.h:807
SWIG_UnpackData
const SWIGRUNTIME char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
Definition: plplotluacLUA_wrap.c:634
_wrap_PLGraphicsIn_pY_set
static int _wrap_PLGraphicsIn_pY_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3566
plspage
#define plspage
Definition: plplot.h:831
plshade
#define plshade
Definition: plplot.h:820
_wrap_gcol0a
static int _wrap_gcol0a(lua_State *L)
Definition: plplotluacLUA_wrap.c:5274
plsurf3d
#define plsurf3d
Definition: plplot.h:847
_wrap_join
static int _wrap_join(lua_State *L)
Definition: plplotluacLUA_wrap.c:6135
f2eval_func
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
Definition: plplotluacLUA_wrap.c:3065
_wrap_PLGraphicsIn_button_get
static int _wrap_PLGraphicsIn_button_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3385
_wrap_PLGraphicsIn_wY_set
static int _wrap_PLGraphicsIn_wY_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3766
plssym
#define plssym
Definition: plplot.h:837
plinit
#define plinit
Definition: plplot.h:755
swig_cast_info
struct swig_cast_info swig_cast_info
SWIG_TypeDynamicCast
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
Definition: plplotluacLUA_wrap.c:470
swig_lua_userdata::own
int own
Definition: plplotluacLUA_wrap.c:1013
swig_SwigModule_namespaces
static swig_lua_namespace * swig_SwigModule_namespaces[]
Definition: plplotluacLUA_wrap.c:13078
plrandd
#define plrandd
Definition: plplot.h:787
_swigc__p_f_double_double__int
static swig_cast_info _swigc__p_f_double_double__int[]
Definition: plplotluacLUA_wrap.c:13127
swig_type_info
struct swig_type_info swig_type_info
plsfci
#define plsfci
Definition: plplot.h:817
myct_funcstr
static char myct_funcstr[255]
Definition: plplotluacLUA_wrap.c:3117
plerry
#define plerry
Definition: plplot.h:715
_wrap_env0
static int _wrap_env0(lua_State *L)
Definition: plplotluacLUA_wrap.c:4797
plMinMax2dGrid
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition: plmem.c:141
_wrap_PLGraphicsIn_subwindow_get
static int _wrap_PLGraphicsIn_subwindow_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3435
SWIGINTERNINLINE
#define SWIGINTERNINLINE
Definition: plplotluacLUA_wrap.c:82
_wrap_rgbhls
static int _wrap_rgbhls(lua_State *L)
Definition: plplotluacLUA_wrap.c:8420
_wrap_plot3dcl
static int _wrap_plot3dcl(lua_State *L)
Definition: plplotluacLUA_wrap.c:7535
plptex3
#define plptex3
Definition: plplot.h:786
swig_type_initial
static swig_type_info * swig_type_initial[]
Definition: plplotluacLUA_wrap.c:13109
_wrap_line3
static int _wrap_line3(lua_State *L)
Definition: plplotluacLUA_wrap.c:6994
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotluacLUA_wrap.c:3062
plgspa
#define plgspa
Definition: plplot.h:743
_wrap_plGetCursor
static int _wrap_plGetCursor(lua_State *L)
Definition: plplotluacLUA_wrap.c:12637
_swigc__p_PLGraphicsIn
static swig_cast_info _swigc__p_PLGraphicsIn[]
Definition: plplotluacLUA_wrap.c:13124
PLcGrid::nz
PLINT nz
Definition: plplot.h:509
PL_UNUSED
#define PL_UNUSED(x)
Definition: plplot.h:138
_wrap_gdiplt
static int _wrap_gdiplt(lua_State *L)
Definition: plplotluacLUA_wrap.c:5466
myL
static lua_State * myL
Definition: plplotluacLUA_wrap.c:2997
_wrap_poin
static int _wrap_poin(lua_State *L)
Definition: plplotluacLUA_wrap.c:8053
_wrap_setopt
static int _wrap_setopt(lua_State *L)
Definition: plplotluacLUA_wrap.c:9470
swig_module
static swig_module_info swig_module
Definition: plplotluacLUA_wrap.c:2684
plstart
#define plstart
Definition: plplot.h:839
SWIG_Lua_namespace_get
SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:1265
SWIG_PackData
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
Definition: plplotluacLUA_wrap.c:618
_wrap_sfnam
static int _wrap_sfnam(lua_State *L)
Definition: plplotluacLUA_wrap.c:9538
swig_lua_namespace::name
const char * name
Definition: plplotluacLUA_wrap.c:987
plgcolbg
#define plgcolbg
Definition: plplot.h:726
SWIGRUNTIME
#define SWIGRUNTIME
Definition: plplotluacLUA_wrap.c:173
plsym
#define plsym
Definition: plplot.h:853
_wrap_plot3d
static int _wrap_plot3d(lua_State *L)
Definition: plplotluacLUA_wrap.c:7347
mylabel_funcstr
static char mylabel_funcstr[255]
Definition: plplotluacLUA_wrap.c:3161
_wrap_scolbga
static int _wrap_scolbga(lua_State *L)
Definition: plplotluacLUA_wrap.c:9209
swig_SwigModule_attributes
static swig_lua_attribute swig_SwigModule_attributes[]
Definition: plplotluacLUA_wrap.c:12703
plimage
#define plimage
Definition: plplot.h:753
plgcol0a
#define plgcol0a
Definition: plplot.h:725
_wrap_setcontlabelformat
static int _wrap_setcontlabelformat(lua_State *L)
Definition: plplotluacLUA_wrap.c:3892
_wrap_PLGraphicsIn_dY_set
static int _wrap_PLGraphicsIn_dY_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3666
swig_lua_rawdata::own
int own
Definition: plplotluacLUA_wrap.c:1024
swig_SwigModule_classes
static swig_lua_class * swig_SwigModule_classes[]
Definition: plplotluacLUA_wrap.c:13074
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:2896
_wrap_seed
static int _wrap_seed(lua_State *L)
Definition: plplotluacLUA_wrap.c:9431
_wrap_eop
static int _wrap_eop(lua_State *L)
Definition: plplotluacLUA_wrap.c:4831
pllab
#define pllab
Definition: plplot.h:757
_wrap_poin3
static int _wrap_poin3(lua_State *L)
Definition: plplotluacLUA_wrap.c:8105
swig_module_info::cast_initial
swig_cast_info ** cast_initial
Definition: plplotluacLUA_wrap.c:354
SWIG_Lua_class_equal
SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L)
Definition: plplotluacLUA_wrap.c:1799
_wrap_gstrm
static int _wrap_gstrm(lua_State *L)
Definition: plplotluacLUA_wrap.c:5858
_wrap_imagefr
static int _wrap_imagefr(lua_State *L)
Definition: plplotluacLUA_wrap.c:12217
_wrap_gfam
static int _wrap_gfam(lua_State *L)
Definition: plplotluacLUA_wrap.c:5498
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:2090
plarc
#define plarc
Definition: plplot.h:693
swig_lua_const_info::type
int type
Definition: plplotluacLUA_wrap.c:967
SWIG_Lua_set_immutable
SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
Definition: plplotluacLUA_wrap.c:1109
plprec
#define plprec
Definition: plplot.h:783
_wrap_gcol0
static int _wrap_gcol0(lua_State *L)
Definition: plplotluacLUA_wrap.c:5243
swig_lua_rawdata::data
char data[1]
Definition: plplotluacLUA_wrap.c:1025
_swigt__p_char
static swig_type_info _swigt__p_char
Definition: plplotluacLUA_wrap.c:13097
_wrap_lab
static int _wrap_lab(lua_State *L)
Definition: plplotluacLUA_wrap.c:6163
SWIG_Lua_add_namespace_details
SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
Definition: plplotluacLUA_wrap.c:1340
SWIG_TypeCmp
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
Definition: plplotluacLUA_wrap.c:381
_wrap_slabelfunc
static int _wrap_slabelfunc(lua_State *L)
Definition: plplotluacLUA_wrap.c:10217
plsetopt
#define plsetopt
Definition: plplot.h:815
plclear
#define plclear
Definition: plplot.h:701
plschr
#define plschr
Definition: plplot.h:790
_wrap_PLGraphicsIn_keysym_set
static int _wrap_PLGraphicsIn_keysym_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3307
pltimefmt
#define pltimefmt
Definition: plplot.h:856
plabort
void plabort(PLCHAR_VECTOR errormsg)
Definition: plctrl.c:1894
plssub
#define plssub
Definition: plplot.h:836
plctime
#define plctime
Definition: plplot.h:708
PLBOOL
PLINT PLBOOL
Definition: plplot.h:204
SWIG_Lua_InstallConstants
SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[])
Definition: plplotluacLUA_wrap.c:2589
_wrap_map
static int _wrap_map(lua_State *L)
Definition: plplotluacLUA_wrap.c:11718
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:2863
SWIG_Lua_pushferrstring
SWIGRUNTIME void SWIG_Lua_pushferrstring(lua_State *L, const char *fmt,...)
Definition: plplotluacLUA_wrap.c:930
pllegend
#define pllegend
Definition: plplot.h:758
swig_type_info::dcast
swig_dycast_func dcast
Definition: plplotluacLUA_wrap.c:332
plcolorbar
#define plcolorbar
Definition: plplot.h:704
SWIG_Lua_get_table
#define SWIG_Lua_get_table(L, n)
Definition: plplotluacLUA_wrap.c:1060
swig_module_info::type_initial
swig_type_info ** type_initial
Definition: plplotluacLUA_wrap.c:353
_wrap_szax
static int _wrap_szax(lua_State *L)
Definition: plplotluacLUA_wrap.c:11140
value
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
swig_module_info
Definition: plplotluacLUA_wrap.c:349
mapform_funcstr
static char mapform_funcstr[255]
Definition: plplotluacLUA_wrap.c:2998
_wrap_PLGraphicsIn_subwindow_set
static int _wrap_PLGraphicsIn_subwindow_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3409
plcont
#define plcont
Definition: plplot.h:706
PLcGrid::nx
PLINT nx
Definition: plplot.h:509
swig_lua_class::cls_static
swig_lua_namespace * cls_static
Definition: plplotluacLUA_wrap.c:1003
_wrap_vsta
static int _wrap_vsta(lua_State *L)
Definition: plplotluacLUA_wrap.c:11583
plscmap1
#define plscmap1
Definition: plplot.h:794
plscmap0a
#define plscmap0a
Definition: plplot.h:792
_wrap_gcolbg
static int _wrap_gcolbg(lua_State *L)
Definition: plplotluacLUA_wrap.c:5309
swig_cast_info::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:340
plscmap1la
#define plscmap1la
Definition: plplot.h:797
_wrap_string3
static int _wrap_string3(lua_State *L)
Definition: plplotluacLUA_wrap.c:10621
pljoin
#define pljoin
Definition: plplot.h:756
name
static const char * name
Definition: tkMain.c:135
_wrap_stripa
static int _wrap_stripa(lua_State *L)
Definition: plplotluacLUA_wrap.c:10691
plstripd
#define plstripd
Definition: plplot.h:845
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
ct_func
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotluacLUA_wrap.c:3063
plmesh
#define plmesh
Definition: plplot.h:770
plxormod
#define plxormod
Definition: plplot.h:865
swig_lua_const_info::pvalue
void * pvalue
Definition: plplotluacLUA_wrap.c:971
_wrap_sdiori
static int _wrap_sdiori(lua_State *L)
Definition: plplotluacLUA_wrap.c:9356
plwarn
void plwarn(PLCHAR_VECTOR errormsg)
Definition: plctrl.c:1863
SWIG_TypeEquiv
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
Definition: plplotluacLUA_wrap.c:400
plvpor
#define plvpor
Definition: plplot.h:860
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:2491
SWIG_Lua_NewPointerObj
SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L, void *ptr, swig_type_info *type, int own)
Definition: plplotluacLUA_wrap.c:2473
swig_lua_var_info::get
lua_CFunction get
Definition: plplotluacLUA_wrap.c:955
defined_func
PLINT(* defined_func)(PLFLT, PLFLT)
Definition: plplotluacLUA_wrap.c:3060
plaxes
#define plaxes
Definition: plplot.h:694
SWIG_Lua_populate_inheritable_metamethods
SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L)
Definition: plplotluacLUA_wrap.c:1814
_wrap_plOptUsage
static int _wrap_plOptUsage(lua_State *L)
Definition: plplotluacLUA_wrap.c:12564
_wrap_scmap1a
static int _wrap_scmap1a(lua_State *L)
Definition: plplotluacLUA_wrap.c:8720
plgcolbga
#define plgcolbga
Definition: plplot.h:727
_wrap_scompression
static int _wrap_scompression(lua_State *L)
Definition: plplotluacLUA_wrap.c:9256
_wrap_scol0
static int _wrap_scol0(lua_State *L)
Definition: plplotluacLUA_wrap.c:9125
_wrap_PLGraphicsIn_pX_get
static int _wrap_PLGraphicsIn_pX_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3542
swig_module_info::next
struct swig_module_info * next
Definition: plplotluacLUA_wrap.c:352
_wrap_pat
static int _wrap_pat(lua_State *L)
Definition: plplotluacLUA_wrap.c:7974
_wrap_start
static int _wrap_start(lua_State *L)
Definition: plplotluacLUA_wrap.c:10503
SWIG_LUA_FLOAT
#define SWIG_LUA_FLOAT
Definition: plplotluacLUA_wrap.c:946
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:1985
SWIG_Lua_namespace_set
SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:1302
plgyax
#define plgyax
Definition: plplot.h:749
SWIG_Lua_init_base_class
SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:1903
SWIG_Lua_dostring
SWIGINTERN int SWIG_Lua_dostring(lua_State *L, const char *str)
Definition: plplotluacLUA_wrap.c:2646
SWIG_Lua_class_tostring
SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L)
Definition: plplotluacLUA_wrap.c:1771
SWIG_Lua_create_class_registry
SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L)
Definition: plplotluacLUA_wrap.c:1834
plcol1
#define plcol1
Definition: plplot.h:703
plgvpd
#define plgvpd
Definition: plplot.h:746
_wrap_plend
static int _wrap_plend(lua_State *L)
Definition: plplotluacLUA_wrap.c:4731
plpsty
#define plpsty
Definition: plplot.h:784
_wrap_vpas
static int _wrap_vpas(lua_State *L)
Definition: plplotluacLUA_wrap.c:11524
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
LUA_DECLARE_TYPEMAP_ARR_FN
#define LUA_DECLARE_TYPEMAP_ARR_FN(NAME, TYPE)
Definition: plplotluacLUA_wrap.c:2704
_wrap_gdev
static int _wrap_gdev(lua_State *L)
Definition: plplotluacLUA_wrap.c:5389
SWIG_LUA_CONSTTAB_INT
#define SWIG_LUA_CONSTTAB_INT(B, C)
Definition: plplotluacLUA_wrap.c:839
pltr2
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:941
SWIG_GetModule
#define SWIG_GetModule(clientdata)
Definition: plplotluacLUA_wrap.c:1037
SWIG_UnpackVoidPtr
const SWIGRUNTIME char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
Definition: plplotluacLUA_wrap.c:673
swig_lua_userdata::ptr
void * ptr
Definition: plplotluacLUA_wrap.c:1014
plbop
#define plbop
Definition: plplot.h:696
swig_lua_namespace
Definition: plplotluacLUA_wrap.c:986
_swigt__p_int
static swig_type_info _swigt__p_int
Definition: plplotluacLUA_wrap.c:13104
plsdiplt
#define plsdiplt
Definition: plplot.h:810
SWIG_FREE_ARRAY
#define SWIG_FREE_ARRAY(PTR)
Definition: plplotluacLUA_wrap.c:2754
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:2019
_wrap_sesc
static int _wrap_sesc(lua_State *L)
Definition: plplotluacLUA_wrap.c:9451
_wrap_plClearOpts
static int _wrap_plClearOpts(lua_State *L)
Definition: plplotluacLUA_wrap.c:12510
plsurf3dl
#define plsurf3dl
Definition: plplot.h:848
swig_delete_PLGraphicsIn
static void swig_delete_PLGraphicsIn(void *obj)
Definition: plplotluacLUA_wrap.c:3833
SWIG_Lua_class_get
SWIGINTERN int SWIG_Lua_class_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:1636
plslabelfunc
#define plslabelfunc
Definition: plplot.h:825
PLcGrid2::xg
PLFLT_NC_MATRIX xg
Definition: plplot.h:520
pl_setcontlabelparam
#define pl_setcontlabelparam
Definition: plplot.h:691
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:2877
_wrap_PLGraphicsIn_dX_set
static int _wrap_PLGraphicsIn_dX_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3616
plgradient
#define plgradient
Definition: plplot.h:741
plgdiori
#define plgdiori
Definition: plplot.h:731
_wrap_sfont
static int _wrap_sfont(lua_State *L)
Definition: plplotluacLUA_wrap.c:9557
_wrap_PLGraphicsIn_wX_get
static int _wrap_PLGraphicsIn_wX_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3742
_wrap_gra
static int _wrap_gra(lua_State *L)
Definition: plplotluacLUA_wrap.c:5659
plgdiplt
#define plgdiplt
Definition: plplot.h:732
plmeridians
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
SWIG_itable_size
SWIGINTERN int SWIG_itable_size(lua_State *L, int index)
Definition: plplotluacLUA_wrap.c:2757
_wrap_schr
static int _wrap_schr(lua_State *L)
Definition: plplotluacLUA_wrap.c:8457
_wrap_line
static int _wrap_line(lua_State *L)
Definition: plplotluacLUA_wrap.c:6945
swig_type_info::cast
struct swig_cast_info * cast
Definition: plplotluacLUA_wrap.c:333
_wrap_image
static int _wrap_image(lua_State *L)
Definition: plplotluacLUA_wrap.c:12138
SWIG_LUA_INT
#define SWIG_LUA_INT
Definition: plplotluacLUA_wrap.c:945
plline3
#define plline3
Definition: plplot.h:762
SWIG_NullReferenceError
#define SWIG_NullReferenceError
Definition: plplotluacLUA_wrap.c:730
swig_lua_namespace::ns_constants
swig_lua_const_info * ns_constants
Definition: plplotluacLUA_wrap.c:990
_wrap_scmap1la
static int _wrap_scmap1la(lua_State *L)
Definition: plplotluacLUA_wrap.c:8924
plsfam
#define plsfam
Definition: plplot.h:816
plsfnam
#define plsfnam
Definition: plplot.h:818
plflush
#define plflush
Definition: plplot.h:719
SWIG_Lua_class_set
SWIGINTERN int SWIG_Lua_class_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:1725
swig_lua_namespace::ns_methods
swig_lua_method * ns_methods
Definition: plplotluacLUA_wrap.c:988
_wrap_font
static int _wrap_font(lua_State *L)
Definition: plplotluacLUA_wrap.c:5181
SWIGRUNTIMEINLINE
#define SWIGRUNTIMEINLINE
Definition: plplotluacLUA_wrap.c:177
SWIG_Lua_class_disown
SWIGINTERN int SWIG_Lua_class_disown(lua_State *L)
Definition: plplotluacLUA_wrap.c:1784
SWIG_init
#define SWIG_init
Definition: plplotluacLUA_wrap.c:2691
plgfam
#define plgfam
Definition: plplot.h:734
SWIG_Lua_class_register_static
SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:2267
SWIG_RUNTIME_VERSION
#define SWIG_RUNTIME_VERSION
Definition: plplotluacLUA_wrap.c:152
plsmin
#define plsmin
Definition: plplot.h:829
plscolor
#define plscolor
Definition: plplot.h:804
_wrap_prec
static int _wrap_prec(lua_State *L)
Definition: plplotluacLUA_wrap.c:8263
SWIG_Lua_get_class_metatable
SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L, const char *cname)
Definition: plplotluacLUA_wrap.c:1888
plconfigtime
#define plconfigtime
Definition: plplot.h:705
_wrap_PLGraphicsIn_state_set
static int _wrap_PLGraphicsIn_state_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3256
SWIG_ERROR
#define SWIG_ERROR
Definition: plplotluacLUA_wrap.c:274
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplotluacLUA_wrap.c:3064
_wrap_plend1
static int _wrap_plend1(lua_State *L)
Definition: plplotluacLUA_wrap.c:4747
lua_rawsetp
#define lua_rawsetp(L, index, ptr)
Definition: plplotluacLUA_wrap.c:900
plscmap1n
#define plscmap1n
Definition: plplot.h:798
pltext
#define pltext
Definition: plplot.h:855
swig_SwigModule_constants
static swig_lua_const_info swig_SwigModule_constants[]
Definition: plplotluacLUA_wrap.c:12706
plgfont
#define plgfont
Definition: plplot.h:737
_wrap_gspa
static int _wrap_gspa(lua_State *L)
Definition: plplotluacLUA_wrap.c:5826
plenv
#define plenv
Definition: plplot.h:711
swig_module_info::types
swig_type_info ** types
Definition: plplotluacLUA_wrap.c:350
_wrap_scol0a
static int _wrap_scol0a(lua_State *L)
Definition: plplotluacLUA_wrap.c:9153
_wrap_mapstring
static int _wrap_mapstring(lua_State *L)
Definition: plplotluacLUA_wrap.c:11851
_wrap_scolbg
static int _wrap_scolbg(lua_State *L)
Definition: plplotluacLUA_wrap.c:9184
swig_lua_const_info::lvalue
long lvalue
Definition: plplotluacLUA_wrap.c:969
lua_rawgetp
#define lua_rawgetp(L, index, ptr)
Definition: plplotluacLUA_wrap.c:905
plscmap1a
#define plscmap1a
Definition: plplot.h:795
mapform
void mapform(PLINT n, PLFLT *x, PLFLT *y)
Definition: plplotluacLUA_wrap.c:3000
plstyl
#define plstyl
Definition: plplot.h:846
swig_lua_class::base_names
const char ** base_names
Definition: plplotluacLUA_wrap.c:1006
_wrap_replot
static int _wrap_replot(lua_State *L)
Definition: plplotluacLUA_wrap.c:8404
_swigt__p_double
static swig_type_info _swigt__p_double
Definition: plplotluacLUA_wrap.c:13098
_wrap_mapline
static int _wrap_mapline(lua_State *L)
Definition: plplotluacLUA_wrap.c:11773
_wrap_gdidev
static int _wrap_gdidev(lua_State *L)
Definition: plplotluacLUA_wrap.c:5414
_wrap_col1
static int _wrap_col1(lua_State *L)
Definition: plplotluacLUA_wrap.c:4307
_wrap_sfam
static int _wrap_sfam(lua_State *L)
Definition: plplotluacLUA_wrap.c:9493
_wrap_PLGraphicsIn_type_get
static int _wrap_PLGraphicsIn_type_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3232
SWIG_TypeCheck
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
Definition: plplotluacLUA_wrap.c:408
swig_lua_class::type
swig_type_info ** type
Definition: plplotluacLUA_wrap.c:998
_wrap_surf3d
static int _wrap_surf3d(lua_State *L)
Definition: plplotluacLUA_wrap.c:7670
_wrap_lightsource
static int _wrap_lightsource(lua_State *L)
Definition: plplotluacLUA_wrap.c:6920
swig_cast_info
Definition: plplotluacLUA_wrap.c:339
SWIG_TypeName
const SWIGRUNTIMEINLINE char * SWIG_TypeName(const swig_type_info *ty)
Definition: plplotluacLUA_wrap.c:484
SWIGEXPORT
#define SWIGEXPORT
Definition: plplotluacLUA_wrap.c:105
_swigt__p_p_double
static swig_type_info _swigt__p_p_double
Definition: plplotluacLUA_wrap.c:13106
_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:13102
_wrap_poly3
static int _wrap_poly3(lua_State *L)
Definition: plplotluacLUA_wrap.c:8175
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:1446
PLcGrid2::zg
PLFLT_NC_MATRIX zg
Definition: plplot.h:520
_wrap_adv
static int _wrap_adv(lua_State *L)
Definition: plplotluacLUA_wrap.c:3942
plgdev
#define plgdev
Definition: plplot.h:729
mypltr
void mypltr(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
SWIG_ConvertPtr
#define SWIG_ConvertPtr(L, idx, ptr, type, flags)
Definition: plplotluacLUA_wrap.c:1030
_wrap_legend
static int _wrap_legend(lua_State *L)
Definition: plplotluacLUA_wrap.c:6188
_swigt__p_p_char
static swig_type_info _swigt__p_p_char
Definition: plplotluacLUA_wrap.c:13105
plfontld
#define plfontld
Definition: plplot.h:721
plot3dcl
#define plot3dcl
Definition: plplot.h:777
swig_lua_const_info::name
char * name
Definition: plplotluacLUA_wrap.c:968
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:2162
_wrap_PLGraphicsIn_dY_get
static int _wrap_PLGraphicsIn_dY_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3692
lua_pushglobaltable
#define lua_pushglobaltable(L)
Definition: plplotluacLUA_wrap.c:890
plfill3
#define plfill3
Definition: plplot.h:718
swig_lua_class::constructor
lua_CFunction constructor
Definition: plplotluacLUA_wrap.c:999
SWIG_fail_ptr
#define SWIG_fail_ptr(func_name, argnum, type)
Definition: plplotluacLUA_wrap.c:1052
read_double_Matrix
PLFLT ** read_double_Matrix(lua_State *L, int index, int *nx, int *ny)
Definition: plplotluacLUA_wrap.c:2908
_wrap_lsty
static int _wrap_lsty(lua_State *L)
Definition: plplotluacLUA_wrap.c:7061
plrgbhls
#define plrgbhls
Definition: plplot.h:789
PLGraphicsIn
Definition: plplot.h:433
_wrap_smaj
static int _wrap_smaj(lua_State *L)
Definition: plplotluacLUA_wrap.c:10261
_wrap_PLGraphicsIn_wY_get
static int _wrap_PLGraphicsIn_wY_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3792
plszax
#define plszax
Definition: plplot.h:854
pltr1
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
SWIG_Lua_SetModule
SWIGRUNTIME void SWIG_Lua_SetModule(lua_State *L, swig_module_info *module)
Definition: plplotluacLUA_wrap.c:1095
SWIGUNUSED
#define SWIGUNUSED
Definition: plplotluacLUA_wrap.c:57
SWIG_Lua_namespace_register
SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg)
Definition: plplotluacLUA_wrap.c:1386
_wrap_PLGraphicsIn_type_set
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3206
plfont
#define plfont
Definition: plplot.h:720
plplotP.h
SWIG_SetModule
#define SWIG_SetModule(clientdata, pointer)
Definition: plplotluacLUA_wrap.c:1038
_wrap_parseopts
static int _wrap_parseopts(lua_State *L)
Definition: plplotluacLUA_wrap.c:7905
plsvect
#define plsvect
Definition: plplot.h:849
plgcmap1_range
#define plgcmap1_range
Definition: plplot.h:723
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:2548
_wrap_scmap1n
static int _wrap_scmap1n(lua_State *L)
Definition: plplotluacLUA_wrap.c:9060
_wrap_spal0
static int _wrap_spal0(lua_State *L)
Definition: plplotluacLUA_wrap.c:10358
PLPointer
void * PLPointer
Definition: plplot.h:209
plResetOpts
void plResetOpts(void)
Definition: plargs.c:843
_wrap_gcolbga
static int _wrap_gcolbga(lua_State *L)
Definition: plplotluacLUA_wrap.c:5337
_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:13128
_swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_PLGraphicsIn
Definition: plplotluacLUA_wrap.c:13096
plbin
#define plbin
Definition: plplot.h:695
SWIG_TypeNewClientData
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
Definition: plplotluacLUA_wrap.c:530
swig_cast_info::converter
swig_converter_func converter
Definition: plplotluacLUA_wrap.c:341
plhlsrgb
#define plhlsrgb
Definition: plplot.h:752
plgfnam
#define plgfnam
Definition: plplot.h:736
plfamadv
#define plfamadv
Definition: plplot.h:716
_wrap_vect
static int _wrap_vect(lua_State *L)
Definition: plplotluacLUA_wrap.c:11216
SWIG_DECLARE_TYPEMAP_ARR_FN
#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME, TYPE)
Definition: plplotluacLUA_wrap.c:2782
lua_rawlen
#define lua_rawlen
Definition: plplotluacLUA_wrap.c:880
SWIG_Lua_class_register_instance
SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:2301
plparseopts
#define plparseopts
Definition: plplot.h:778
Ylen
static PLINT Ylen
Definition: plplotluacLUA_wrap.c:2746
plsori
#define plsori
Definition: plplot.h:830
swig_lua_rawdata
Definition: plplotluacLUA_wrap.c:1022
_wrap_stransform
static int _wrap_stransform(lua_State *L)
Definition: plplotluacLUA_wrap.c:10528
SWIG_NewMemberObj
#define SWIG_NewMemberObj(L, ptr, sz, type)
Definition: plplotluacLUA_wrap.c:1034
PLcGrid2::yg
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
_wrap_hist
static int _wrap_hist(lua_State *L)
Definition: plplotluacLUA_wrap.c:6039
swig_PLGraphicsIn_bases
static swig_lua_class * swig_PLGraphicsIn_bases[]
Definition: plplotluacLUA_wrap.c:3888
_wrap_bop
static int _wrap_bop(lua_State *L)
Definition: plplotluacLUA_wrap.c:4136
_swigc__p_double
static swig_cast_info _swigc__p_double[]
Definition: plplotluacLUA_wrap.c:13126
SWIG_TypeCheckStruct
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
Definition: plplotluacLUA_wrap.c:435
_wrap_ssym
static int _wrap_ssym(lua_State *L)
Definition: plplotluacLUA_wrap.c:10459
plimagefr
#define plimagefr
Definition: plplot.h:754
plstar
#define plstar
Definition: plplot.h:838
SWIGTYPE_p_PLGraphicsIn
#define SWIGTYPE_p_PLGraphicsIn
Definition: plplotluacLUA_wrap.c:2671
plend1
#define plend1
Definition: plplot.h:710
swig_lua_class::name
const char * name
Definition: plplotluacLUA_wrap.c:996
plstripa
#define plstripa
Definition: plplot.h:843
_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:13100
_wrap_scmap1
static int _wrap_scmap1(lua_State *L)
Definition: plplotluacLUA_wrap.c:8652
swig_PLGraphicsIn_base_names
static const char * swig_PLGraphicsIn_base_names[]
Definition: plplotluacLUA_wrap.c:3889
_wrap_scmap0n
static int _wrap_scmap0n(lua_State *L)
Definition: plplotluacLUA_wrap.c:8633
_wrap_plot3dc
static int _wrap_plot3dc(lua_State *L)
Definition: plplotluacLUA_wrap.c:7435
SWIG_TypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplotluacLUA_wrap.c:589
_wrap_famadv
static int _wrap_famadv(lua_State *L)
Definition: plplotluacLUA_wrap.c:4981
plvsta
#define plvsta
Definition: plplot.h:861
swig_PLGraphicsIn_Sf_SwigStatic
static swig_lua_namespace swig_PLGraphicsIn_Sf_SwigStatic
Definition: plplotluacLUA_wrap.c:3880
_wrap_randd
static int _wrap_randd(lua_State *L)
Definition: plplotluacLUA_wrap.c:8387
_wrap_cont
static int _wrap_cont(lua_State *L)
Definition: plplotluacLUA_wrap.c:4375
_wrap_erry
static int _wrap_erry(lua_State *L)
Definition: plplotluacLUA_wrap.c:4914
pleop
#define pleop
Definition: plplot.h:713
_wrap_meshc
static int _wrap_meshc(lua_State *L)
Definition: plplotluacLUA_wrap.c:7165
pltr0
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition: plcont.c:858
swig_lua_class::attributes
swig_lua_attribute * attributes
Definition: plplotluacLUA_wrap.c:1002
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:2002
SWIG_TypePrettyName
const SWIGRUNTIME char * SWIG_TypePrettyName(const swig_type_info *type)
Definition: plplotluacLUA_wrap.c:493
_wrap_sym
static int _wrap_sym(lua_State *L)
Definition: plplotluacLUA_wrap.c:11088
_wrap_PLGraphicsIn_wX_set
static int _wrap_PLGraphicsIn_wX_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3716
plvect
#define plvect
Definition: plplot.h:858
plgpage
#define plgpage
Definition: plplot.h:739
plsdimap
#define plsdimap
Definition: plplot.h:808
_wrap_sdiplz
static int _wrap_sdiplz(lua_State *L)
Definition: plplotluacLUA_wrap.c:9403
SWIG_InitializeModule
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
Definition: plplotluacLUA_wrap.c:13209
swig_lua_base_iterator_func
int(* swig_lua_base_iterator_func)(lua_State *, swig_type_info *, int, int *ret)
Definition: plplotluacLUA_wrap.c:1444
_proxy__wrap_new_PLGraphicsIn
static int _proxy__wrap_new_PLGraphicsIn(lua_State *L)
Definition: plplotluacLUA_wrap.c:3837
plscol0a
#define plscol0a
Definition: plplot.h:801
pllightsource
#define pllightsource
Definition: plplot.h:759
plshades
#define plshades
Definition: plplot.h:824
_wrap_box3
static int _wrap_box3(lua_State *L)
Definition: plplotluacLUA_wrap.c:4186
SWIG_fail_arg
#define SWIG_fail_arg(func_name, argnum, type)
Definition: plplotluacLUA_wrap.c:1048
SWIG_Lua_add_namespace_classes
SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
Definition: plplotluacLUA_wrap.c:1364
plgchr
#define plgchr
Definition: plplot.h:722
_wrap_gfont
static int _wrap_gfont(lua_State *L)
Definition: plplotluacLUA_wrap.c:5571
_wrap_sfci
static int _wrap_sfci(lua_State *L)
Definition: plplotluacLUA_wrap.c:9518
plsdev
#define plsdev
Definition: plplot.h:806
_wrap_glevel
static int _wrap_glevel(lua_State *L)
Definition: plplotluacLUA_wrap.c:5599
_wrap_smin
static int _wrap_smin(lua_State *L)
Definition: plplotluacLUA_wrap.c:10283
swig_lua_namespace::ns_classes
struct swig_lua_class ** ns_classes
Definition: plplotluacLUA_wrap.c:991
SWIG_Lua_add_function
#define SWIG_Lua_add_function(L, n, f)
Definition: plplotluacLUA_wrap.c:1063
_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:13130
plpoly3
#define plpoly3
Definition: plplot.h:782
plscolbg
#define plscolbg
Definition: plplot.h:802
SWIG_LUA_CONSTTAB_FLOAT
#define SWIG_LUA_CONSTTAB_FLOAT(B, C)
Definition: plplotluacLUA_wrap.c:840
swig_lua_namespace
struct swig_lua_namespace swig_lua_namespace
_wrap_ptex3
static int _wrap_ptex3(lua_State *L)
Definition: plplotluacLUA_wrap.c:8338
_wrap_sori
static int _wrap_sori(lua_State *L)
Definition: plplotluacLUA_wrap.c:10305
_wrap_cpstrm
static int _wrap_cpstrm(lua_State *L)
Definition: plplotluacLUA_wrap.c:4709
plseed
#define plseed
Definition: plplot.h:813
_wrap_griddata
static int _wrap_griddata(lua_State *L)
Definition: plplotluacLUA_wrap.c:5675
plstring
#define plstring
Definition: plplot.h:841
plpath
#define plpath
Definition: plplot.h:761
_wrap_new_PLGraphicsIn
static int _wrap_new_PLGraphicsIn(lua_State *L)
Definition: plplotluacLUA_wrap.c:3816
_wrap_text
static int _wrap_text(lua_State *L)
Definition: plplotluacLUA_wrap.c:11162
Alen
static PLINT Alen
Definition: plplotluacLUA_wrap.c:2745
PLcGrid::yg
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
plscolbga
#define plscolbga
Definition: plplot.h:803
plbox3
#define plbox3
Definition: plplot.h:698
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:1663
PLcGrid
Definition: plplot.h:506
PLINT
int PLINT
Definition: plplot.h:181
plcpstrm
#define plcpstrm
Definition: plplot.h:707
plClearOpts
void plClearOpts(void)
Definition: plargs.c:830
SWIG_Lua_AddMetatable
SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L, swig_type_info *type)
Definition: plplotluacLUA_wrap.c:2456
PLcGrid::zg
PLFLT_NC_FE_POINTER zg
Definition: plplot.h:508
_wrap_gzax
static int _wrap_gzax(lua_State *L)
Definition: plplotluacLUA_wrap.c:6015
SWIG_isptrtype
#define SWIG_isptrtype(L, I)
Definition: plplotluacLUA_wrap.c:1074
plreplot
#define plreplot
Definition: plplot.h:788
SWIG_LUA_CHAR
#define SWIG_LUA_CHAR
Definition: plplotluacLUA_wrap.c:950
_wrap_gver
static int _wrap_gver(lua_State *L)
Definition: plplotluacLUA_wrap.c:5878
plsmaj
#define plsmaj
Definition: plplot.h:826
plstring3
#define plstring3
Definition: plplot.h:842
plcalc_world
#define plcalc_world
Definition: plplot.h:700
SWIG_Lua_type
SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
Definition: plplotluacLUA_wrap.c:2576
plstripc
#define plstripc
Definition: plplot.h:844
PLcGrid2::nx
PLINT nx
Definition: plplot.h:521
_wrap_surf3dl
static int _wrap_surf3dl(lua_State *L)
Definition: plplotluacLUA_wrap.c:7770
SWIG_Lua_GetModule
SWIGRUNTIME swig_module_info * SWIG_Lua_GetModule(lua_State *L)
Definition: plplotluacLUA_wrap.c:1084
swig_lua_attribute
Definition: plplotluacLUA_wrap.c:977
plvpas
#define plvpas
Definition: plplot.h:859
SWIG_TypeNameComp
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
Definition: plplotluacLUA_wrap.c:366
_wrap_plSetUsage
static int _wrap_plSetUsage(lua_State *L)
Definition: plplotluacLUA_wrap.c:12542
_wrap_plResetOpts
static int _wrap_plResetOpts(lua_State *L)
Definition: plplotluacLUA_wrap.c:12526
SWIG_NewPointerObj
#define SWIG_NewPointerObj(L, ptr, type, owner)
Definition: plplotluacLUA_wrap.c:1029
_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:13101
SWIG_table_size
SWIGINTERN int SWIG_table_size(lua_State *L, int index)
Definition: plplotluacLUA_wrap.c:2770
_wrap_path
static int _wrap_path(lua_State *L)
Definition: plplotluacLUA_wrap.c:8022
swig_PLGraphicsIn_meta
static swig_lua_method swig_PLGraphicsIn_meta[]
Definition: plplotluacLUA_wrap.c:3863
swig_PLGraphicsIn_Sf_SwigStatic_classes
static swig_lua_class * swig_PLGraphicsIn_Sf_SwigStatic_classes[]
Definition: plplotluacLUA_wrap.c:3876
SWIG_TypeCast
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
Definition: plplotluacLUA_wrap.c:462
_wrap_mkstrm
static int _wrap_mkstrm(lua_State *L)
Definition: plplotluacLUA_wrap.c:7265
swig_PLGraphicsIn_Sf_SwigStatic_methods
static swig_lua_method swig_PLGraphicsIn_Sf_SwigStatic_methods[]
Definition: plplotluacLUA_wrap.c:3873
_wrap_ctime
static int _wrap_ctime(lua_State *L)
Definition: plplotluacLUA_wrap.c:4671
_wrap_wind
static int _wrap_wind(lua_State *L)
Definition: plplotluacLUA_wrap.c:11667
_wrap_gcompression
static int _wrap_gcompression(lua_State *L)
Definition: plplotluacLUA_wrap.c:5369
mypltr_funcstr
static char mypltr_funcstr[255]
Definition: plplotluacLUA_wrap.c:3073
_wrap_scmap0
static int _wrap_scmap0(lua_State *L)
Definition: plplotluacLUA_wrap.c:8479
swig_lua_attribute::setmethod
lua_CFunction setmethod
Definition: plplotluacLUA_wrap.c:980
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
plmeshc
#define plmeshc
Definition: plplot.h:771
_wrap_ptex
static int _wrap_ptex(lua_State *L)
Definition: plplotluacLUA_wrap.c:8304
_wrap_PLGraphicsIn_string_get
static int _wrap_PLGraphicsIn_string_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3492
SWIG_ALLOC_ARRAY
#define SWIG_ALLOC_ARRAY(TYPE, LEN)
Definition: plplotluacLUA_wrap.c:2753
_wrap_gpage
static int _wrap_gpage(lua_State *L)
Definition: plplotluacLUA_wrap.c:5619
plline
#define plline
Definition: plplot.h:760
plgcompression
#define plgcompression
Definition: plplot.h:728
_wrap_env
static int _wrap_env(lua_State *L)
Definition: plplotluacLUA_wrap.c:4763
_swigt__p_unsigned_int
static swig_type_info _swigt__p_unsigned_int
Definition: plplotluacLUA_wrap.c:13107
_swigc__p_p_double
static swig_cast_info _swigc__p_p_double[]
Definition: plplotluacLUA_wrap.c:13134
swig_lua_attribute::getmethod
lua_CFunction getmethod
Definition: plplotluacLUA_wrap.c:979
LUA_FREE_ARRAY
#define LUA_FREE_ARRAY(PTR)
Definition: plplotluacLUA_wrap.c:2700
_wrap_gxax
static int _wrap_gxax(lua_State *L)
Definition: plplotluacLUA_wrap.c:5967
_wrap_gvpw
static int _wrap_gvpw(lua_State *L)
Definition: plplotluacLUA_wrap.c:5935
SWIG_LUA_STRING
#define SWIG_LUA_STRING
Definition: plplotluacLUA_wrap.c:947
_wrap_MinMax2dGrid
static int _wrap_MinMax2dGrid(lua_State *L)
Definition: plplotluacLUA_wrap.c:12580
swig_lua_var_info::name
const char * name
Definition: plplotluacLUA_wrap.c:954
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:2210
swig_lua_class::methods
swig_lua_method * methods
Definition: plplotluacLUA_wrap.c:1001
mylabel
void mylabel(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
_wrap_PLGraphicsIn_button_set
static int _wrap_PLGraphicsIn_button_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3358
_swigt__p_f_double_double__int
static swig_type_info _swigt__p_f_double_double__int
Definition: plplotluacLUA_wrap.c:13099
_wrap_w3d
static int _wrap_w3d(lua_State *L)
Definition: plplotluacLUA_wrap.c:11599
plspause
#define plspause
Definition: plplot.h:834
SWIG_AddCast
#define SWIG_AddCast(r)
Definition: plplotluacLUA_wrap.c:314
_wrap_vasp
static int _wrap_vasp(lua_State *L)
Definition: plplotluacLUA_wrap.c:11197
plspal0
#define plspal0
Definition: plplot.h:832
_wrap_mtex
static int _wrap_mtex(lua_State *L)
Definition: plplotluacLUA_wrap.c:7285
SWIG_Lua_add_boolean
#define SWIG_Lua_add_boolean(L, n, b)
Definition: plplotluacLUA_wrap.c:1068
PLcGrid2
Definition: plplot.h:518
_wrap_colorbar
static int _wrap_colorbar(lua_State *L)
Definition: plplotluacLUA_wrap.c:6670
plsesc
#define plsesc
Definition: plplot.h:814
swig_lua_class::bases
struct swig_lua_class ** bases
Definition: plplotluacLUA_wrap.c:1005
plptex
#define plptex
Definition: plplot.h:785
SWIG_POINTER_DISOWN
#define SWIG_POINTER_DISOWN
Definition: plplotluacLUA_wrap.c:186
swig_type_info::str
const char * str
Definition: plplotluacLUA_wrap.c:331
_wrap_warn
static int _wrap_warn(lua_State *L)
Definition: plplotluacLUA_wrap.c:12661
plscol0
#define plscol0
Definition: plplot.h:800
plgver
#define plgver
Definition: plplot.h:745
swig_cast_initial
static swig_cast_info * swig_cast_initial[]
Definition: plplotluacLUA_wrap.c:13137
_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:13103
_wrap_star
static int _wrap_star(lua_State *L)
Definition: plplotluacLUA_wrap.c:10481
_wrap_init
static int _wrap_init(lua_State *L)
Definition: plplotluacLUA_wrap.c:6119
plSetUsage
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition: plargs.c:1287
SWIGINTERN
#define SWIGINTERN
Definition: plplotluacLUA_wrap.c:77
_wrap_sdidev
static int _wrap_sdidev(lua_State *L)
Definition: plplotluacLUA_wrap.c:9294
SWIG_lua_isnilstring
SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx)
Definition: plplotluacLUA_wrap.c:3196
swig_lua_const_info
Definition: plplotluacLUA_wrap.c:966
plwidth
#define plwidth
Definition: plplot.h:863
plbtime
#define plbtime
Definition: plplot.h:699
plstransform
#define plstransform
Definition: plplot.h:840
_wrap_gfci
static int _wrap_gfci(lua_State *L)
Definition: plplotluacLUA_wrap.c:5526
plspal1
#define plspal1
Definition: plplot.h:833
plcol0
#define plcol0
Definition: plplot.h:702
SWIG_MangledTypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplotluacLUA_wrap.c:544
_wrap_gyax
static int _wrap_gyax(lua_State *L)
Definition: plplotluacLUA_wrap.c:5991
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:2851
SWIG_POINTER_NO_NULL
#define SWIG_POINTER_NO_NULL
Definition: plplotluacLUA_wrap.c:188
plgra
#define plgra
Definition: plplot.h:740
_wrap_maptex
static int _wrap_maptex(lua_State *L)
Definition: plplotluacLUA_wrap.c:11932
_wrap_shade
static int _wrap_shade(lua_State *L)
Definition: plplotluacLUA_wrap.c:9898
SWIG_LUA_BINARY
#define SWIG_LUA_BINARY
Definition: plplotluacLUA_wrap.c:949
_wrap_setcontlabelparam
static int _wrap_setcontlabelparam(lua_State *L)
Definition: plplotluacLUA_wrap.c:3914
swig_lua_class
struct swig_lua_class swig_lua_class
SWIG_TYPE_TABLE_NAME
#define SWIG_TYPE_TABLE_NAME
Definition: plplotluacLUA_wrap.c:160
_swigc__p_char
static swig_cast_info _swigc__p_char[]
Definition: plplotluacLUA_wrap.c:13125
_wrap_PLGraphicsIn_state_get
static int _wrap_PLGraphicsIn_state_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3283
SWIG_UnpackDataName
const SWIGRUNTIME char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
Definition: plplotluacLUA_wrap.c:701
plsxax
#define plsxax
Definition: plplot.h:851
PLFLT
float PLFLT
Definition: plplot.h:163
SWIG_init_user
#define SWIG_init_user
Definition: plplotluacLUA_wrap.c:2692
plgzax
#define plgzax
Definition: plplot.h:750
PLcGrid::xg
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
Xlen
static PLINT Xlen
Definition: plplotluacLUA_wrap.c:2746
_wrap_class_PLGraphicsIn
static swig_lua_class _wrap_class_PLGraphicsIn
Definition: plplotluacLUA_wrap.c:3890
_wrap_sdev
static int _wrap_sdev(lua_State *L)
Definition: plplotluacLUA_wrap.c:9275
swig_converter_func
void *(* swig_converter_func)(void *, int *)
Definition: plplotluacLUA_wrap.c:325
swig_lua_userdata
Definition: plplotluacLUA_wrap.c:1011
_wrap_mesh
static int _wrap_mesh(lua_State *L)
Definition: plplotluacLUA_wrap.c:7080
_wrap_timefmt
static int _wrap_timefmt(lua_State *L)
Definition: plplotluacLUA_wrap.c:11178
plgcol0
#define plgcol0
Definition: plplot.h:724
plsfont
#define plsfont
Definition: plplot.h:819
_swigc__p_p_char
static swig_cast_info _swigc__p_p_char[]
Definition: plplotluacLUA_wrap.c:13133
plw3d
#define plw3d
Definition: plplot.h:862
swig_module_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:355
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:1546
swig_lua_var_info
Definition: plplotluacLUA_wrap.c:953
SWIG_LUACODE
#define SWIG_LUACODE
Definition: plplotluacLUA_wrap.c:2694
swig_module_info::size
size_t size
Definition: plplotluacLUA_wrap.c:351
_wrap_gfnam
static int _wrap_gfnam(lua_State *L)
Definition: plplotluacLUA_wrap.c:5546
PLcGrid::ny
PLINT ny
Definition: plplot.h:509
swig_cast_info::prev
struct swig_cast_info * prev
Definition: plplotluacLUA_wrap.c:343
swig_PLGraphicsIn_methods
static swig_lua_method swig_PLGraphicsIn_methods[]
Definition: plplotluacLUA_wrap.c:3860
_wrap_configtime
static int _wrap_configtime(lua_State *L)
Definition: plplotluacLUA_wrap.c:4326
SWIG_LUA_POINTER
#define SWIG_LUA_POINTER
Definition: plplotluacLUA_wrap.c:948
_wrap_col0
static int _wrap_col0(lua_State *L)
Definition: plplotluacLUA_wrap.c:4288
SWIG_Lua_NewPackedObj
SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L, void *ptr, size_t size, swig_type_info *type)
Definition: plplotluacLUA_wrap.c:2536
plgvpw
#define plgvpw
Definition: plplot.h:747
swig_module_info
struct swig_module_info swig_module_info
_wrap_gvpd
static int _wrap_gvpd(lua_State *L)
Definition: plplotluacLUA_wrap.c:5903
_wrap_fontld
static int _wrap_fontld(lua_State *L)
Definition: plplotluacLUA_wrap.c:5200
_wrap_calc_world
static int _wrap_calc_world(lua_State *L)
Definition: plplotluacLUA_wrap.c:4238
_wrap_errx
static int _wrap_errx(lua_State *L)
Definition: plplotluacLUA_wrap.c:4847
plmkstrm
#define plmkstrm
Definition: plplot.h:772
plhist
#define plhist
Definition: plplot.h:751
_wrap_mapfill
static int _wrap_mapfill(lua_State *L)
Definition: plplotluacLUA_wrap.c:12002
SWIG_TypeClientData
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
Definition: plplotluacLUA_wrap.c:514
_wrap_scmap1l
static int _wrap_scmap1l(lua_State *L)
Definition: plplotluacLUA_wrap.c:8806
_wrap_svpa
static int _wrap_svpa(lua_State *L)
Definition: plplotluacLUA_wrap.c:11016
SWIG_Lua_get_inheritable_metamethods
SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L)
Definition: plplotluacLUA_wrap.c:1873
plsvpa
#define plsvpa
Definition: plplot.h:850
plgriddata
#define plgriddata
Definition: plplot.h:742
swig_lua_attribute::name
const char * name
Definition: plplotluacLUA_wrap.c:978
_wrap_styl
static int _wrap_styl(lua_State *L)
Definition: plplotluacLUA_wrap.c:10896
_wrap_clear
static int _wrap_clear(lua_State *L)
Definition: plplotluacLUA_wrap.c:4272
lua_absindex
#define lua_absindex(L, i)
Definition: plplotluacLUA_wrap.c:895
plsdiplz
#define plsdiplz
Definition: plplot.h:811
_wrap_fill
static int _wrap_fill(lua_State *L)
Definition: plplotluacLUA_wrap.c:4997
swig_types
static swig_type_info * swig_types[13]
Definition: plplotluacLUA_wrap.c:2683
plwind
#define plwind
Definition: plplot.h:864
myct
void myct(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
plbox
#define plbox
Definition: plplot.h:697
swig_cast_info::next
struct swig_cast_info * next
Definition: plplotluacLUA_wrap.c:342
plOptUsage
void plOptUsage(void)
Definition: plargs.c:1304
swig_PLGraphicsIn_Sf_SwigStatic_constants
static swig_lua_const_info swig_PLGraphicsIn_Sf_SwigStatic_constants[]
Definition: plplotluacLUA_wrap.c:3870
_wrap_psty
static int _wrap_psty(lua_State *L)
Definition: plplotluacLUA_wrap.c:8285
SWIG_OK
#define SWIG_OK
Definition: plplotluacLUA_wrap.c:273
swig_lua_method
luaL_Reg swig_lua_method
Definition: plplotluacLUA_wrap.c:963
swig_type_info::owndata
int owndata
Definition: plplotluacLUA_wrap.c:335
_wrap_width
static int _wrap_width(lua_State *L)
Definition: plplotluacLUA_wrap.c:11648
_wrap_fill3
static int _wrap_fill3(lua_State *L)
Definition: plplotluacLUA_wrap.c:5046
_wrap_string
static int _wrap_string(lua_State *L)
Definition: plplotluacLUA_wrap.c:10569
_wrap_stripd
static int _wrap_stripd(lua_State *L)
Definition: plplotluacLUA_wrap.c:10877
plot3d
#define plot3d
Definition: plplot.h:775
_wrap_btime
static int _wrap_btime(lua_State *L)
Definition: plplotluacLUA_wrap.c:4093
plmap
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
SWIG_Lua_class_destruct
SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L)
Definition: plplotluacLUA_wrap.c:1750
SWIG_PackDataName
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
Definition: plplotluacLUA_wrap.c:686
plpoin3
#define plpoin3
Definition: plplot.h:781
swig_lua_var_info::set
lua_CFunction set
Definition: plplotluacLUA_wrap.c:956
_wrap_mtex3
static int _wrap_mtex3(lua_State *L)
Definition: plplotluacLUA_wrap.c:7316
_wrap_syax
static int _wrap_syax(lua_State *L)
Definition: plplotluacLUA_wrap.c:11066
swig_type_info::name
const char * name
Definition: plplotluacLUA_wrap.c:330
SWIG_Lua_get_class_registry
SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L)
Definition: plplotluacLUA_wrap.c:1858
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
swig_SwigModule_methods
static swig_lua_method swig_SwigModule_methods[]
Definition: plplotluacLUA_wrap.c:12894
_wrap_gchr
static int _wrap_gchr(lua_State *L)
Definition: plplotluacLUA_wrap.c:5219
plmtex3
#define plmtex3
Definition: plplot.h:774
SWIG_IsOK
#define SWIG_IsOK(r)
Definition: plplotluacLUA_wrap.c:275
_wrap_svect
static int _wrap_svect(lua_State *L)
Definition: plplotluacLUA_wrap.c:10944
swig_lua_const_info::dvalue
double dvalue
Definition: plplotluacLUA_wrap.c:970
_wrap_abort
static int _wrap_abort(lua_State *L)
Definition: plplotluacLUA_wrap.c:12682
swig_lua_class::fqname
const char * fqname
Definition: plplotluacLUA_wrap.c:997
_wrap_flush
static int _wrap_flush(lua_State *L)
Definition: plplotluacLUA_wrap.c:5165
pladv
#define pladv
Definition: plplot.h:692
_wrap_scmap1_range
static int _wrap_scmap1_range(lua_State *L)
Definition: plplotluacLUA_wrap.c:9079
plGetCursor
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
plvasp
#define plvasp
Definition: plplot.h:857
SWIG_Lua_pusherrstring
SWIGRUNTIME void SWIG_Lua_pusherrstring(lua_State *L, const char *str)
Definition: plplotluacLUA_wrap.c:919
swig_PLGraphicsIn_attributes
static swig_lua_attribute swig_PLGraphicsIn_attributes[]
Definition: plplotluacLUA_wrap.c:3845
plscmap0n
#define plscmap0n
Definition: plplot.h:793
SWIG_Lua_resolve_metamethod
SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L)
Definition: plplotluacLUA_wrap.c:2125
pl_setcontlabelformat
#define pl_setcontlabelformat
Definition: plplot.h:690
SWIG_PropagateClientData
SWIGRUNTIME void SWIG_PropagateClientData(void)
Definition: plplotluacLUA_wrap.c:13357
plpoin
#define plpoin
Definition: plplot.h:780
label_func
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
Definition: plplotluacLUA_wrap.c:3066
plscmap0
#define plscmap0
Definition: plplot.h:791
_wrap_spage
static int _wrap_spage(lua_State *L)
Definition: plplotluacLUA_wrap.c:10324
_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:13129
plpat
#define plpat
Definition: plplot.h:779
plgxax
#define plgxax
Definition: plplot.h:748
_wrap_PLGraphicsIn_string_set
static int _wrap_PLGraphicsIn_string_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3459
_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:13131
SWIG_contract_assert
#define SWIG_contract_assert(expr, msg)
Definition: plplotluacLUA_wrap.c:1042
plenv0
#define plenv0
Definition: plplot.h:712
_wrap_sxax
static int _wrap_sxax(lua_State *L)
Definition: plplotluacLUA_wrap.c:11044
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:2525
_wrap_shades
static int _wrap_shades(lua_State *L)
Definition: plplotluacLUA_wrap.c:9582
swig_PLGraphicsIn_Sf_SwigStatic_attributes
static swig_lua_attribute swig_PLGraphicsIn_Sf_SwigStatic_attributes[]
Definition: plplotluacLUA_wrap.c:3867
_swigc__p_int
static swig_cast_info _swigc__p_int[]
Definition: plplotluacLUA_wrap.c:13132
SWIG_Lua_typename
const SWIGRUNTIME char * SWIG_Lua_typename(lua_State *L, int tp)
Definition: plplotluacLUA_wrap.c:2562
_wrap_PLGraphicsIn_pX_set
static int _wrap_PLGraphicsIn_pX_set(lua_State *L)
Definition: plplotluacLUA_wrap.c:3516
swig_lua_namespace::ns_attributes
swig_lua_attribute * ns_attributes
Definition: plplotluacLUA_wrap.c:989
_wrap_xormod
static int _wrap_xormod(lua_State *L)
Definition: plplotluacLUA_wrap.c:11695
swig_dycast_func
struct swig_type_info *(* swig_dycast_func)(void **)
Definition: plplotluacLUA_wrap.c:326
SWIG_CheckState
#define SWIG_CheckState(r)
Definition: plplotluacLUA_wrap.c:315
swig_lua_const_info::ptype
swig_type_info ** ptype
Definition: plplotluacLUA_wrap.c:972
swig_SwigModule
static swig_lua_namespace swig_SwigModule
Definition: plplotluacLUA_wrap.c:13082
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:1584
plot3dc
#define plot3dc
Definition: plplot.h:776
swig_lua_userdata::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:1012
_wrap_hlsrgb
static int _wrap_hlsrgb(lua_State *L)
Definition: plplotluacLUA_wrap.c:6082
swig_lua_namespace::ns_namespaces
struct swig_lua_namespace ** ns_namespaces
Definition: plplotluacLUA_wrap.c:992
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_PLGraphicsIn_pY_get
static int _wrap_PLGraphicsIn_pY_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3592
_wrap_gradient
static int _wrap_gradient(lua_State *L)
Definition: plplotluacLUA_wrap.c:5113
_wrap_meridians
static int _wrap_meridians(lua_State *L)
Definition: plplotluacLUA_wrap.c:12080
_wrap_gcmap1_range
static int _wrap_gcmap1_range(lua_State *L)
Definition: plplotluacLUA_wrap.c:9101
swig_lua_class::metatable
swig_lua_method * metatable
Definition: plplotluacLUA_wrap.c:1004
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
_wrap_PLGraphicsIn_dX_get
static int _wrap_PLGraphicsIn_dX_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3642
_wrap_axes
static int _wrap_axes(lua_State *L)
Definition: plplotluacLUA_wrap.c:4001
_wrap_ssub
static int _wrap_ssub(lua_State *L)
Definition: plplotluacLUA_wrap.c:10437
plfill
#define plfill
Definition: plplot.h:717
_wrap_bin
static int _wrap_bin(lua_State *L)
Definition: plplotluacLUA_wrap.c:4041
_swigc__p_unsigned_int
static swig_cast_info _swigc__p_unsigned_int[]
Definition: plplotluacLUA_wrap.c:13135
plsyax
#define plsyax
Definition: plplot.h:852
plglevel
#define plglevel
Definition: plplot.h:738
plgdidev
#define plgdidev
Definition: plplot.h:730
swig_type_info
Definition: plplotluacLUA_wrap.c:329
_wrap_PLGraphicsIn_keysym_get
static int _wrap_PLGraphicsIn_keysym_get(lua_State *L)
Definition: plplotluacLUA_wrap.c:3334
SWIG_fail
#define SWIG_fail
Definition: plplotluacLUA_wrap.c:1047
plerrx
#define plerrx
Definition: plplot.h:714
_wrap_sdimap
static int _wrap_sdimap(lua_State *L)
Definition: plplotluacLUA_wrap.c:9322
plscompression
#define plscompression
Definition: plplot.h:805
plgfci
#define plgfci
Definition: plplot.h:735
_wrap_gdiori
static int _wrap_gdiori(lua_State *L)
Definition: plplotluacLUA_wrap.c:5446
SWIG_PackVoidPtr
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
Definition: plplotluacLUA_wrap.c:662
swig_type_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:334
plsdiori
#define plsdiori
Definition: plplot.h:809
_wrap_scolor
static int _wrap_scolor(lua_State *L)
Definition: plplotluacLUA_wrap.c:9237
_wrap_stripc
static int _wrap_stripc(lua_State *L)
Definition: plplotluacLUA_wrap.c:10719
plscmap1l
#define plscmap1l
Definition: plplot.h:796
_wrap_box
static int _wrap_box(lua_State *L)
Definition: plplotluacLUA_wrap.c:4152
LUA_ALLOC_ARRAY
#define LUA_ALLOC_ARRAY(TYPE, LEN)
Definition: plplotluacLUA_wrap.c:2699
_wrap_spal1
static int _wrap_spal1(lua_State *L)
Definition: plplotluacLUA_wrap.c:10377
_wrap_spause
static int _wrap_spause(lua_State *L)
Definition: plplotluacLUA_wrap.c:10399
plmtex
#define plmtex
Definition: plplot.h:773
PLcGrid2::ny
PLINT ny
Definition: plplot.h:521
_wrap_sstrm
static int _wrap_sstrm(lua_State *L)
Definition: plplotluacLUA_wrap.c:10418
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplotluacLUA_wrap.c:3061
plgstrm
#define plgstrm
Definition: plplot.h:744
plend
#define plend
Definition: plplot.h:709
swig_lua_class
Definition: plplotluacLUA_wrap.c:995
_wrap_arc
static int _wrap_arc(lua_State *L)
Definition: plplotluacLUA_wrap.c:3961
SWIG_Lua_class_register
SWIGINTERN void SWIG_Lua_class_register(lua_State *L, swig_lua_class *clss)
Definition: plplotluacLUA_wrap.c:2383