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_double swig_types[2]
1522 #define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void swig_types[3]
1523 #define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void swig_types[4]
1524 static swig_type_info *swig_types[6];
1525 static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
1526 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1527 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1528
1529 /* -------- TYPES TABLE (END) -------- */
1530
1531 #define SWIG_init boot_Math__GSL__Fit
1532
1533 #define SWIG_name "Math::GSL::Fitc::boot_Math__GSL__Fit"
1534 #define SWIG_prefix "Math::GSL::Fitc::"
1535
1536 #define SWIGVERSION 0x040001
1537 #define SWIG_VERSION SWIGVERSION
1538
1539
1540 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1541 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1542
1543
1544 #ifdef __cplusplus
1545 extern "C"
1546 #endif
1547 #ifndef PERL_OBJECT
1548 #ifndef MULTIPLICITY
1549 SWIGEXPORT void SWIG_init (CV* cv);
1550 #else
1551 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1552 #endif
1553 #else
1554 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1555 #endif
1556
1557
1558 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(double value)1559 SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value)
1560 {
1561 return sv_2mortal(newSVnv(value));
1562 }
1563
1564
1565 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(long value)1566 SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
1567 {
1568 SV *sv;
1569 if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
1570 sv = newSViv(value);
1571 else
1572 sv = newSVpvf("%ld", value);
1573 return sv_2mortal(sv);
1574 }
1575
1576
1577 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(int value)1578 SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
1579 {
1580 return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
1581 }
1582
1583
1584 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)1585 SWIG_pchar_descriptor(void)
1586 {
1587 static int init = 0;
1588 static swig_type_info* info = 0;
1589 if (!init) {
1590 info = SWIG_TypeQuery("_p_char");
1591 init = 1;
1592 }
1593 return info;
1594 }
1595
1596
1597 SWIGINTERN int
SWIG_AsCharPtrAndSize(SV * obj,char ** cptr,size_t * psize,int * alloc)1598 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1599 {
1600 if (SvMAGICAL(obj)) {
1601 SV *tmp = sv_newmortal();
1602 SvSetSV(tmp, obj);
1603 obj = tmp;
1604 }
1605 if (SvPOK(obj)) {
1606 STRLEN len = 0;
1607 char *cstr = SvPV(obj, len);
1608 size_t size = len + 1;
1609 if (cptr) {
1610 if (alloc) {
1611 if (*alloc == SWIG_NEWOBJ) {
1612 *cptr = (char *)memcpy(malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1613 } else {
1614 *cptr = cstr;
1615 *alloc = SWIG_OLDOBJ;
1616 }
1617 }
1618 }
1619 if (psize) *psize = size;
1620 return SWIG_OK;
1621 } else {
1622 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1623 if (pchar_descriptor) {
1624 char* vptr = 0;
1625 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1626 if (cptr) *cptr = vptr;
1627 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1628 if (alloc) *alloc = SWIG_OLDOBJ;
1629 return SWIG_OK;
1630 }
1631 }
1632 }
1633 return SWIG_TypeError;
1634 }
1635
1636
1637
1638
1639
1640 #include <limits.h>
1641 #if !defined(SWIG_NO_LLONG_MAX)
1642 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1643 # define LLONG_MAX __LONG_LONG_MAX__
1644 # define LLONG_MIN (-LLONG_MAX - 1LL)
1645 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1646 # endif
1647 #endif
1648
1649
1650 #include <stdlib.h>
1651 #ifdef _MSC_VER
1652 # ifndef strtoull
1653 # define strtoull _strtoui64
1654 # endif
1655 # ifndef strtoll
1656 # define strtoll _strtoi64
1657 # endif
1658 #endif
1659
1660
1661 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,double * val)1662 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1663 {
1664 if (SvNIOK(obj)) {
1665 if (val) *val = SvNV(obj);
1666 return SWIG_OK;
1667 } else if (SvIOK(obj)) {
1668 if (val) *val = (double) SvIV(obj);
1669 return SWIG_AddCast(SWIG_OK);
1670 } else {
1671 const char *nptr = SvPV_nolen(obj);
1672 if (nptr) {
1673 char *endptr;
1674 double v;
1675 errno = 0;
1676 v = strtod(nptr, &endptr);
1677 if (errno == ERANGE) {
1678 errno = 0;
1679 return SWIG_OverflowError;
1680 } else {
1681 if (*endptr == '\0') {
1682 if (val) *val = v;
1683 return SWIG_Str2NumCast(SWIG_OK);
1684 }
1685 }
1686 }
1687 }
1688 return SWIG_TypeError;
1689 }
1690
1691
1692 #include <float.h>
1693
1694
1695 #include <math.h>
1696
1697
1698 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)1699 SWIG_CanCastAsInteger(double *d, double min, double max) {
1700 double x = *d;
1701 if ((min <= x && x <= max)) {
1702 double fx = floor(x);
1703 double cx = ceil(x);
1704 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1705 if ((errno == EDOM) || (errno == ERANGE)) {
1706 errno = 0;
1707 } else {
1708 double summ, reps, diff;
1709 if (rd < x) {
1710 diff = x - rd;
1711 } else if (rd > x) {
1712 diff = rd - x;
1713 } else {
1714 return 1;
1715 }
1716 summ = rd + x;
1717 reps = diff/summ;
1718 if (reps < 8*DBL_EPSILON) {
1719 *d = rd;
1720 return 1;
1721 }
1722 }
1723 }
1724 return 0;
1725 }
1726
1727
1728 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,long * val)1729 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1730 {
1731 if (SvUOK(obj)) {
1732 UV v = SvUV(obj);
1733 if (UVSIZE < sizeof(*val) || v <= LONG_MAX) {
1734 if (val) *val = v;
1735 return SWIG_OK;
1736 }
1737 return SWIG_OverflowError;
1738 } else if (SvIOK(obj)) {
1739 IV v = SvIV(obj);
1740 if (IVSIZE <= sizeof(*val) || (v >= LONG_MIN && v <= LONG_MAX)) {
1741 if(val) *val = v;
1742 return SWIG_OK;
1743 }
1744 return SWIG_OverflowError;
1745 } else {
1746 int dispatch = 0;
1747 const char *nptr = SvPV_nolen(obj);
1748 if (nptr) {
1749 char *endptr;
1750 long v;
1751 errno = 0;
1752 v = strtol(nptr, &endptr,0);
1753 if (errno == ERANGE) {
1754 errno = 0;
1755 return SWIG_OverflowError;
1756 } else {
1757 if (*endptr == '\0') {
1758 if (val) *val = v;
1759 return SWIG_Str2NumCast(SWIG_OK);
1760 }
1761 }
1762 }
1763 if (!dispatch) {
1764 double d;
1765 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1766 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1767 if (val) *val = (long)(d);
1768 return res;
1769 }
1770 }
1771 }
1772 return SWIG_TypeError;
1773 }
1774
1775
1776 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,int * val)1777 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1778 {
1779 long v;
1780 int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1781 if (SWIG_IsOK(res)) {
1782 if ((v < INT_MIN || v > INT_MAX)) {
1783 return SWIG_OverflowError;
1784 } else {
1785 if (val) *val = (int)(v);
1786 }
1787 }
1788 return res;
1789 }
1790
1791
1792 SWIGINTERNINLINE SV *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)1793 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1794 {
1795 SV *obj = sv_newmortal();
1796 if (carray) {
1797 sv_setpvn(obj, carray, size);
1798 } else {
1799 sv_setsv(obj, &PL_sv_undef);
1800 }
1801 return obj;
1802 }
1803
1804
1805 SWIGINTERNINLINE SV *
SWIG_FromCharPtr(const char * cptr)1806 SWIG_FromCharPtr(const char *cptr)
1807 {
1808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1809 }
1810
1811
1812 #include "gsl/gsl_nan.h"
1813 #include "gsl/gsl_errno.h"
1814 #include "gsl/gsl_math.h"
1815 #include "gsl/gsl_monte.h"
1816
1817
1818 struct perl_array {
1819 I32 len;
1820 AV *array;
1821 };
1822
1823
1824
1825 enum awType { awDouble, awFloat, awInt, awUnsigned };
1826
1827 typedef struct {
1828 I32 size;
1829 enum awType type;
1830 void * data;
1831 } array_wrapper;
1832
array_wrapper_alloc(int numelem,enum awType type)1833 array_wrapper * array_wrapper_alloc(int numelem, enum awType type){
1834 array_wrapper * rv = malloc(sizeof(array_wrapper));
1835
1836 if (rv == NULL)
1837 croak("array_wrapper_alloc: can't malloc wrapper\n");
1838
1839 switch (type){
1840 case awDouble:
1841 rv->data = malloc(sizeof(double) * numelem);
1842 break;
1843 case awFloat:
1844 rv->data = malloc(sizeof(float) * numelem);
1845 break;
1846 case awInt:
1847 rv->data = malloc(sizeof(int) * numelem);
1848 break;
1849 case awUnsigned:
1850 rv->data = malloc(sizeof(unsigned int) * numelem);
1851 break;
1852 default:
1853 croak("array_wrapper_alloc: type should be awDouble, awFloat, awInt, or awUnsigned");
1854 }
1855
1856 if (rv->data == NULL)
1857 croak("array_wrapper_alloc: can't malloc data");
1858
1859 rv->size = numelem;
1860 rv->type = type;
1861 return rv;
1862 }
1863
array_wrapper_free(array_wrapper * daw)1864 void array_wrapper_free(array_wrapper * daw){
1865 free(daw->data);
1866 free(daw);
1867 }
1868
1869
1870 /* structure to hold required information while the gsl function call
1871 for each callback
1872 */
1873 struct gsl_function_perl {
1874 gsl_function C_gsl_function;
1875 SV * function;
1876 SV * params;
1877 };
1878
1879 struct gsl_function_fdf_perl {
1880 gsl_function_fdf C_gsl_function_fdf;
1881 SV * f;
1882 SV * df;
1883 SV * fdf;
1884 SV * params;
1885 };
1886
1887 struct gsl_monte_function_perl {
1888 gsl_monte_function C_gsl_monte_function;
1889 SV * f;
1890 SV * dim;
1891 SV * params;
1892 };
1893
gsl_function_perl_free(struct gsl_function_perl * perl_f)1894 void gsl_function_perl_free(struct gsl_function_perl * perl_f){
1895 if (perl_f != NULL) {
1896 SvREFCNT_dec(perl_f->function);
1897 SvREFCNT_dec(perl_f->params);
1898 Safefree(perl_f);
1899 }
1900 }
1901
gsl_function_fdf_perl_free(struct gsl_function_fdf_perl * perl_fdf)1902 void gsl_function_fdf_perl_free(struct gsl_function_fdf_perl * perl_fdf){
1903 if (perl_fdf != NULL) {
1904 SvREFCNT_dec(perl_fdf->f);
1905 SvREFCNT_dec(perl_fdf->df);
1906 SvREFCNT_dec(perl_fdf->fdf);
1907 SvREFCNT_dec(perl_fdf->params);
1908 Safefree(perl_fdf);
1909 }
1910 }
1911
1912 /* These functions (C callbacks) calls the perl callbacks.
1913 Info for perl callback can be found using the 'void*params' parameter
1914 */
call_gsl_function_x_params(SV * function,double x,SV * params)1915 double call_gsl_function_x_params(SV* function, double x, SV *params){
1916 unsigned int count;
1917 double y;
1918 dSP;
1919
1920 //fprintf(stderr, "LOOKUP CALLBACK\n");
1921 ENTER;
1922 SAVETMPS;
1923
1924 PUSHMARK(SP);
1925 XPUSHs(sv_2mortal(newSVnv((double)x)));
1926 XPUSHs(params);
1927 PUTBACK; /* make local stack pointer global */
1928
1929 count = call_sv(function, G_SCALAR);
1930 SPAGAIN;
1931
1932 if (count != 1)
1933 croak("Expected to call subroutine in scalar context!");
1934
1935 y = POPn;
1936
1937 PUTBACK; /* make local stack pointer global */
1938 FREETMPS;
1939 LEAVE;
1940
1941 return y;
1942 }
1943
call_gsl_function(double x,void * params)1944 double call_gsl_function(double x , void *params){
1945 struct gsl_function_perl *F=(struct gsl_function_perl*)params;
1946 return call_gsl_function_x_params( F->function, x, F->params );
1947 }
1948
call_gsl_function_fdf_f(double x,void * params)1949 double call_gsl_function_fdf_f(double x , void *params){
1950 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1951 return call_gsl_function_x_params( F->f, x, F->params );
1952 }
1953
call_gsl_function_fdf_df(double x,void * params)1954 double call_gsl_function_fdf_df(double x , void *params){
1955 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1956 return call_gsl_function_x_params( F->df, x, F->params );
1957 }
1958
call_gsl_function_fdf_fdf(double x,void * params,double * f,double * df)1959 void call_gsl_function_fdf_fdf(double x , void *params, double *f, double *df ){
1960 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1961
1962 dSP;
1963
1964 ENTER;
1965 SAVETMPS;
1966
1967 PUSHMARK(SP);
1968 EXTEND(SP, 2);
1969 PUSHs(sv_2mortal(newSVnv((double)x)));
1970 PUSHs(F->params);
1971 PUTBACK; /* make local stack pointer global */
1972
1973 {
1974 unsigned int count = call_sv(F->fdf, G_ARRAY);
1975 SPAGAIN;
1976
1977 if (count != 2)
1978 croak( "Expected two return values, got %d", count );
1979 }
1980
1981 *df = POPn;
1982 *f = POPn;
1983
1984 PUTBACK; /* make local stack pointer global */
1985 FREETMPS;
1986 LEAVE;
1987 }
1988
call_gsl_monte_function(double * x_array,size_t dim,void * params)1989 double call_gsl_monte_function(double *x_array , size_t dim, void *params){
1990 struct gsl_monte_function_perl *F=(struct gsl_monte_function_perl*)params;
1991 unsigned int count;
1992 unsigned int i;
1993 AV* perl_array;
1994 double y;
1995 dSP;
1996
1997 //fprintf(stderr, "LOOKUP CALLBACK\n");
1998 ENTER;
1999 SAVETMPS;
2000
2001 PUSHMARK(SP);
2002 perl_array=newAV();
2003 sv_2mortal((SV*)perl_array);
2004 XPUSHs(sv_2mortal(newRV((SV *)perl_array)));
2005 for(i=0; i<dim; i++) {
2006 /* no mortal : it is referenced by the array */
2007 av_push(perl_array, newSVnv(x_array[i]));
2008 }
2009 XPUSHs(sv_2mortal(newSViv(dim)));
2010 XPUSHs(F->params);
2011 PUTBACK; /* make local stack pointer global */
2012
2013 count = call_sv(F->f, G_SCALAR);
2014 SPAGAIN;
2015
2016 if (count != 1)
2017 croak("Expected to call subroutine in scalar context!");
2018
2019 y = POPn;
2020
2021 PUTBACK; /* make local stack pointer global */
2022 FREETMPS;
2023 LEAVE;
2024
2025 return y;
2026 }
2027
2028
gsl_function_fdf_extract(char * param_name,HV * hash,SV * func[])2029 void gsl_function_fdf_extract( char* param_name, HV* hash, SV* func[] ) {
2030 static const char *keys[3] = { "f", "df", "fdf" };
2031
2032 int ikey;
2033
2034 for ( ikey = 0 ; ikey < 3 ; ++ikey ) {
2035 func[ikey] = 0;
2036 const char* key = keys[ikey];
2037 /* it just so happens that strlen(keys[ikey]) == ikey + 1 */
2038 SV** pp_sv = hv_fetch( hash, key, ikey+1, 0 );
2039 SV* function;
2040
2041 if ( !pp_sv )
2042 croak("Math::GSL : %s: missing key %s!", param_name, key);
2043
2044 function = *pp_sv;
2045
2046 if ( SvPOK(function) || ( SvROK( function ) && SvTYPE(SvRV(function)) == SVt_PVCV ) ) {
2047 /* hold on to SV after the enclosing hash goes away */
2048 SvREFCNT_inc( function );
2049 func[ikey] = function;
2050 }
2051 else {
2052 croak( "Math::GSL : %s: key %s is not a reference to code!", param_name, key);
2053 }
2054 }
2055 }
2056
2057
2058
2059 #include "gsl/gsl_fit.h"
2060
2061
2062 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long * val)2063 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
2064 {
2065 if (SvUOK(obj)) {
2066 UV v = SvUV(obj);
2067 if (UVSIZE <= sizeof(*val) || v <= ULONG_MAX) {
2068 if (val) *val = v;
2069 return SWIG_OK;
2070 }
2071 return SWIG_OverflowError;
2072 } else if (SvIOK(obj)) {
2073 IV v = SvIV(obj);
2074 if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULONG_MAX)) {
2075 if (val) *val = v;
2076 return SWIG_OK;
2077 }
2078 return SWIG_OverflowError;
2079 } else {
2080 int dispatch = 0;
2081 const char *nptr = SvPV_nolen(obj);
2082 if (nptr) {
2083 char *endptr;
2084 unsigned long v;
2085 errno = 0;
2086 v = strtoul(nptr, &endptr,0);
2087 if (errno == ERANGE) {
2088 errno = 0;
2089 return SWIG_OverflowError;
2090 } else {
2091 if (*endptr == '\0') {
2092 if (val) *val = v;
2093 return SWIG_Str2NumCast(SWIG_OK);
2094 }
2095 }
2096 }
2097 if (!dispatch) {
2098 double d;
2099 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2100 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2101 if (val) *val = (unsigned long)(d);
2102 return res;
2103 }
2104 }
2105 }
2106 return SWIG_TypeError;
2107 }
2108
2109
2110 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
2111 # define SWIG_LONG_LONG_AVAILABLE
2112 #endif
2113
2114
2115 #ifdef SWIG_LONG_LONG_AVAILABLE
2116 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long long * val)2117 SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long long *val)
2118 {
2119 if (SvUOK(obj)) {
2120 /* pretty sure this should be conditional on
2121 * (UVSIZE <= sizeof(*val) || v <= ULLONG_MAX) */
2122 if (val) *val = SvUV(obj);
2123 return SWIG_OK;
2124 } else if (SvIOK(obj)) {
2125 IV v = SvIV(obj);
2126 if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULLONG_MAX)) {
2127 if (val) *val = v;
2128 return SWIG_OK;
2129 } else {
2130 return SWIG_OverflowError;
2131 }
2132 } else {
2133 int dispatch = 0;
2134 const char *nptr = SvPV_nolen(obj);
2135 if (nptr) {
2136 char *endptr;
2137 unsigned long long v;
2138 errno = 0;
2139 v = strtoull(nptr, &endptr,0);
2140 if (errno == ERANGE) {
2141 errno = 0;
2142 return SWIG_OverflowError;
2143 } else {
2144 if (*endptr == '\0') {
2145 if (val) *val = v;
2146 return SWIG_Str2NumCast(SWIG_OK);
2147 }
2148 }
2149 }
2150 if (!dispatch) {
2151 const double mant_max = 1LL << DBL_MANT_DIG;
2152 double d;
2153 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2154 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
2155 if (val) *val = (unsigned long long)(d);
2156 return res;
2157 }
2158 }
2159 }
2160 return SWIG_TypeError;
2161 }
2162 #endif
2163
2164
2165 SWIGINTERNINLINE int
SWIG_PERL_DECL_ARGS_2(SV * obj,size_t * val)2166 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
2167 {
2168 int res = SWIG_TypeError;
2169 #ifdef SWIG_LONG_LONG_AVAILABLE
2170 if (sizeof(size_t) <= sizeof(unsigned long)) {
2171 #endif
2172 unsigned long v;
2173 res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2174 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2175 #ifdef SWIG_LONG_LONG_AVAILABLE
2176 } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
2177 unsigned long long v;
2178 res = SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2179 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2180 }
2181 #endif
2182 return res;
2183 }
2184
2185 #ifdef __cplusplus
2186 extern "C" {
2187 #endif
2188
2189 #ifdef PERL_OBJECT
2190 #define MAGIC_CLASS _wrap_Math__GSL__Fit_var::
2191 class _wrap_Math__GSL__Fit_var : public CPerlObj {
2192 public:
2193 #else
2194 #define MAGIC_CLASS
2195 #endif
swig_magic_readonly(pTHX_ SV * SWIGUNUSEDPARM (sv),MAGIC * SWIGUNUSEDPARM (mg))2196 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2197 MAGIC_PPERL
2198 croak("Value is read-only.");
2199 return 0;
2200 }
2201
2202
2203 #ifdef PERL_OBJECT
2204 };
2205 #endif
2206
2207 #ifdef __cplusplus
2208 }
2209 #endif
2210
2211 #ifdef __cplusplus
2212 extern "C" {
2213 #endif
XS(_wrap_gsl_error)2214 XS(_wrap_gsl_error) {
2215 {
2216 char *arg1 = (char *) 0 ;
2217 char *arg2 = (char *) 0 ;
2218 int arg3 ;
2219 int arg4 ;
2220 int res1 ;
2221 char *buf1 = 0 ;
2222 int alloc1 = 0 ;
2223 int res2 ;
2224 char *buf2 = 0 ;
2225 int alloc2 = 0 ;
2226 int val3 ;
2227 int ecode3 = 0 ;
2228 int val4 ;
2229 int ecode4 = 0 ;
2230 int argvi = 0;
2231 dXSARGS;
2232
2233 if ((items < 4) || (items > 4)) {
2234 SWIG_croak("Usage: gsl_error(reason,file,line,gsl_errno);");
2235 }
2236 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2237 if (!SWIG_IsOK(res1)) {
2238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_error" "', argument " "1"" of type '" "char const *""'");
2239 }
2240 arg1 = (char *)(buf1);
2241 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2242 if (!SWIG_IsOK(res2)) {
2243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_error" "', argument " "2"" of type '" "char const *""'");
2244 }
2245 arg2 = (char *)(buf2);
2246 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2247 if (!SWIG_IsOK(ecode3)) {
2248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_error" "', argument " "3"" of type '" "int""'");
2249 }
2250 arg3 = (int)(val3);
2251 ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2252 if (!SWIG_IsOK(ecode4)) {
2253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_error" "', argument " "4"" of type '" "int""'");
2254 }
2255 arg4 = (int)(val4);
2256 gsl_error((char const *)arg1,(char const *)arg2,arg3,arg4);
2257 ST(argvi) = &PL_sv_undef;
2258 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2259 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2260
2261
2262 XSRETURN(argvi);
2263 fail:
2264 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2265 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2266
2267
2268 SWIG_croak_null();
2269 }
2270 }
2271
2272
XS(_wrap_gsl_stream_printf)2273 XS(_wrap_gsl_stream_printf) {
2274 {
2275 char *arg1 = (char *) 0 ;
2276 char *arg2 = (char *) 0 ;
2277 int arg3 ;
2278 char *arg4 = (char *) 0 ;
2279 int res1 ;
2280 char *buf1 = 0 ;
2281 int alloc1 = 0 ;
2282 int res2 ;
2283 char *buf2 = 0 ;
2284 int alloc2 = 0 ;
2285 int val3 ;
2286 int ecode3 = 0 ;
2287 int res4 ;
2288 char *buf4 = 0 ;
2289 int alloc4 = 0 ;
2290 int argvi = 0;
2291 dXSARGS;
2292
2293 if ((items < 4) || (items > 4)) {
2294 SWIG_croak("Usage: gsl_stream_printf(label,file,line,reason);");
2295 }
2296 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2297 if (!SWIG_IsOK(res1)) {
2298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_stream_printf" "', argument " "1"" of type '" "char const *""'");
2299 }
2300 arg1 = (char *)(buf1);
2301 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2302 if (!SWIG_IsOK(res2)) {
2303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_stream_printf" "', argument " "2"" of type '" "char const *""'");
2304 }
2305 arg2 = (char *)(buf2);
2306 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2307 if (!SWIG_IsOK(ecode3)) {
2308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_stream_printf" "', argument " "3"" of type '" "int""'");
2309 }
2310 arg3 = (int)(val3);
2311 res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2312 if (!SWIG_IsOK(res4)) {
2313 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gsl_stream_printf" "', argument " "4"" of type '" "char const *""'");
2314 }
2315 arg4 = (char *)(buf4);
2316 gsl_stream_printf((char const *)arg1,(char const *)arg2,arg3,(char const *)arg4);
2317 ST(argvi) = &PL_sv_undef;
2318 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2319 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2320
2321 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2322 XSRETURN(argvi);
2323 fail:
2324 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2325 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2326
2327 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2328 SWIG_croak_null();
2329 }
2330 }
2331
2332
XS(_wrap_gsl_strerror)2333 XS(_wrap_gsl_strerror) {
2334 {
2335 int arg1 ;
2336 int val1 ;
2337 int ecode1 = 0 ;
2338 int argvi = 0;
2339 char *result = 0 ;
2340 dXSARGS;
2341
2342 if ((items < 1) || (items > 1)) {
2343 SWIG_croak("Usage: gsl_strerror(gsl_errno);");
2344 }
2345 ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2346 if (!SWIG_IsOK(ecode1)) {
2347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_strerror" "', argument " "1"" of type '" "int""'");
2348 }
2349 arg1 = (int)(val1);
2350 result = (char *)gsl_strerror(arg1);
2351 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2352
2353 XSRETURN(argvi);
2354 fail:
2355
2356 SWIG_croak_null();
2357 }
2358 }
2359
2360
XS(_wrap_gsl_set_error_handler)2361 XS(_wrap_gsl_set_error_handler) {
2362 {
2363 gsl_error_handler_t *arg1 = (gsl_error_handler_t *) 0 ;
2364 int argvi = 0;
2365 gsl_error_handler_t *result = 0 ;
2366 dXSARGS;
2367
2368 if ((items < 1) || (items > 1)) {
2369 SWIG_croak("Usage: gsl_set_error_handler(new_handler);");
2370 }
2371 {
2372 int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void);
2373 if (!SWIG_IsOK(res)) {
2374 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_error_handler" "', argument " "1"" of type '" "gsl_error_handler_t *""'");
2375 }
2376 }
2377 result = (gsl_error_handler_t *)gsl_set_error_handler(arg1);
2378 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2379
2380 XSRETURN(argvi);
2381 fail:
2382
2383 SWIG_croak_null();
2384 }
2385 }
2386
2387
XS(_wrap_gsl_set_error_handler_off)2388 XS(_wrap_gsl_set_error_handler_off) {
2389 {
2390 int argvi = 0;
2391 gsl_error_handler_t *result = 0 ;
2392 dXSARGS;
2393
2394 if ((items < 0) || (items > 0)) {
2395 SWIG_croak("Usage: gsl_set_error_handler_off();");
2396 }
2397 result = (gsl_error_handler_t *)gsl_set_error_handler_off();
2398 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2399 XSRETURN(argvi);
2400 fail:
2401 SWIG_croak_null();
2402 }
2403 }
2404
2405
XS(_wrap_gsl_set_stream_handler)2406 XS(_wrap_gsl_set_stream_handler) {
2407 {
2408 gsl_stream_handler_t *arg1 = (gsl_stream_handler_t *) 0 ;
2409 int argvi = 0;
2410 gsl_stream_handler_t *result = 0 ;
2411 dXSARGS;
2412
2413 if ((items < 1) || (items > 1)) {
2414 SWIG_croak("Usage: gsl_set_stream_handler(new_handler);");
2415 }
2416 {
2417 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);
2418 if (!SWIG_IsOK(res)) {
2419 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_stream_handler" "', argument " "1"" of type '" "gsl_stream_handler_t *""'");
2420 }
2421 }
2422 result = (gsl_stream_handler_t *)gsl_set_stream_handler(arg1);
2423 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void); argvi++ ;
2424
2425 XSRETURN(argvi);
2426 fail:
2427
2428 SWIG_croak_null();
2429 }
2430 }
2431
2432
XS(_wrap_gsl_set_stream)2433 XS(_wrap_gsl_set_stream) {
2434 {
2435 FILE *arg1 = (FILE *) 0 ;
2436 void *argp1 = 0 ;
2437 int res1 = 0 ;
2438 int argvi = 0;
2439 FILE *result = 0 ;
2440 dXSARGS;
2441
2442 if ((items < 1) || (items > 1)) {
2443 SWIG_croak("Usage: gsl_set_stream(new_stream);");
2444 }
2445 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_FILE, 0 | 0 );
2446 if (!SWIG_IsOK(res1)) {
2447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_set_stream" "', argument " "1"" of type '" "FILE *""'");
2448 }
2449 arg1 = (FILE *)(argp1);
2450 result = (FILE *)gsl_set_stream(arg1);
2451 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0); argvi++ ;
2452
2453 XSRETURN(argvi);
2454 fail:
2455
2456 SWIG_croak_null();
2457 }
2458 }
2459
2460
XS(_wrap_gsl_fit_linear)2461 XS(_wrap_gsl_fit_linear) {
2462 {
2463 double *arg1 = (double *) 0 ;
2464 size_t arg2 ;
2465 double *arg3 = (double *) 0 ;
2466 size_t arg4 ;
2467 size_t arg5 ;
2468 double *arg6 = (double *) 0 ;
2469 double *arg7 = (double *) 0 ;
2470 double *arg8 = (double *) 0 ;
2471 double *arg9 = (double *) 0 ;
2472 double *arg10 = (double *) 0 ;
2473 double *arg11 = (double *) 0 ;
2474 size_t val2 ;
2475 int ecode2 = 0 ;
2476 size_t val4 ;
2477 int ecode4 = 0 ;
2478 size_t val5 ;
2479 int ecode5 = 0 ;
2480 double temp6 ;
2481 int res6 = SWIG_TMPOBJ ;
2482 double temp7 ;
2483 int res7 = SWIG_TMPOBJ ;
2484 double temp8 ;
2485 int res8 = SWIG_TMPOBJ ;
2486 double temp9 ;
2487 int res9 = SWIG_TMPOBJ ;
2488 double temp10 ;
2489 int res10 = SWIG_TMPOBJ ;
2490 double temp11 ;
2491 int res11 = SWIG_TMPOBJ ;
2492 int argvi = 0;
2493 int result;
2494 dXSARGS;
2495
2496 arg6 = &temp6;
2497 arg7 = &temp7;
2498 arg8 = &temp8;
2499 arg9 = &temp9;
2500 arg10 = &temp10;
2501 arg11 = &temp11;
2502 if ((items < 5) || (items > 5)) {
2503 SWIG_croak("Usage: gsl_fit_linear(x,xstride,y,ystride,n);");
2504 }
2505 {
2506 AV *tempav;
2507 I32 len;
2508 int i;
2509 SV **tv;
2510 if (!SvROK(ST(0)))
2511 croak("Math::GSL : $x is not a reference!");
2512 if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
2513 croak("Math::GSL : $x is not an array ref!");
2514
2515 tempav = (AV*)SvRV(ST(0));
2516 len = av_len(tempav);
2517 arg1 = (double *) malloc((len+2)*sizeof(double));
2518 for (i = 0; i <= len; i++) {
2519 tv = av_fetch(tempav, i, 0);
2520 arg1[i] = (double) SvNV(*tv);
2521 }
2522 }
2523 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2524 if (!SWIG_IsOK(ecode2)) {
2525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_fit_linear" "', argument " "2"" of type '" "size_t""'");
2526 }
2527 arg2 = (size_t)(val2);
2528 {
2529 AV *tempav;
2530 I32 len;
2531 int i;
2532 SV **tv;
2533 if (!SvROK(ST(2)))
2534 croak("Math::GSL : $y is not a reference!");
2535 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
2536 croak("Math::GSL : $y is not an array ref!");
2537
2538 tempav = (AV*)SvRV(ST(2));
2539 len = av_len(tempav);
2540 arg3 = (double *) malloc((len+2)*sizeof(double));
2541 for (i = 0; i <= len; i++) {
2542 tv = av_fetch(tempav, i, 0);
2543 arg3[i] = (double) SvNV(*tv);
2544 }
2545 }
2546 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2547 if (!SWIG_IsOK(ecode4)) {
2548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_fit_linear" "', argument " "4"" of type '" "size_t""'");
2549 }
2550 arg4 = (size_t)(val4);
2551 ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
2552 if (!SWIG_IsOK(ecode5)) {
2553 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_fit_linear" "', argument " "5"" of type '" "size_t""'");
2554 }
2555 arg5 = (size_t)(val5);
2556 result = (int)gsl_fit_linear((double const *)arg1,arg2,(double const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
2557 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2558 if (SWIG_IsTmpObj(res6)) {
2559 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg6)); argvi++ ;
2560 } else {
2561 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0) : 0;
2562 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags); argvi++ ;
2563 }
2564 if (SWIG_IsTmpObj(res7)) {
2565 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg7)); argvi++ ;
2566 } else {
2567 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0) : 0;
2568 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags); argvi++ ;
2569 }
2570 if (SWIG_IsTmpObj(res8)) {
2571 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg8)); argvi++ ;
2572 } else {
2573 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0) : 0;
2574 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags); argvi++ ;
2575 }
2576 if (SWIG_IsTmpObj(res9)) {
2577 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg9)); argvi++ ;
2578 } else {
2579 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0) : 0;
2580 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags); argvi++ ;
2581 }
2582 if (SWIG_IsTmpObj(res10)) {
2583 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg10)); argvi++ ;
2584 } else {
2585 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0) : 0;
2586 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags); argvi++ ;
2587 }
2588 if (SWIG_IsTmpObj(res11)) {
2589 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg11)); argvi++ ;
2590 } else {
2591 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0) : 0;
2592 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_double, new_flags); argvi++ ;
2593 }
2594 {
2595 if (arg1) free(arg1);
2596 }
2597
2598 {
2599 if (arg3) free(arg3);
2600 }
2601
2602
2603
2604
2605
2606
2607
2608
2609 XSRETURN(argvi);
2610 fail:
2611 {
2612 if (arg1) free(arg1);
2613 }
2614
2615 {
2616 if (arg3) free(arg3);
2617 }
2618
2619
2620
2621
2622
2623
2624
2625
2626 SWIG_croak_null();
2627 }
2628 }
2629
2630
XS(_wrap_gsl_fit_wlinear)2631 XS(_wrap_gsl_fit_wlinear) {
2632 {
2633 double *arg1 = (double *) 0 ;
2634 size_t arg2 ;
2635 double *arg3 = (double *) 0 ;
2636 size_t arg4 ;
2637 double *arg5 = (double *) 0 ;
2638 size_t arg6 ;
2639 size_t arg7 ;
2640 double *arg8 = (double *) 0 ;
2641 double *arg9 = (double *) 0 ;
2642 double *arg10 = (double *) 0 ;
2643 double *arg11 = (double *) 0 ;
2644 double *arg12 = (double *) 0 ;
2645 double *arg13 = (double *) 0 ;
2646 size_t val2 ;
2647 int ecode2 = 0 ;
2648 size_t val4 ;
2649 int ecode4 = 0 ;
2650 size_t val6 ;
2651 int ecode6 = 0 ;
2652 size_t val7 ;
2653 int ecode7 = 0 ;
2654 double temp8 ;
2655 int res8 = SWIG_TMPOBJ ;
2656 double temp9 ;
2657 int res9 = SWIG_TMPOBJ ;
2658 double temp10 ;
2659 int res10 = SWIG_TMPOBJ ;
2660 double temp11 ;
2661 int res11 = SWIG_TMPOBJ ;
2662 double temp12 ;
2663 int res12 = SWIG_TMPOBJ ;
2664 double temp13 ;
2665 int res13 = SWIG_TMPOBJ ;
2666 int argvi = 0;
2667 int result;
2668 dXSARGS;
2669
2670 arg8 = &temp8;
2671 arg9 = &temp9;
2672 arg10 = &temp10;
2673 arg11 = &temp11;
2674 arg12 = &temp12;
2675 arg13 = &temp13;
2676 if ((items < 7) || (items > 7)) {
2677 SWIG_croak("Usage: gsl_fit_wlinear(x,xstride,w,wstride,y,ystride,n);");
2678 }
2679 {
2680 AV *tempav;
2681 I32 len;
2682 int i;
2683 SV **tv;
2684 if (!SvROK(ST(0)))
2685 croak("Math::GSL : $x is not a reference!");
2686 if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
2687 croak("Math::GSL : $x is not an array ref!");
2688
2689 tempav = (AV*)SvRV(ST(0));
2690 len = av_len(tempav);
2691 arg1 = (double *) malloc((len+2)*sizeof(double));
2692 for (i = 0; i <= len; i++) {
2693 tv = av_fetch(tempav, i, 0);
2694 arg1[i] = (double) SvNV(*tv);
2695 }
2696 }
2697 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2698 if (!SWIG_IsOK(ecode2)) {
2699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_fit_wlinear" "', argument " "2"" of type '" "size_t""'");
2700 }
2701 arg2 = (size_t)(val2);
2702 {
2703 AV *tempav;
2704 I32 len;
2705 int i;
2706 SV **tv;
2707 if (!SvROK(ST(2)))
2708 croak("Math::GSL : $w is not a reference!");
2709 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
2710 croak("Math::GSL : $w is not an array ref!");
2711
2712 tempav = (AV*)SvRV(ST(2));
2713 len = av_len(tempav);
2714 arg3 = (double *) malloc((len+2)*sizeof(double));
2715 for (i = 0; i <= len; i++) {
2716 tv = av_fetch(tempav, i, 0);
2717 arg3[i] = (double) SvNV(*tv);
2718 }
2719 }
2720 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2721 if (!SWIG_IsOK(ecode4)) {
2722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_fit_wlinear" "', argument " "4"" of type '" "size_t""'");
2723 }
2724 arg4 = (size_t)(val4);
2725 {
2726 AV *tempav;
2727 I32 len;
2728 int i;
2729 SV **tv;
2730 if (!SvROK(ST(4)))
2731 croak("Math::GSL : $y is not a reference!");
2732 if (SvTYPE(SvRV(ST(4))) != SVt_PVAV)
2733 croak("Math::GSL : $y is not an array ref!");
2734
2735 tempav = (AV*)SvRV(ST(4));
2736 len = av_len(tempav);
2737 arg5 = (double *) malloc((len+2)*sizeof(double));
2738 for (i = 0; i <= len; i++) {
2739 tv = av_fetch(tempav, i, 0);
2740 arg5[i] = (double) SvNV(*tv);
2741 }
2742 }
2743 ecode6 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
2744 if (!SWIG_IsOK(ecode6)) {
2745 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gsl_fit_wlinear" "', argument " "6"" of type '" "size_t""'");
2746 }
2747 arg6 = (size_t)(val6);
2748 ecode7 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
2749 if (!SWIG_IsOK(ecode7)) {
2750 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gsl_fit_wlinear" "', argument " "7"" of type '" "size_t""'");
2751 }
2752 arg7 = (size_t)(val7);
2753 result = (int)gsl_fit_wlinear((double const *)arg1,arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
2754 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2755 if (SWIG_IsTmpObj(res8)) {
2756 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg8)); argvi++ ;
2757 } else {
2758 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0) : 0;
2759 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags); argvi++ ;
2760 }
2761 if (SWIG_IsTmpObj(res9)) {
2762 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg9)); argvi++ ;
2763 } else {
2764 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0) : 0;
2765 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags); argvi++ ;
2766 }
2767 if (SWIG_IsTmpObj(res10)) {
2768 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg10)); argvi++ ;
2769 } else {
2770 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0) : 0;
2771 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags); argvi++ ;
2772 }
2773 if (SWIG_IsTmpObj(res11)) {
2774 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg11)); argvi++ ;
2775 } else {
2776 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0) : 0;
2777 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_double, new_flags); argvi++ ;
2778 }
2779 if (SWIG_IsTmpObj(res12)) {
2780 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg12)); argvi++ ;
2781 } else {
2782 int new_flags = SWIG_IsNewObj(res12) ? (SWIG_POINTER_OWN | 0) : 0;
2783 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg12), SWIGTYPE_p_double, new_flags); argvi++ ;
2784 }
2785 if (SWIG_IsTmpObj(res13)) {
2786 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg13)); argvi++ ;
2787 } else {
2788 int new_flags = SWIG_IsNewObj(res13) ? (SWIG_POINTER_OWN | 0) : 0;
2789 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg13), SWIGTYPE_p_double, new_flags); argvi++ ;
2790 }
2791 {
2792 if (arg1) free(arg1);
2793 }
2794
2795 {
2796 if (arg3) free(arg3);
2797 }
2798
2799 {
2800 if (arg5) free(arg5);
2801 }
2802
2803
2804
2805
2806
2807
2808
2809
2810 XSRETURN(argvi);
2811 fail:
2812 {
2813 if (arg1) free(arg1);
2814 }
2815
2816 {
2817 if (arg3) free(arg3);
2818 }
2819
2820 {
2821 if (arg5) free(arg5);
2822 }
2823
2824
2825
2826
2827
2828
2829
2830
2831 SWIG_croak_null();
2832 }
2833 }
2834
2835
XS(_wrap_gsl_fit_linear_est)2836 XS(_wrap_gsl_fit_linear_est) {
2837 {
2838 double arg1 ;
2839 double arg2 ;
2840 double arg3 ;
2841 double arg4 ;
2842 double arg5 ;
2843 double arg6 ;
2844 double *arg7 = (double *) 0 ;
2845 double *arg8 = (double *) 0 ;
2846 double val1 ;
2847 int ecode1 = 0 ;
2848 double val2 ;
2849 int ecode2 = 0 ;
2850 double val3 ;
2851 int ecode3 = 0 ;
2852 double val4 ;
2853 int ecode4 = 0 ;
2854 double val5 ;
2855 int ecode5 = 0 ;
2856 double val6 ;
2857 int ecode6 = 0 ;
2858 void *argp7 = 0 ;
2859 int res7 = 0 ;
2860 void *argp8 = 0 ;
2861 int res8 = 0 ;
2862 int argvi = 0;
2863 int result;
2864 dXSARGS;
2865
2866 if ((items < 8) || (items > 8)) {
2867 SWIG_croak("Usage: gsl_fit_linear_est(x,c0,c1,cov00,cov01,cov11,y,y_err);");
2868 }
2869 ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2870 if (!SWIG_IsOK(ecode1)) {
2871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_fit_linear_est" "', argument " "1"" of type '" "double""'");
2872 }
2873 arg1 = (double)(val1);
2874 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2875 if (!SWIG_IsOK(ecode2)) {
2876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_fit_linear_est" "', argument " "2"" of type '" "double""'");
2877 }
2878 arg2 = (double)(val2);
2879 ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2880 if (!SWIG_IsOK(ecode3)) {
2881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_fit_linear_est" "', argument " "3"" of type '" "double""'");
2882 }
2883 arg3 = (double)(val3);
2884 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2885 if (!SWIG_IsOK(ecode4)) {
2886 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_fit_linear_est" "', argument " "4"" of type '" "double""'");
2887 }
2888 arg4 = (double)(val4);
2889 ecode5 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
2890 if (!SWIG_IsOK(ecode5)) {
2891 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_fit_linear_est" "', argument " "5"" of type '" "double""'");
2892 }
2893 arg5 = (double)(val5);
2894 ecode6 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
2895 if (!SWIG_IsOK(ecode6)) {
2896 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gsl_fit_linear_est" "', argument " "6"" of type '" "double""'");
2897 }
2898 arg6 = (double)(val6);
2899 res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_double, 0 | 0 );
2900 if (!SWIG_IsOK(res7)) {
2901 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "gsl_fit_linear_est" "', argument " "7"" of type '" "double *""'");
2902 }
2903 arg7 = (double *)(argp7);
2904 res8 = SWIG_ConvertPtr(ST(7), &argp8,SWIGTYPE_p_double, 0 | 0 );
2905 if (!SWIG_IsOK(res8)) {
2906 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "gsl_fit_linear_est" "', argument " "8"" of type '" "double *""'");
2907 }
2908 arg8 = (double *)(argp8);
2909 result = (int)gsl_fit_linear_est(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
2910 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2911
2912
2913
2914
2915
2916
2917
2918
2919 XSRETURN(argvi);
2920 fail:
2921
2922
2923
2924
2925
2926
2927
2928
2929 SWIG_croak_null();
2930 }
2931 }
2932
2933
XS(_wrap_gsl_fit_mul)2934 XS(_wrap_gsl_fit_mul) {
2935 {
2936 double *arg1 = (double *) 0 ;
2937 size_t arg2 ;
2938 double *arg3 = (double *) 0 ;
2939 size_t arg4 ;
2940 size_t arg5 ;
2941 double *arg6 = (double *) 0 ;
2942 double *arg7 = (double *) 0 ;
2943 double *arg8 = (double *) 0 ;
2944 size_t val2 ;
2945 int ecode2 = 0 ;
2946 size_t val4 ;
2947 int ecode4 = 0 ;
2948 size_t val5 ;
2949 int ecode5 = 0 ;
2950 double temp6 ;
2951 int res6 = SWIG_TMPOBJ ;
2952 double temp7 ;
2953 int res7 = SWIG_TMPOBJ ;
2954 double temp8 ;
2955 int res8 = SWIG_TMPOBJ ;
2956 int argvi = 0;
2957 int result;
2958 dXSARGS;
2959
2960 arg6 = &temp6;
2961 arg7 = &temp7;
2962 arg8 = &temp8;
2963 if ((items < 5) || (items > 5)) {
2964 SWIG_croak("Usage: gsl_fit_mul(x,xstride,y,ystride,n);");
2965 }
2966 {
2967 AV *tempav;
2968 I32 len;
2969 int i;
2970 SV **tv;
2971 if (!SvROK(ST(0)))
2972 croak("Math::GSL : $x is not a reference!");
2973 if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
2974 croak("Math::GSL : $x is not an array ref!");
2975
2976 tempav = (AV*)SvRV(ST(0));
2977 len = av_len(tempav);
2978 arg1 = (double *) malloc((len+2)*sizeof(double));
2979 for (i = 0; i <= len; i++) {
2980 tv = av_fetch(tempav, i, 0);
2981 arg1[i] = (double) SvNV(*tv);
2982 }
2983 }
2984 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2985 if (!SWIG_IsOK(ecode2)) {
2986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_fit_mul" "', argument " "2"" of type '" "size_t""'");
2987 }
2988 arg2 = (size_t)(val2);
2989 {
2990 AV *tempav;
2991 I32 len;
2992 int i;
2993 SV **tv;
2994 if (!SvROK(ST(2)))
2995 croak("Math::GSL : $y is not a reference!");
2996 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
2997 croak("Math::GSL : $y is not an array ref!");
2998
2999 tempav = (AV*)SvRV(ST(2));
3000 len = av_len(tempav);
3001 arg3 = (double *) malloc((len+2)*sizeof(double));
3002 for (i = 0; i <= len; i++) {
3003 tv = av_fetch(tempav, i, 0);
3004 arg3[i] = (double) SvNV(*tv);
3005 }
3006 }
3007 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3008 if (!SWIG_IsOK(ecode4)) {
3009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_fit_mul" "', argument " "4"" of type '" "size_t""'");
3010 }
3011 arg4 = (size_t)(val4);
3012 ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
3013 if (!SWIG_IsOK(ecode5)) {
3014 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_fit_mul" "', argument " "5"" of type '" "size_t""'");
3015 }
3016 arg5 = (size_t)(val5);
3017 result = (int)gsl_fit_mul((double const *)arg1,arg2,(double const *)arg3,arg4,arg5,arg6,arg7,arg8);
3018 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3019 if (SWIG_IsTmpObj(res6)) {
3020 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg6)); argvi++ ;
3021 } else {
3022 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0) : 0;
3023 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags); argvi++ ;
3024 }
3025 if (SWIG_IsTmpObj(res7)) {
3026 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg7)); argvi++ ;
3027 } else {
3028 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0) : 0;
3029 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags); argvi++ ;
3030 }
3031 if (SWIG_IsTmpObj(res8)) {
3032 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg8)); argvi++ ;
3033 } else {
3034 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0) : 0;
3035 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags); argvi++ ;
3036 }
3037 {
3038 if (arg1) free(arg1);
3039 }
3040
3041 {
3042 if (arg3) free(arg3);
3043 }
3044
3045
3046
3047
3048
3049 XSRETURN(argvi);
3050 fail:
3051 {
3052 if (arg1) free(arg1);
3053 }
3054
3055 {
3056 if (arg3) free(arg3);
3057 }
3058
3059
3060
3061
3062
3063 SWIG_croak_null();
3064 }
3065 }
3066
3067
XS(_wrap_gsl_fit_wmul)3068 XS(_wrap_gsl_fit_wmul) {
3069 {
3070 double *arg1 = (double *) 0 ;
3071 size_t arg2 ;
3072 double *arg3 = (double *) 0 ;
3073 size_t arg4 ;
3074 double *arg5 = (double *) 0 ;
3075 size_t arg6 ;
3076 size_t arg7 ;
3077 double *arg8 = (double *) 0 ;
3078 double *arg9 = (double *) 0 ;
3079 double *arg10 = (double *) 0 ;
3080 size_t val2 ;
3081 int ecode2 = 0 ;
3082 size_t val4 ;
3083 int ecode4 = 0 ;
3084 size_t val6 ;
3085 int ecode6 = 0 ;
3086 size_t val7 ;
3087 int ecode7 = 0 ;
3088 double temp8 ;
3089 int res8 = SWIG_TMPOBJ ;
3090 double temp9 ;
3091 int res9 = SWIG_TMPOBJ ;
3092 double temp10 ;
3093 int res10 = SWIG_TMPOBJ ;
3094 int argvi = 0;
3095 int result;
3096 dXSARGS;
3097
3098 arg8 = &temp8;
3099 arg9 = &temp9;
3100 arg10 = &temp10;
3101 if ((items < 7) || (items > 7)) {
3102 SWIG_croak("Usage: gsl_fit_wmul(x,xstride,w,wstride,y,ystride,n);");
3103 }
3104 {
3105 AV *tempav;
3106 I32 len;
3107 int i;
3108 SV **tv;
3109 if (!SvROK(ST(0)))
3110 croak("Math::GSL : $x is not a reference!");
3111 if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
3112 croak("Math::GSL : $x is not an array ref!");
3113
3114 tempav = (AV*)SvRV(ST(0));
3115 len = av_len(tempav);
3116 arg1 = (double *) malloc((len+2)*sizeof(double));
3117 for (i = 0; i <= len; i++) {
3118 tv = av_fetch(tempav, i, 0);
3119 arg1[i] = (double) SvNV(*tv);
3120 }
3121 }
3122 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3123 if (!SWIG_IsOK(ecode2)) {
3124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_fit_wmul" "', argument " "2"" of type '" "size_t""'");
3125 }
3126 arg2 = (size_t)(val2);
3127 {
3128 AV *tempav;
3129 I32 len;
3130 int i;
3131 SV **tv;
3132 if (!SvROK(ST(2)))
3133 croak("Math::GSL : $w is not a reference!");
3134 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
3135 croak("Math::GSL : $w is not an array ref!");
3136
3137 tempav = (AV*)SvRV(ST(2));
3138 len = av_len(tempav);
3139 arg3 = (double *) malloc((len+2)*sizeof(double));
3140 for (i = 0; i <= len; i++) {
3141 tv = av_fetch(tempav, i, 0);
3142 arg3[i] = (double) SvNV(*tv);
3143 }
3144 }
3145 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3146 if (!SWIG_IsOK(ecode4)) {
3147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_fit_wmul" "', argument " "4"" of type '" "size_t""'");
3148 }
3149 arg4 = (size_t)(val4);
3150 {
3151 AV *tempav;
3152 I32 len;
3153 int i;
3154 SV **tv;
3155 if (!SvROK(ST(4)))
3156 croak("Math::GSL : $y is not a reference!");
3157 if (SvTYPE(SvRV(ST(4))) != SVt_PVAV)
3158 croak("Math::GSL : $y is not an array ref!");
3159
3160 tempav = (AV*)SvRV(ST(4));
3161 len = av_len(tempav);
3162 arg5 = (double *) malloc((len+2)*sizeof(double));
3163 for (i = 0; i <= len; i++) {
3164 tv = av_fetch(tempav, i, 0);
3165 arg5[i] = (double) SvNV(*tv);
3166 }
3167 }
3168 ecode6 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
3169 if (!SWIG_IsOK(ecode6)) {
3170 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gsl_fit_wmul" "', argument " "6"" of type '" "size_t""'");
3171 }
3172 arg6 = (size_t)(val6);
3173 ecode7 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
3174 if (!SWIG_IsOK(ecode7)) {
3175 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gsl_fit_wmul" "', argument " "7"" of type '" "size_t""'");
3176 }
3177 arg7 = (size_t)(val7);
3178 result = (int)gsl_fit_wmul((double const *)arg1,arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,arg7,arg8,arg9,arg10);
3179 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3180 if (SWIG_IsTmpObj(res8)) {
3181 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg8)); argvi++ ;
3182 } else {
3183 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0) : 0;
3184 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags); argvi++ ;
3185 }
3186 if (SWIG_IsTmpObj(res9)) {
3187 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg9)); argvi++ ;
3188 } else {
3189 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0) : 0;
3190 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags); argvi++ ;
3191 }
3192 if (SWIG_IsTmpObj(res10)) {
3193 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg10)); argvi++ ;
3194 } else {
3195 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0) : 0;
3196 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags); argvi++ ;
3197 }
3198 {
3199 if (arg1) free(arg1);
3200 }
3201
3202 {
3203 if (arg3) free(arg3);
3204 }
3205
3206 {
3207 if (arg5) free(arg5);
3208 }
3209
3210
3211
3212
3213
3214 XSRETURN(argvi);
3215 fail:
3216 {
3217 if (arg1) free(arg1);
3218 }
3219
3220 {
3221 if (arg3) free(arg3);
3222 }
3223
3224 {
3225 if (arg5) free(arg5);
3226 }
3227
3228
3229
3230
3231
3232 SWIG_croak_null();
3233 }
3234 }
3235
3236
XS(_wrap_gsl_fit_mul_est)3237 XS(_wrap_gsl_fit_mul_est) {
3238 {
3239 double arg1 ;
3240 double arg2 ;
3241 double arg3 ;
3242 double *arg4 = (double *) 0 ;
3243 double *arg5 = (double *) 0 ;
3244 double val1 ;
3245 int ecode1 = 0 ;
3246 double val2 ;
3247 int ecode2 = 0 ;
3248 double val3 ;
3249 int ecode3 = 0 ;
3250 void *argp4 = 0 ;
3251 int res4 = 0 ;
3252 void *argp5 = 0 ;
3253 int res5 = 0 ;
3254 int argvi = 0;
3255 int result;
3256 dXSARGS;
3257
3258 if ((items < 5) || (items > 5)) {
3259 SWIG_croak("Usage: gsl_fit_mul_est(x,c1,cov11,y,y_err);");
3260 }
3261 ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
3262 if (!SWIG_IsOK(ecode1)) {
3263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_fit_mul_est" "', argument " "1"" of type '" "double""'");
3264 }
3265 arg1 = (double)(val1);
3266 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3267 if (!SWIG_IsOK(ecode2)) {
3268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_fit_mul_est" "', argument " "2"" of type '" "double""'");
3269 }
3270 arg2 = (double)(val2);
3271 ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
3272 if (!SWIG_IsOK(ecode3)) {
3273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_fit_mul_est" "', argument " "3"" of type '" "double""'");
3274 }
3275 arg3 = (double)(val3);
3276 res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_double, 0 | 0 );
3277 if (!SWIG_IsOK(res4)) {
3278 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gsl_fit_mul_est" "', argument " "4"" of type '" "double *""'");
3279 }
3280 arg4 = (double *)(argp4);
3281 res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_double, 0 | 0 );
3282 if (!SWIG_IsOK(res5)) {
3283 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gsl_fit_mul_est" "', argument " "5"" of type '" "double *""'");
3284 }
3285 arg5 = (double *)(argp5);
3286 result = (int)gsl_fit_mul_est(arg1,arg2,arg3,arg4,arg5);
3287 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3288
3289
3290
3291
3292
3293 XSRETURN(argvi);
3294 fail:
3295
3296
3297
3298
3299
3300 SWIG_croak_null();
3301 }
3302 }
3303
3304
3305
3306 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3307
3308 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
3309 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3310 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
3311 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};
3312 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};
3313
3314 static swig_type_info *swig_type_initial[] = {
3315 &_swigt__p_FILE,
3316 &_swigt__p_char,
3317 &_swigt__p_double,
3318 &_swigt__p_f_p_q_const__char_p_q_const__char_int_int__void,
3319 &_swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
3320 };
3321
3322 static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
3323 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3324 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
3325 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}};
3326 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}};
3327
3328 static swig_cast_info *swig_cast_initial[] = {
3329 _swigc__p_FILE,
3330 _swigc__p_char,
3331 _swigc__p_double,
3332 _swigc__p_f_p_q_const__char_p_q_const__char_int_int__void,
3333 _swigc__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
3334 };
3335
3336
3337 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3338
3339 static swig_constant_info swig_constants[] = {
3340 {0,0,0,0,0,0}
3341 };
3342 #ifdef __cplusplus
3343 }
3344 #endif
3345 static swig_variable_info swig_variables[] = {
3346 {0,0,0,0}
3347 };
3348 static swig_command_info swig_commands[] = {
3349 {"Math::GSL::Fitc::gsl_error", _wrap_gsl_error},
3350 {"Math::GSL::Fitc::gsl_stream_printf", _wrap_gsl_stream_printf},
3351 {"Math::GSL::Fitc::gsl_strerror", _wrap_gsl_strerror},
3352 {"Math::GSL::Fitc::gsl_set_error_handler", _wrap_gsl_set_error_handler},
3353 {"Math::GSL::Fitc::gsl_set_error_handler_off", _wrap_gsl_set_error_handler_off},
3354 {"Math::GSL::Fitc::gsl_set_stream_handler", _wrap_gsl_set_stream_handler},
3355 {"Math::GSL::Fitc::gsl_set_stream", _wrap_gsl_set_stream},
3356 {"Math::GSL::Fitc::gsl_fit_linear", _wrap_gsl_fit_linear},
3357 {"Math::GSL::Fitc::gsl_fit_wlinear", _wrap_gsl_fit_wlinear},
3358 {"Math::GSL::Fitc::gsl_fit_linear_est", _wrap_gsl_fit_linear_est},
3359 {"Math::GSL::Fitc::gsl_fit_mul", _wrap_gsl_fit_mul},
3360 {"Math::GSL::Fitc::gsl_fit_wmul", _wrap_gsl_fit_wmul},
3361 {"Math::GSL::Fitc::gsl_fit_mul_est", _wrap_gsl_fit_mul_est},
3362 {0,0}
3363 };
3364 /* -----------------------------------------------------------------------------
3365 * Type initialization:
3366 * This problem is tough by the requirement that no dynamic
3367 * memory is used. Also, since swig_type_info structures store pointers to
3368 * swig_cast_info structures and swig_cast_info structures store pointers back
3369 * to swig_type_info structures, we need some lookup code at initialization.
3370 * The idea is that swig generates all the structures that are needed.
3371 * The runtime then collects these partially filled structures.
3372 * The SWIG_InitializeModule function takes these initial arrays out of
3373 * swig_module, and does all the lookup, filling in the swig_module.types
3374 * array with the correct data and linking the correct swig_cast_info
3375 * structures together.
3376 *
3377 * The generated swig_type_info structures are assigned statically to an initial
3378 * array. We just loop through that array, and handle each type individually.
3379 * First we lookup if this type has been already loaded, and if so, use the
3380 * loaded structure instead of the generated one. Then we have to fill in the
3381 * cast linked list. The cast data is initially stored in something like a
3382 * two-dimensional array. Each row corresponds to a type (there are the same
3383 * number of rows as there are in the swig_type_initial array). Each entry in
3384 * a column is one of the swig_cast_info structures for that type.
3385 * The cast_initial array is actually an array of arrays, because each row has
3386 * a variable number of columns. So to actually build the cast linked list,
3387 * we find the array of casts associated with the type, and loop through it
3388 * adding the casts to the list. The one last trick we need to do is making
3389 * sure the type pointer in the swig_cast_info struct is correct.
3390 *
3391 * First off, we lookup the cast->type name to see if it is already loaded.
3392 * There are three cases to handle:
3393 * 1) If the cast->type has already been loaded AND the type we are adding
3394 * casting info to has not been loaded (it is in this module), THEN we
3395 * replace the cast->type pointer with the type pointer that has already
3396 * been loaded.
3397 * 2) If BOTH types (the one we are adding casting info to, and the
3398 * cast->type) are loaded, THEN the cast info has already been loaded by
3399 * the previous module so we just ignore it.
3400 * 3) Finally, if cast->type has not already been loaded, then we add that
3401 * swig_cast_info to the linked list (because the cast->type) pointer will
3402 * be correct.
3403 * ----------------------------------------------------------------------------- */
3404
3405 #ifdef __cplusplus
3406 extern "C" {
3407 #if 0
3408 } /* c-mode */
3409 #endif
3410 #endif
3411
3412 #if 0
3413 #define SWIGRUNTIME_DEBUG
3414 #endif
3415
3416
3417 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)3418 SWIG_InitializeModule(void *clientdata) {
3419 size_t i;
3420 swig_module_info *module_head, *iter;
3421 int init;
3422
3423 /* check to see if the circular list has been setup, if not, set it up */
3424 if (swig_module.next==0) {
3425 /* Initialize the swig_module */
3426 swig_module.type_initial = swig_type_initial;
3427 swig_module.cast_initial = swig_cast_initial;
3428 swig_module.next = &swig_module;
3429 init = 1;
3430 } else {
3431 init = 0;
3432 }
3433
3434 /* Try and load any already created modules */
3435 module_head = SWIG_GetModule(clientdata);
3436 if (!module_head) {
3437 /* This is the first module loaded for this interpreter */
3438 /* so set the swig module into the interpreter */
3439 SWIG_SetModule(clientdata, &swig_module);
3440 } else {
3441 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3442 iter=module_head;
3443 do {
3444 if (iter==&swig_module) {
3445 /* Our module is already in the list, so there's nothing more to do. */
3446 return;
3447 }
3448 iter=iter->next;
3449 } while (iter!= module_head);
3450
3451 /* otherwise we must add our module into the list */
3452 swig_module.next = module_head->next;
3453 module_head->next = &swig_module;
3454 }
3455
3456 /* When multiple interpreters are used, a module could have already been initialized in
3457 a different interpreter, but not yet have a pointer in this interpreter.
3458 In this case, we do not want to continue adding types... everything should be
3459 set up already */
3460 if (init == 0) return;
3461
3462 /* Now work on filling in swig_module.types */
3463 #ifdef SWIGRUNTIME_DEBUG
3464 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
3465 #endif
3466 for (i = 0; i < swig_module.size; ++i) {
3467 swig_type_info *type = 0;
3468 swig_type_info *ret;
3469 swig_cast_info *cast;
3470
3471 #ifdef SWIGRUNTIME_DEBUG
3472 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
3473 #endif
3474
3475 /* if there is another module already loaded */
3476 if (swig_module.next != &swig_module) {
3477 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3478 }
3479 if (type) {
3480 /* Overwrite clientdata field */
3481 #ifdef SWIGRUNTIME_DEBUG
3482 printf("SWIG_InitializeModule: found type %s\n", type->name);
3483 #endif
3484 if (swig_module.type_initial[i]->clientdata) {
3485 type->clientdata = swig_module.type_initial[i]->clientdata;
3486 #ifdef SWIGRUNTIME_DEBUG
3487 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3488 #endif
3489 }
3490 } else {
3491 type = swig_module.type_initial[i];
3492 }
3493
3494 /* Insert casting types */
3495 cast = swig_module.cast_initial[i];
3496 while (cast->type) {
3497 /* Don't need to add information already in the list */
3498 ret = 0;
3499 #ifdef SWIGRUNTIME_DEBUG
3500 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3501 #endif
3502 if (swig_module.next != &swig_module) {
3503 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3504 #ifdef SWIGRUNTIME_DEBUG
3505 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3506 #endif
3507 }
3508 if (ret) {
3509 if (type == swig_module.type_initial[i]) {
3510 #ifdef SWIGRUNTIME_DEBUG
3511 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3512 #endif
3513 cast->type = ret;
3514 ret = 0;
3515 } else {
3516 /* Check for casting already in the list */
3517 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3518 #ifdef SWIGRUNTIME_DEBUG
3519 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3520 #endif
3521 if (!ocast) ret = 0;
3522 }
3523 }
3524
3525 if (!ret) {
3526 #ifdef SWIGRUNTIME_DEBUG
3527 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3528 #endif
3529 if (type->cast) {
3530 type->cast->prev = cast;
3531 cast->next = type->cast;
3532 }
3533 type->cast = cast;
3534 }
3535 cast++;
3536 }
3537 /* Set entry in modules->types array equal to the type */
3538 swig_module.types[i] = type;
3539 }
3540 swig_module.types[i] = 0;
3541
3542 #ifdef SWIGRUNTIME_DEBUG
3543 printf("**** SWIG_InitializeModule: Cast List ******\n");
3544 for (i = 0; i < swig_module.size; ++i) {
3545 int j = 0;
3546 swig_cast_info *cast = swig_module.cast_initial[i];
3547 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
3548 while (cast->type) {
3549 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3550 cast++;
3551 ++j;
3552 }
3553 printf("---- Total casts: %d\n",j);
3554 }
3555 printf("**** SWIG_InitializeModule: Cast List ******\n");
3556 #endif
3557 }
3558
3559 /* This function will propagate the clientdata field of type to
3560 * any new swig_type_info structures that have been added into the list
3561 * of equivalent types. It is like calling
3562 * SWIG_TypeClientData(type, clientdata) a second time.
3563 */
3564 SWIGRUNTIME void
SWIG_PropagateClientData(void)3565 SWIG_PropagateClientData(void) {
3566 size_t i;
3567 swig_cast_info *equiv;
3568 static int init_run = 0;
3569
3570 if (init_run) return;
3571 init_run = 1;
3572
3573 for (i = 0; i < swig_module.size; i++) {
3574 if (swig_module.types[i]->clientdata) {
3575 equiv = swig_module.types[i]->cast;
3576 while (equiv) {
3577 if (!equiv->converter) {
3578 if (equiv->type && !equiv->type->clientdata)
3579 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3580 }
3581 equiv = equiv->next;
3582 }
3583 }
3584 }
3585 }
3586
3587 #ifdef __cplusplus
3588 #if 0
3589 {
3590 /* c-mode */
3591 #endif
3592 }
3593 #endif
3594
3595
3596
3597 #if defined(__cplusplus) && ! defined(XSPROTO)
3598 extern "C"
3599 #endif
3600
XS(SWIG_init)3601 XS(SWIG_init) {
3602 dXSARGS;
3603 int i;
3604 (void)items;
3605
3606 SWIG_InitializeModule(0);
3607
3608 /* Install commands */
3609 for (i = 0; swig_commands[i].name; i++) {
3610 /* Casts only needed for Perl < 5.10. */
3611 #ifdef __cplusplus
3612 newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
3613 #else
3614 newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
3615 #endif
3616 }
3617
3618 /* Install variables */
3619 for (i = 0; swig_variables[i].name; i++) {
3620 SV *sv;
3621 sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
3622 if (swig_variables[i].type) {
3623 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
3624 } else {
3625 sv_setiv(sv,(IV) 0);
3626 }
3627 swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
3628 }
3629
3630 /* Install constant */
3631 for (i = 0; swig_constants[i].type; i++) {
3632 SV *sv;
3633 sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
3634 switch(swig_constants[i].type) {
3635 case SWIG_INT:
3636 sv_setiv(sv, (IV) swig_constants[i].lvalue);
3637 break;
3638 case SWIG_FLOAT:
3639 sv_setnv(sv, (double) swig_constants[i].dvalue);
3640 break;
3641 case SWIG_STRING:
3642 sv_setpv(sv, (const char *) swig_constants[i].pvalue);
3643 break;
3644 case SWIG_POINTER:
3645 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
3646 break;
3647 case SWIG_BINARY:
3648 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
3649 break;
3650 default:
3651 break;
3652 }
3653 SvREADONLY_on(sv);
3654 }
3655
3656 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3657 SV *sv = get_sv((char*) SWIG_prefix "GSL_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3658 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(2.7)));
3659 SvREADONLY_on(sv);
3660 } while(0) /*@SWIG@*/;
3661 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3662 SV *sv = get_sv((char*) SWIG_prefix "GSL_MAJOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3663 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(2)));
3664 SvREADONLY_on(sv);
3665 } while(0) /*@SWIG@*/;
3666 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3667 SV *sv = get_sv((char*) SWIG_prefix "GSL_MINOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3668 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(7)));
3669 SvREADONLY_on(sv);
3670 } while(0) /*@SWIG@*/;
3671 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3672 SV *sv = get_sv((char*) SWIG_prefix "GSL_POSZERO", TRUE | 0x2 | GV_ADDMULTI);
3673 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)((+0.0))));
3674 SvREADONLY_on(sv);
3675 } while(0) /*@SWIG@*/;
3676 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3677 SV *sv = get_sv((char*) SWIG_prefix "GSL_NEGZERO", TRUE | 0x2 | GV_ADDMULTI);
3678 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)((-0.0))));
3679 SvREADONLY_on(sv);
3680 } while(0) /*@SWIG@*/;
3681 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3682 SV *sv = get_sv((char*) SWIG_prefix "GSL_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
3683 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_SUCCESS)));
3684 SvREADONLY_on(sv);
3685 } while(0) /*@SWIG@*/;
3686 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3687 SV *sv = get_sv((char*) SWIG_prefix "GSL_FAILURE", TRUE | 0x2 | GV_ADDMULTI);
3688 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_FAILURE)));
3689 SvREADONLY_on(sv);
3690 } while(0) /*@SWIG@*/;
3691 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3692 SV *sv = get_sv((char*) SWIG_prefix "GSL_CONTINUE", TRUE | 0x2 | GV_ADDMULTI);
3693 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_CONTINUE)));
3694 SvREADONLY_on(sv);
3695 } while(0) /*@SWIG@*/;
3696 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3697 SV *sv = get_sv((char*) SWIG_prefix "GSL_EDOM", TRUE | 0x2 | GV_ADDMULTI);
3698 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EDOM)));
3699 SvREADONLY_on(sv);
3700 } while(0) /*@SWIG@*/;
3701 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3702 SV *sv = get_sv((char*) SWIG_prefix "GSL_ERANGE", TRUE | 0x2 | GV_ADDMULTI);
3703 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ERANGE)));
3704 SvREADONLY_on(sv);
3705 } while(0) /*@SWIG@*/;
3706 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3707 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAULT", TRUE | 0x2 | GV_ADDMULTI);
3708 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAULT)));
3709 SvREADONLY_on(sv);
3710 } while(0) /*@SWIG@*/;
3711 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3712 SV *sv = get_sv((char*) SWIG_prefix "GSL_EINVAL", TRUE | 0x2 | GV_ADDMULTI);
3713 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EINVAL)));
3714 SvREADONLY_on(sv);
3715 } while(0) /*@SWIG@*/;
3716 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3717 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAILED", TRUE | 0x2 | GV_ADDMULTI);
3718 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAILED)));
3719 SvREADONLY_on(sv);
3720 } while(0) /*@SWIG@*/;
3721 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3722 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFACTOR", TRUE | 0x2 | GV_ADDMULTI);
3723 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFACTOR)));
3724 SvREADONLY_on(sv);
3725 } while(0) /*@SWIG@*/;
3726 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3727 SV *sv = get_sv((char*) SWIG_prefix "GSL_ESANITY", TRUE | 0x2 | GV_ADDMULTI);
3728 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ESANITY)));
3729 SvREADONLY_on(sv);
3730 } while(0) /*@SWIG@*/;
3731 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3732 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOMEM", TRUE | 0x2 | GV_ADDMULTI);
3733 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOMEM)));
3734 SvREADONLY_on(sv);
3735 } while(0) /*@SWIG@*/;
3736 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3737 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADFUNC", TRUE | 0x2 | GV_ADDMULTI);
3738 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADFUNC)));
3739 SvREADONLY_on(sv);
3740 } while(0) /*@SWIG@*/;
3741 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3742 SV *sv = get_sv((char*) SWIG_prefix "GSL_ERUNAWAY", TRUE | 0x2 | GV_ADDMULTI);
3743 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ERUNAWAY)));
3744 SvREADONLY_on(sv);
3745 } while(0) /*@SWIG@*/;
3746 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3747 SV *sv = get_sv((char*) SWIG_prefix "GSL_EMAXITER", TRUE | 0x2 | GV_ADDMULTI);
3748 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EMAXITER)));
3749 SvREADONLY_on(sv);
3750 } while(0) /*@SWIG@*/;
3751 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3752 SV *sv = get_sv((char*) SWIG_prefix "GSL_EZERODIV", TRUE | 0x2 | GV_ADDMULTI);
3753 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EZERODIV)));
3754 SvREADONLY_on(sv);
3755 } while(0) /*@SWIG@*/;
3756 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3757 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADTOL", TRUE | 0x2 | GV_ADDMULTI);
3758 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADTOL)));
3759 SvREADONLY_on(sv);
3760 } while(0) /*@SWIG@*/;
3761 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3762 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOL", TRUE | 0x2 | GV_ADDMULTI);
3763 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOL)));
3764 SvREADONLY_on(sv);
3765 } while(0) /*@SWIG@*/;
3766 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3767 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNDRFLW", TRUE | 0x2 | GV_ADDMULTI);
3768 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNDRFLW)));
3769 SvREADONLY_on(sv);
3770 } while(0) /*@SWIG@*/;
3771 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3772 SV *sv = get_sv((char*) SWIG_prefix "GSL_EOVRFLW", TRUE | 0x2 | GV_ADDMULTI);
3773 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EOVRFLW)));
3774 SvREADONLY_on(sv);
3775 } while(0) /*@SWIG@*/;
3776 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3777 SV *sv = get_sv((char*) SWIG_prefix "GSL_ELOSS", TRUE | 0x2 | GV_ADDMULTI);
3778 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ELOSS)));
3779 SvREADONLY_on(sv);
3780 } while(0) /*@SWIG@*/;
3781 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3782 SV *sv = get_sv((char*) SWIG_prefix "GSL_EROUND", TRUE | 0x2 | GV_ADDMULTI);
3783 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EROUND)));
3784 SvREADONLY_on(sv);
3785 } while(0) /*@SWIG@*/;
3786 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3787 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADLEN", TRUE | 0x2 | GV_ADDMULTI);
3788 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADLEN)));
3789 SvREADONLY_on(sv);
3790 } while(0) /*@SWIG@*/;
3791 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3792 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOTSQR", TRUE | 0x2 | GV_ADDMULTI);
3793 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOTSQR)));
3794 SvREADONLY_on(sv);
3795 } while(0) /*@SWIG@*/;
3796 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3797 SV *sv = get_sv((char*) SWIG_prefix "GSL_ESING", TRUE | 0x2 | GV_ADDMULTI);
3798 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ESING)));
3799 SvREADONLY_on(sv);
3800 } while(0) /*@SWIG@*/;
3801 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3802 SV *sv = get_sv((char*) SWIG_prefix "GSL_EDIVERGE", TRUE | 0x2 | GV_ADDMULTI);
3803 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EDIVERGE)));
3804 SvREADONLY_on(sv);
3805 } while(0) /*@SWIG@*/;
3806 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3807 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNSUP", TRUE | 0x2 | GV_ADDMULTI);
3808 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNSUP)));
3809 SvREADONLY_on(sv);
3810 } while(0) /*@SWIG@*/;
3811 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3812 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNIMPL", TRUE | 0x2 | GV_ADDMULTI);
3813 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNIMPL)));
3814 SvREADONLY_on(sv);
3815 } while(0) /*@SWIG@*/;
3816 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3817 SV *sv = get_sv((char*) SWIG_prefix "GSL_ECACHE", TRUE | 0x2 | GV_ADDMULTI);
3818 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ECACHE)));
3819 SvREADONLY_on(sv);
3820 } while(0) /*@SWIG@*/;
3821 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3822 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETABLE", TRUE | 0x2 | GV_ADDMULTI);
3823 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETABLE)));
3824 SvREADONLY_on(sv);
3825 } while(0) /*@SWIG@*/;
3826 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3827 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROG", TRUE | 0x2 | GV_ADDMULTI);
3828 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROG)));
3829 SvREADONLY_on(sv);
3830 } while(0) /*@SWIG@*/;
3831 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3832 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROGJ", TRUE | 0x2 | GV_ADDMULTI);
3833 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROGJ)));
3834 SvREADONLY_on(sv);
3835 } while(0) /*@SWIG@*/;
3836 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3837 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLF", TRUE | 0x2 | GV_ADDMULTI);
3838 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLF)));
3839 SvREADONLY_on(sv);
3840 } while(0) /*@SWIG@*/;
3841 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3842 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLX", TRUE | 0x2 | GV_ADDMULTI);
3843 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLX)));
3844 SvREADONLY_on(sv);
3845 } while(0) /*@SWIG@*/;
3846 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3847 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLG", TRUE | 0x2 | GV_ADDMULTI);
3848 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLG)));
3849 SvREADONLY_on(sv);
3850 } while(0) /*@SWIG@*/;
3851 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3852 SV *sv = get_sv((char*) SWIG_prefix "GSL_EOF", TRUE | 0x2 | GV_ADDMULTI);
3853 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EOF)));
3854 SvREADONLY_on(sv);
3855 } while(0) /*@SWIG@*/;
3856 ST(0) = &PL_sv_yes;
3857 XSRETURN(1);
3858 }
3859
3860