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 SWIGPERL
13 #define SWIGPERL
14 #endif
15 
16 #define SWIG_CASTRANK_MODE
17 
18 /* -----------------------------------------------------------------------------
19  *  This section contains generic SWIG labels for method/variable
20  *  declarations/attributes, and other compiler dependent labels.
21  * ----------------------------------------------------------------------------- */
22 
23 /* template workaround for compilers that cannot correctly implement the C++ standard */
24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26 #  define SWIGTEMPLATEDISAMBIGUATOR template
27 # elif defined(__HP_aCC)
28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
30 #  define SWIGTEMPLATEDISAMBIGUATOR template
31 # else
32 #  define SWIGTEMPLATEDISAMBIGUATOR
33 # endif
34 #endif
35 
36 /* inline attribute */
37 #ifndef SWIGINLINE
38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39 #   define SWIGINLINE inline
40 # else
41 #   define SWIGINLINE
42 # endif
43 #endif
44 
45 /* attribute recognised by some compilers to avoid 'unused' warnings */
46 #ifndef SWIGUNUSED
47 # if defined(__GNUC__)
48 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49 #     define SWIGUNUSED __attribute__ ((__unused__))
50 #   else
51 #     define SWIGUNUSED
52 #   endif
53 # elif defined(__ICC)
54 #   define SWIGUNUSED __attribute__ ((__unused__))
55 # else
56 #   define SWIGUNUSED
57 # endif
58 #endif
59 
60 #ifndef SWIG_MSC_UNSUPPRESS_4505
61 # if defined(_MSC_VER)
62 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
63 # endif
64 #endif
65 
66 #ifndef SWIGUNUSEDPARM
67 # ifdef __cplusplus
68 #   define SWIGUNUSEDPARM(p)
69 # else
70 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
71 # endif
72 #endif
73 
74 /* internal SWIG method */
75 #ifndef SWIGINTERN
76 # define SWIGINTERN static SWIGUNUSED
77 #endif
78 
79 /* internal inline SWIG method */
80 #ifndef SWIGINTERNINLINE
81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82 #endif
83 
84 /* exporting methods */
85 #if defined(__GNUC__)
86 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87 #    ifndef GCC_HASCLASSVISIBILITY
88 #      define GCC_HASCLASSVISIBILITY
89 #    endif
90 #  endif
91 #endif
92 
93 #ifndef SWIGEXPORT
94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95 #   if defined(STATIC_LINKED)
96 #     define SWIGEXPORT
97 #   else
98 #     define SWIGEXPORT __declspec(dllexport)
99 #   endif
100 # else
101 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102 #     define SWIGEXPORT __attribute__ ((visibility("default")))
103 #   else
104 #     define SWIGEXPORT
105 #   endif
106 # endif
107 #endif
108 
109 /* calling conventions for Windows */
110 #ifndef SWIGSTDCALL
111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112 #   define SWIGSTDCALL __stdcall
113 # else
114 #   define SWIGSTDCALL
115 # endif
116 #endif
117 
118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120 # define _CRT_SECURE_NO_DEPRECATE
121 #endif
122 
123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125 # define _SCL_SECURE_NO_DEPRECATE
126 #endif
127 
128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
131 #endif
132 
133 /* Intel's compiler complains if a variable which was never initialised is
134  * cast to void, which is a common idiom which we use to indicate that we
135  * are aware a variable isn't used.  So we just silence that warning.
136  * See: https://github.com/swig/swig/issues/192 for more discussion.
137  */
138 #ifdef __INTEL_COMPILER
139 # pragma warning disable 592
140 #endif
141 
142 /* -----------------------------------------------------------------------------
143  * swigrun.swg
144  *
145  * This file contains generic C API SWIG runtime support for pointer
146  * type checking.
147  * ----------------------------------------------------------------------------- */
148 
149 /* This should only be incremented when either the layout of swig_type_info changes,
150    or for whatever reason, the runtime changes incompatibly */
151 #define SWIG_RUNTIME_VERSION "4"
152 
153 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
154 #ifdef SWIG_TYPE_TABLE
155 # define SWIG_QUOTE_STRING(x) #x
156 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
157 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
158 #else
159 # define SWIG_TYPE_TABLE_NAME
160 #endif
161 
162 /*
163   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
164   creating a static or dynamic library from the SWIG runtime code.
165   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
166 
167   But only do this if strictly necessary, ie, if you have problems
168   with your compiler or suchlike.
169 */
170 
171 #ifndef SWIGRUNTIME
172 # define SWIGRUNTIME SWIGINTERN
173 #endif
174 
175 #ifndef SWIGRUNTIMEINLINE
176 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
177 #endif
178 
179 /*  Generic buffer size */
180 #ifndef SWIG_BUFFER_SIZE
181 # define SWIG_BUFFER_SIZE 1024
182 #endif
183 
184 /* Flags for pointer conversions */
185 #define SWIG_POINTER_DISOWN        0x1
186 #define SWIG_CAST_NEW_MEMORY       0x2
187 #define SWIG_POINTER_NO_NULL       0x4
188 
189 /* Flags for new pointer objects */
190 #define SWIG_POINTER_OWN           0x1
191 
192 
193 /*
194    Flags/methods for returning states.
195 
196    The SWIG conversion methods, as ConvertPtr, return an integer
197    that tells if the conversion was successful or not. And if not,
198    an error code can be returned (see swigerrors.swg for the codes).
199 
200    Use the following macros/flags to set or process the returning
201    states.
202 
203    In old versions of SWIG, code such as the following was usually written:
204 
205      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
206        // success code
207      } else {
208        //fail code
209      }
210 
211    Now you can be more explicit:
212 
213     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
214     if (SWIG_IsOK(res)) {
215       // success code
216     } else {
217       // fail code
218     }
219 
220    which is the same really, but now you can also do
221 
222     Type *ptr;
223     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
224     if (SWIG_IsOK(res)) {
225       // success code
226       if (SWIG_IsNewObj(res) {
227         ...
228 	delete *ptr;
229       } else {
230         ...
231       }
232     } else {
233       // fail code
234     }
235 
236    I.e., now SWIG_ConvertPtr can return new objects and you can
237    identify the case and take care of the deallocation. Of course that
238    also requires SWIG_ConvertPtr to return new result values, such as
239 
240       int SWIG_ConvertPtr(obj, ptr,...) {
241         if (<obj is ok>) {
242           if (<need new object>) {
243             *ptr = <ptr to new allocated object>;
244             return SWIG_NEWOBJ;
245           } else {
246             *ptr = <ptr to old object>;
247             return SWIG_OLDOBJ;
248           }
249         } else {
250           return SWIG_BADOBJ;
251         }
252       }
253 
254    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
255    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
256    SWIG errors code.
257 
258    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
259    allows to return the 'cast rank', for example, if you have this
260 
261        int food(double)
262        int fooi(int);
263 
264    and you call
265 
266       food(1)   // cast rank '1'  (1 -> 1.0)
267       fooi(1)   // cast rank '0'
268 
269    just use the SWIG_AddCast()/SWIG_CheckState()
270 */
271 
272 #define SWIG_OK                    (0)
273 #define SWIG_ERROR                 (-1)
274 #define SWIG_IsOK(r)               (r >= 0)
275 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
276 
277 /* The CastRankLimit says how many bits are used for the cast rank */
278 #define SWIG_CASTRANKLIMIT         (1 << 8)
279 /* The NewMask denotes the object was created (using new/malloc) */
280 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
281 /* The TmpMask is for in/out typemaps that use temporal objects */
282 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
283 /* Simple returning values */
284 #define SWIG_BADOBJ                (SWIG_ERROR)
285 #define SWIG_OLDOBJ                (SWIG_OK)
286 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
287 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
288 /* Check, add and del mask methods */
289 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
290 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
291 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
292 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
293 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
294 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
295 
296 /* Cast-Rank Mode */
297 #if defined(SWIG_CASTRANK_MODE)
298 #  ifndef SWIG_TypeRank
299 #    define SWIG_TypeRank             unsigned long
300 #  endif
301 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
302 #    define SWIG_MAXCASTRANK          (2)
303 #  endif
304 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
305 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIG_AddCast(int r)306 SWIGINTERNINLINE int SWIG_AddCast(int r) {
307   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
308 }
SWIG_CheckState(int r)309 SWIGINTERNINLINE int SWIG_CheckState(int r) {
310   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
311 }
312 #else /* no cast-rank mode */
313 #  define SWIG_AddCast(r) (r)
314 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
315 #endif
316 
317 
318 #include <string.h>
319 
320 #ifdef __cplusplus
321 extern "C" {
322 #endif
323 
324 typedef void *(*swig_converter_func)(void *, int *);
325 typedef struct swig_type_info *(*swig_dycast_func)(void **);
326 
327 /* Structure to store information on one type */
328 typedef struct swig_type_info {
329   const char             *name;			/* mangled name of this type */
330   const char             *str;			/* human readable name of this type */
331   swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
332   struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
333   void                   *clientdata;		/* language specific type data */
334   int                    owndata;		/* flag if the structure owns the clientdata */
335 } swig_type_info;
336 
337 /* Structure to store a type and conversion function used for casting */
338 typedef struct swig_cast_info {
339   swig_type_info         *type;			/* pointer to type that is equivalent to this type */
340   swig_converter_func     converter;		/* function to cast the void pointers */
341   struct swig_cast_info  *next;			/* pointer to next cast in linked list */
342   struct swig_cast_info  *prev;			/* pointer to the previous cast */
343 } swig_cast_info;
344 
345 /* Structure used to store module information
346  * Each module generates one structure like this, and the runtime collects
347  * all of these structures and stores them in a circularly linked list.*/
348 typedef struct swig_module_info {
349   swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
350   size_t                 size;		        /* Number of types in this module */
351   struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
352   swig_type_info         **type_initial;	/* Array of initially generated type structures */
353   swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
354   void                    *clientdata;		/* Language specific module data */
355 } swig_module_info;
356 
357 /*
358   Compare two type names skipping the space characters, therefore
359   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
360 
361   Return 0 when the two name types are equivalent, as in
362   strncmp, but skipping ' '.
363 */
364 SWIGRUNTIME int
SWIG_TypeNameComp(const char * f1,const char * l1,const char * f2,const char * l2)365 SWIG_TypeNameComp(const char *f1, const char *l1,
366 		  const char *f2, const char *l2) {
367   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
368     while ((*f1 == ' ') && (f1 != l1)) ++f1;
369     while ((*f2 == ' ') && (f2 != l2)) ++f2;
370     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
371   }
372   return (int)((l1 - f1) - (l2 - f2));
373 }
374 
375 /*
376   Check type equivalence in a name list like <name1>|<name2>|...
377   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
378 */
379 SWIGRUNTIME int
SWIG_TypeCmp(const char * nb,const char * tb)380 SWIG_TypeCmp(const char *nb, const char *tb) {
381   int equiv = 1;
382   const char* te = tb + strlen(tb);
383   const char* ne = nb;
384   while (equiv != 0 && *ne) {
385     for (nb = ne; *ne; ++ne) {
386       if (*ne == '|') break;
387     }
388     equiv = SWIG_TypeNameComp(nb, ne, tb, te);
389     if (*ne) ++ne;
390   }
391   return equiv;
392 }
393 
394 /*
395   Check type equivalence in a name list like <name1>|<name2>|...
396   Return 0 if not equal, 1 if equal
397 */
398 SWIGRUNTIME int
SWIG_TypeEquiv(const char * nb,const char * tb)399 SWIG_TypeEquiv(const char *nb, const char *tb) {
400   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
401 }
402 
403 /*
404   Check the typename
405 */
406 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char * c,swig_type_info * ty)407 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
408   if (ty) {
409     swig_cast_info *iter = ty->cast;
410     while (iter) {
411       if (strcmp(iter->type->name, c) == 0) {
412         if (iter == ty->cast)
413           return iter;
414         /* Move iter to the top of the linked list */
415         iter->prev->next = iter->next;
416         if (iter->next)
417           iter->next->prev = iter->prev;
418         iter->next = ty->cast;
419         iter->prev = 0;
420         if (ty->cast) ty->cast->prev = iter;
421         ty->cast = iter;
422         return iter;
423       }
424       iter = iter->next;
425     }
426   }
427   return 0;
428 }
429 
430 /*
431   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
432 */
433 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info * from,swig_type_info * ty)434 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
435   if (ty) {
436     swig_cast_info *iter = ty->cast;
437     while (iter) {
438       if (iter->type == from) {
439         if (iter == ty->cast)
440           return iter;
441         /* Move iter to the top of the linked list */
442         iter->prev->next = iter->next;
443         if (iter->next)
444           iter->next->prev = iter->prev;
445         iter->next = ty->cast;
446         iter->prev = 0;
447         if (ty->cast) ty->cast->prev = iter;
448         ty->cast = iter;
449         return iter;
450       }
451       iter = iter->next;
452     }
453   }
454   return 0;
455 }
456 
457 /*
458   Cast a pointer up an inheritance hierarchy
459 */
460 SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info * ty,void * ptr,int * newmemory)461 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
462   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
463 }
464 
465 /*
466    Dynamic pointer casting. Down an inheritance hierarchy
467 */
468 SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info * ty,void ** ptr)469 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
470   swig_type_info *lastty = ty;
471   if (!ty || !ty->dcast) return ty;
472   while (ty && (ty->dcast)) {
473     ty = (*ty->dcast)(ptr);
474     if (ty) lastty = ty;
475   }
476   return lastty;
477 }
478 
479 /*
480   Return the name associated with this type
481 */
482 SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info * ty)483 SWIG_TypeName(const swig_type_info *ty) {
484   return ty->name;
485 }
486 
487 /*
488   Return the pretty name associated with this type,
489   that is an unmangled type name in a form presentable to the user.
490 */
491 SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info * type)492 SWIG_TypePrettyName(const swig_type_info *type) {
493   /* The "str" field contains the equivalent pretty names of the
494      type, separated by vertical-bar characters.  We choose
495      to print the last name, as it is often (?) the most
496      specific. */
497   if (!type) return NULL;
498   if (type->str != NULL) {
499     const char *last_name = type->str;
500     const char *s;
501     for (s = type->str; *s; s++)
502       if (*s == '|') last_name = s+1;
503     return last_name;
504   }
505   else
506     return type->name;
507 }
508 
509 /*
510    Set the clientdata field for a type
511 */
512 SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info * ti,void * clientdata)513 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
514   swig_cast_info *cast = ti->cast;
515   /* if (ti->clientdata == clientdata) return; */
516   ti->clientdata = clientdata;
517 
518   while (cast) {
519     if (!cast->converter) {
520       swig_type_info *tc = cast->type;
521       if (!tc->clientdata) {
522 	SWIG_TypeClientData(tc, clientdata);
523       }
524     }
525     cast = cast->next;
526   }
527 }
528 SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info * ti,void * clientdata)529 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
530   SWIG_TypeClientData(ti, clientdata);
531   ti->owndata = 1;
532 }
533 
534 /*
535   Search for a swig_type_info structure only by mangled name
536   Search is a O(log #types)
537 
538   We start searching at module start, and finish searching when start == end.
539   Note: if start == end at the beginning of the function, we go all the way around
540   the circular list.
541 */
542 SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)543 SWIG_MangledTypeQueryModule(swig_module_info *start,
544                             swig_module_info *end,
545 		            const char *name) {
546   swig_module_info *iter = start;
547   do {
548     if (iter->size) {
549       size_t l = 0;
550       size_t r = iter->size - 1;
551       do {
552 	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
553 	size_t i = (l + r) >> 1;
554 	const char *iname = iter->types[i]->name;
555 	if (iname) {
556 	  int compare = strcmp(name, iname);
557 	  if (compare == 0) {
558 	    return iter->types[i];
559 	  } else if (compare < 0) {
560 	    if (i) {
561 	      r = i - 1;
562 	    } else {
563 	      break;
564 	    }
565 	  } else if (compare > 0) {
566 	    l = i + 1;
567 	  }
568 	} else {
569 	  break; /* should never happen */
570 	}
571       } while (l <= r);
572     }
573     iter = iter->next;
574   } while (iter != end);
575   return 0;
576 }
577 
578 /*
579   Search for a swig_type_info structure for either a mangled name or a human readable name.
580   It first searches the mangled names of the types, which is a O(log #types)
581   If a type is not found it then searches the human readable names, which is O(#types).
582 
583   We start searching at module start, and finish searching when start == end.
584   Note: if start == end at the beginning of the function, we go all the way around
585   the circular list.
586 */
587 SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)588 SWIG_TypeQueryModule(swig_module_info *start,
589                      swig_module_info *end,
590 		     const char *name) {
591   /* STEP 1: Search the name field using binary search */
592   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
593   if (ret) {
594     return ret;
595   } else {
596     /* STEP 2: If the type hasn't been found, do a complete search
597        of the str field (the human readable name) */
598     swig_module_info *iter = start;
599     do {
600       size_t i = 0;
601       for (; i < iter->size; ++i) {
602 	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
603 	  return iter->types[i];
604       }
605       iter = iter->next;
606     } while (iter != end);
607   }
608 
609   /* neither found a match */
610   return 0;
611 }
612 
613 /*
614    Pack binary data into a string
615 */
616 SWIGRUNTIME char *
SWIG_PackData(char * c,void * ptr,size_t sz)617 SWIG_PackData(char *c, void *ptr, size_t sz) {
618   static const char hex[17] = "0123456789abcdef";
619   const unsigned char *u = (unsigned char *) ptr;
620   const unsigned char *eu =  u + sz;
621   for (; u != eu; ++u) {
622     unsigned char uu = *u;
623     *(c++) = hex[(uu & 0xf0) >> 4];
624     *(c++) = hex[uu & 0xf];
625   }
626   return c;
627 }
628 
629 /*
630    Unpack binary data from a string
631 */
632 SWIGRUNTIME const char *
SWIG_UnpackData(const char * c,void * ptr,size_t sz)633 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
634   unsigned char *u = (unsigned char *) ptr;
635   const unsigned char *eu = u + sz;
636   for (; u != eu; ++u) {
637     char d = *(c++);
638     unsigned char uu;
639     if ((d >= '0') && (d <= '9'))
640       uu = (unsigned char)((d - '0') << 4);
641     else if ((d >= 'a') && (d <= 'f'))
642       uu = (unsigned char)((d - ('a'-10)) << 4);
643     else
644       return (char *) 0;
645     d = *(c++);
646     if ((d >= '0') && (d <= '9'))
647       uu |= (unsigned char)(d - '0');
648     else if ((d >= 'a') && (d <= 'f'))
649       uu |= (unsigned char)(d - ('a'-10));
650     else
651       return (char *) 0;
652     *u = uu;
653   }
654   return c;
655 }
656 
657 /*
658    Pack 'void *' into a string buffer.
659 */
660 SWIGRUNTIME char *
SWIG_PackVoidPtr(char * buff,void * ptr,const char * name,size_t bsz)661 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
662   char *r = buff;
663   if ((2*sizeof(void *) + 2) > bsz) return 0;
664   *(r++) = '_';
665   r = SWIG_PackData(r,&ptr,sizeof(void *));
666   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
667   strcpy(r,name);
668   return buff;
669 }
670 
671 SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char * c,void ** ptr,const char * name)672 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
673   if (*c != '_') {
674     if (strcmp(c,"NULL") == 0) {
675       *ptr = (void *) 0;
676       return name;
677     } else {
678       return 0;
679     }
680   }
681   return SWIG_UnpackData(++c,ptr,sizeof(void *));
682 }
683 
684 SWIGRUNTIME char *
SWIG_PackDataName(char * buff,void * ptr,size_t sz,const char * name,size_t bsz)685 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
686   char *r = buff;
687   size_t lname = (name ? strlen(name) : 0);
688   if ((2*sz + 2 + lname) > bsz) return 0;
689   *(r++) = '_';
690   r = SWIG_PackData(r,ptr,sz);
691   if (lname) {
692     strncpy(r,name,lname+1);
693   } else {
694     *r = 0;
695   }
696   return buff;
697 }
698 
699 SWIGRUNTIME const char *
SWIG_UnpackDataName(const char * c,void * ptr,size_t sz,const char * name)700 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
701   if (*c != '_') {
702     if (strcmp(c,"NULL") == 0) {
703       memset(ptr,0,sz);
704       return name;
705     } else {
706       return 0;
707     }
708   }
709   return SWIG_UnpackData(++c,ptr,sz);
710 }
711 
712 #ifdef __cplusplus
713 }
714 #endif
715 
716 /*  Errors in SWIG */
717 #define  SWIG_UnknownError    	   -1
718 #define  SWIG_IOError        	   -2
719 #define  SWIG_RuntimeError   	   -3
720 #define  SWIG_IndexError     	   -4
721 #define  SWIG_TypeError      	   -5
722 #define  SWIG_DivisionByZero 	   -6
723 #define  SWIG_OverflowError  	   -7
724 #define  SWIG_SyntaxError    	   -8
725 #define  SWIG_ValueError     	   -9
726 #define  SWIG_SystemError    	   -10
727 #define  SWIG_AttributeError 	   -11
728 #define  SWIG_MemoryError    	   -12
729 #define  SWIG_NullReferenceError   -13
730 
731 
732 
733 #ifdef __cplusplus
734 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
735 #include <math.h>
736 #include <stdlib.h>
737 extern "C" {
738 #endif
739 #include "EXTERN.h"
740 #include "perl.h"
741 #include "XSUB.h"
742 
743 /* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
744 
745 /* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
746 #ifndef PERL_REVISION
747 #  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
748 #    define PERL_PATCHLEVEL_H_IMPLICIT
749 #    include <patchlevel.h>
750 #  endif
751 #  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
752 #    include <could_not_find_Perl_patchlevel.h>
753 #  endif
754 #  ifndef PERL_REVISION
755 #    define PERL_REVISION       (5)
756 #    define PERL_VERSION        PATCHLEVEL
757 #    define PERL_SUBVERSION     SUBVERSION
758 #  endif
759 #endif
760 
761 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
762 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
763 #endif
764 
765 #ifndef SvIOK_UV
766 # define SvIOK_UV(sv)       (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
767 #endif
768 
769 #ifndef SvUOK
770 # define SvUOK(sv)           SvIOK_UV(sv)
771 #endif
772 
773 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
774 #  define PL_sv_undef               sv_undef
775 #  define PL_na	                    na
776 #  define PL_errgv                  errgv
777 #  define PL_sv_no                  sv_no
778 #  define PL_sv_yes                 sv_yes
779 #  define PL_markstack_ptr          markstack_ptr
780 #endif
781 
782 #ifndef IVSIZE
783 #  ifdef LONGSIZE
784 #    define IVSIZE LONGSIZE
785 #  else
786 #    define IVSIZE 4 /* A bold guess, but the best we can make. */
787 #  endif
788 #endif
789 
790 #ifndef INT2PTR
791 #  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
792 #    define PTRV                  UV
793 #    define INT2PTR(any,d)        (any)(d)
794 #  else
795 #    if PTRSIZE == LONGSIZE
796 #      define PTRV                unsigned long
797 #    else
798 #      define PTRV                unsigned
799 #    endif
800 #    define INT2PTR(any,d)        (any)(PTRV)(d)
801 #  endif
802 
803 #  define NUM2PTR(any,d)  (any)(PTRV)(d)
804 #  define PTR2IV(p)       INT2PTR(IV,p)
805 #  define PTR2UV(p)       INT2PTR(UV,p)
806 #  define PTR2NV(p)       NUM2PTR(NV,p)
807 
808 #  if PTRSIZE == LONGSIZE
809 #    define PTR2ul(p)     (unsigned long)(p)
810 #  else
811 #    define PTR2ul(p)     INT2PTR(unsigned long,p)
812 #  endif
813 #endif /* !INT2PTR */
814 
815 #ifndef SvPV_nolen
816 # define SvPV_nolen(x) SvPV(x,PL_na)
817 #endif
818 
819 #ifndef get_sv
820 #  define get_sv perl_get_sv
821 #endif
822 
823 #ifndef ERRSV
824 #  define ERRSV get_sv("@",FALSE)
825 #endif
826 
827 #ifndef pTHX_
828 #define pTHX_
829 #endif
830 
831 #include <string.h>
832 #ifdef __cplusplus
833 }
834 #endif
835 
836 /* -----------------------------------------------------------------------------
837  * error manipulation
838  * ----------------------------------------------------------------------------- */
839 
840 SWIGINTERN const char*
SWIG_Perl_ErrorType(int code)841 SWIG_Perl_ErrorType(int code) {
842   switch(code) {
843   case SWIG_MemoryError:
844     return "MemoryError";
845   case SWIG_IOError:
846     return "IOError";
847   case SWIG_RuntimeError:
848     return "RuntimeError";
849   case SWIG_IndexError:
850     return "IndexError";
851   case SWIG_TypeError:
852     return "TypeError";
853   case SWIG_DivisionByZero:
854     return "ZeroDivisionError";
855   case SWIG_OverflowError:
856     return "OverflowError";
857   case SWIG_SyntaxError:
858     return "SyntaxError";
859   case SWIG_ValueError:
860     return "ValueError";
861   case SWIG_SystemError:
862     return "SystemError";
863   case SWIG_AttributeError:
864     return "AttributeError";
865   default:
866     return "RuntimeError";
867   }
868 }
869 
870 
871 /* -----------------------------------------------------------------------------
872  * perlrun.swg
873  *
874  * This file contains the runtime support for Perl modules
875  * and includes code for managing global variables and pointer
876  * type checking.
877  * ----------------------------------------------------------------------------- */
878 
879 #ifdef PERL_OBJECT
880 #define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
881 #define SWIG_PERL_OBJECT_CALL pPerl,
882 #else
883 #define SWIG_PERL_OBJECT_DECL
884 #define SWIG_PERL_OBJECT_CALL
885 #endif
886 
887 /* Common SWIG API */
888 
889 /* for raw pointers */
890 #define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
891 #define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
892 #define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
893 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Perl_AcquirePtr(ptr, src)
894 #define swig_owntype                                    int
895 
896 /* for raw packed data */
897 #define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
898 #define SWIG_NewPackedObj(p, s, type)	                SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
899 
900 /* for class or struct pointers */
901 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
902 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
903 
904 /* for C or C++ function pointers */
905 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
906 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
907 
908 /* for C++ member pointers, ie, member methods */
909 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
910 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
911 
912 
913 /* Runtime API */
914 
915 #define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule(clientdata)
916 #define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
917 
918 
919 /* Error manipulation */
920 
921 #define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)
922 #define SWIG_Error(code, msg)            		sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
923 #define SWIG_fail                        		goto fail
924 
925 /* Perl-specific SWIG API */
926 
927 #define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
928 #define SWIG_MakePackedObj(sv, p, s, type)	        SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
929 #define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
930 
931 
932 #define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
933 #define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
934 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
935 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
936 
937 /* -----------------------------------------------------------------------------
938  * pointers/data manipulation
939  * ----------------------------------------------------------------------------- */
940 
941 /* For backward compatibility only */
942 #define SWIG_POINTER_EXCEPTION  0
943 
944 #ifdef __cplusplus
945 extern "C" {
946 #endif
947 
948 #define SWIG_OWNER   SWIG_POINTER_OWN
949 #define SWIG_SHADOW  SWIG_OWNER << 1
950 
951 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
952 
953 /* SWIG Perl macros */
954 
955 /* Macro to declare an XS function */
956 #ifndef XSPROTO
957 #   define XSPROTO(name) void name(pTHX_ CV* cv)
958 #endif
959 
960 /* Macro to call an XS function */
961 #ifdef PERL_OBJECT
962 #  define SWIG_CALLXS(_name) _name(cv,pPerl)
963 #else
964 #  ifndef MULTIPLICITY
965 #    define SWIG_CALLXS(_name) _name(cv)
966 #  else
967 #    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
968 #  endif
969 #endif
970 
971 #ifdef PERL_OBJECT
972 #define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
973 
974 #ifdef __cplusplus
975 extern "C" {
976 #endif
977 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
978 #ifdef __cplusplus
979 }
980 #endif
981 
982 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
983 #define SWIGCLASS_STATIC
984 
985 #else /* PERL_OBJECT */
986 
987 #define MAGIC_PPERL
988 #define SWIGCLASS_STATIC static SWIGUNUSED
989 
990 #ifndef MULTIPLICITY
991 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
992 
993 #ifdef __cplusplus
994 extern "C" {
995 #endif
996 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
997 #ifdef __cplusplus
998 }
999 #endif
1000 
1001 #else /* MULTIPLICITY */
1002 
1003 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
1004 
1005 #ifdef __cplusplus
1006 extern "C" {
1007 #endif
1008 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1009 #ifdef __cplusplus
1010 }
1011 #endif
1012 
1013 #endif /* MULTIPLICITY */
1014 #endif /* PERL_OBJECT */
1015 
1016 #  ifdef PERL_OBJECT
1017 #    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
SWIG_Perl_croak_null(CPerlObj * pPerl)1018 static void SWIGUNUSED SWIG_Perl_croak_null(CPerlObj *pPerl)
1019 #  else
1020 static void SWIGUNUSED SWIG_croak_null()
1021 #  endif
1022 {
1023   SV *err = get_sv("@", GV_ADD);
1024 #  if (PERL_VERSION < 6)
1025   croak("%_", err);
1026 #  else
1027   if (sv_isobject(err))
1028     croak(0);
1029   else
1030     croak("%s", SvPV_nolen(err));
1031 #  endif
1032 }
1033 
1034 
1035 /*
1036    Define how strict is the cast between strings and integers/doubles
1037    when overloading between these types occurs.
1038 
1039    The default is making it as strict as possible by using SWIG_AddCast
1040    when needed.
1041 
1042    You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1043    disable the SWIG_AddCast, making the casting between string and
1044    numbers less strict.
1045 
1046    In the end, we try to solve the overloading between strings and
1047    numerical types in the more natural way, but if you can avoid it,
1048    well, avoid it using %rename, for example.
1049 */
1050 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
1051 # ifndef SWIG_PERL_STRICT_STR2NUM
1052 #  define SWIG_PERL_STRICT_STR2NUM
1053 # endif
1054 #endif
1055 #ifdef SWIG_PERL_STRICT_STR2NUM
1056 /* string takes precedence */
1057 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1058 #else
1059 /* number takes precedence */
1060 #define SWIG_Str2NumCast(x) x
1061 #endif
1062 
1063 
1064 
1065 #include <stdlib.h>
1066 
1067 SWIGRUNTIME const char *
SWIG_Perl_TypeProxyName(const swig_type_info * type)1068 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1069   if (!type) return NULL;
1070   if (type->clientdata != NULL) {
1071     return (const char*) type->clientdata;
1072   }
1073   else {
1074     return type->name;
1075   }
1076 }
1077 
1078 /* Identical to SWIG_TypeCheck, except for strcmp comparison */
1079 SWIGRUNTIME swig_cast_info *
SWIG_TypeProxyCheck(const char * c,swig_type_info * ty)1080 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1081   if (ty) {
1082     swig_cast_info *iter = ty->cast;
1083     while (iter) {
1084       if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
1085         if (iter == ty->cast)
1086           return iter;
1087         /* Move iter to the top of the linked list */
1088         iter->prev->next = iter->next;
1089         if (iter->next)
1090           iter->next->prev = iter->prev;
1091         iter->next = ty->cast;
1092         iter->prev = 0;
1093         if (ty->cast) ty->cast->prev = iter;
1094         ty->cast = iter;
1095         return iter;
1096       }
1097       iter = iter->next;
1098     }
1099   }
1100   return 0;
1101 }
1102 
1103 /* Acquire a pointer value */
1104 
1105 SWIGRUNTIME int
SWIG_Perl_AcquirePtr(SWIG_MAYBE_PERL_OBJECT SV * sv,int own)1106 SWIG_Perl_AcquirePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, int own) {
1107   /* TODO */
1108   return 0;
1109 }
1110 
1111 /* Function for getting a pointer value */
1112 
1113 SWIGRUNTIME int
SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV * sv,void ** ptr,swig_type_info * _t,int flags,int * own)1114 SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
1115   swig_cast_info *tc;
1116   void *voidptr = (void *)0;
1117   SV *tsv = 0;
1118 
1119   if (own)
1120     *own = 0;
1121 
1122   /* If magical, apply more magic */
1123   if (SvGMAGICAL(sv))
1124     mg_get(sv);
1125 
1126   /* Check to see if this is an object */
1127   if (sv_isobject(sv)) {
1128     IV tmp = 0;
1129     tsv = (SV*) SvRV(sv);
1130     if ((SvTYPE(tsv) == SVt_PVHV)) {
1131       MAGIC *mg;
1132       if (SvMAGICAL(tsv)) {
1133         mg = mg_find(tsv,'P');
1134         if (mg) {
1135           sv = mg->mg_obj;
1136           if (sv_isobject(sv)) {
1137 	    tsv = (SV*)SvRV(sv);
1138             tmp = SvIV(tsv);
1139           }
1140         }
1141       } else {
1142         return SWIG_ERROR;
1143       }
1144     } else {
1145       tmp = SvIV(tsv);
1146     }
1147     voidptr = INT2PTR(void *,tmp);
1148   } else if (! SvOK(sv)) {            /* Check for undef */
1149     *(ptr) = (void *) 0;
1150     return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
1151   } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
1152     if (!SvROK(sv)) {
1153       /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value.  */
1154       if (SvIOK(sv)) {
1155         return SWIG_ERROR;
1156       } else {
1157         /* NULL pointer (reference to undef). */
1158         *(ptr) = (void *) 0;
1159         return SWIG_OK;
1160       }
1161     } else {
1162       return SWIG_ERROR;
1163     }
1164   } else {                            /* Don't know what it is */
1165     return SWIG_ERROR;
1166   }
1167   if (_t) {
1168     /* Now see if the types match */
1169     char *_c = HvNAME(SvSTASH(SvRV(sv)));
1170     tc = SWIG_TypeProxyCheck(_c,_t);
1171 #ifdef SWIG_DIRECTORS
1172     if (!tc && !sv_derived_from(sv,SWIG_Perl_TypeProxyName(_t))) {
1173 #else
1174     if (!tc) {
1175 #endif
1176       return SWIG_ERROR;
1177     }
1178     {
1179       int newmemory = 0;
1180       *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1181       if (newmemory == SWIG_CAST_NEW_MEMORY) {
1182         assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1183         if (own)
1184           *own = *own | SWIG_CAST_NEW_MEMORY;
1185       }
1186     }
1187   } else {
1188     *ptr = voidptr;
1189   }
1190 
1191   /*
1192    *  DISOWN implementation: we need a perl guru to check this one.
1193    */
1194   if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1195     /*
1196      *  almost copy paste code from below SWIG_POINTER_OWN setting
1197      */
1198     SV *obj = sv;
1199     HV *stash = SvSTASH(SvRV(obj));
1200     GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1201     if (isGV(gv)) {
1202       HV *hv = GvHVn(gv);
1203       /*
1204        * To set ownership (see below), a newSViv(1) entry is added.
1205        * Hence, to remove ownership, we delete the entry.
1206        */
1207       if (hv_exists_ent(hv, obj, 0)) {
1208 	hv_delete_ent(hv, obj, 0, 0);
1209       }
1210     }
1211   }
1212   return SWIG_OK;
1213 }
1214 
1215 SWIGRUNTIME int
1216 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1217   return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
1218 }
1219 
1220 SWIGRUNTIME void
1221 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1222   if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
1223     SV *self;
1224     SV *obj=newSV(0);
1225     HV *hash=newHV();
1226     HV *stash;
1227     sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
1228     stash=SvSTASH(SvRV(obj));
1229     if (flags & SWIG_POINTER_OWN) {
1230       HV *hv;
1231       GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1232       if (!isGV(gv))
1233         gv_init(gv, stash, "OWNER", 5, FALSE);
1234       hv=GvHVn(gv);
1235       hv_store_ent(hv, obj, newSViv(1), 0);
1236     }
1237     sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1238     SvREFCNT_dec(obj);
1239     self=newRV_noinc((SV *)hash);
1240     sv_setsv(sv, self);
1241     SvREFCNT_dec((SV *)self);
1242     sv_bless(sv, stash);
1243   }
1244   else {
1245     sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
1246   }
1247 }
1248 
1249 SWIGRUNTIMEINLINE SV *
1250 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1251   SV *result = sv_newmortal();
1252   SWIG_MakePtr(result, ptr, t, flags);
1253   return result;
1254 }
1255 
1256 SWIGRUNTIME void
1257 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1258   char result[1024];
1259   char *r = result;
1260   if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1261   *(r++) = '_';
1262   r = SWIG_PackData(r,ptr,sz);
1263   strcpy(r,SWIG_Perl_TypeProxyName(type));
1264   sv_setpv(sv, result);
1265 }
1266 
1267 SWIGRUNTIME SV *
1268 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1269   SV *result = sv_newmortal();
1270   SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1271   return result;
1272 }
1273 
1274 /* Convert a packed pointer value */
1275 SWIGRUNTIME int
1276 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1277   swig_cast_info *tc;
1278   const char  *c = 0;
1279 
1280   if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1281   c = SvPV_nolen(obj);
1282   /* Pointer values must start with leading underscore */
1283   if (*c != '_') return SWIG_ERROR;
1284   c++;
1285   c = SWIG_UnpackData(c,ptr,sz);
1286   if (ty) {
1287     tc = SWIG_TypeCheck(c,ty);
1288     if (!tc) return SWIG_ERROR;
1289   }
1290   return SWIG_OK;
1291 }
1292 
1293 
1294 /* Macros for low-level exception handling */
1295 #define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1296 
1297 
1298 typedef XSPROTO(SwigPerlWrapper);
1299 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1300 
1301 /* Structure for command table */
1302 typedef struct {
1303   const char         *name;
1304   SwigPerlWrapperPtr  wrapper;
1305 } swig_command_info;
1306 
1307 /* Information for constant table */
1308 
1309 #define SWIG_INT     1
1310 #define SWIG_FLOAT   2
1311 #define SWIG_STRING  3
1312 #define SWIG_POINTER 4
1313 #define SWIG_BINARY  5
1314 
1315 /* Constant information structure */
1316 typedef struct swig_constant_info {
1317     int              type;
1318     const char      *name;
1319     long             lvalue;
1320     double           dvalue;
1321     void            *pvalue;
1322     swig_type_info **ptype;
1323 } swig_constant_info;
1324 
1325 
1326 /* Structure for variable table */
1327 typedef struct {
1328   const char   *name;
1329   SwigMagicFunc   set;
1330   SwigMagicFunc   get;
1331   swig_type_info  **type;
1332 } swig_variable_info;
1333 
1334 /* Magic variable code */
1335 #ifndef PERL_OBJECT
1336 # ifdef __cplusplus
1337 #  define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
1338 # else
1339 #  define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
1340 # endif
1341 # ifndef MULTIPLICITY
1342 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1343 # else
1344 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1345 # endif
1346 #else
1347 #  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1348 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1349 #endif
1350 {
1351   MAGIC *mg;
1352   sv_magic(sv,sv,'U',name,strlen(name));
1353   mg = mg_find(sv,'U');
1354   mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1355   mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1356   mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1357   mg->mg_virtual->svt_len = 0;
1358   mg->mg_virtual->svt_clear = 0;
1359   mg->mg_virtual->svt_free = 0;
1360 }
1361 
1362 
1363 SWIGRUNTIME swig_module_info *
1364 SWIG_Perl_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
1365   static void *type_pointer = (void *)0;
1366   SV *pointer;
1367 
1368   /* first check if pointer already created */
1369   if (!type_pointer) {
1370     pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1371     if (pointer && SvOK(pointer)) {
1372       type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1373     }
1374   }
1375 
1376   return (swig_module_info *) type_pointer;
1377 }
1378 
1379 SWIGRUNTIME void
1380 SWIG_Perl_SetModule(swig_module_info *module) {
1381   SV *pointer;
1382 
1383   /* create a new pointer */
1384   pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1385   sv_setiv(pointer, PTR2IV(module));
1386 }
1387 
1388 #ifdef __cplusplus
1389 }
1390 #endif
1391 
1392 /* Workaround perl5 global namespace pollution. Note that undefining library
1393  * functions like fopen will not solve the problem on all platforms as fopen
1394  * might be a macro on Windows but not necessarily on other operating systems. */
1395 #ifdef do_open
1396   #undef do_open
1397 #endif
1398 #ifdef do_close
1399   #undef do_close
1400 #endif
1401 #ifdef do_exec
1402   #undef do_exec
1403 #endif
1404 #ifdef scalar
1405   #undef scalar
1406 #endif
1407 #ifdef list
1408   #undef list
1409 #endif
1410 #ifdef apply
1411   #undef apply
1412 #endif
1413 #ifdef convert
1414   #undef convert
1415 #endif
1416 #ifdef Error
1417   #undef Error
1418 #endif
1419 #ifdef form
1420   #undef form
1421 #endif
1422 #ifdef vform
1423   #undef vform
1424 #endif
1425 #ifdef LABEL
1426   #undef LABEL
1427 #endif
1428 #ifdef METHOD
1429   #undef METHOD
1430 #endif
1431 #ifdef Move
1432   #undef Move
1433 #endif
1434 #ifdef yylex
1435   #undef yylex
1436 #endif
1437 #ifdef yyparse
1438   #undef yyparse
1439 #endif
1440 #ifdef yyerror
1441   #undef yyerror
1442 #endif
1443 #ifdef invert
1444   #undef invert
1445 #endif
1446 #ifdef ref
1447   #undef ref
1448 #endif
1449 #ifdef read
1450   #undef read
1451 #endif
1452 #ifdef write
1453   #undef write
1454 #endif
1455 #ifdef eof
1456   #undef eof
1457 #endif
1458 #ifdef close
1459   #undef close
1460 #endif
1461 #ifdef rewind
1462   #undef rewind
1463 #endif
1464 #ifdef free
1465   #undef free
1466 #endif
1467 #ifdef malloc
1468   #undef malloc
1469 #endif
1470 #ifdef calloc
1471   #undef calloc
1472 #endif
1473 #ifdef Stat
1474   #undef Stat
1475 #endif
1476 #ifdef check
1477   #undef check
1478 #endif
1479 #ifdef seekdir
1480   #undef seekdir
1481 #endif
1482 #ifdef open
1483   #undef open
1484 #endif
1485 #ifdef readdir
1486   #undef readdir
1487 #endif
1488 #ifdef bind
1489   #undef bind
1490 #endif
1491 #ifdef access
1492   #undef access
1493 #endif
1494 #ifdef stat
1495   #undef stat
1496 #endif
1497 #ifdef seed
1498   #undef seed
1499 #endif
1500 
1501 #ifdef bool
1502   /* Leave if macro is from C99 stdbool.h */
1503   #ifndef __bool_true_false_are_defined
1504     #undef bool
1505   #endif
1506 #endif
1507 
1508 
1509 
1510 
1511 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1512 
1513 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1514 
1515 
1516 
1517 /* -------- TYPES TABLE (BEGIN) -------- */
1518 
1519 #define SWIGTYPE_p_FILE swig_types[0]
1520 #define SWIGTYPE_p_char swig_types[1]
1521 #define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void swig_types[2]
1522 #define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void swig_types[3]
1523 #define SWIGTYPE_p_int swig_types[4]
1524 #define SWIGTYPE_p_long_double swig_types[5]
1525 static swig_type_info *swig_types[7];
1526 static swig_module_info swig_module = {swig_types, 6, 0, 0, 0, 0};
1527 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1528 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1529 
1530 /* -------- TYPES TABLE (END) -------- */
1531 
1532 #define SWIG_init    boot_Math__GSL__Sys
1533 
1534 #define SWIG_name   "Math::GSL::Sysc::boot_Math__GSL__Sys"
1535 #define SWIG_prefix "Math::GSL::Sysc::"
1536 
1537 #define SWIGVERSION 0x040001
1538 #define SWIG_VERSION SWIGVERSION
1539 
1540 
1541 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1542 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1543 
1544 
1545 #ifdef __cplusplus
1546 extern "C"
1547 #endif
1548 #ifndef PERL_OBJECT
1549 #ifndef MULTIPLICITY
1550 SWIGEXPORT void SWIG_init (CV* cv);
1551 #else
1552 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1553 #endif
1554 #else
1555 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1556 #endif
1557 
1558 
1559 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(double value)1560 SWIG_From_double  SWIG_PERL_DECL_ARGS_1(double value)
1561 {
1562   return sv_2mortal(newSVnv(value));
1563 }
1564 
1565 
1566 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(long value)1567 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1568 {
1569   SV *sv;
1570   if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
1571     sv = newSViv(value);
1572   else
1573     sv = newSVpvf("%ld", value);
1574   return sv_2mortal(sv);
1575 }
1576 
1577 
1578 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(int value)1579 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1580 {
1581   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1582 }
1583 
1584 
1585 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)1586 SWIG_pchar_descriptor(void)
1587 {
1588   static int init = 0;
1589   static swig_type_info* info = 0;
1590   if (!init) {
1591     info = SWIG_TypeQuery("_p_char");
1592     init = 1;
1593   }
1594   return info;
1595 }
1596 
1597 
1598 SWIGINTERN int
SWIG_AsCharPtrAndSize(SV * obj,char ** cptr,size_t * psize,int * alloc)1599 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1600 {
1601   if (SvMAGICAL(obj)) {
1602      SV *tmp = sv_newmortal();
1603      SvSetSV(tmp, obj);
1604      obj = tmp;
1605   }
1606   if (SvPOK(obj)) {
1607     STRLEN len = 0;
1608     char *cstr = SvPV(obj, len);
1609     size_t size = len + 1;
1610     if (cptr)  {
1611       if (alloc) {
1612 	if (*alloc == SWIG_NEWOBJ) {
1613 	  *cptr = (char *)memcpy(malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1614 	} else {
1615 	  *cptr = cstr;
1616 	  *alloc = SWIG_OLDOBJ;
1617 	}
1618       }
1619     }
1620     if (psize) *psize = size;
1621     return SWIG_OK;
1622   } else {
1623     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1624     if (pchar_descriptor) {
1625       char* vptr = 0;
1626       if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1627 	if (cptr) *cptr = vptr;
1628 	if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1629 	if (alloc) *alloc = SWIG_OLDOBJ;
1630 	return SWIG_OK;
1631       }
1632     }
1633   }
1634   return SWIG_TypeError;
1635 }
1636 
1637 
1638 
1639 
1640 
1641 #include <limits.h>
1642 #if !defined(SWIG_NO_LLONG_MAX)
1643 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1644 #   define LLONG_MAX __LONG_LONG_MAX__
1645 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1646 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1647 # endif
1648 #endif
1649 
1650 
1651 #include <stdlib.h>
1652 #ifdef _MSC_VER
1653 # ifndef strtoull
1654 #  define strtoull _strtoui64
1655 # endif
1656 # ifndef strtoll
1657 #  define strtoll _strtoi64
1658 # endif
1659 #endif
1660 
1661 
1662 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,double * val)1663 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1664 {
1665   if (SvNIOK(obj)) {
1666     if (val) *val = SvNV(obj);
1667     return SWIG_OK;
1668   } else if (SvIOK(obj)) {
1669     if (val) *val = (double) SvIV(obj);
1670     return SWIG_AddCast(SWIG_OK);
1671   } else {
1672     const char *nptr = SvPV_nolen(obj);
1673     if (nptr) {
1674       char *endptr;
1675       double v;
1676       errno = 0;
1677       v = strtod(nptr, &endptr);
1678       if (errno == ERANGE) {
1679 	errno = 0;
1680 	return SWIG_OverflowError;
1681       } else {
1682 	if (*endptr == '\0') {
1683 	  if (val) *val = v;
1684 	  return SWIG_Str2NumCast(SWIG_OK);
1685 	}
1686       }
1687     }
1688   }
1689   return SWIG_TypeError;
1690 }
1691 
1692 
1693 #include <float.h>
1694 
1695 
1696 #include <math.h>
1697 
1698 
1699 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)1700 SWIG_CanCastAsInteger(double *d, double min, double max) {
1701   double x = *d;
1702   if ((min <= x && x <= max)) {
1703    double fx = floor(x);
1704    double cx = ceil(x);
1705    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1706    if ((errno == EDOM) || (errno == ERANGE)) {
1707      errno = 0;
1708    } else {
1709      double summ, reps, diff;
1710      if (rd < x) {
1711        diff = x - rd;
1712      } else if (rd > x) {
1713        diff = rd - x;
1714      } else {
1715        return 1;
1716      }
1717      summ = rd + x;
1718      reps = diff/summ;
1719      if (reps < 8*DBL_EPSILON) {
1720        *d = rd;
1721        return 1;
1722      }
1723    }
1724   }
1725   return 0;
1726 }
1727 
1728 
1729 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,long * val)1730 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1731 {
1732   if (SvUOK(obj)) {
1733     UV v = SvUV(obj);
1734     if (UVSIZE < sizeof(*val) || v <= LONG_MAX) {
1735       if (val) *val = v;
1736       return SWIG_OK;
1737     }
1738     return SWIG_OverflowError;
1739   } else if (SvIOK(obj)) {
1740     IV v = SvIV(obj);
1741     if (IVSIZE <= sizeof(*val) || (v >= LONG_MIN && v <= LONG_MAX)) {
1742       if(val) *val = v;
1743       return SWIG_OK;
1744     }
1745     return SWIG_OverflowError;
1746   } else {
1747     int dispatch = 0;
1748     const char *nptr = SvPV_nolen(obj);
1749     if (nptr) {
1750       char *endptr;
1751       long v;
1752       errno = 0;
1753       v = strtol(nptr, &endptr,0);
1754       if (errno == ERANGE) {
1755 	errno = 0;
1756 	return SWIG_OverflowError;
1757       } else {
1758 	if (*endptr == '\0') {
1759 	  if (val) *val = v;
1760 	  return SWIG_Str2NumCast(SWIG_OK);
1761 	}
1762       }
1763     }
1764     if (!dispatch) {
1765       double d;
1766       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1767       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1768 	if (val) *val = (long)(d);
1769 	return res;
1770       }
1771     }
1772   }
1773   return SWIG_TypeError;
1774 }
1775 
1776 
1777 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,int * val)1778 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1779 {
1780   long v;
1781   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1782   if (SWIG_IsOK(res)) {
1783     if ((v < INT_MIN || v > INT_MAX)) {
1784       return SWIG_OverflowError;
1785     } else {
1786       if (val) *val = (int)(v);
1787     }
1788   }
1789   return res;
1790 }
1791 
1792 
1793 SWIGINTERNINLINE SV *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)1794 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1795 {
1796   SV *obj = sv_newmortal();
1797   if (carray) {
1798     sv_setpvn(obj, carray, size);
1799   } else {
1800     sv_setsv(obj, &PL_sv_undef);
1801   }
1802   return obj;
1803 }
1804 
1805 
1806 SWIGINTERNINLINE SV *
SWIG_FromCharPtr(const char * cptr)1807 SWIG_FromCharPtr(const char *cptr)
1808 {
1809   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1810 }
1811 
1812 
1813     #include "gsl/gsl_nan.h"
1814     #include "gsl/gsl_errno.h"
1815     #include "gsl/gsl_math.h"
1816     #include "gsl/gsl_monte.h"
1817 
1818 
1819     struct perl_array {
1820         I32 len;
1821         AV *array;
1822     };
1823 
1824 
1825 
1826 enum awType { awDouble, awFloat, awInt, awUnsigned };
1827 
1828 typedef struct {
1829     I32 size;
1830     enum awType type;
1831     void * data;
1832 } array_wrapper;
1833 
array_wrapper_alloc(int numelem,enum awType type)1834 array_wrapper * array_wrapper_alloc(int numelem, enum awType type){
1835     array_wrapper * rv =  malloc(sizeof(array_wrapper));
1836 
1837     if (rv == NULL)
1838         croak("array_wrapper_alloc: can't malloc wrapper\n");
1839 
1840     switch (type){
1841         case awDouble:
1842             rv->data = malloc(sizeof(double) * numelem);
1843             break;
1844         case awFloat:
1845             rv->data = malloc(sizeof(float) * numelem);
1846             break;
1847         case awInt:
1848             rv->data = malloc(sizeof(int) * numelem);
1849             break;
1850         case awUnsigned:
1851             rv->data = malloc(sizeof(unsigned int) * numelem);
1852             break;
1853         default:
1854             croak("array_wrapper_alloc: type should be awDouble, awFloat, awInt, or awUnsigned");
1855     }
1856 
1857     if (rv->data == NULL)
1858         croak("array_wrapper_alloc: can't malloc data");
1859 
1860     rv->size = numelem;
1861     rv->type = type;
1862     return rv;
1863 }
1864 
array_wrapper_free(array_wrapper * daw)1865 void array_wrapper_free(array_wrapper * daw){
1866     free(daw->data);
1867     free(daw);
1868 }
1869 
1870 
1871     /* structure to hold required information while the gsl function call
1872        for each callback
1873      */
1874     struct gsl_function_perl {
1875         gsl_function C_gsl_function;
1876         SV * function;
1877         SV * params;
1878     };
1879 
1880     struct gsl_function_fdf_perl {
1881         gsl_function_fdf C_gsl_function_fdf;
1882         SV * f;
1883         SV * df;
1884         SV * fdf;
1885         SV * params;
1886     };
1887 
1888     struct gsl_monte_function_perl {
1889         gsl_monte_function C_gsl_monte_function;
1890         SV * f;
1891         SV * dim;
1892         SV * params;
1893     };
1894 
gsl_function_perl_free(struct gsl_function_perl * perl_f)1895     void gsl_function_perl_free(struct gsl_function_perl * perl_f){
1896         if (perl_f != NULL) {
1897             SvREFCNT_dec(perl_f->function);
1898             SvREFCNT_dec(perl_f->params);
1899             Safefree(perl_f);
1900         }
1901     }
1902 
gsl_function_fdf_perl_free(struct gsl_function_fdf_perl * perl_fdf)1903     void gsl_function_fdf_perl_free(struct gsl_function_fdf_perl * perl_fdf){
1904         if (perl_fdf != NULL) {
1905 	  SvREFCNT_dec(perl_fdf->f);
1906 	  SvREFCNT_dec(perl_fdf->df);
1907 	  SvREFCNT_dec(perl_fdf->fdf);
1908 	  SvREFCNT_dec(perl_fdf->params);
1909 	  Safefree(perl_fdf);
1910         }
1911     }
1912 
1913     /* These functions (C callbacks) calls the perl callbacks.
1914        Info for perl callback can be found using the 'void*params' parameter
1915     */
call_gsl_function_x_params(SV * function,double x,SV * params)1916     double call_gsl_function_x_params(SV* function, double x, SV *params){
1917         unsigned int count;
1918         double y;
1919         dSP;
1920 
1921         //fprintf(stderr, "LOOKUP CALLBACK\n");
1922         ENTER;
1923         SAVETMPS;
1924 
1925         PUSHMARK(SP);
1926         XPUSHs(sv_2mortal(newSVnv((double)x)));
1927         XPUSHs(params);
1928         PUTBACK;                                /* make local stack pointer global */
1929 
1930         count = call_sv(function, G_SCALAR);
1931         SPAGAIN;
1932 
1933         if (count != 1)
1934                 croak("Expected to call subroutine in scalar context!");
1935 
1936         y = POPn;
1937 
1938         PUTBACK;                                /* make local stack pointer global */
1939         FREETMPS;
1940         LEAVE;
1941 
1942         return y;
1943     }
1944 
call_gsl_function(double x,void * params)1945     double call_gsl_function(double x , void *params){
1946         struct gsl_function_perl *F=(struct gsl_function_perl*)params;
1947 	return call_gsl_function_x_params( F->function, x, F->params );
1948     }
1949 
call_gsl_function_fdf_f(double x,void * params)1950     double call_gsl_function_fdf_f(double x , void *params){
1951         struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1952 	return call_gsl_function_x_params( F->f, x, F->params );
1953     }
1954 
call_gsl_function_fdf_df(double x,void * params)1955     double call_gsl_function_fdf_df(double x , void *params){
1956         struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1957 	return call_gsl_function_x_params( F->df, x, F->params );
1958     }
1959 
call_gsl_function_fdf_fdf(double x,void * params,double * f,double * df)1960     void call_gsl_function_fdf_fdf(double x , void *params, double *f, double *df ){
1961         struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1962 
1963         dSP;
1964 
1965         ENTER;
1966         SAVETMPS;
1967 
1968         PUSHMARK(SP);
1969 	EXTEND(SP, 2);
1970         PUSHs(sv_2mortal(newSVnv((double)x)));
1971         PUSHs(F->params);
1972         PUTBACK;                                /* make local stack pointer global */
1973 
1974 	{
1975 	  unsigned int count = call_sv(F->fdf, G_ARRAY);
1976 	  SPAGAIN;
1977 
1978 	  if (count != 2)
1979 	    croak( "Expected two return values, got %d", count );
1980 	}
1981 
1982 	*df = POPn;
1983         *f = POPn;
1984 
1985         PUTBACK;                                /* make local stack pointer global */
1986         FREETMPS;
1987         LEAVE;
1988     }
1989 
call_gsl_monte_function(double * x_array,size_t dim,void * params)1990     double call_gsl_monte_function(double *x_array , size_t dim, void *params){
1991         struct gsl_monte_function_perl *F=(struct gsl_monte_function_perl*)params;
1992         unsigned int count;
1993         unsigned int i;
1994         AV* perl_array;
1995         double y;
1996         dSP;
1997 
1998         //fprintf(stderr, "LOOKUP CALLBACK\n");
1999         ENTER;
2000         SAVETMPS;
2001 
2002         PUSHMARK(SP);
2003         perl_array=newAV();
2004         sv_2mortal((SV*)perl_array);
2005         XPUSHs(sv_2mortal(newRV((SV *)perl_array)));
2006         for(i=0; i<dim; i++) {
2007                 /* no mortal : it is referenced by the array */
2008                 av_push(perl_array, newSVnv(x_array[i]));
2009         }
2010         XPUSHs(sv_2mortal(newSViv(dim)));
2011         XPUSHs(F->params);
2012         PUTBACK;                                /* make local stack pointer global */
2013 
2014         count = call_sv(F->f, G_SCALAR);
2015         SPAGAIN;
2016 
2017         if (count != 1)
2018                 croak("Expected to call subroutine in scalar context!");
2019 
2020         y = POPn;
2021 
2022         PUTBACK;                                /* make local stack pointer global */
2023         FREETMPS;
2024         LEAVE;
2025 
2026         return y;
2027     }
2028 
2029 
gsl_function_fdf_extract(char * param_name,HV * hash,SV * func[])2030   void gsl_function_fdf_extract( char* param_name, HV* hash, SV* func[] ) {
2031     static const char *keys[3] = { "f", "df", "fdf" };
2032 
2033     int ikey;
2034 
2035     for ( ikey = 0 ; ikey < 3 ; ++ikey ) {
2036       func[ikey] = 0;
2037       const char* key = keys[ikey];
2038       /* it just so happens that strlen(keys[ikey]) == ikey + 1 */
2039       SV** pp_sv = hv_fetch( hash, key, ikey+1, 0 );
2040       SV* function;
2041 
2042       if ( !pp_sv )
2043 	croak("Math::GSL : %s: missing key %s!", param_name, key);
2044 
2045       function = *pp_sv;
2046 
2047       if ( SvPOK(function) || ( SvROK( function ) && SvTYPE(SvRV(function)) == SVt_PVCV ) ) {
2048         /* hold on to SV after the enclosing hash goes away */
2049         SvREFCNT_inc( function );
2050 	func[ikey] = function;
2051       }
2052       else {
2053 	croak( "Math::GSL : %s:  key %s is not a reference to code!", param_name, key);
2054       }
2055     }
2056   }
2057 
2058 
2059 
2060     #include "gsl/gsl_sys.h"
2061 
2062 
2063 /* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
2064 #ifndef SWIG_isfinite
2065 /* isfinite() is a macro for C99 */
2066 # if defined(isfinite)
2067 #  define SWIG_isfinite(X) (isfinite(X))
2068 # elif defined(__cplusplus) && __cplusplus >= 201103L
2069 /* Use a template so that this works whether isfinite() is std::isfinite() or
2070  * in the global namespace.  The reality seems to vary between compiler
2071  * versions.
2072  *
2073  * Make sure namespace std exists to avoid compiler warnings.
2074  *
2075  * extern "C++" is required as this fragment can end up inside an extern "C" { } block
2076  */
2077 namespace std { }
2078 extern "C++" template<typename T>
SWIG_isfinite_func(T x)2079 inline int SWIG_isfinite_func(T x) {
2080   using namespace std;
2081   return isfinite(x);
2082 }
2083 #  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
2084 # elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
2085 #  define SWIG_isfinite(X) (__builtin_isfinite(X))
2086 # elif defined(__clang__) && defined(__has_builtin)
2087 #  if __has_builtin(__builtin_isfinite)
2088 #   define SWIG_isfinite(X) (__builtin_isfinite(X))
2089 #  endif
2090 # elif defined(_MSC_VER)
2091 #  define SWIG_isfinite(X) (_finite(X))
2092 # elif defined(__sun) && defined(__SVR4)
2093 #  include <ieeefp.h>
2094 #  define SWIG_isfinite(X) (finite(X))
2095 # endif
2096 #endif
2097 
2098 
2099 /* Accept infinite as a valid float value unless we are unable to check if a value is finite */
2100 #ifdef SWIG_isfinite
2101 # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
2102 #else
2103 # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
2104 #endif
2105 
2106 
2107 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,float * val)2108 SWIG_AsVal_float SWIG_PERL_DECL_ARGS_2(SV * obj, float *val)
2109 {
2110   double v;
2111   int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj, &v);
2112   if (SWIG_IsOK(res)) {
2113     if (SWIG_Float_Overflow_Check(v)) {
2114       return SWIG_OverflowError;
2115     } else {
2116       if (val) *val = (float)(v);
2117     }
2118   }
2119   return res;
2120 }
2121 
2122 
2123 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(float value)2124 SWIG_From_float  SWIG_PERL_DECL_ARGS_1(float value)
2125 {
2126   return SWIG_From_double  SWIG_PERL_CALL_ARGS_1(value);
2127 }
2128 
2129 #ifdef __cplusplus
2130 extern "C" {
2131 #endif
2132 
2133 #ifdef PERL_OBJECT
2134 #define MAGIC_CLASS _wrap_Math__GSL__Sys_var::
2135 class _wrap_Math__GSL__Sys_var : public CPerlObj {
2136 public:
2137 #else
2138 #define MAGIC_CLASS
2139 #endif
swig_magic_readonly(pTHX_ SV * SWIGUNUSEDPARM (sv),MAGIC * SWIGUNUSEDPARM (mg))2140 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2141     MAGIC_PPERL
2142     croak("Value is read-only.");
2143     return 0;
2144 }
2145 
2146 
2147 #ifdef PERL_OBJECT
2148 };
2149 #endif
2150 
2151 #ifdef __cplusplus
2152 }
2153 #endif
2154 
2155 #ifdef __cplusplus
2156 extern "C" {
2157 #endif
XS(_wrap_gsl_error)2158 XS(_wrap_gsl_error) {
2159   {
2160     char *arg1 = (char *) 0 ;
2161     char *arg2 = (char *) 0 ;
2162     int arg3 ;
2163     int arg4 ;
2164     int res1 ;
2165     char *buf1 = 0 ;
2166     int alloc1 = 0 ;
2167     int res2 ;
2168     char *buf2 = 0 ;
2169     int alloc2 = 0 ;
2170     int val3 ;
2171     int ecode3 = 0 ;
2172     int val4 ;
2173     int ecode4 = 0 ;
2174     int argvi = 0;
2175     dXSARGS;
2176 
2177     if ((items < 4) || (items > 4)) {
2178       SWIG_croak("Usage: gsl_error(reason,file,line,gsl_errno);");
2179     }
2180     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2181     if (!SWIG_IsOK(res1)) {
2182       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_error" "', argument " "1"" of type '" "char const *""'");
2183     }
2184     arg1 = (char *)(buf1);
2185     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2186     if (!SWIG_IsOK(res2)) {
2187       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_error" "', argument " "2"" of type '" "char const *""'");
2188     }
2189     arg2 = (char *)(buf2);
2190     ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2191     if (!SWIG_IsOK(ecode3)) {
2192       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_error" "', argument " "3"" of type '" "int""'");
2193     }
2194     arg3 = (int)(val3);
2195     ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2196     if (!SWIG_IsOK(ecode4)) {
2197       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_error" "', argument " "4"" of type '" "int""'");
2198     }
2199     arg4 = (int)(val4);
2200     gsl_error((char const *)arg1,(char const *)arg2,arg3,arg4);
2201     ST(argvi) = &PL_sv_undef;
2202     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2203     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2204 
2205 
2206     XSRETURN(argvi);
2207   fail:
2208     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2209     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2210 
2211 
2212     SWIG_croak_null();
2213   }
2214 }
2215 
2216 
XS(_wrap_gsl_stream_printf)2217 XS(_wrap_gsl_stream_printf) {
2218   {
2219     char *arg1 = (char *) 0 ;
2220     char *arg2 = (char *) 0 ;
2221     int arg3 ;
2222     char *arg4 = (char *) 0 ;
2223     int res1 ;
2224     char *buf1 = 0 ;
2225     int alloc1 = 0 ;
2226     int res2 ;
2227     char *buf2 = 0 ;
2228     int alloc2 = 0 ;
2229     int val3 ;
2230     int ecode3 = 0 ;
2231     int res4 ;
2232     char *buf4 = 0 ;
2233     int alloc4 = 0 ;
2234     int argvi = 0;
2235     dXSARGS;
2236 
2237     if ((items < 4) || (items > 4)) {
2238       SWIG_croak("Usage: gsl_stream_printf(label,file,line,reason);");
2239     }
2240     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2241     if (!SWIG_IsOK(res1)) {
2242       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_stream_printf" "', argument " "1"" of type '" "char const *""'");
2243     }
2244     arg1 = (char *)(buf1);
2245     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2246     if (!SWIG_IsOK(res2)) {
2247       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_stream_printf" "', argument " "2"" of type '" "char const *""'");
2248     }
2249     arg2 = (char *)(buf2);
2250     ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2251     if (!SWIG_IsOK(ecode3)) {
2252       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_stream_printf" "', argument " "3"" of type '" "int""'");
2253     }
2254     arg3 = (int)(val3);
2255     res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2256     if (!SWIG_IsOK(res4)) {
2257       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gsl_stream_printf" "', argument " "4"" of type '" "char const *""'");
2258     }
2259     arg4 = (char *)(buf4);
2260     gsl_stream_printf((char const *)arg1,(char const *)arg2,arg3,(char const *)arg4);
2261     ST(argvi) = &PL_sv_undef;
2262     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2263     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2264 
2265     if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2266     XSRETURN(argvi);
2267   fail:
2268     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2269     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2270 
2271     if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2272     SWIG_croak_null();
2273   }
2274 }
2275 
2276 
XS(_wrap_gsl_strerror)2277 XS(_wrap_gsl_strerror) {
2278   {
2279     int arg1 ;
2280     int val1 ;
2281     int ecode1 = 0 ;
2282     int argvi = 0;
2283     char *result = 0 ;
2284     dXSARGS;
2285 
2286     if ((items < 1) || (items > 1)) {
2287       SWIG_croak("Usage: gsl_strerror(gsl_errno);");
2288     }
2289     ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2290     if (!SWIG_IsOK(ecode1)) {
2291       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_strerror" "', argument " "1"" of type '" "int""'");
2292     }
2293     arg1 = (int)(val1);
2294     result = (char *)gsl_strerror(arg1);
2295     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2296 
2297     XSRETURN(argvi);
2298   fail:
2299 
2300     SWIG_croak_null();
2301   }
2302 }
2303 
2304 
XS(_wrap_gsl_set_error_handler)2305 XS(_wrap_gsl_set_error_handler) {
2306   {
2307     gsl_error_handler_t *arg1 = (gsl_error_handler_t *) 0 ;
2308     int argvi = 0;
2309     gsl_error_handler_t *result = 0 ;
2310     dXSARGS;
2311 
2312     if ((items < 1) || (items > 1)) {
2313       SWIG_croak("Usage: gsl_set_error_handler(new_handler);");
2314     }
2315     {
2316       int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void);
2317       if (!SWIG_IsOK(res)) {
2318         SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_error_handler" "', argument " "1"" of type '" "gsl_error_handler_t *""'");
2319       }
2320     }
2321     result = (gsl_error_handler_t *)gsl_set_error_handler(arg1);
2322     ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2323 
2324     XSRETURN(argvi);
2325   fail:
2326 
2327     SWIG_croak_null();
2328   }
2329 }
2330 
2331 
XS(_wrap_gsl_set_error_handler_off)2332 XS(_wrap_gsl_set_error_handler_off) {
2333   {
2334     int argvi = 0;
2335     gsl_error_handler_t *result = 0 ;
2336     dXSARGS;
2337 
2338     if ((items < 0) || (items > 0)) {
2339       SWIG_croak("Usage: gsl_set_error_handler_off();");
2340     }
2341     result = (gsl_error_handler_t *)gsl_set_error_handler_off();
2342     ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2343     XSRETURN(argvi);
2344   fail:
2345     SWIG_croak_null();
2346   }
2347 }
2348 
2349 
XS(_wrap_gsl_set_stream_handler)2350 XS(_wrap_gsl_set_stream_handler) {
2351   {
2352     gsl_stream_handler_t *arg1 = (gsl_stream_handler_t *) 0 ;
2353     int argvi = 0;
2354     gsl_stream_handler_t *result = 0 ;
2355     dXSARGS;
2356 
2357     if ((items < 1) || (items > 1)) {
2358       SWIG_croak("Usage: gsl_set_stream_handler(new_handler);");
2359     }
2360     {
2361       int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void);
2362       if (!SWIG_IsOK(res)) {
2363         SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_stream_handler" "', argument " "1"" of type '" "gsl_stream_handler_t *""'");
2364       }
2365     }
2366     result = (gsl_stream_handler_t *)gsl_set_stream_handler(arg1);
2367     ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void); argvi++ ;
2368 
2369     XSRETURN(argvi);
2370   fail:
2371 
2372     SWIG_croak_null();
2373   }
2374 }
2375 
2376 
XS(_wrap_gsl_set_stream)2377 XS(_wrap_gsl_set_stream) {
2378   {
2379     FILE *arg1 = (FILE *) 0 ;
2380     void *argp1 = 0 ;
2381     int res1 = 0 ;
2382     int argvi = 0;
2383     FILE *result = 0 ;
2384     dXSARGS;
2385 
2386     if ((items < 1) || (items > 1)) {
2387       SWIG_croak("Usage: gsl_set_stream(new_stream);");
2388     }
2389     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_FILE, 0 |  0 );
2390     if (!SWIG_IsOK(res1)) {
2391       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_set_stream" "', argument " "1"" of type '" "FILE *""'");
2392     }
2393     arg1 = (FILE *)(argp1);
2394     result = (FILE *)gsl_set_stream(arg1);
2395     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0); argvi++ ;
2396 
2397     XSRETURN(argvi);
2398   fail:
2399 
2400     SWIG_croak_null();
2401   }
2402 }
2403 
2404 
XS(_wrap_gsl_log1p)2405 XS(_wrap_gsl_log1p) {
2406   {
2407     double arg1 ;
2408     double val1 ;
2409     int ecode1 = 0 ;
2410     int argvi = 0;
2411     double result;
2412     dXSARGS;
2413 
2414     if ((items < 1) || (items > 1)) {
2415       SWIG_croak("Usage: gsl_log1p(x);");
2416     }
2417     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2418     if (!SWIG_IsOK(ecode1)) {
2419       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_log1p" "', argument " "1"" of type '" "double""'");
2420     }
2421     arg1 = (double)(val1);
2422     result = (double)gsl_log1p(arg1);
2423     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2424 
2425     XSRETURN(argvi);
2426   fail:
2427 
2428     SWIG_croak_null();
2429   }
2430 }
2431 
2432 
XS(_wrap_gsl_expm1)2433 XS(_wrap_gsl_expm1) {
2434   {
2435     double arg1 ;
2436     double val1 ;
2437     int ecode1 = 0 ;
2438     int argvi = 0;
2439     double result;
2440     dXSARGS;
2441 
2442     if ((items < 1) || (items > 1)) {
2443       SWIG_croak("Usage: gsl_expm1(x);");
2444     }
2445     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2446     if (!SWIG_IsOK(ecode1)) {
2447       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_expm1" "', argument " "1"" of type '" "double""'");
2448     }
2449     arg1 = (double)(val1);
2450     result = (double)gsl_expm1(arg1);
2451     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2452 
2453     XSRETURN(argvi);
2454   fail:
2455 
2456     SWIG_croak_null();
2457   }
2458 }
2459 
2460 
XS(_wrap_gsl_hypot)2461 XS(_wrap_gsl_hypot) {
2462   {
2463     double arg1 ;
2464     double arg2 ;
2465     double val1 ;
2466     int ecode1 = 0 ;
2467     double val2 ;
2468     int ecode2 = 0 ;
2469     int argvi = 0;
2470     double result;
2471     dXSARGS;
2472 
2473     if ((items < 2) || (items > 2)) {
2474       SWIG_croak("Usage: gsl_hypot(x,y);");
2475     }
2476     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2477     if (!SWIG_IsOK(ecode1)) {
2478       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_hypot" "', argument " "1"" of type '" "double""'");
2479     }
2480     arg1 = (double)(val1);
2481     ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2482     if (!SWIG_IsOK(ecode2)) {
2483       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_hypot" "', argument " "2"" of type '" "double""'");
2484     }
2485     arg2 = (double)(val2);
2486     result = (double)gsl_hypot(arg1,arg2);
2487     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2488 
2489 
2490     XSRETURN(argvi);
2491   fail:
2492 
2493 
2494     SWIG_croak_null();
2495   }
2496 }
2497 
2498 
XS(_wrap_gsl_hypot3)2499 XS(_wrap_gsl_hypot3) {
2500   {
2501     double arg1 ;
2502     double arg2 ;
2503     double arg3 ;
2504     double val1 ;
2505     int ecode1 = 0 ;
2506     double val2 ;
2507     int ecode2 = 0 ;
2508     double val3 ;
2509     int ecode3 = 0 ;
2510     int argvi = 0;
2511     double result;
2512     dXSARGS;
2513 
2514     if ((items < 3) || (items > 3)) {
2515       SWIG_croak("Usage: gsl_hypot3(x,y,z);");
2516     }
2517     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2518     if (!SWIG_IsOK(ecode1)) {
2519       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_hypot3" "', argument " "1"" of type '" "double""'");
2520     }
2521     arg1 = (double)(val1);
2522     ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2523     if (!SWIG_IsOK(ecode2)) {
2524       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_hypot3" "', argument " "2"" of type '" "double""'");
2525     }
2526     arg2 = (double)(val2);
2527     ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2528     if (!SWIG_IsOK(ecode3)) {
2529       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_hypot3" "', argument " "3"" of type '" "double""'");
2530     }
2531     arg3 = (double)(val3);
2532     result = (double)gsl_hypot3(arg1,arg2,arg3);
2533     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2534 
2535 
2536 
2537     XSRETURN(argvi);
2538   fail:
2539 
2540 
2541 
2542     SWIG_croak_null();
2543   }
2544 }
2545 
2546 
XS(_wrap_gsl_acosh)2547 XS(_wrap_gsl_acosh) {
2548   {
2549     double arg1 ;
2550     double val1 ;
2551     int ecode1 = 0 ;
2552     int argvi = 0;
2553     double result;
2554     dXSARGS;
2555 
2556     if ((items < 1) || (items > 1)) {
2557       SWIG_croak("Usage: gsl_acosh(x);");
2558     }
2559     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2560     if (!SWIG_IsOK(ecode1)) {
2561       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_acosh" "', argument " "1"" of type '" "double""'");
2562     }
2563     arg1 = (double)(val1);
2564     result = (double)gsl_acosh(arg1);
2565     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2566 
2567     XSRETURN(argvi);
2568   fail:
2569 
2570     SWIG_croak_null();
2571   }
2572 }
2573 
2574 
XS(_wrap_gsl_asinh)2575 XS(_wrap_gsl_asinh) {
2576   {
2577     double arg1 ;
2578     double val1 ;
2579     int ecode1 = 0 ;
2580     int argvi = 0;
2581     double result;
2582     dXSARGS;
2583 
2584     if ((items < 1) || (items > 1)) {
2585       SWIG_croak("Usage: gsl_asinh(x);");
2586     }
2587     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2588     if (!SWIG_IsOK(ecode1)) {
2589       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_asinh" "', argument " "1"" of type '" "double""'");
2590     }
2591     arg1 = (double)(val1);
2592     result = (double)gsl_asinh(arg1);
2593     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2594 
2595     XSRETURN(argvi);
2596   fail:
2597 
2598     SWIG_croak_null();
2599   }
2600 }
2601 
2602 
XS(_wrap_gsl_atanh)2603 XS(_wrap_gsl_atanh) {
2604   {
2605     double arg1 ;
2606     double val1 ;
2607     int ecode1 = 0 ;
2608     int argvi = 0;
2609     double result;
2610     dXSARGS;
2611 
2612     if ((items < 1) || (items > 1)) {
2613       SWIG_croak("Usage: gsl_atanh(x);");
2614     }
2615     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2616     if (!SWIG_IsOK(ecode1)) {
2617       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_atanh" "', argument " "1"" of type '" "double""'");
2618     }
2619     arg1 = (double)(val1);
2620     result = (double)gsl_atanh(arg1);
2621     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2622 
2623     XSRETURN(argvi);
2624   fail:
2625 
2626     SWIG_croak_null();
2627   }
2628 }
2629 
2630 
XS(_wrap_gsl_isnan)2631 XS(_wrap_gsl_isnan) {
2632   {
2633     double arg1 ;
2634     double val1 ;
2635     int ecode1 = 0 ;
2636     int argvi = 0;
2637     int result;
2638     dXSARGS;
2639 
2640     if ((items < 1) || (items > 1)) {
2641       SWIG_croak("Usage: gsl_isnan(x);");
2642     }
2643     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2644     if (!SWIG_IsOK(ecode1)) {
2645       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_isnan" "', argument " "1"" of type '" "double""'");
2646     }
2647     arg1 = (double)(val1);
2648     result = (int)gsl_isnan(arg1);
2649     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2650 
2651     XSRETURN(argvi);
2652   fail:
2653 
2654     SWIG_croak_null();
2655   }
2656 }
2657 
2658 
XS(_wrap_gsl_isinf)2659 XS(_wrap_gsl_isinf) {
2660   {
2661     double arg1 ;
2662     double val1 ;
2663     int ecode1 = 0 ;
2664     int argvi = 0;
2665     int result;
2666     dXSARGS;
2667 
2668     if ((items < 1) || (items > 1)) {
2669       SWIG_croak("Usage: gsl_isinf(x);");
2670     }
2671     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2672     if (!SWIG_IsOK(ecode1)) {
2673       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_isinf" "', argument " "1"" of type '" "double""'");
2674     }
2675     arg1 = (double)(val1);
2676     result = (int)gsl_isinf(arg1);
2677     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2678 
2679     XSRETURN(argvi);
2680   fail:
2681 
2682     SWIG_croak_null();
2683   }
2684 }
2685 
2686 
XS(_wrap_gsl_finite)2687 XS(_wrap_gsl_finite) {
2688   {
2689     double arg1 ;
2690     double val1 ;
2691     int ecode1 = 0 ;
2692     int argvi = 0;
2693     int result;
2694     dXSARGS;
2695 
2696     if ((items < 1) || (items > 1)) {
2697       SWIG_croak("Usage: gsl_finite(x);");
2698     }
2699     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2700     if (!SWIG_IsOK(ecode1)) {
2701       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_finite" "', argument " "1"" of type '" "double""'");
2702     }
2703     arg1 = (double)(val1);
2704     result = (int)gsl_finite(arg1);
2705     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2706 
2707     XSRETURN(argvi);
2708   fail:
2709 
2710     SWIG_croak_null();
2711   }
2712 }
2713 
2714 
XS(_wrap_gsl_nan)2715 XS(_wrap_gsl_nan) {
2716   {
2717     int argvi = 0;
2718     double result;
2719     dXSARGS;
2720 
2721     if ((items < 0) || (items > 0)) {
2722       SWIG_croak("Usage: gsl_nan();");
2723     }
2724     result = (double)gsl_nan();
2725     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2726     XSRETURN(argvi);
2727   fail:
2728     SWIG_croak_null();
2729   }
2730 }
2731 
2732 
XS(_wrap_gsl_posinf)2733 XS(_wrap_gsl_posinf) {
2734   {
2735     int argvi = 0;
2736     double result;
2737     dXSARGS;
2738 
2739     if ((items < 0) || (items > 0)) {
2740       SWIG_croak("Usage: gsl_posinf();");
2741     }
2742     result = (double)gsl_posinf();
2743     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2744     XSRETURN(argvi);
2745   fail:
2746     SWIG_croak_null();
2747   }
2748 }
2749 
2750 
XS(_wrap_gsl_neginf)2751 XS(_wrap_gsl_neginf) {
2752   {
2753     int argvi = 0;
2754     double result;
2755     dXSARGS;
2756 
2757     if ((items < 0) || (items > 0)) {
2758       SWIG_croak("Usage: gsl_neginf();");
2759     }
2760     result = (double)gsl_neginf();
2761     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2762     XSRETURN(argvi);
2763   fail:
2764     SWIG_croak_null();
2765   }
2766 }
2767 
2768 
XS(_wrap_gsl_fdiv)2769 XS(_wrap_gsl_fdiv) {
2770   {
2771     double arg1 ;
2772     double arg2 ;
2773     double val1 ;
2774     int ecode1 = 0 ;
2775     double val2 ;
2776     int ecode2 = 0 ;
2777     int argvi = 0;
2778     double result;
2779     dXSARGS;
2780 
2781     if ((items < 2) || (items > 2)) {
2782       SWIG_croak("Usage: gsl_fdiv(x,y);");
2783     }
2784     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2785     if (!SWIG_IsOK(ecode1)) {
2786       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_fdiv" "', argument " "1"" of type '" "double""'");
2787     }
2788     arg1 = (double)(val1);
2789     ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2790     if (!SWIG_IsOK(ecode2)) {
2791       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_fdiv" "', argument " "2"" of type '" "double""'");
2792     }
2793     arg2 = (double)(val2);
2794     result = (double)gsl_fdiv(arg1,arg2);
2795     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2796 
2797 
2798     XSRETURN(argvi);
2799   fail:
2800 
2801 
2802     SWIG_croak_null();
2803   }
2804 }
2805 
2806 
XS(_wrap_gsl_coerce_double)2807 XS(_wrap_gsl_coerce_double) {
2808   {
2809     double arg1 ;
2810     double val1 ;
2811     int ecode1 = 0 ;
2812     int argvi = 0;
2813     double result;
2814     dXSARGS;
2815 
2816     if ((items < 1) || (items > 1)) {
2817       SWIG_croak("Usage: gsl_coerce_double(x);");
2818     }
2819     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2820     if (!SWIG_IsOK(ecode1)) {
2821       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_coerce_double" "', argument " "1"" of type '" "double""'");
2822     }
2823     arg1 = (double)(val1);
2824     result = (double)gsl_coerce_double(arg1);
2825     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2826 
2827     XSRETURN(argvi);
2828   fail:
2829 
2830     SWIG_croak_null();
2831   }
2832 }
2833 
2834 
XS(_wrap_gsl_coerce_float)2835 XS(_wrap_gsl_coerce_float) {
2836   {
2837     float arg1 ;
2838     float val1 ;
2839     int ecode1 = 0 ;
2840     int argvi = 0;
2841     float result;
2842     dXSARGS;
2843 
2844     if ((items < 1) || (items > 1)) {
2845       SWIG_croak("Usage: gsl_coerce_float(x);");
2846     }
2847     ecode1 = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2848     if (!SWIG_IsOK(ecode1)) {
2849       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_coerce_float" "', argument " "1"" of type '" "float""'");
2850     }
2851     arg1 = (float)(val1);
2852     result = (float)gsl_coerce_float(arg1);
2853     ST(argvi) = SWIG_From_float  SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
2854 
2855     XSRETURN(argvi);
2856   fail:
2857 
2858     SWIG_croak_null();
2859   }
2860 }
2861 
2862 
XS(_wrap_gsl_coerce_long_double)2863 XS(_wrap_gsl_coerce_long_double) {
2864   {
2865     long double arg1 ;
2866     void *argp1 ;
2867     int res1 = 0 ;
2868     int argvi = 0;
2869     long double result;
2870     dXSARGS;
2871 
2872     if ((items < 1) || (items > 1)) {
2873       SWIG_croak("Usage: gsl_coerce_long_double(x);");
2874     }
2875     {
2876       res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_long_double,  0 );
2877       if (!SWIG_IsOK(res1)) {
2878         SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_coerce_long_double" "', argument " "1"" of type '" "long double const""'");
2879       }
2880       if (!argp1) {
2881         SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gsl_coerce_long_double" "', argument " "1"" of type '" "long double const""'");
2882       } else {
2883         arg1 = *((long double *)(argp1));
2884       }
2885     }
2886     result = (long double)gsl_coerce_long_double(arg1);
2887     ST(argvi) = SWIG_NewPointerObj((long double *)memcpy((long double *)calloc(1,sizeof(long double)),&result,sizeof(long double)), SWIGTYPE_p_long_double, SWIG_POINTER_OWN | 0); argvi++ ;
2888     XSRETURN(argvi);
2889   fail:
2890     SWIG_croak_null();
2891   }
2892 }
2893 
2894 
XS(_wrap_gsl_ldexp)2895 XS(_wrap_gsl_ldexp) {
2896   {
2897     double arg1 ;
2898     int arg2 ;
2899     double val1 ;
2900     int ecode1 = 0 ;
2901     int val2 ;
2902     int ecode2 = 0 ;
2903     int argvi = 0;
2904     double result;
2905     dXSARGS;
2906 
2907     if ((items < 2) || (items > 2)) {
2908       SWIG_croak("Usage: gsl_ldexp(x,e);");
2909     }
2910     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2911     if (!SWIG_IsOK(ecode1)) {
2912       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_ldexp" "', argument " "1"" of type '" "double""'");
2913     }
2914     arg1 = (double)(val1);
2915     ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2916     if (!SWIG_IsOK(ecode2)) {
2917       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_ldexp" "', argument " "2"" of type '" "int""'");
2918     }
2919     arg2 = (int)(val2);
2920     result = (double)gsl_ldexp(arg1,arg2);
2921     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2922 
2923 
2924     XSRETURN(argvi);
2925   fail:
2926 
2927 
2928     SWIG_croak_null();
2929   }
2930 }
2931 
2932 
XS(_wrap_gsl_frexp)2933 XS(_wrap_gsl_frexp) {
2934   {
2935     double arg1 ;
2936     int *arg2 = (int *) 0 ;
2937     double val1 ;
2938     int ecode1 = 0 ;
2939     int temp2 ;
2940     int res2 = SWIG_TMPOBJ ;
2941     int argvi = 0;
2942     double result;
2943     dXSARGS;
2944 
2945     arg2 = &temp2;
2946     if ((items < 1) || (items > 1)) {
2947       SWIG_croak("Usage: gsl_frexp(x);");
2948     }
2949     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2950     if (!SWIG_IsOK(ecode1)) {
2951       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_frexp" "', argument " "1"" of type '" "double""'");
2952     }
2953     arg1 = (double)(val1);
2954     result = (double)gsl_frexp(arg1,arg2);
2955     ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2956     if (SWIG_IsTmpObj(res2)) {
2957       if (argvi >= items) EXTEND(sp, argvi+1);  ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((*arg2)); argvi++  ;
2958     } else {
2959       int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0) : 0;
2960       if (argvi >= items) EXTEND(sp, argvi+1);  ST(argvi) = SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags); argvi++  ;
2961     }
2962 
2963 
2964     XSRETURN(argvi);
2965   fail:
2966 
2967 
2968     SWIG_croak_null();
2969   }
2970 }
2971 
2972 
XS(_wrap_gsl_fcmp)2973 XS(_wrap_gsl_fcmp) {
2974   {
2975     double arg1 ;
2976     double arg2 ;
2977     double arg3 ;
2978     double val1 ;
2979     int ecode1 = 0 ;
2980     double val2 ;
2981     int ecode2 = 0 ;
2982     double val3 ;
2983     int ecode3 = 0 ;
2984     int argvi = 0;
2985     int result;
2986     dXSARGS;
2987 
2988     if ((items < 3) || (items > 3)) {
2989       SWIG_croak("Usage: gsl_fcmp(x1,x2,epsilon);");
2990     }
2991     ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2992     if (!SWIG_IsOK(ecode1)) {
2993       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_fcmp" "', argument " "1"" of type '" "double""'");
2994     }
2995     arg1 = (double)(val1);
2996     ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2997     if (!SWIG_IsOK(ecode2)) {
2998       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_fcmp" "', argument " "2"" of type '" "double""'");
2999     }
3000     arg2 = (double)(val2);
3001     ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
3002     if (!SWIG_IsOK(ecode3)) {
3003       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_fcmp" "', argument " "3"" of type '" "double""'");
3004     }
3005     arg3 = (double)(val3);
3006     result = (int)gsl_fcmp(arg1,arg2,arg3);
3007     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3008 
3009 
3010 
3011     XSRETURN(argvi);
3012   fail:
3013 
3014 
3015 
3016     SWIG_croak_null();
3017   }
3018 }
3019 
3020 
3021 
3022 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3023 
3024 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
3025 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3026 static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__char_int_int__void = {"_p_f_p_q_const__char_p_q_const__char_int_int__void", "void (*)(char const *,char const *,int,int)|gsl_error_handler_t *", 0, 0, (void*)0, 0};
3027 static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void = {"_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void", "gsl_stream_handler_t *|void (*)(char const *,char const *,int,char const *)", 0, 0, (void*)0, 0};
3028 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
3029 static swig_type_info _swigt__p_long_double = {"_p_long_double", "long double *", 0, 0, (void*)0, 0};
3030 
3031 static swig_type_info *swig_type_initial[] = {
3032   &_swigt__p_FILE,
3033   &_swigt__p_char,
3034   &_swigt__p_f_p_q_const__char_p_q_const__char_int_int__void,
3035   &_swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
3036   &_swigt__p_int,
3037   &_swigt__p_long_double,
3038 };
3039 
3040 static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
3041 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3042 static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__char_int_int__void[] = {  {&_swigt__p_f_p_q_const__char_p_q_const__char_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
3043 static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void[] = {  {&_swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void, 0, 0, 0},{0, 0, 0, 0}};
3044 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
3045 static swig_cast_info _swigc__p_long_double[] = {  {&_swigt__p_long_double, 0, 0, 0},{0, 0, 0, 0}};
3046 
3047 static swig_cast_info *swig_cast_initial[] = {
3048   _swigc__p_FILE,
3049   _swigc__p_char,
3050   _swigc__p_f_p_q_const__char_p_q_const__char_int_int__void,
3051   _swigc__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
3052   _swigc__p_int,
3053   _swigc__p_long_double,
3054 };
3055 
3056 
3057 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3058 
3059 static swig_constant_info swig_constants[] = {
3060 {0,0,0,0,0,0}
3061 };
3062 #ifdef __cplusplus
3063 }
3064 #endif
3065 static swig_variable_info swig_variables[] = {
3066 {0,0,0,0}
3067 };
3068 static swig_command_info swig_commands[] = {
3069 {"Math::GSL::Sysc::gsl_error", _wrap_gsl_error},
3070 {"Math::GSL::Sysc::gsl_stream_printf", _wrap_gsl_stream_printf},
3071 {"Math::GSL::Sysc::gsl_strerror", _wrap_gsl_strerror},
3072 {"Math::GSL::Sysc::gsl_set_error_handler", _wrap_gsl_set_error_handler},
3073 {"Math::GSL::Sysc::gsl_set_error_handler_off", _wrap_gsl_set_error_handler_off},
3074 {"Math::GSL::Sysc::gsl_set_stream_handler", _wrap_gsl_set_stream_handler},
3075 {"Math::GSL::Sysc::gsl_set_stream", _wrap_gsl_set_stream},
3076 {"Math::GSL::Sysc::gsl_log1p", _wrap_gsl_log1p},
3077 {"Math::GSL::Sysc::gsl_expm1", _wrap_gsl_expm1},
3078 {"Math::GSL::Sysc::gsl_hypot", _wrap_gsl_hypot},
3079 {"Math::GSL::Sysc::gsl_hypot3", _wrap_gsl_hypot3},
3080 {"Math::GSL::Sysc::gsl_acosh", _wrap_gsl_acosh},
3081 {"Math::GSL::Sysc::gsl_asinh", _wrap_gsl_asinh},
3082 {"Math::GSL::Sysc::gsl_atanh", _wrap_gsl_atanh},
3083 {"Math::GSL::Sysc::gsl_isnan", _wrap_gsl_isnan},
3084 {"Math::GSL::Sysc::gsl_isinf", _wrap_gsl_isinf},
3085 {"Math::GSL::Sysc::gsl_finite", _wrap_gsl_finite},
3086 {"Math::GSL::Sysc::gsl_nan", _wrap_gsl_nan},
3087 {"Math::GSL::Sysc::gsl_posinf", _wrap_gsl_posinf},
3088 {"Math::GSL::Sysc::gsl_neginf", _wrap_gsl_neginf},
3089 {"Math::GSL::Sysc::gsl_fdiv", _wrap_gsl_fdiv},
3090 {"Math::GSL::Sysc::gsl_coerce_double", _wrap_gsl_coerce_double},
3091 {"Math::GSL::Sysc::gsl_coerce_float", _wrap_gsl_coerce_float},
3092 {"Math::GSL::Sysc::gsl_coerce_long_double", _wrap_gsl_coerce_long_double},
3093 {"Math::GSL::Sysc::gsl_ldexp", _wrap_gsl_ldexp},
3094 {"Math::GSL::Sysc::gsl_frexp", _wrap_gsl_frexp},
3095 {"Math::GSL::Sysc::gsl_fcmp", _wrap_gsl_fcmp},
3096 {0,0}
3097 };
3098 /* -----------------------------------------------------------------------------
3099  * Type initialization:
3100  * This problem is tough by the requirement that no dynamic
3101  * memory is used. Also, since swig_type_info structures store pointers to
3102  * swig_cast_info structures and swig_cast_info structures store pointers back
3103  * to swig_type_info structures, we need some lookup code at initialization.
3104  * The idea is that swig generates all the structures that are needed.
3105  * The runtime then collects these partially filled structures.
3106  * The SWIG_InitializeModule function takes these initial arrays out of
3107  * swig_module, and does all the lookup, filling in the swig_module.types
3108  * array with the correct data and linking the correct swig_cast_info
3109  * structures together.
3110  *
3111  * The generated swig_type_info structures are assigned statically to an initial
3112  * array. We just loop through that array, and handle each type individually.
3113  * First we lookup if this type has been already loaded, and if so, use the
3114  * loaded structure instead of the generated one. Then we have to fill in the
3115  * cast linked list. The cast data is initially stored in something like a
3116  * two-dimensional array. Each row corresponds to a type (there are the same
3117  * number of rows as there are in the swig_type_initial array). Each entry in
3118  * a column is one of the swig_cast_info structures for that type.
3119  * The cast_initial array is actually an array of arrays, because each row has
3120  * a variable number of columns. So to actually build the cast linked list,
3121  * we find the array of casts associated with the type, and loop through it
3122  * adding the casts to the list. The one last trick we need to do is making
3123  * sure the type pointer in the swig_cast_info struct is correct.
3124  *
3125  * First off, we lookup the cast->type name to see if it is already loaded.
3126  * There are three cases to handle:
3127  *  1) If the cast->type has already been loaded AND the type we are adding
3128  *     casting info to has not been loaded (it is in this module), THEN we
3129  *     replace the cast->type pointer with the type pointer that has already
3130  *     been loaded.
3131  *  2) If BOTH types (the one we are adding casting info to, and the
3132  *     cast->type) are loaded, THEN the cast info has already been loaded by
3133  *     the previous module so we just ignore it.
3134  *  3) Finally, if cast->type has not already been loaded, then we add that
3135  *     swig_cast_info to the linked list (because the cast->type) pointer will
3136  *     be correct.
3137  * ----------------------------------------------------------------------------- */
3138 
3139 #ifdef __cplusplus
3140 extern "C" {
3141 #if 0
3142 } /* c-mode */
3143 #endif
3144 #endif
3145 
3146 #if 0
3147 #define SWIGRUNTIME_DEBUG
3148 #endif
3149 
3150 
3151 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)3152 SWIG_InitializeModule(void *clientdata) {
3153   size_t i;
3154   swig_module_info *module_head, *iter;
3155   int init;
3156 
3157   /* check to see if the circular list has been setup, if not, set it up */
3158   if (swig_module.next==0) {
3159     /* Initialize the swig_module */
3160     swig_module.type_initial = swig_type_initial;
3161     swig_module.cast_initial = swig_cast_initial;
3162     swig_module.next = &swig_module;
3163     init = 1;
3164   } else {
3165     init = 0;
3166   }
3167 
3168   /* Try and load any already created modules */
3169   module_head = SWIG_GetModule(clientdata);
3170   if (!module_head) {
3171     /* This is the first module loaded for this interpreter */
3172     /* so set the swig module into the interpreter */
3173     SWIG_SetModule(clientdata, &swig_module);
3174   } else {
3175     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3176     iter=module_head;
3177     do {
3178       if (iter==&swig_module) {
3179         /* Our module is already in the list, so there's nothing more to do. */
3180         return;
3181       }
3182       iter=iter->next;
3183     } while (iter!= module_head);
3184 
3185     /* otherwise we must add our module into the list */
3186     swig_module.next = module_head->next;
3187     module_head->next = &swig_module;
3188   }
3189 
3190   /* When multiple interpreters are used, a module could have already been initialized in
3191        a different interpreter, but not yet have a pointer in this interpreter.
3192        In this case, we do not want to continue adding types... everything should be
3193        set up already */
3194   if (init == 0) return;
3195 
3196   /* Now work on filling in swig_module.types */
3197 #ifdef SWIGRUNTIME_DEBUG
3198   printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
3199 #endif
3200   for (i = 0; i < swig_module.size; ++i) {
3201     swig_type_info *type = 0;
3202     swig_type_info *ret;
3203     swig_cast_info *cast;
3204 
3205 #ifdef SWIGRUNTIME_DEBUG
3206     printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
3207 #endif
3208 
3209     /* if there is another module already loaded */
3210     if (swig_module.next != &swig_module) {
3211       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3212     }
3213     if (type) {
3214       /* Overwrite clientdata field */
3215 #ifdef SWIGRUNTIME_DEBUG
3216       printf("SWIG_InitializeModule: found type %s\n", type->name);
3217 #endif
3218       if (swig_module.type_initial[i]->clientdata) {
3219         type->clientdata = swig_module.type_initial[i]->clientdata;
3220 #ifdef SWIGRUNTIME_DEBUG
3221         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3222 #endif
3223       }
3224     } else {
3225       type = swig_module.type_initial[i];
3226     }
3227 
3228     /* Insert casting types */
3229     cast = swig_module.cast_initial[i];
3230     while (cast->type) {
3231       /* Don't need to add information already in the list */
3232       ret = 0;
3233 #ifdef SWIGRUNTIME_DEBUG
3234       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3235 #endif
3236       if (swig_module.next != &swig_module) {
3237         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3238 #ifdef SWIGRUNTIME_DEBUG
3239         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3240 #endif
3241       }
3242       if (ret) {
3243         if (type == swig_module.type_initial[i]) {
3244 #ifdef SWIGRUNTIME_DEBUG
3245           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3246 #endif
3247           cast->type = ret;
3248           ret = 0;
3249         } else {
3250           /* Check for casting already in the list */
3251           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3252 #ifdef SWIGRUNTIME_DEBUG
3253           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3254 #endif
3255           if (!ocast) ret = 0;
3256         }
3257       }
3258 
3259       if (!ret) {
3260 #ifdef SWIGRUNTIME_DEBUG
3261         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3262 #endif
3263         if (type->cast) {
3264           type->cast->prev = cast;
3265           cast->next = type->cast;
3266         }
3267         type->cast = cast;
3268       }
3269       cast++;
3270     }
3271     /* Set entry in modules->types array equal to the type */
3272     swig_module.types[i] = type;
3273   }
3274   swig_module.types[i] = 0;
3275 
3276 #ifdef SWIGRUNTIME_DEBUG
3277   printf("**** SWIG_InitializeModule: Cast List ******\n");
3278   for (i = 0; i < swig_module.size; ++i) {
3279     int j = 0;
3280     swig_cast_info *cast = swig_module.cast_initial[i];
3281     printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
3282     while (cast->type) {
3283       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3284       cast++;
3285       ++j;
3286     }
3287     printf("---- Total casts: %d\n",j);
3288   }
3289   printf("**** SWIG_InitializeModule: Cast List ******\n");
3290 #endif
3291 }
3292 
3293 /* This function will propagate the clientdata field of type to
3294 * any new swig_type_info structures that have been added into the list
3295 * of equivalent types.  It is like calling
3296 * SWIG_TypeClientData(type, clientdata) a second time.
3297 */
3298 SWIGRUNTIME void
SWIG_PropagateClientData(void)3299 SWIG_PropagateClientData(void) {
3300   size_t i;
3301   swig_cast_info *equiv;
3302   static int init_run = 0;
3303 
3304   if (init_run) return;
3305   init_run = 1;
3306 
3307   for (i = 0; i < swig_module.size; i++) {
3308     if (swig_module.types[i]->clientdata) {
3309       equiv = swig_module.types[i]->cast;
3310       while (equiv) {
3311         if (!equiv->converter) {
3312           if (equiv->type && !equiv->type->clientdata)
3313           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3314         }
3315         equiv = equiv->next;
3316       }
3317     }
3318   }
3319 }
3320 
3321 #ifdef __cplusplus
3322 #if 0
3323 {
3324   /* c-mode */
3325 #endif
3326 }
3327 #endif
3328 
3329 
3330 
3331 #if defined(__cplusplus) && ! defined(XSPROTO)
3332 extern "C"
3333 #endif
3334 
XS(SWIG_init)3335 XS(SWIG_init) {
3336   dXSARGS;
3337   int i;
3338   (void)items;
3339 
3340   SWIG_InitializeModule(0);
3341 
3342   /* Install commands */
3343   for (i = 0; swig_commands[i].name; i++) {
3344     /* Casts only needed for Perl < 5.10. */
3345 #ifdef __cplusplus
3346     newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
3347 #else
3348     newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
3349 #endif
3350   }
3351 
3352   /* Install variables */
3353   for (i = 0; swig_variables[i].name; i++) {
3354     SV *sv;
3355     sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
3356     if (swig_variables[i].type) {
3357       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
3358     } else {
3359       sv_setiv(sv,(IV) 0);
3360     }
3361     swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
3362   }
3363 
3364   /* Install constant */
3365   for (i = 0; swig_constants[i].type; i++) {
3366     SV *sv;
3367     sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
3368     switch(swig_constants[i].type) {
3369     case SWIG_INT:
3370       sv_setiv(sv, (IV) swig_constants[i].lvalue);
3371       break;
3372     case SWIG_FLOAT:
3373       sv_setnv(sv, (double) swig_constants[i].dvalue);
3374       break;
3375     case SWIG_STRING:
3376       sv_setpv(sv, (const char *) swig_constants[i].pvalue);
3377       break;
3378     case SWIG_POINTER:
3379       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
3380       break;
3381     case SWIG_BINARY:
3382       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
3383       break;
3384     default:
3385       break;
3386     }
3387     SvREADONLY_on(sv);
3388   }
3389 
3390   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3391     SV *sv = get_sv((char*) SWIG_prefix "GSL_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3392     sv_setsv(sv, SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)(2.7)));
3393     SvREADONLY_on(sv);
3394   } while(0) /*@SWIG@*/;
3395   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3396     SV *sv = get_sv((char*) SWIG_prefix "GSL_MAJOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3397     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(2)));
3398     SvREADONLY_on(sv);
3399   } while(0) /*@SWIG@*/;
3400   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3401     SV *sv = get_sv((char*) SWIG_prefix "GSL_MINOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3402     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(7)));
3403     SvREADONLY_on(sv);
3404   } while(0) /*@SWIG@*/;
3405   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3406     SV *sv = get_sv((char*) SWIG_prefix "GSL_POSZERO", TRUE | 0x2 | GV_ADDMULTI);
3407     sv_setsv(sv, SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)((+0.0))));
3408     SvREADONLY_on(sv);
3409   } while(0) /*@SWIG@*/;
3410   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3411     SV *sv = get_sv((char*) SWIG_prefix "GSL_NEGZERO", TRUE | 0x2 | GV_ADDMULTI);
3412     sv_setsv(sv, SWIG_From_double  SWIG_PERL_CALL_ARGS_1((double)((-0.0))));
3413     SvREADONLY_on(sv);
3414   } while(0) /*@SWIG@*/;
3415   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3416     SV *sv = get_sv((char*) SWIG_prefix "GSL_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
3417     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_SUCCESS)));
3418     SvREADONLY_on(sv);
3419   } while(0) /*@SWIG@*/;
3420   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3421     SV *sv = get_sv((char*) SWIG_prefix "GSL_FAILURE", TRUE | 0x2 | GV_ADDMULTI);
3422     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_FAILURE)));
3423     SvREADONLY_on(sv);
3424   } while(0) /*@SWIG@*/;
3425   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3426     SV *sv = get_sv((char*) SWIG_prefix "GSL_CONTINUE", TRUE | 0x2 | GV_ADDMULTI);
3427     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_CONTINUE)));
3428     SvREADONLY_on(sv);
3429   } while(0) /*@SWIG@*/;
3430   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3431     SV *sv = get_sv((char*) SWIG_prefix "GSL_EDOM", TRUE | 0x2 | GV_ADDMULTI);
3432     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EDOM)));
3433     SvREADONLY_on(sv);
3434   } while(0) /*@SWIG@*/;
3435   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3436     SV *sv = get_sv((char*) SWIG_prefix "GSL_ERANGE", TRUE | 0x2 | GV_ADDMULTI);
3437     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ERANGE)));
3438     SvREADONLY_on(sv);
3439   } while(0) /*@SWIG@*/;
3440   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3441     SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAULT", TRUE | 0x2 | GV_ADDMULTI);
3442     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAULT)));
3443     SvREADONLY_on(sv);
3444   } while(0) /*@SWIG@*/;
3445   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3446     SV *sv = get_sv((char*) SWIG_prefix "GSL_EINVAL", TRUE | 0x2 | GV_ADDMULTI);
3447     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EINVAL)));
3448     SvREADONLY_on(sv);
3449   } while(0) /*@SWIG@*/;
3450   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3451     SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAILED", TRUE | 0x2 | GV_ADDMULTI);
3452     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAILED)));
3453     SvREADONLY_on(sv);
3454   } while(0) /*@SWIG@*/;
3455   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3456     SV *sv = get_sv((char*) SWIG_prefix "GSL_EFACTOR", TRUE | 0x2 | GV_ADDMULTI);
3457     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EFACTOR)));
3458     SvREADONLY_on(sv);
3459   } while(0) /*@SWIG@*/;
3460   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3461     SV *sv = get_sv((char*) SWIG_prefix "GSL_ESANITY", TRUE | 0x2 | GV_ADDMULTI);
3462     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ESANITY)));
3463     SvREADONLY_on(sv);
3464   } while(0) /*@SWIG@*/;
3465   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3466     SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOMEM", TRUE | 0x2 | GV_ADDMULTI);
3467     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOMEM)));
3468     SvREADONLY_on(sv);
3469   } while(0) /*@SWIG@*/;
3470   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3471     SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADFUNC", TRUE | 0x2 | GV_ADDMULTI);
3472     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADFUNC)));
3473     SvREADONLY_on(sv);
3474   } while(0) /*@SWIG@*/;
3475   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3476     SV *sv = get_sv((char*) SWIG_prefix "GSL_ERUNAWAY", TRUE | 0x2 | GV_ADDMULTI);
3477     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ERUNAWAY)));
3478     SvREADONLY_on(sv);
3479   } while(0) /*@SWIG@*/;
3480   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3481     SV *sv = get_sv((char*) SWIG_prefix "GSL_EMAXITER", TRUE | 0x2 | GV_ADDMULTI);
3482     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EMAXITER)));
3483     SvREADONLY_on(sv);
3484   } while(0) /*@SWIG@*/;
3485   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3486     SV *sv = get_sv((char*) SWIG_prefix "GSL_EZERODIV", TRUE | 0x2 | GV_ADDMULTI);
3487     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EZERODIV)));
3488     SvREADONLY_on(sv);
3489   } while(0) /*@SWIG@*/;
3490   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3491     SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADTOL", TRUE | 0x2 | GV_ADDMULTI);
3492     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADTOL)));
3493     SvREADONLY_on(sv);
3494   } while(0) /*@SWIG@*/;
3495   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3496     SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOL", TRUE | 0x2 | GV_ADDMULTI);
3497     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOL)));
3498     SvREADONLY_on(sv);
3499   } while(0) /*@SWIG@*/;
3500   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3501     SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNDRFLW", TRUE | 0x2 | GV_ADDMULTI);
3502     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNDRFLW)));
3503     SvREADONLY_on(sv);
3504   } while(0) /*@SWIG@*/;
3505   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3506     SV *sv = get_sv((char*) SWIG_prefix "GSL_EOVRFLW", TRUE | 0x2 | GV_ADDMULTI);
3507     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EOVRFLW)));
3508     SvREADONLY_on(sv);
3509   } while(0) /*@SWIG@*/;
3510   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3511     SV *sv = get_sv((char*) SWIG_prefix "GSL_ELOSS", TRUE | 0x2 | GV_ADDMULTI);
3512     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ELOSS)));
3513     SvREADONLY_on(sv);
3514   } while(0) /*@SWIG@*/;
3515   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3516     SV *sv = get_sv((char*) SWIG_prefix "GSL_EROUND", TRUE | 0x2 | GV_ADDMULTI);
3517     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EROUND)));
3518     SvREADONLY_on(sv);
3519   } while(0) /*@SWIG@*/;
3520   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3521     SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADLEN", TRUE | 0x2 | GV_ADDMULTI);
3522     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADLEN)));
3523     SvREADONLY_on(sv);
3524   } while(0) /*@SWIG@*/;
3525   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3526     SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOTSQR", TRUE | 0x2 | GV_ADDMULTI);
3527     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOTSQR)));
3528     SvREADONLY_on(sv);
3529   } while(0) /*@SWIG@*/;
3530   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3531     SV *sv = get_sv((char*) SWIG_prefix "GSL_ESING", TRUE | 0x2 | GV_ADDMULTI);
3532     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ESING)));
3533     SvREADONLY_on(sv);
3534   } while(0) /*@SWIG@*/;
3535   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3536     SV *sv = get_sv((char*) SWIG_prefix "GSL_EDIVERGE", TRUE | 0x2 | GV_ADDMULTI);
3537     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EDIVERGE)));
3538     SvREADONLY_on(sv);
3539   } while(0) /*@SWIG@*/;
3540   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3541     SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNSUP", TRUE | 0x2 | GV_ADDMULTI);
3542     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNSUP)));
3543     SvREADONLY_on(sv);
3544   } while(0) /*@SWIG@*/;
3545   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3546     SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNIMPL", TRUE | 0x2 | GV_ADDMULTI);
3547     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNIMPL)));
3548     SvREADONLY_on(sv);
3549   } while(0) /*@SWIG@*/;
3550   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3551     SV *sv = get_sv((char*) SWIG_prefix "GSL_ECACHE", TRUE | 0x2 | GV_ADDMULTI);
3552     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ECACHE)));
3553     SvREADONLY_on(sv);
3554   } while(0) /*@SWIG@*/;
3555   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3556     SV *sv = get_sv((char*) SWIG_prefix "GSL_ETABLE", TRUE | 0x2 | GV_ADDMULTI);
3557     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ETABLE)));
3558     SvREADONLY_on(sv);
3559   } while(0) /*@SWIG@*/;
3560   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3561     SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROG", TRUE | 0x2 | GV_ADDMULTI);
3562     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROG)));
3563     SvREADONLY_on(sv);
3564   } while(0) /*@SWIG@*/;
3565   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3566     SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROGJ", TRUE | 0x2 | GV_ADDMULTI);
3567     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROGJ)));
3568     SvREADONLY_on(sv);
3569   } while(0) /*@SWIG@*/;
3570   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3571     SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLF", TRUE | 0x2 | GV_ADDMULTI);
3572     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLF)));
3573     SvREADONLY_on(sv);
3574   } while(0) /*@SWIG@*/;
3575   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3576     SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLX", TRUE | 0x2 | GV_ADDMULTI);
3577     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLX)));
3578     SvREADONLY_on(sv);
3579   } while(0) /*@SWIG@*/;
3580   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3581     SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLG", TRUE | 0x2 | GV_ADDMULTI);
3582     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLG)));
3583     SvREADONLY_on(sv);
3584   } while(0) /*@SWIG@*/;
3585   /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3586     SV *sv = get_sv((char*) SWIG_prefix "GSL_EOF", TRUE | 0x2 | GV_ADDMULTI);
3587     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(GSL_EOF)));
3588     SvREADONLY_on(sv);
3589   } while(0) /*@SWIG@*/;
3590   ST(0) = &PL_sv_yes;
3591   XSRETURN(1);
3592 }
3593 
3594