--- /dev/null
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 2.0.8
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+#define SWIGPERL
+#define SWIG_CASTRANK_MODE
+
+/* -----------------------------------------------------------------------------
+ * This section contains generic SWIG labels for method/variable
+ * declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+# define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+# define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+# define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+# define SWIGINLINE inline
+# else
+# define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+# elif defined(__ICC)
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+# define SWIGUNUSEDPARM(p)
+# else
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# ifndef GCC_HASCLASSVISIBILITY
+# define GCC_HASCLASSVISIBILITY
+# endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# if defined(STATIC_LINKED)
+# define SWIGEXPORT
+# else
+# define SWIGEXPORT __declspec(dllexport)
+# endif
+# else
+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+# define SWIGEXPORT __attribute__ ((visibility("default")))
+# else
+# define SWIGEXPORT
+# endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# define SWIGSTDCALL __stdcall
+# else
+# define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+ or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+ You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+ creating a static or dynamic library from the SWIG runtime code.
+ In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+ But only do this if strictly necessary, ie, if you have problems
+ with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/* Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN 0x1
+#define SWIG_CAST_NEW_MEMORY 0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN 0x1
+
+
+/*
+ Flags/methods for returning states.
+
+ The SWIG conversion methods, as ConvertPtr, return an integer
+ that tells if the conversion was successful or not. And if not,
+ an error code can be returned (see swigerrors.swg for the codes).
+
+ Use the following macros/flags to set or process the returning
+ states.
+
+ In old versions of SWIG, code such as the following was usually written:
+
+ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+ // success code
+ } else {
+ //fail code
+ }
+
+ Now you can be more explicit:
+
+ int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+ if (SWIG_IsOK(res)) {
+ // success code
+ } else {
+ // fail code
+ }
+
+ which is the same really, but now you can also do
+
+ Type *ptr;
+ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+ if (SWIG_IsOK(res)) {
+ // success code
+ if (SWIG_IsNewObj(res) {
+ ...
+ delete *ptr;
+ } else {
+ ...
+ }
+ } else {
+ // fail code
+ }
+
+ I.e., now SWIG_ConvertPtr can return new objects and you can
+ identify the case and take care of the deallocation. Of course that
+ also requires SWIG_ConvertPtr to return new result values, such as
+
+ int SWIG_ConvertPtr(obj, ptr,...) {
+ if (<obj is ok>) {
+ if (<need new object>) {
+ *ptr = <ptr to new allocated object>;
+ return SWIG_NEWOBJ;
+ } else {
+ *ptr = <ptr to old object>;
+ return SWIG_OLDOBJ;
+ }
+ } else {
+ return SWIG_BADOBJ;
+ }
+ }
+
+ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+ SWIG errors code.
+
+ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+ allows to return the 'cast rank', for example, if you have this
+
+ int food(double)
+ int fooi(int);
+
+ and you call
+
+ food(1) // cast rank '1' (1 -> 1.0)
+ fooi(1) // cast rank '0'
+
+ just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK (0)
+#define SWIG_ERROR (-1)
+#define SWIG_IsOK(r) (r >= 0)
+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ (SWIG_ERROR)
+#define SWIG_OLDOBJ (SWIG_OK)
+#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+# ifndef SWIG_TypeRank
+# define SWIG_TypeRank unsigned long
+# endif
+# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
+# define SWIG_MAXCASTRANK (2)
+# endif
+# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
+# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+# define SWIG_AddCast
+# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+ const char *name; /* mangled name of this type */
+ const char *str; /* human readable name of this type */
+ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
+ struct swig_cast_info *cast; /* linked list of types that can cast into this type */
+ void *clientdata; /* language specific type data */
+ int owndata; /* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+ swig_type_info *type; /* pointer to type that is equivalent to this type */
+ swig_converter_func converter; /* function to cast the void pointers */
+ struct swig_cast_info *next; /* pointer to next cast in linked list */
+ struct swig_cast_info *prev; /* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
+ size_t size; /* Number of types in this module */
+ struct swig_module_info *next; /* Pointer to next element in circularly linked list */
+ swig_type_info **type_initial; /* Array of initially generated type structures */
+ swig_cast_info **cast_initial; /* Array of initially generated casting structures */
+ void *clientdata; /* Language specific module data */
+} swig_module_info;
+
+/*
+ Compare two type names skipping the space characters, therefore
+ "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+ Return 0 when the two name types are equivalent, as in
+ strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+ const char *f2, const char *l2) {
+ for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+ while ((*f1 == ' ') && (f1 != l1)) ++f1;
+ while ((*f2 == ' ') && (f2 != l2)) ++f2;
+ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+ }
+ return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+ Check type equivalence in a name list like <name1>|<name2>|...
+ Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
+}
+
+/*
+ Check type equivalence in a name list like <name1>|<name2>|...
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCompare(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
+}
+
+
+/*
+ Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (strcmp(iter->type->name, c) == 0) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
+}
+
+/*
+ Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (iter->type == from) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
+}
+
+/*
+ Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+ Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+ swig_type_info *lastty = ty;
+ if (!ty || !ty->dcast) return ty;
+ while (ty && (ty->dcast)) {
+ ty = (*ty->dcast)(ptr);
+ if (ty) lastty = ty;
+ }
+ return lastty;
+}
+
+/*
+ Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+ return ty->name;
+}
+
+/*
+ Return the pretty name associated with this type,
+ that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+ /* The "str" field contains the equivalent pretty names of the
+ type, separated by vertical-bar characters. We choose
+ to print the last name, as it is often (?) the most
+ specific. */
+ if (!type) return NULL;
+ if (type->str != NULL) {
+ const char *last_name = type->str;
+ const char *s;
+ for (s = type->str; *s; s++)
+ if (*s == '|') last_name = s+1;
+ return last_name;
+ }
+ else
+ return type->name;
+}
+
+/*
+ Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+ swig_cast_info *cast = ti->cast;
+ /* if (ti->clientdata == clientdata) return; */
+ ti->clientdata = clientdata;
+
+ while (cast) {
+ if (!cast->converter) {
+ swig_type_info *tc = cast->type;
+ if (!tc->clientdata) {
+ SWIG_TypeClientData(tc, clientdata);
+ }
+ }
+ cast = cast->next;
+ }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+ SWIG_TypeClientData(ti, clientdata);
+ ti->owndata = 1;
+}
+
+/*
+ Search for a swig_type_info structure only by mangled name
+ Search is a O(log #types)
+
+ We start searching at module start, and finish searching when start == end.
+ Note: if start == end at the beginning of the function, we go all the way around
+ the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
+ const char *name) {
+ swig_module_info *iter = start;
+ do {
+ if (iter->size) {
+ register size_t l = 0;
+ register size_t r = iter->size - 1;
+ do {
+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */
+ register size_t i = (l + r) >> 1;
+ const char *iname = iter->types[i]->name;
+ if (iname) {
+ register int compare = strcmp(name, iname);
+ if (compare == 0) {
+ return iter->types[i];
+ } else if (compare < 0) {
+ if (i) {
+ r = i - 1;
+ } else {
+ break;
+ }
+ } else if (compare > 0) {
+ l = i + 1;
+ }
+ } else {
+ break; /* should never happen */
+ }
+ } while (l <= r);
+ }
+ iter = iter->next;
+ } while (iter != end);
+ return 0;
+}
+
+/*
+ Search for a swig_type_info structure for either a mangled name or a human readable name.
+ It first searches the mangled names of the types, which is a O(log #types)
+ If a type is not found it then searches the human readable names, which is O(#types).
+
+ We start searching at module start, and finish searching when start == end.
+ Note: if start == end at the beginning of the function, we go all the way around
+ the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
+ const char *name) {
+ /* STEP 1: Search the name field using binary search */
+ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+ if (ret) {
+ return ret;
+ } else {
+ /* STEP 2: If the type hasn't been found, do a complete search
+ of the str field (the human readable name) */
+ swig_module_info *iter = start;
+ do {
+ register size_t i = 0;
+ for (; i < iter->size; ++i) {
+ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+ return iter->types[i];
+ }
+ iter = iter->next;
+ } while (iter != end);
+ }
+
+ /* neither found a match */
+ return 0;
+}
+
+/*
+ Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+ static const char hex[17] = "0123456789abcdef";
+ register const unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
+ for (; u != eu; ++u) {
+ register unsigned char uu = *u;
+ *(c++) = hex[(uu & 0xf0) >> 4];
+ *(c++) = hex[uu & 0xf];
+ }
+ return c;
+}
+
+/*
+ Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+ register unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
+ for (; u != eu; ++u) {
+ register char d = *(c++);
+ register unsigned char uu;
+ if ((d >= '0') && (d <= '9'))
+ uu = ((d - '0') << 4);
+ else if ((d >= 'a') && (d <= 'f'))
+ uu = ((d - ('a'-10)) << 4);
+ else
+ return (char *) 0;
+ d = *(c++);
+ if ((d >= '0') && (d <= '9'))
+ uu |= (d - '0');
+ else if ((d >= 'a') && (d <= 'f'))
+ uu |= (d - ('a'-10));
+ else
+ return (char *) 0;
+ *u = uu;
+ }
+ return c;
+}
+
+/*
+ Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+ char *r = buff;
+ if ((2*sizeof(void *) + 2) > bsz) return 0;
+ *(r++) = '_';
+ r = SWIG_PackData(r,&ptr,sizeof(void *));
+ if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+ strcpy(r,name);
+ return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+ if (*c != '_') {
+ if (strcmp(c,"NULL") == 0) {
+ *ptr = (void *) 0;
+ return name;
+ } else {
+ return 0;
+ }
+ }
+ return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+ char *r = buff;
+ size_t lname = (name ? strlen(name) : 0);
+ if ((2*sz + 2 + lname) > bsz) return 0;
+ *(r++) = '_';
+ r = SWIG_PackData(r,ptr,sz);
+ if (lname) {
+ strncpy(r,name,lname+1);
+ } else {
+ *r = 0;
+ }
+ return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+ if (*c != '_') {
+ if (strcmp(c,"NULL") == 0) {
+ memset(ptr,0,sz);
+ return name;
+ } else {
+ return 0;
+ }
+ }
+ return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Errors in SWIG */
+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
+#define SWIG_SystemError -10
+#define SWIG_AttributeError -11
+#define SWIG_MemoryError -12
+#define SWIG_NullReferenceError -13
+
+
+
+#ifdef __cplusplus
+/* Needed on some windows machines---since MS plays funny games with the header files under C++ */
+#include <math.h>
+#include <stdlib.h>
+extern "C" {
+#endif
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+/* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
+
+/* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
+#ifndef PERL_REVISION
+# if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
+# define PERL_PATCHLEVEL_H_IMPLICIT
+# include <patchlevel.h>
+# endif
+# if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
+# include <could_not_find_Perl_patchlevel.h>
+# endif
+# ifndef PERL_REVISION
+# define PERL_REVISION (5)
+# define PERL_VERSION PATCHLEVEL
+# define PERL_SUBVERSION SUBVERSION
+# endif
+#endif
+
+#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
+#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
+#endif
+
+#ifndef SvIOK_UV
+# define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
+#endif
+
+#ifndef SvUOK
+# define SvUOK(sv) SvIOK_UV(sv)
+#endif
+
+#if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
+# define PL_sv_undef sv_undef
+# define PL_na na
+# define PL_errgv errgv
+# define PL_sv_no sv_no
+# define PL_sv_yes sv_yes
+# define PL_markstack_ptr markstack_ptr
+#endif
+
+#ifndef IVSIZE
+# ifdef LONGSIZE
+# define IVSIZE LONGSIZE
+# else
+# define IVSIZE 4 /* A bold guess, but the best we can make. */
+# endif
+#endif
+
+#ifndef INT2PTR
+# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
+# define PTRV UV
+# define INT2PTR(any,d) (any)(d)
+# else
+# if PTRSIZE == LONGSIZE
+# define PTRV unsigned long
+# else
+# define PTRV unsigned
+# endif
+# define INT2PTR(any,d) (any)(PTRV)(d)
+# endif
+
+# define NUM2PTR(any,d) (any)(PTRV)(d)
+# define PTR2IV(p) INT2PTR(IV,p)
+# define PTR2UV(p) INT2PTR(UV,p)
+# define PTR2NV(p) NUM2PTR(NV,p)
+
+# if PTRSIZE == LONGSIZE
+# define PTR2ul(p) (unsigned long)(p)
+# else
+# define PTR2ul(p) INT2PTR(unsigned long,p)
+# endif
+#endif /* !INT2PTR */
+
+#ifndef SvPV_nolen
+# define SvPV_nolen(x) SvPV(x,PL_na)
+#endif
+
+#ifndef get_sv
+# define get_sv perl_get_sv
+#endif
+
+#ifndef ERRSV
+# define ERRSV get_sv("@",FALSE)
+#endif
+
+#ifndef pTHX_
+#define pTHX_
+#endif
+
+#include <string.h>
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+SWIGINTERN const char*
+SWIG_Perl_ErrorType(int code) {
+ switch(code) {
+ case SWIG_MemoryError:
+ return "MemoryError";
+ case SWIG_IOError:
+ return "IOError";
+ case SWIG_RuntimeError:
+ return "RuntimeError";
+ case SWIG_IndexError:
+ return "IndexError";
+ case SWIG_TypeError:
+ return "TypeError";
+ case SWIG_DivisionByZero:
+ return "ZeroDivisionError";
+ case SWIG_OverflowError:
+ return "OverflowError";
+ case SWIG_SyntaxError:
+ return "SyntaxError";
+ case SWIG_ValueError:
+ return "ValueError";
+ case SWIG_SystemError:
+ return "SystemError";
+ case SWIG_AttributeError:
+ return "AttributeError";
+ default:
+ return "RuntimeError";
+ }
+}
+
+
+/* -----------------------------------------------------------------------------
+ * perlrun.swg
+ *
+ * This file contains the runtime support for Perl modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef PERL_OBJECT
+#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
+#define SWIG_PERL_OBJECT_CALL pPerl,
+#else
+#define SWIG_PERL_OBJECT_DECL
+#define SWIG_PERL_OBJECT_CALL
+#endif
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
+#define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
+#define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata) SWIG_Perl_GetModule()
+#define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
+#define SWIG_Error(code, msg) sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
+#define SWIG_fail goto fail
+
+/* Perl-specific SWIG API */
+
+#define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
+#define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
+#define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
+
+
+#define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
+#define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
+#define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
+#define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION 0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIG_OWNER SWIG_POINTER_OWN
+#define SWIG_SHADOW SWIG_OWNER << 1
+
+#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
+
+/* SWIG Perl macros */
+
+/* Macro to declare an XS function */
+#ifndef XSPROTO
+# define XSPROTO(name) void name(pTHX_ CV* cv)
+#endif
+
+/* Macro to call an XS function */
+#ifdef PERL_OBJECT
+# define SWIG_CALLXS(_name) _name(cv,pPerl)
+#else
+# ifndef MULTIPLICITY
+# define SWIG_CALLXS(_name) _name(cv)
+# else
+# define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
+# endif
+#endif
+
+#ifdef PERL_OBJECT
+#define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+#define SWIGCLASS_STATIC
+
+#else /* PERL_OBJECT */
+
+#define MAGIC_PPERL
+#define SWIGCLASS_STATIC static SWIGUNUSED
+
+#ifndef MULTIPLICITY
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFunc)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#else /* MULTIPLICITY */
+
+#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MULTIPLICITY */
+#endif /* PERL_OBJECT */
+
+# ifdef PERL_OBJECT
+# define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
+static void SWIG_Perl_croak_null(CPerlObj *pPerl)
+# else
+static void SWIG_croak_null()
+# endif
+{
+ SV *err = get_sv("@", GV_ADD);
+# if (PERL_VERSION < 6)
+ croak("%_", err);
+# else
+ if (sv_isobject(err))
+ croak(0);
+ else
+ croak("%s", SvPV_nolen(err));
+# endif
+}
+
+
+/*
+ Define how strict is the cast between strings and integers/doubles
+ when overloading between these types occurs.
+
+ The default is making it as strict as possible by using SWIG_AddCast
+ when needed.
+
+ You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
+ disable the SWIG_AddCast, making the casting between string and
+ numbers less strict.
+
+ In the end, we try to solve the overloading between strings and
+ numerical types in the more natural way, but if you can avoid it,
+ well, avoid it using %rename, for example.
+*/
+#ifndef SWIG_PERL_NO_STRICT_STR2NUM
+# ifndef SWIG_PERL_STRICT_STR2NUM
+# define SWIG_PERL_STRICT_STR2NUM
+# endif
+#endif
+#ifdef SWIG_PERL_STRICT_STR2NUM
+/* string takes precedence */
+#define SWIG_Str2NumCast(x) SWIG_AddCast(x)
+#else
+/* number takes precedence */
+#define SWIG_Str2NumCast(x) x
+#endif
+
+
+
+#include <stdlib.h>
+
+SWIGRUNTIME const char *
+SWIG_Perl_TypeProxyName(const swig_type_info *type) {
+ if (!type) return NULL;
+ if (type->clientdata != NULL) {
+ return (const char*) type->clientdata;
+ }
+ else {
+ return type->name;
+ }
+}
+
+/* Identical to SWIG_TypeCheck, except for strcmp comparison */
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
+}
+
+/* Function for getting a pointer value */
+
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
+ swig_cast_info *tc;
+ void *voidptr = (void *)0;
+ SV *tsv = 0;
+
+ if (own)
+ *own = 0;
+
+ /* If magical, apply more magic */
+ if (SvGMAGICAL(sv))
+ mg_get(sv);
+
+ /* Check to see if this is an object */
+ if (sv_isobject(sv)) {
+ IV tmp = 0;
+ tsv = (SV*) SvRV(sv);
+ if ((SvTYPE(tsv) == SVt_PVHV)) {
+ MAGIC *mg;
+ if (SvMAGICAL(tsv)) {
+ mg = mg_find(tsv,'P');
+ if (mg) {
+ sv = mg->mg_obj;
+ if (sv_isobject(sv)) {
+ tsv = (SV*)SvRV(sv);
+ tmp = SvIV(tsv);
+ }
+ }
+ } else {
+ return SWIG_ERROR;
+ }
+ } else {
+ tmp = SvIV(tsv);
+ }
+ voidptr = INT2PTR(void *,tmp);
+ } else if (! SvOK(sv)) { /* Check for undef */
+ *(ptr) = (void *) 0;
+ return SWIG_OK;
+ } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
+ if (!SvROK(sv)) {
+ /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value. */
+ if (SvIOK(sv)) {
+ return SWIG_ERROR;
+ } else {
+ /* NULL pointer (reference to undef). */
+ *(ptr) = (void *) 0;
+ return SWIG_OK;
+ }
+ } else {
+ return SWIG_ERROR;
+ }
+ } else { /* Don't know what it is */
+ return SWIG_ERROR;
+ }
+ if (_t) {
+ /* Now see if the types match */
+ char *_c = HvNAME(SvSTASH(SvRV(sv)));
+ tc = SWIG_TypeProxyCheck(_c,_t);
+ if (!tc) {
+ return SWIG_ERROR;
+ }
+ {
+ int newmemory = 0;
+ *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
+ if (newmemory == SWIG_CAST_NEW_MEMORY) {
+ assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+ if (own)
+ *own = *own | SWIG_CAST_NEW_MEMORY;
+ }
+ }
+ } else {
+ *ptr = voidptr;
+ }
+
+ /*
+ * DISOWN implementation: we need a perl guru to check this one.
+ */
+ if (tsv && (flags & SWIG_POINTER_DISOWN)) {
+ /*
+ * almost copy paste code from below SWIG_POINTER_OWN setting
+ */
+ SV *obj = sv;
+ HV *stash = SvSTASH(SvRV(obj));
+ GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+ if (isGV(gv)) {
+ HV *hv = GvHVn(gv);
+ /*
+ * To set ownership (see below), a newSViv(1) entry is added.
+ * Hence, to remove ownership, we delete the entry.
+ */
+ if (hv_exists_ent(hv, obj, 0)) {
+ hv_delete_ent(hv, obj, 0, 0);
+ }
+ }
+ }
+ return SWIG_OK;
+}
+
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+ return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
+ if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
+ SV *self;
+ SV *obj=newSV(0);
+ HV *hash=newHV();
+ HV *stash;
+ sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
+ stash=SvSTASH(SvRV(obj));
+ if (flags & SWIG_POINTER_OWN) {
+ HV *hv;
+ GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+ if (!isGV(gv))
+ gv_init(gv, stash, "OWNER", 5, FALSE);
+ hv=GvHVn(gv);
+ hv_store_ent(hv, obj, newSViv(1), 0);
+ }
+ sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
+ SvREFCNT_dec(obj);
+ self=newRV_noinc((SV *)hash);
+ sv_setsv(sv, self);
+ SvREFCNT_dec((SV *)self);
+ sv_bless(sv, stash);
+ }
+ else {
+ sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
+ }
+}
+
+SWIGRUNTIMEINLINE SV *
+SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
+ SV *result = sv_newmortal();
+ SWIG_MakePtr(result, ptr, t, flags);
+ return result;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
+ char result[1024];
+ char *r = result;
+ if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
+ *(r++) = '_';
+ r = SWIG_PackData(r,ptr,sz);
+ strcpy(r,SWIG_Perl_TypeProxyName(type));
+ sv_setpv(sv, result);
+}
+
+SWIGRUNTIME SV *
+SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
+ SV *result = sv_newmortal();
+ SWIG_Perl_MakePackedObj(result, ptr, sz, type);
+ return result;
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
+ swig_cast_info *tc;
+ const char *c = 0;
+
+ if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
+ c = SvPV_nolen(obj);
+ /* Pointer values must start with leading underscore */
+ if (*c != '_') return SWIG_ERROR;
+ c++;
+ c = SWIG_UnpackData(c,ptr,sz);
+ if (ty) {
+ tc = SWIG_TypeCheck(c,ty);
+ if (!tc) return SWIG_ERROR;
+ }
+ return SWIG_OK;
+}
+
+
+/* Macros for low-level exception handling */
+#define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
+
+
+typedef XSPROTO(SwigPerlWrapper);
+typedef SwigPerlWrapper *SwigPerlWrapperPtr;
+
+/* Structure for command table */
+typedef struct {
+ const char *name;
+ SwigPerlWrapperPtr wrapper;
+} swig_command_info;
+
+/* Information for constant table */
+
+#define SWIG_INT 1
+#define SWIG_FLOAT 2
+#define SWIG_STRING 3
+#define SWIG_POINTER 4
+#define SWIG_BINARY 5
+
+/* Constant information structure */
+typedef struct swig_constant_info {
+ int type;
+ const char *name;
+ long lvalue;
+ double dvalue;
+ void *pvalue;
+ swig_type_info **ptype;
+} swig_constant_info;
+
+
+/* Structure for variable table */
+typedef struct {
+ const char *name;
+ SwigMagicFunc set;
+ SwigMagicFunc get;
+ swig_type_info **type;
+} swig_variable_info;
+
+/* Magic variable code */
+#ifndef PERL_OBJECT
+# ifdef __cplusplus
+# define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
+# else
+# define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
+# endif
+# ifndef MULTIPLICITY
+SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
+# else
+SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
+# endif
+#else
+# define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
+SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
+#endif
+{
+ MAGIC *mg;
+ sv_magic(sv,sv,'U',name,strlen(name));
+ mg = mg_find(sv,'U');
+ mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
+ mg->mg_virtual->svt_get = (SwigMagicFunc) get;
+ mg->mg_virtual->svt_set = (SwigMagicFunc) set;
+ mg->mg_virtual->svt_len = 0;
+ mg->mg_virtual->svt_clear = 0;
+ mg->mg_virtual->svt_free = 0;
+}
+
+
+SWIGRUNTIME swig_module_info *
+SWIG_Perl_GetModule(void) {
+ static void *type_pointer = (void *)0;
+ SV *pointer;
+
+ /* first check if pointer already created */
+ if (!type_pointer) {
+ pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
+ if (pointer && SvOK(pointer)) {
+ type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
+ }
+ }
+
+ return (swig_module_info *) type_pointer;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_SetModule(swig_module_info *module) {
+ SV *pointer;
+
+ /* create a new pointer */
+ pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
+ sv_setiv(pointer, PTR2IV(module));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Workaround perl5 global namespace pollution. Note that undefining library
+ * functions like fopen will not solve the problem on all platforms as fopen
+ * might be a macro on Windows but not necessarily on other operating systems. */
+#ifdef do_open
+ #undef do_open
+#endif
+#ifdef do_close
+ #undef do_close
+#endif
+#ifdef do_exec
+ #undef do_exec
+#endif
+#ifdef scalar
+ #undef scalar
+#endif
+#ifdef list
+ #undef list
+#endif
+#ifdef apply
+ #undef apply
+#endif
+#ifdef convert
+ #undef convert
+#endif
+#ifdef Error
+ #undef Error
+#endif
+#ifdef form
+ #undef form
+#endif
+#ifdef vform
+ #undef vform
+#endif
+#ifdef LABEL
+ #undef LABEL
+#endif
+#ifdef METHOD
+ #undef METHOD
+#endif
+#ifdef Move
+ #undef Move
+#endif
+#ifdef yylex
+ #undef yylex
+#endif
+#ifdef yyparse
+ #undef yyparse
+#endif
+#ifdef yyerror
+ #undef yyerror
+#endif
+#ifdef invert
+ #undef invert
+#endif
+#ifdef ref
+ #undef ref
+#endif
+#ifdef read
+ #undef read
+#endif
+#ifdef write
+ #undef write
+#endif
+#ifdef eof
+ #undef eof
+#endif
+#ifdef close
+ #undef close
+#endif
+#ifdef rewind
+ #undef rewind
+#endif
+#ifdef free
+ #undef free
+#endif
+#ifdef malloc
+ #undef malloc
+#endif
+#ifdef calloc
+ #undef calloc
+#endif
+#ifdef Stat
+ #undef Stat
+#endif
+#ifdef check
+ #undef check
+#endif
+#ifdef seekdir
+ #undef seekdir
+#endif
+#ifdef open
+ #undef open
+#endif
+#ifdef readdir
+ #undef readdir
+#endif
+#ifdef bind
+ #undef bind
+#endif
+#ifdef access
+ #undef access
+#endif
+#ifdef stat
+ #undef stat
+#endif
+
+#ifdef bool
+ /* Leave if macro is from C99 stdbool.h */
+ #ifndef __bool_true_false_are_defined
+ #undef bool
+ #endif
+#endif
+
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
+
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_COORDINATE swig_types[0]
+#define SWIGTYPE_p_ConcEnt swig_types[1]
+#define SWIGTYPE_p_FILE swig_types[2]
+#define SWIGTYPE_p_SOLUTION swig_types[3]
+#define SWIGTYPE_p_Tree swig_types[4]
+#define SWIGTYPE_p_bondT swig_types[5]
+#define SWIGTYPE_p_char swig_types[6]
+#define SWIGTYPE_p_cofoldF swig_types[7]
+#define SWIGTYPE_p_cpair swig_types[8]
+#define SWIGTYPE_p_double swig_types[9]
+#define SWIGTYPE_p_doubleArray swig_types[10]
+#define SWIGTYPE_p_duplexT swig_types[11]
+#define SWIGTYPE_p_float swig_types[12]
+#define SWIGTYPE_p_floatArray swig_types[13]
+#define SWIGTYPE_p_int swig_types[14]
+#define SWIGTYPE_p_intArray swig_types[15]
+#define SWIGTYPE_p_model_detailsT swig_types[16]
+#define SWIGTYPE_p_p_char swig_types[17]
+#define SWIGTYPE_p_p_double swig_types[18]
+#define SWIGTYPE_p_p_doubleArray swig_types[19]
+#define SWIGTYPE_p_p_float swig_types[20]
+#define SWIGTYPE_p_p_floatArray swig_types[21]
+#define SWIGTYPE_p_p_int swig_types[22]
+#define SWIGTYPE_p_p_intArray swig_types[23]
+#define SWIGTYPE_p_p_p_char swig_types[24]
+#define SWIGTYPE_p_p_p_short swig_types[25]
+#define SWIGTYPE_p_p_p_unsigned_short swig_types[26]
+#define SWIGTYPE_p_p_paramT swig_types[27]
+#define SWIGTYPE_p_p_plist swig_types[28]
+#define SWIGTYPE_p_p_short swig_types[29]
+#define SWIGTYPE_p_p_void swig_types[30]
+#define SWIGTYPE_p_paramT swig_types[31]
+#define SWIGTYPE_p_path_t swig_types[32]
+#define SWIGTYPE_p_pf_paramT swig_types[33]
+#define SWIGTYPE_p_plist swig_types[34]
+#define SWIGTYPE_p_short swig_types[35]
+#define SWIGTYPE_p_swString swig_types[36]
+#define SWIGTYPE_p_unsigned_int swig_types[37]
+#define SWIGTYPE_p_unsigned_short swig_types[38]
+#define SWIGTYPE_p_void swig_types[39]
+static swig_type_info *swig_types[41];
+static swig_module_info swig_module = {swig_types, 40, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init boot_RNA
+
+#define SWIG_name "RNAc::boot_RNA"
+#define SWIG_prefix "RNAc::"
+
+#define SWIGVERSION 0x020008
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) (void *)((const void *)(a))
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+#ifndef PERL_OBJECT
+#ifndef MULTIPLICITY
+SWIGEXPORT void SWIG_init (CV* cv);
+#else
+SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
+#endif
+#else
+SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
+#endif
+
+
+#include "../H/data_structures.h"
+#include "../H/utils.h"
+#include "../H/fold_vars.h"
+#undef fold
+#include "../H/fold.h"
+#include "../H/cofold.h"
+#include "../H/part_func.h"
+#include "../H/part_func_co.h"
+#include "../H/naview.h"
+#include "../H/plot_layouts.h"
+#include "../H/PS_dot.h"
+#include "../H/inverse.h"
+#include "../H/RNAstruct.h"
+#include "../H/treedist.h"
+#include "../H/stringdist.h"
+#include "../H/profiledist.h"
+#include "../H/dist_vars.h"
+#include "../H/pair_mat.h"
+#include "../H/subopt.h"
+#include "../H/energy_const.h"
+#include "../H/params.h"
+#include "../H/duplex.h"
+#include "../H/alifold.h"
+#include "../H/aln_util.h"
+#include "../H/findpath.h"
+#include "../H/Lfold.h"
+#include "../H/read_epars.h"
+
+
+
+ static int *new_intP(size_t nelements) {
+ return (int *)malloc((nelements)*sizeof(int));
+ }
+
+ static void delete_intP(int *ary) {
+ free((char*)ary);
+ }
+
+ static int intP_getitem(int *ary, size_t index) {
+ return ary[index];
+ }
+ static void intP_setitem(int *ary, size_t index, int value) {
+ ary[index] = value;
+ }
+
+
+SWIGINTERN int
+SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
+{
+ if (SvNIOK(obj)) {
+ if (val) *val = SvNV(obj);
+ return SWIG_OK;
+ } else if (SvIOK(obj)) {
+ if (val) *val = (double) SvIV(obj);
+ return SWIG_AddCast(SWIG_OK);
+ } else {
+ const char *nptr = SvPV_nolen(obj);
+ if (nptr) {
+ char *endptr;
+ double v;
+ errno = 0;
+ v = strtod(nptr, &endptr);
+ if (errno == ERANGE) {
+ errno = 0;
+ return SWIG_OverflowError;
+ } else {
+ if (*endptr == '\0') {
+ if (val) *val = v;
+ return SWIG_Str2NumCast(SWIG_OK);
+ }
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+#include <float.h>
+
+
+#include <math.h>
+
+
+SWIGINTERNINLINE int
+SWIG_CanCastAsInteger(double *d, double min, double max) {
+ double x = *d;
+ if ((min <= x && x <= max)) {
+ double fx = floor(x);
+ double cx = ceil(x);
+ double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
+ if ((errno == EDOM) || (errno == ERANGE)) {
+ errno = 0;
+ } else {
+ double summ, reps, diff;
+ if (rd < x) {
+ diff = x - rd;
+ } else if (rd > x) {
+ diff = rd - x;
+ } else {
+ return 1;
+ }
+ summ = rd + x;
+ reps = diff/summ;
+ if (reps < 8*DBL_EPSILON) {
+ *d = rd;
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
+{
+ if (SvUOK(obj)) {
+ UV v = SvUV(obj);
+ if (v <= ULONG_MAX) {
+ if (val) *val = v;
+ return SWIG_OK;
+ }
+ return SWIG_OverflowError;
+ } else if (SvIOK(obj)) {
+ IV v = SvIV(obj);
+ if (v >= 0 && v <= ULONG_MAX) {
+ if (val) *val = v;
+ return SWIG_OK;
+ }
+ return SWIG_OverflowError;
+ } else {
+ int dispatch = 0;
+ const char *nptr = SvPV_nolen(obj);
+ if (nptr) {
+ char *endptr;
+ unsigned long v;
+ errno = 0;
+ v = strtoul(nptr, &endptr,0);
+ if (errno == ERANGE) {
+ errno = 0;
+ return SWIG_OverflowError;
+ } else {
+ if (*endptr == '\0') {
+ if (val) *val = v;
+ return SWIG_Str2NumCast(SWIG_OK);
+ }
+ }
+ }
+ if (!dispatch) {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+ if (val) *val = (unsigned long)(d);
+ return res;
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
+{
+ unsigned long v;
+ int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
+ if (SWIG_IsOK(res) && val) *val = (size_t)(v);
+ return res;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
+{
+ SV *sv;
+ if (value >= IV_MIN && value <= IV_MAX)
+ sv = newSViv(value);
+ else
+ sv = newSVpvf("%ld", value);
+ return sv_2mortal(sv);
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
+{
+ return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+# define LLONG_MAX __LONG_LONG_MAX__
+# define LLONG_MIN (-LLONG_MAX - 1LL)
+# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+SWIGINTERN int
+SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
+{
+ if (SvUOK(obj)) {
+ UV v = SvUV(obj);
+ if (v <= LONG_MAX) {
+ if (val) *val = v;
+ return SWIG_OK;
+ }
+ return SWIG_OverflowError;
+ } else if (SvIOK(obj)) {
+ IV v = SvIV(obj);
+ if (v >= LONG_MIN && v <= LONG_MAX) {
+ if(val) *val = v;
+ return SWIG_OK;
+ }
+ return SWIG_OverflowError;
+ } else {
+ int dispatch = 0;
+ const char *nptr = SvPV_nolen(obj);
+ if (nptr) {
+ char *endptr;
+ long v;
+ errno = 0;
+ v = strtol(nptr, &endptr,0);
+ if (errno == ERANGE) {
+ errno = 0;
+ return SWIG_OverflowError;
+ } else {
+ if (*endptr == '\0') {
+ if (val) *val = v;
+ return SWIG_Str2NumCast(SWIG_OK);
+ }
+ }
+ }
+ if (!dispatch) {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
+ if (val) *val = (long)(d);
+ return res;
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
+{
+ long v;
+ int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < INT_MIN || v > INT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = (int)(v);
+ }
+ }
+ return res;
+}
+
+
+typedef int intArray;
+
+SWIGINTERN intArray *new_intArray(size_t nelements){
+ return (int *)malloc((nelements)*sizeof(int));
+ }
+SWIGINTERN void delete_intArray(intArray *self){
+ free((char*)self);
+ }
+SWIGINTERN int intArray_getitem(intArray *self,size_t index){
+ return self[index];
+ }
+SWIGINTERN void intArray_setitem(intArray *self,size_t index,int value){
+ self[index] = value;
+ }
+SWIGINTERN int *intArray_cast(intArray *self){
+ return self;
+ }
+SWIGINTERN intArray *intArray_frompointer(int *t){
+ return (intArray *)(t);
+ }
+
+ static float *new_floatP(size_t nelements) {
+ return (float *)malloc((nelements)*sizeof(float));
+ }
+
+ static void delete_floatP(float *ary) {
+ free((char*)ary);
+ }
+
+ static float floatP_getitem(float *ary, size_t index) {
+ return ary[index];
+ }
+ static void floatP_setitem(float *ary, size_t index, float value) {
+ ary[index] = value;
+ }
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value)
+{
+ return sv_2mortal(newSVnv(value));
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_float SWIG_PERL_DECL_ARGS_1(float value)
+{
+ return SWIG_From_double SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_float SWIG_PERL_DECL_ARGS_2(SV * obj, float *val)
+{
+ double v;
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < -FLT_MAX || v > FLT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = (float)(v);
+ }
+ }
+ return res;
+}
+
+
+typedef float floatArray;
+
+SWIGINTERN floatArray *new_floatArray(size_t nelements){
+ return (float *)malloc((nelements)*sizeof(float));
+ }
+SWIGINTERN void delete_floatArray(floatArray *self){
+ free((char*)self);
+ }
+SWIGINTERN float floatArray_getitem(floatArray *self,size_t index){
+ return self[index];
+ }
+SWIGINTERN void floatArray_setitem(floatArray *self,size_t index,float value){
+ self[index] = value;
+ }
+SWIGINTERN float *floatArray_cast(floatArray *self){
+ return self;
+ }
+SWIGINTERN floatArray *floatArray_frompointer(float *t){
+ return (floatArray *)(t);
+ }
+
+ static double *new_doubleP(size_t nelements) {
+ return (double *)malloc((nelements)*sizeof(double));
+ }
+
+ static void delete_doubleP(double *ary) {
+ free((char*)ary);
+ }
+
+ static double doubleP_getitem(double *ary, size_t index) {
+ return ary[index];
+ }
+ static void doubleP_setitem(double *ary, size_t index, double value) {
+ ary[index] = value;
+ }
+
+
+typedef double doubleArray;
+
+SWIGINTERN doubleArray *new_doubleArray(size_t nelements){
+ return (double *)malloc((nelements)*sizeof(double));
+ }
+SWIGINTERN void delete_doubleArray(doubleArray *self){
+ free((char*)self);
+ }
+SWIGINTERN double doubleArray_getitem(doubleArray *self,size_t index){
+ return self[index];
+ }
+SWIGINTERN void doubleArray_setitem(doubleArray *self,size_t index,double value){
+ self[index] = value;
+ }
+SWIGINTERN double *doubleArray_cast(doubleArray *self){
+ return self;
+ }
+SWIGINTERN doubleArray *doubleArray_frompointer(double *t){
+ return (doubleArray *)(t);
+ }
+
+ static unsigned short *new_ushortP(size_t nelements) {
+ return (unsigned short *)malloc((nelements)*sizeof(unsigned short));
+ }
+
+ static void delete_ushortP(unsigned short *ary) {
+ free((char*)ary);
+ }
+
+ static unsigned short ushortP_getitem(unsigned short *ary, size_t index) {
+ return ary[index];
+ }
+ static void ushortP_setitem(unsigned short *ary, size_t index, unsigned short value) {
+ ary[index] = value;
+ }
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_unsigned_SS_long SWIG_PERL_DECL_ARGS_1(unsigned long value)
+{
+ SV *sv;
+ if (value <= UV_MAX)
+ sv = newSVuv(value);
+ else
+ sv = newSVpvf("%lu", value);
+ return sv_2mortal(sv);
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_unsigned_SS_short SWIG_PERL_DECL_ARGS_1(unsigned short value)
+{
+ return SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_short SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned short *val)
+{
+ unsigned long v;
+ int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v > USHRT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = (unsigned short)(v);
+ }
+ }
+ return res;
+}
+
+
+ static short *new_shortP(size_t nelements) {
+ return (short *)malloc((nelements)*sizeof(short));
+ }
+
+ static void delete_shortP(short *ary) {
+ free((char*)ary);
+ }
+
+ static short shortP_getitem(short *ary, size_t index) {
+ return ary[index];
+ }
+ static void shortP_setitem(short *ary, size_t index, short value) {
+ ary[index] = value;
+ }
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_short SWIG_PERL_DECL_ARGS_1(short value)
+{
+ return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_short SWIG_PERL_DECL_ARGS_2(SV * obj, short *val)
+{
+ long v;
+ int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < SHRT_MIN || v > SHRT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = (short)(v);
+ }
+ }
+ return res;
+}
+
+
+typedef struct SWIGCDATA {
+ char *data;
+ size_t len;
+} SWIGCDATA;
+
+
+
+
+
+
+static SWIGCDATA cdata_void(void *ptr, size_t nelements)
+
+
+
+{
+ SWIGCDATA d;
+ d.data = (char *) ptr;
+
+
+
+ d.len = nelements;
+
+ return d;
+}
+
+
+
+
+
+SWIGINTERNINLINE SV *
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+ SV *obj = sv_newmortal();
+ if (carray) {
+ sv_setpvn(obj, carray, size);
+ } else {
+ sv_setsv(obj, &PL_sv_undef);
+ }
+ return obj;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+ static int init = 0;
+ static swig_type_info* info = 0;
+ if (!init) {
+ info = SWIG_TypeQuery("_p_char");
+ init = 1;
+ }
+ return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
+{
+ if (SvMAGICAL(obj)) {
+ SV *tmp = sv_newmortal();
+ SvSetSV(tmp, obj);
+ obj = tmp;
+ }
+ if (SvPOK(obj)) {
+ STRLEN len = 0;
+ char *cstr = SvPV(obj, len);
+ size_t size = len + 1;
+ if (cptr) {
+ if (alloc) {
+ if (*alloc == SWIG_NEWOBJ) {
+ *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
+ } else {
+ *cptr = cstr;
+ *alloc = SWIG_OLDOBJ;
+ }
+ }
+ }
+ if (psize) *psize = size;
+ return SWIG_OK;
+ } else {
+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+ if (pchar_descriptor) {
+ char* vptr = 0;
+ if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
+ if (cptr) *cptr = vptr;
+ if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
+ if (alloc) *alloc = SWIG_OLDOBJ;
+ return SWIG_OK;
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+ char *my_fold(char *string, char *constraints, float *energy) {
+ char *struc;
+ struc = calloc(strlen(string)+1,sizeof(char));
+ if (constraints && fold_constrained)
+ strncpy(struc, constraints, strlen(string));
+ *energy = fold(string, struc);
+ if (constraints)
+ strncpy(constraints, struc, strlen(constraints));
+ return(struc);
+ }
+
+
+
+
+
+SWIGINTERNINLINE SV *
+SWIG_FromCharPtr(const char *cptr)
+{
+ return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+ char *my_cofold(char *string, char *constraints, float *energy) {
+ char *struc;
+ struc = calloc(strlen(string)+1,sizeof(char));
+ if (constraints && fold_constrained)
+ strncpy(struc, constraints, strlen(string));
+ if (cut_point > strlen(string)) {
+ cut_point = -1;
+ }
+ *energy = cofold(string, struc);
+ if (constraints)
+ strncpy(constraints, struc, strlen(constraints));
+ return(struc);
+ }
+
+
+ char *my_pf_fold(char *string, char *constraints, float *energy) {
+ char *struc;
+ struc = calloc(strlen(string)+1,sizeof(char));
+ if (constraints && fold_constrained)
+ strncpy(struc, constraints, strlen(string));
+ *energy = pf_fold(string, struc);
+ if (constraints)
+ strncpy(constraints, struc, strlen(constraints));
+ return(struc);
+ }
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned int *val)
+{
+ unsigned long v;
+ int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v > UINT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = (unsigned int)(v);
+ }
+ }
+ return res;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_char SWIG_PERL_DECL_ARGS_1(char c)
+{
+ return SWIG_FromCharPtrAndSize(&c,1);
+}
+
+
+ char *my_co_pf_fold(char *string, char *constraints, float *FA, float *FB, float *FcAB, float *FAB) {
+ char *struc;
+ float en;
+ cofoldF temp;
+ struc = calloc(strlen(string)+1,sizeof(char));
+ if (constraints && fold_constrained)
+ strncpy(struc, constraints, strlen(string));
+ temp=co_pf_fold(string, struc);
+ *FAB = temp.FAB;
+ *FcAB = temp.FcAB;
+ *FA = temp.FA;
+ *FB = temp.FB;
+ if (constraints)
+ strncpy(constraints, struc, strlen(constraints));
+ return(struc);
+ }
+
+
+ void my_get_concentrations(double FcAB, double FcAA, double FcBB, double FEA, double FEB, double A0, double B0, double *AB, double *AA, double *BB, double *A, double *B) {
+ ConcEnt *temp;
+ double *concis;
+ concis = (double *)calloc(4,sizeof(double));
+ concis[0]=A0;
+ concis[1]=B0;
+ concis[2]=0;
+ temp=get_concentrations(FcAB,FcAA,FcBB,FEA,FEB,concis);
+ *AB=temp->ABc;
+ *AA=temp->AAc;
+ *BB=temp->BBc;
+ *A=temp->Ac;
+ *B=temp->Bc;
+ free(concis);
+ free(temp);
+ return;
+ }
+
+
+ char *my_inverse_fold(char *start, const char *target, float *cost) {
+ char *seq;
+ int n;
+ n = strlen(target);
+ seq = random_string(n, symbolset);
+ if (start)
+ strncpy(seq, start, strlen(start));
+ *cost = inverse_fold(seq, target);
+ if (start)
+ /* for backward compatibility modify start */
+ strncpy(start, seq, strlen(start));
+ return(seq);
+ }
+
+
+ char *my_inverse_pf_fold(char *start, const char *target, float *cost) {
+ char *seq;
+ int n;
+ n = strlen(target);
+ seq = random_string(n, symbolset);
+ if (start) strncpy(seq, start, n);
+ *cost = inverse_pf_fold(seq, target);
+ if (start)
+ /* for backward compatibility modify start */
+ strncpy(start, seq, strlen(start));
+ return(seq);
+ }
+
+
+SWIGINTERN int
+SWIG_AsCharArray(SV * obj, char *val, size_t size)
+{
+ char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
+ int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
+ if (SWIG_IsOK(res)) {
+ if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
+ if (csize <= size) {
+ if (val) {
+ if (csize) memcpy(val, cptr, csize*sizeof(char));
+ if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
+ }
+ if (alloc == SWIG_NEWOBJ) {
+ free((char*)cptr);
+ res = SWIG_DelNewMask(res);
+ }
+ return res;
+ }
+ if (alloc == SWIG_NEWOBJ) free((char*)cptr);
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_char SWIG_PERL_DECL_ARGS_2(SV * obj, char *val)
+{
+ int res = SWIG_AsCharArray(obj, val, 1);
+ if (!SWIG_IsOK(res)) {
+ long v;
+ res = SWIG_AddCast(SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v));
+ if (SWIG_IsOK(res)) {
+ if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
+ if (val) *val = (char)(v);
+ } else {
+ res = SWIG_OverflowError;
+ }
+ }
+ }
+ return res;
+}
+
+
+ char *my_alifold(char **strings, char *constraints, float *energy) {
+ char *struc;
+ struc = calloc(strlen(strings[0])+1,sizeof(char));
+ if (constraints && fold_constrained)
+ strncpy(struc, constraints, strlen(strings[0]));
+ *energy = alifold(strings, struc);
+ if (constraints)
+ strncpy(constraints, struc, strlen(constraints));
+ return(struc);
+ }
+
+SWIGINTERN COORDINATE *COORDINATE_get(COORDINATE *self,int i){
+ return self+i;
+ }
+
+ COORDINATE *get_xy_coordinates(const char *structure){
+ int i;
+ short *table = make_pair_table(structure);
+ short length = (short) strlen(structure);
+
+ COORDINATE *coords = (COORDINATE *) space((length+1)*sizeof(COORDINATE));
+ float *X = (float *) space((length+1)*sizeof(float));
+ float *Y = (float *) space((length+1)*sizeof(float));
+
+ switch(rna_plot_type){
+ case VRNA_PLOT_TYPE_SIMPLE: simple_xy_coordinates(table, X, Y);
+ break;
+ case VRNA_PLOT_TYPE_CIRCULAR: simple_circplot_coordinates(table, X, Y);
+ break;
+ default: naview_xy_coordinates(table, X, Y);
+ break;
+ }
+
+ for(i=0;i<=length;i++){
+ coords[i].X = X[i];
+ coords[i].Y = Y[i];
+ }
+ free(table);
+ free(X);
+ free(Y);
+ return(coords);
+ }
+
+SWIGINTERN SOLUTION *SOLUTION_get(SOLUTION *self,int i){
+// static int size=-1;
+// if (size<0) {
+// SOLUTION *s;
+// for (s=self; s->structure; s++);
+// size= (int) (s-self);
+// }
+// if (i>=size) {
+// warn("value out of range");
+// return NULL;
+// }
+ return self+i;
+ }
+SWIGINTERN int SOLUTION_size(SOLUTION *self){
+ SOLUTION *s;
+ for (s=self; s->structure; s++);
+ return (int)(s-self);
+ }
+SWIGINTERN void delete_SOLUTION(SOLUTION *self){
+ SOLUTION *s;
+ for (s=self; s->structure; s++) free(s->structure);
+ free(self);
+ }
+
+double get_pr(int i, int j) {
+ int ii;
+ if (i>j) {ii=i; i=j; j=ii;}
+ return pr[iindx[i]-j];
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_unsigned_SS_int SWIG_PERL_DECL_ARGS_1(unsigned int value)
+{
+ return SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+void *deref_any(void **ptr, int index) {
+ /* dereference arbitray pointer */
+ return (void *) ptr[index];
+}
+
+
+char *get_aligned_line(int i) {
+ i = i % 2;
+ return aligned_line[i];
+}
+
+
+ short *make_loop_index(const char *structure) {
+ /* number each position by which loop it belongs to (positions start at 0) */
+ int i,hx,l,nl;
+ int length;
+ short *stack;
+ short *loop;
+ length = strlen(structure);
+ stack = (short *) space(sizeof(short)*(length+1));
+ loop = (short *) space(sizeof(short)*(length+2));
+ hx=l=nl=0;
+ for (i=0; i<length; i++) {
+ if (structure[i] == '(') {
+ nl++; l=nl;
+ stack[hx++]=i;
+ }
+ loop[i]=l;
+ if (structure[i] ==')') {
+ --hx;
+ if (hx>0)
+ l = loop[stack[hx-1]]; /* index of enclosing loop */
+ else l=0; /* external loop has index 0 */
+ if (hx<0) {
+ fprintf(stderr, "%s\n", structure);
+ nrerror("unbalanced brackets in make_pair_table");
+ }
+ }
+ }
+ free(stack);
+ return loop;
+ }
+
+
+short *encode_seq(char *sequence) {
+ unsigned int i,l;
+ short *S;
+ l = strlen(sequence);
+ S = (short *) space(sizeof(short)*(l+2));
+ S[0] = (short) l;
+
+ /* make numerical encoding of sequence */
+ for (i=1; i<=l; i++)
+ S[i]= (short) encode_char(toupper(sequence[i-1]));
+
+ /* for circular folding add first base at position n+1 */
+ S[l+1] = S[1];
+
+ return S;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef PERL_OBJECT
+#define MAGIC_CLASS _wrap_RNA_var::
+class _wrap_RNA_var : public CPerlObj {
+public:
+#else
+#define MAGIC_CLASS
+#endif
+SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ croak("Value is read-only.");
+ return 0;
+}
+SWIGCLASS_STATIC int _wrap_logML_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""logML""' of type '""int""'");
+ }
+ logML = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_logML_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(logML))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_uniq_ML_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""uniq_ML""' of type '""int""'");
+ }
+ uniq_ML = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_uniq_ML_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(uniq_ML))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_cut_point_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""cut_point""' of type '""int""'");
+ }
+ cut_point = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_cut_point_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(cut_point))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_eos_debug_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""eos_debug""' of type '""int""'");
+ }
+ eos_debug = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_eos_debug_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(eos_debug))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_st_back_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""st_back""' of type '""int""'");
+ }
+ st_back = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_st_back_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(st_back))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_mirnatog_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""mirnatog""' of type '""int""'");
+ }
+ mirnatog = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_mirnatog_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(mirnatog))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_F_monomer_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ double *inp = 0;
+ int res = SWIG_ConvertPtr(sv, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_double, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""F_monomer""' of type '""double [2]""'");
+ } else if (inp) {
+ size_t ii = 0;
+ for (; ii < (size_t)2; ++ii) F_monomer[ii] = inp[ii];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""F_monomer""' of type '""double [2]""'");
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_F_monomer_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(F_monomer));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_symbolset_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
+ int res = SWIG_AsCharPtrAndSize(sv, &cptr, &csize, &alloc);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""symbolset""' of type '""char *""'");
+ }
+ if (symbolset) free((char*)symbolset);
+ if (alloc == SWIG_NEWOBJ) {
+ symbolset = cptr;
+ } else {
+ symbolset = csize ? (char *)(char *)memcpy((char *)malloc((csize)*sizeof(char)), cptr, sizeof(char)*(csize)) : 0;
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_symbolset_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_FromCharPtr(symbolset)) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_final_cost_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ float val;
+ int res = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""final_cost""' of type '""float""'");
+ }
+ final_cost = (float)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_final_cost_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(final_cost))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_give_up_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""give_up""' of type '""int""'");
+ }
+ give_up = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_give_up_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(give_up))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_inv_verbose_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""inv_verbose""' of type '""int""'");
+ }
+ inv_verbose = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_inv_verbose_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(inv_verbose))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_fold_constrained_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""fold_constrained""' of type '""int""'");
+ }
+ fold_constrained = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_fold_constrained_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(fold_constrained))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_noLonelyPairs_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""noLonelyPairs""' of type '""int""'");
+ }
+ noLonelyPairs = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_noLonelyPairs_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(noLonelyPairs))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_dangles_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""dangles""' of type '""int""'");
+ }
+ dangles = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_dangles_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(dangles))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_noGU_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""noGU""' of type '""int""'");
+ }
+ noGU = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_noGU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(noGU))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_no_closingGU_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""no_closingGU""' of type '""int""'");
+ }
+ no_closingGU = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_no_closingGU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(no_closingGU))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_tetra_loop_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""tetra_loop""' of type '""int""'");
+ }
+ tetra_loop = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_tetra_loop_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(tetra_loop))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_energy_set_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""energy_set""' of type '""int""'");
+ }
+ energy_set = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_energy_set_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(energy_set))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_circ_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""circ""' of type '""int""'");
+ }
+ circ = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_circ_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(circ))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_csv_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""csv""' of type '""int""'");
+ }
+ csv = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_csv_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(csv))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_oldAliEn_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""oldAliEn""' of type '""int""'");
+ }
+ oldAliEn = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_oldAliEn_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(oldAliEn))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_ribo_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""ribo""' of type '""int""'");
+ }
+ ribo = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_ribo_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(ribo))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_RibosumFile_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
+ int res = SWIG_AsCharPtrAndSize(sv, &cptr, &csize, &alloc);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""RibosumFile""' of type '""char *""'");
+ }
+ if (RibosumFile) free((char*)RibosumFile);
+ if (alloc == SWIG_NEWOBJ) {
+ RibosumFile = cptr;
+ } else {
+ RibosumFile = csize ? (char *)(char *)memcpy((char *)malloc((csize)*sizeof(char)), cptr, sizeof(char)*(csize)) : 0;
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_RibosumFile_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_FromCharPtr(RibosumFile)) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_nonstandards_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
+ int res = SWIG_AsCharPtrAndSize(sv, &cptr, &csize, &alloc);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""nonstandards""' of type '""char *""'");
+ }
+ if (nonstandards) free((char*)nonstandards);
+ if (alloc == SWIG_NEWOBJ) {
+ nonstandards = cptr;
+ } else {
+ nonstandards = csize ? (char *)(char *)memcpy((char *)malloc((csize)*sizeof(char)), cptr, sizeof(char)*(csize)) : 0;
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_nonstandards_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_FromCharPtr(nonstandards)) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_temperature_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ double val;
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""temperature""' of type '""double""'");
+ }
+ temperature = (double)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_temperature_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(temperature))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_james_rule_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""james_rule""' of type '""int""'");
+ }
+ james_rule = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_james_rule_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(james_rule))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_base_pair_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ void *argp = 0;
+ int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_bondT, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""base_pair""' of type '""bondT *""'");
+ }
+ base_pair = (bondT *)(argp);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_base_pair_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(base_pair));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_pr_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ void *argp = 0;
+ int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_double, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""pr""' of type '""double *""'");
+ }
+ pr = (double *)(argp);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_pr_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(pr));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_iindx_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ void *argp = 0;
+ int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_int, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""iindx""' of type '""int *""'");
+ }
+ iindx = (int *)(argp);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_iindx_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(iindx));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_pf_scale_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ double val;
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""pf_scale""' of type '""double""'");
+ }
+ pf_scale = (double)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_pf_scale_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(pf_scale))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_do_backtrack_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""do_backtrack""' of type '""int""'");
+ }
+ do_backtrack = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_do_backtrack_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(do_backtrack))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_backtrack_type_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ char val;
+ int res = SWIG_AsVal_char SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""backtrack_type""' of type '""char""'");
+ }
+ backtrack_type = (char)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_backtrack_type_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_char SWIG_PERL_CALL_ARGS_1((char)(backtrack_type))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_gquad_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gquad""' of type '""int""'");
+ }
+ gquad = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_gquad_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(gquad))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_cv_fact_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ double val;
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""cv_fact""' of type '""double""'");
+ }
+ cv_fact = (double)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_cv_fact_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(cv_fact))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_nc_fact_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ double val;
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""nc_fact""' of type '""double""'");
+ }
+ nc_fact = (double)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_nc_fact_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(nc_fact))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_subopt_sorted_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""subopt_sorted""' of type '""int""'");
+ }
+ subopt_sorted = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_subopt_sorted_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(subopt_sorted))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_loop_size_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int *inp = 0;
+ int res = SWIG_ConvertPtr(sv, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_int, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""loop_size""' of type '""int [1000]""'");
+ } else if (inp) {
+ size_t ii = 0;
+ for (; ii < (size_t)1000; ++ii) loop_size[ii] = inp[ii];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""loop_size""' of type '""int [1000]""'");
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_loop_size_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(loop_size));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_helix_size_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int *inp = 0;
+ int res = SWIG_ConvertPtr(sv, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_int, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""helix_size""' of type '""int [1000]""'");
+ } else if (inp) {
+ size_t ii = 0;
+ for (; ii < (size_t)1000; ++ii) helix_size[ii] = inp[ii];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""helix_size""' of type '""int [1000]""'");
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_helix_size_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(helix_size));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_loop_degree_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int *inp = 0;
+ int res = SWIG_ConvertPtr(sv, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_int, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""loop_degree""' of type '""int [1000]""'");
+ } else if (inp) {
+ size_t ii = 0;
+ for (; ii < (size_t)1000; ++ii) loop_degree[ii] = inp[ii];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""loop_degree""' of type '""int [1000]""'");
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_loop_degree_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(loop_degree));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_loops_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""loops""' of type '""int""'");
+ }
+ loops = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_loops_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(loops))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_unpaired_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""unpaired""' of type '""int""'");
+ }
+ unpaired = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_unpaired_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(unpaired))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_pairs_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""pairs""' of type '""int""'");
+ }
+ pairs = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_pairs_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(pairs))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_edit_backtrack_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""edit_backtrack""' of type '""int""'");
+ }
+ edit_backtrack = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_edit_backtrack_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(edit_backtrack))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_aligned_line_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ char * *inp = 0;
+ int res = SWIG_ConvertPtr(sv, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""aligned_line""' of type '""char *[2]""'");
+ } else if (inp) {
+ size_t ii = 0;
+ for (; ii < (size_t)2; ++ii) aligned_line[ii] = inp[ii];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""aligned_line""' of type '""char *[2]""'");
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_aligned_line_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(aligned_line));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_cost_matrix_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""cost_matrix""' of type '""int""'");
+ }
+ cost_matrix = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_cost_matrix_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(cost_matrix))) ;
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_xsubi_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ unsigned short *inp = 0;
+ int res = SWIG_ConvertPtr(sv, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_unsigned_short, 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""xsubi""' of type '""unsigned short [3]""'");
+ } else if (inp) {
+ size_t ii = 0;
+ for (; ii < (size_t)3; ++ii) xsubi[ii] = inp[ii];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""xsubi""' of type '""unsigned short [3]""'");
+ }
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_xsubi_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setiv(SvRV(sv),PTR2IV(xsubi));
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_rna_plot_type_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ {
+ int val;
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in variable '""rna_plot_type""' of type '""int""'");
+ }
+ rna_plot_type = (int)(val);
+ }
+fail:
+ return 1;
+}
+
+
+SWIGCLASS_STATIC int _wrap_rna_plot_type_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ sv_setsv(sv,SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(rna_plot_type))) ;
+ return 1;
+}
+
+
+
+
+#ifdef PERL_OBJECT
+};
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+XS(_wrap_new_intP) {
+ {
+ size_t arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ int *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_intP(nelements);");
+ }
+ ecode1 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intP" "', argument " "1"" of type '" "size_t""'");
+ }
+ arg1 = (size_t)(val1);
+ result = (int *)new_intP(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_intP) {
+ {
+ int *arg1 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_intP(ary);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intP" "', argument " "1"" of type '" "int *""'");
+ }
+ arg1 = (int *)(argp1);
+ delete_intP(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_intP_getitem) {
+ {
+ int *arg1 = (int *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: intP_getitem(ary,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intP_getitem" "', argument " "1"" of type '" "int *""'");
+ }
+ arg1 = (int *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intP_getitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (int)intP_getitem(arg1,arg2);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_intP_setitem) {
+ {
+ int *arg1 = (int *) 0 ;
+ size_t arg2 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: intP_setitem(ary,index,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intP_setitem" "', argument " "1"" of type '" "int *""'");
+ }
+ arg1 = (int *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intP_setitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intP_setitem" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ intP_setitem(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_intArray) {
+ {
+ size_t arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ intArray *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_intArray(nelements);");
+ }
+ ecode1 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "size_t""'");
+ }
+ arg1 = (size_t)(val1);
+ result = (intArray *)new_intArray(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intArray, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_intArray) {
+ {
+ intArray *arg1 = (intArray *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_intArray(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_intArray, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intArray" "', argument " "1"" of type '" "intArray *""'");
+ }
+ arg1 = (intArray *)(argp1);
+ delete_intArray(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_intArray_getitem) {
+ {
+ intArray *arg1 = (intArray *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: intArray_getitem(self,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_intArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_getitem" "', argument " "1"" of type '" "intArray *""'");
+ }
+ arg1 = (intArray *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_getitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (int)intArray_getitem(arg1,arg2);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_intArray_setitem) {
+ {
+ intArray *arg1 = (intArray *) 0 ;
+ size_t arg2 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: intArray_setitem(self,index,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_intArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_setitem" "', argument " "1"" of type '" "intArray *""'");
+ }
+ arg1 = (intArray *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_setitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_setitem" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ intArray_setitem(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_intArray_cast) {
+ {
+ intArray *arg1 = (intArray *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ int *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: intArray_cast(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_intArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_cast" "', argument " "1"" of type '" "intArray *""'");
+ }
+ arg1 = (intArray *)(argp1);
+ result = (int *)intArray_cast(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_intArray_frompointer) {
+ {
+ int *arg1 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ intArray *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: intArray_frompointer(t);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_frompointer" "', argument " "1"" of type '" "int *""'");
+ }
+ arg1 = (int *)(argp1);
+ result = (intArray *)intArray_frompointer(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intArray, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_floatP) {
+ {
+ size_t arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ float *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_floatP(nelements);");
+ }
+ ecode1 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatP" "', argument " "1"" of type '" "size_t""'");
+ }
+ arg1 = (size_t)(val1);
+ result = (float *)new_floatP(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_floatP) {
+ {
+ float *arg1 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_floatP(ary);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_floatP" "', argument " "1"" of type '" "float *""'");
+ }
+ arg1 = (float *)(argp1);
+ delete_floatP(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_floatP_getitem) {
+ {
+ float *arg1 = (float *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: floatP_getitem(ary,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatP_getitem" "', argument " "1"" of type '" "float *""'");
+ }
+ arg1 = (float *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatP_getitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (float)floatP_getitem(arg1,arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_floatP_setitem) {
+ {
+ float *arg1 = (float *) 0 ;
+ size_t arg2 ;
+ float arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ float val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: floatP_setitem(ary,index,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatP_setitem" "', argument " "1"" of type '" "float *""'");
+ }
+ arg1 = (float *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatP_setitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ ecode3 = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatP_setitem" "', argument " "3"" of type '" "float""'");
+ }
+ arg3 = (float)(val3);
+ floatP_setitem(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_floatArray) {
+ {
+ size_t arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ floatArray *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_floatArray(nelements);");
+ }
+ ecode1 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatArray" "', argument " "1"" of type '" "size_t""'");
+ }
+ arg1 = (size_t)(val1);
+ result = (floatArray *)new_floatArray(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_floatArray, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_floatArray) {
+ {
+ floatArray *arg1 = (floatArray *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_floatArray(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_floatArray, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_floatArray" "', argument " "1"" of type '" "floatArray *""'");
+ }
+ arg1 = (floatArray *)(argp1);
+ delete_floatArray(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_floatArray_getitem) {
+ {
+ floatArray *arg1 = (floatArray *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: floatArray_getitem(self,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_floatArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray_getitem" "', argument " "1"" of type '" "floatArray *""'");
+ }
+ arg1 = (floatArray *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatArray_getitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (float)floatArray_getitem(arg1,arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_floatArray_setitem) {
+ {
+ floatArray *arg1 = (floatArray *) 0 ;
+ size_t arg2 ;
+ float arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ float val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: floatArray_setitem(self,index,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_floatArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray_setitem" "', argument " "1"" of type '" "floatArray *""'");
+ }
+ arg1 = (floatArray *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatArray_setitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ ecode3 = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatArray_setitem" "', argument " "3"" of type '" "float""'");
+ }
+ arg3 = (float)(val3);
+ floatArray_setitem(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_floatArray_cast) {
+ {
+ floatArray *arg1 = (floatArray *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ float *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: floatArray_cast(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_floatArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray_cast" "', argument " "1"" of type '" "floatArray *""'");
+ }
+ arg1 = (floatArray *)(argp1);
+ result = (float *)floatArray_cast(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_floatArray_frompointer) {
+ {
+ float *arg1 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ floatArray *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: floatArray_frompointer(t);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray_frompointer" "', argument " "1"" of type '" "float *""'");
+ }
+ arg1 = (float *)(argp1);
+ result = (floatArray *)floatArray_frompointer(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_floatArray, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_doubleP) {
+ {
+ size_t arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ double *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_doubleP(nelements);");
+ }
+ ecode1 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleP" "', argument " "1"" of type '" "size_t""'");
+ }
+ arg1 = (size_t)(val1);
+ result = (double *)new_doubleP(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_doubleP) {
+ {
+ double *arg1 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_doubleP(ary);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_doubleP" "', argument " "1"" of type '" "double *""'");
+ }
+ arg1 = (double *)(argp1);
+ delete_doubleP(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_doubleP_getitem) {
+ {
+ double *arg1 = (double *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: doubleP_getitem(ary,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleP_getitem" "', argument " "1"" of type '" "double *""'");
+ }
+ arg1 = (double *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleP_getitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (double)doubleP_getitem(arg1,arg2);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_doubleP_setitem) {
+ {
+ double *arg1 = (double *) 0 ;
+ size_t arg2 ;
+ double arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: doubleP_setitem(ary,index,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleP_setitem" "', argument " "1"" of type '" "double *""'");
+ }
+ arg1 = (double *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleP_setitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleP_setitem" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ doubleP_setitem(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_doubleArray) {
+ {
+ size_t arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ doubleArray *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_doubleArray(nelements);");
+ }
+ ecode1 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "size_t""'");
+ }
+ arg1 = (size_t)(val1);
+ result = (doubleArray *)new_doubleArray(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doubleArray, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_doubleArray) {
+ {
+ doubleArray *arg1 = (doubleArray *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_doubleArray(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_doubleArray, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_doubleArray" "', argument " "1"" of type '" "doubleArray *""'");
+ }
+ arg1 = (doubleArray *)(argp1);
+ delete_doubleArray(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_doubleArray_getitem) {
+ {
+ doubleArray *arg1 = (doubleArray *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: doubleArray_getitem(self,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_doubleArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_getitem" "', argument " "1"" of type '" "doubleArray *""'");
+ }
+ arg1 = (doubleArray *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_getitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (double)doubleArray_getitem(arg1,arg2);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_doubleArray_setitem) {
+ {
+ doubleArray *arg1 = (doubleArray *) 0 ;
+ size_t arg2 ;
+ double arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: doubleArray_setitem(self,index,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_doubleArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_setitem" "', argument " "1"" of type '" "doubleArray *""'");
+ }
+ arg1 = (doubleArray *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_setitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_setitem" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ doubleArray_setitem(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_doubleArray_cast) {
+ {
+ doubleArray *arg1 = (doubleArray *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ double *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: doubleArray_cast(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_doubleArray, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_cast" "', argument " "1"" of type '" "doubleArray *""'");
+ }
+ arg1 = (doubleArray *)(argp1);
+ result = (double *)doubleArray_cast(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_doubleArray_frompointer) {
+ {
+ double *arg1 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ doubleArray *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: doubleArray_frompointer(t);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_frompointer" "', argument " "1"" of type '" "double *""'");
+ }
+ arg1 = (double *)(argp1);
+ result = (doubleArray *)doubleArray_frompointer(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doubleArray, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_ushortP) {
+ {
+ size_t arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ unsigned short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_ushortP(nelements);");
+ }
+ ecode1 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ushortP" "', argument " "1"" of type '" "size_t""'");
+ }
+ arg1 = (size_t)(val1);
+ result = (unsigned short *)new_ushortP(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_ushortP) {
+ {
+ unsigned short *arg1 = (unsigned short *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_ushortP(ary);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_unsigned_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ushortP" "', argument " "1"" of type '" "unsigned short *""'");
+ }
+ arg1 = (unsigned short *)(argp1);
+ delete_ushortP(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_ushortP_getitem) {
+ {
+ unsigned short *arg1 = (unsigned short *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ unsigned short result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ushortP_getitem(ary,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_unsigned_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ushortP_getitem" "', argument " "1"" of type '" "unsigned short *""'");
+ }
+ arg1 = (unsigned short *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ushortP_getitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (unsigned short)ushortP_getitem(arg1,arg2);
+ ST(argvi) = SWIG_From_unsigned_SS_short SWIG_PERL_CALL_ARGS_1((unsigned short)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_ushortP_setitem) {
+ {
+ unsigned short *arg1 = (unsigned short *) 0 ;
+ size_t arg2 ;
+ unsigned short arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ unsigned short val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: ushortP_setitem(ary,index,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_unsigned_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ushortP_setitem" "', argument " "1"" of type '" "unsigned short *""'");
+ }
+ arg1 = (unsigned short *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ushortP_setitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ ecode3 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ushortP_setitem" "', argument " "3"" of type '" "unsigned short""'");
+ }
+ arg3 = (unsigned short)(val3);
+ ushortP_setitem(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_shortP) {
+ {
+ size_t arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_shortP(nelements);");
+ }
+ ecode1 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_shortP" "', argument " "1"" of type '" "size_t""'");
+ }
+ arg1 = (size_t)(val1);
+ result = (short *)new_shortP(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_shortP) {
+ {
+ short *arg1 = (short *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_shortP(ary);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_shortP" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ delete_shortP(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_shortP_getitem) {
+ {
+ short *arg1 = (short *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ short result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: shortP_getitem(ary,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shortP_getitem" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shortP_getitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (short)shortP_getitem(arg1,arg2);
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1((short)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_shortP_setitem) {
+ {
+ short *arg1 = (short *) 0 ;
+ size_t arg2 ;
+ short arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: shortP_setitem(ary,index,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shortP_setitem" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shortP_setitem" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "shortP_setitem" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = (short)(val3);
+ shortP_setitem(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_cdata) {
+ {
+ void *arg1 = (void *) 0 ;
+ size_t arg2 = (size_t) 1 ;
+ int res1 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ SWIGCDATA result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: cdata(ptr,nelements);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0),SWIG_as_voidptrptr(&arg1), 0, 0);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdata" "', argument " "1"" of type '" "void *""'");
+ }
+ if (items > 1) {
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdata" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ }
+ result = cdata_void(arg1,arg2);
+ ST(argvi) = SWIG_FromCharPtrAndSize((&result)->data,(&result)->len); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_memmove) {
+ {
+ void *arg1 = (void *) 0 ;
+ void *arg2 = (void *) 0 ;
+ size_t arg3 ;
+ int res1 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ size_t size2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: memmove(data,indata,inlen);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0),SWIG_as_voidptrptr(&arg1), 0, 0);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memmove" "', argument " "1"" of type '" "void *""'");
+ }
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, &size2, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memmove" "', argument " "2"" of type '" "void const *""'");
+ }
+ arg2 = (void *)(buf2);
+ arg3 = (size_t)(size2);
+ memmove(arg1,(void const *)arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_fold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) NULL ;
+ float *arg3 = (float *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ float temp3 ;
+ int res3 = SWIG_TMPOBJ ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ arg3 = &temp3;
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: fold(string,constraints);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ if (items > 1) {
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ }
+ result = (char *)my_fold(arg1,arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (SWIG_IsTmpObj(res3)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg3)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_fold_par) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ paramT *arg3 = (paramT *) 0 ;
+ int arg4 ;
+ int arg5 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: fold_par(sequence,structure,parameters,is_constrained,is_circular);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_par" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_par" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fold_par" "', argument " "3"" of type '" "paramT *""'");
+ }
+ arg3 = (paramT *)(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_par" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_par" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ result = (float)fold_par((char const *)arg1,arg2,arg3,arg4,arg5);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_circfold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: circfold(sequence,structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "circfold" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "circfold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (float)circfold((char const *)arg1,arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: energy_of_structure(string,structure,verbosity_level);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_structure" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_structure" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_structure" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (float)energy_of_structure((char const *)arg1,(char const *)arg2,arg3);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_struct_par) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ paramT *arg3 = (paramT *) 0 ;
+ int arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: energy_of_struct_par(string,structure,parameters,verbosity_level);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_struct_par" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_struct_par" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_struct_par" "', argument " "3"" of type '" "paramT *""'");
+ }
+ arg3 = (paramT *)(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "energy_of_struct_par" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (float)energy_of_struct_par((char const *)arg1,(char const *)arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_circ_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: energy_of_circ_structure(string,structure,verbosity_level);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_circ_structure" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_circ_structure" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_circ_structure" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (float)energy_of_circ_structure((char const *)arg1,(char const *)arg2,arg3);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_circ_struct_par) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ paramT *arg3 = (paramT *) 0 ;
+ int arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: energy_of_circ_struct_par(string,structure,parameters,verbosity_level);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_circ_struct_par" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_circ_struct_par" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_circ_struct_par" "', argument " "3"" of type '" "paramT *""'");
+ }
+ arg3 = (paramT *)(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "energy_of_circ_struct_par" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (float)energy_of_circ_struct_par((char const *)arg1,(char const *)arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_gquad_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: energy_of_gquad_structure(string,structure,verbosity_level);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_gquad_structure" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_gquad_structure" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_gquad_structure" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (float)energy_of_gquad_structure((char const *)arg1,(char const *)arg2,arg3);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_structure_pt) {
+ {
+ char *arg1 = (char *) 0 ;
+ short *arg2 = (short *) 0 ;
+ short *arg3 = (short *) 0 ;
+ short *arg4 = (short *) 0 ;
+ int arg5 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: energy_of_structure_pt(string,ptable,s,s1,verbosity_level);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_structure_pt" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_structure_pt" "', argument " "2"" of type '" "short *""'");
+ }
+ arg2 = (short *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_structure_pt" "', argument " "3"" of type '" "short *""'");
+ }
+ arg3 = (short *)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "energy_of_structure_pt" "', argument " "4"" of type '" "short *""'");
+ }
+ arg4 = (short *)(argp4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "energy_of_structure_pt" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ result = (int)energy_of_structure_pt((char const *)arg1,arg2,arg3,arg4,arg5);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_struct_pt_par) {
+ {
+ char *arg1 = (char *) 0 ;
+ short *arg2 = (short *) 0 ;
+ short *arg3 = (short *) 0 ;
+ short *arg4 = (short *) 0 ;
+ paramT *arg5 = (paramT *) 0 ;
+ int arg6 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: energy_of_struct_pt_par(string,ptable,s,s1,parameters,verbosity_level);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_struct_pt_par" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_struct_pt_par" "', argument " "2"" of type '" "short *""'");
+ }
+ arg2 = (short *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_struct_pt_par" "', argument " "3"" of type '" "short *""'");
+ }
+ arg3 = (short *)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "energy_of_struct_pt_par" "', argument " "4"" of type '" "short *""'");
+ }
+ arg4 = (short *)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "energy_of_struct_pt_par" "', argument " "5"" of type '" "paramT *""'");
+ }
+ arg5 = (paramT *)(argp5);
+ ecode6 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "energy_of_struct_pt_par" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ result = (int)energy_of_struct_pt_par((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_arrays) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: free_arrays();");
+ }
+ free_arrays();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_parenthesis_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ bondT *arg2 = (bondT *) 0 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: parenthesis_structure(structure,bp,length);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parenthesis_structure" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_bondT, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parenthesis_structure" "', argument " "2"" of type '" "bondT *""'");
+ }
+ arg2 = (bondT *)(argp2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parenthesis_structure" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ parenthesis_structure(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_parenthesis_zuker) {
+ {
+ char *arg1 = (char *) 0 ;
+ bondT *arg2 = (bondT *) 0 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: parenthesis_zuker(structure,bp,length);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parenthesis_zuker" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_bondT, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parenthesis_zuker" "', argument " "2"" of type '" "bondT *""'");
+ }
+ arg2 = (bondT *)(argp2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parenthesis_zuker" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ parenthesis_zuker(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_letter_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ bondT *arg2 = (bondT *) 0 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: letter_structure(structure,bp,length);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "letter_structure" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_bondT, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "letter_structure" "', argument " "2"" of type '" "bondT *""'");
+ }
+ arg2 = (bondT *)(argp2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "letter_structure" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ letter_structure(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_fold_params) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: update_fold_params();");
+ }
+ update_fold_params();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_fold_params_par) {
+ {
+ paramT *arg1 = (paramT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: update_fold_params_par(parameters);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "update_fold_params_par" "', argument " "1"" of type '" "paramT *""'");
+ }
+ arg1 = (paramT *)(argp1);
+ update_fold_params_par(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_backtrack_fold_from_pair) {
+ {
+ char *arg1 = (char *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: backtrack_fold_from_pair(sequence,i,j);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "backtrack_fold_from_pair" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "backtrack_fold_from_pair" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "backtrack_fold_from_pair" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (char *)backtrack_fold_from_pair(arg1,arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_move) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ int arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: energy_of_move(string,structure,m1,m2);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_move" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_move" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_move" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "energy_of_move" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (float)energy_of_move((char const *)arg1,(char const *)arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_move_pt) {
+ {
+ short *arg1 = (short *) 0 ;
+ short *arg2 = (short *) 0 ;
+ short *arg3 = (short *) 0 ;
+ int arg4 ;
+ int arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: energy_of_move_pt(pt,s,s1,m1,m2);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_move_pt" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_move_pt" "', argument " "2"" of type '" "short *""'");
+ }
+ arg2 = (short *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_move_pt" "', argument " "3"" of type '" "short *""'");
+ }
+ arg3 = (short *)(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "energy_of_move_pt" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "energy_of_move_pt" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ result = (int)energy_of_move_pt(arg1,arg2,arg3,arg4,arg5);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_loop_energy) {
+ {
+ short *arg1 = (short *) 0 ;
+ short *arg2 = (short *) 0 ;
+ short *arg3 = (short *) 0 ;
+ int arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: loop_energy(ptable,s,s1,i);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loop_energy" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loop_energy" "', argument " "2"" of type '" "short *""'");
+ }
+ arg2 = (short *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "loop_energy" "', argument " "3"" of type '" "short *""'");
+ }
+ arg3 = (short *)(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "loop_energy" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (int)loop_energy(arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_fold_arrays) {
+ {
+ int **arg1 = (int **) 0 ;
+ int **arg2 = (int **) 0 ;
+ int **arg3 = (int **) 0 ;
+ int **arg4 = (int **) 0 ;
+ int **arg5 = (int **) 0 ;
+ char **arg6 = (char **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: export_fold_arrays(f5_p,c_p,fML_p,fM1_p,indx_p,ptype_p);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "export_fold_arrays" "', argument " "1"" of type '" "int **""'");
+ }
+ arg1 = (int **)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "export_fold_arrays" "', argument " "2"" of type '" "int **""'");
+ }
+ arg2 = (int **)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "export_fold_arrays" "', argument " "3"" of type '" "int **""'");
+ }
+ arg3 = (int **)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "export_fold_arrays" "', argument " "4"" of type '" "int **""'");
+ }
+ arg4 = (int **)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "export_fold_arrays" "', argument " "5"" of type '" "int **""'");
+ }
+ arg5 = (int **)(argp5);
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(5)))
+ croak("Argument 6 is not a reference.");
+ if (SvTYPE(SvRV(ST(5))) != SVt_PVAV)
+ croak("Argument 6 is not an array.");
+ tempav = (AV*)SvRV(ST(5));
+ len = av_len(tempav);
+ arg6 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg6[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg6[i] = NULL;
+ }
+ export_fold_arrays(arg1,arg2,arg3,arg4,arg5,arg6);
+ ST(argvi) = sv_newmortal();
+
+
+
+
+
+ {
+ free(arg6);
+ }
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+ {
+ free(arg6);
+ }
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_fold_arrays_par) {
+ {
+ int **arg1 = (int **) 0 ;
+ int **arg2 = (int **) 0 ;
+ int **arg3 = (int **) 0 ;
+ int **arg4 = (int **) 0 ;
+ int **arg5 = (int **) 0 ;
+ char **arg6 = (char **) 0 ;
+ paramT **arg7 = (paramT **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 7) || (items > 7)) {
+ SWIG_croak("Usage: export_fold_arrays_par(f5_p,c_p,fML_p,fM1_p,indx_p,ptype_p,P_p);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "export_fold_arrays_par" "', argument " "1"" of type '" "int **""'");
+ }
+ arg1 = (int **)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "export_fold_arrays_par" "', argument " "2"" of type '" "int **""'");
+ }
+ arg2 = (int **)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "export_fold_arrays_par" "', argument " "3"" of type '" "int **""'");
+ }
+ arg3 = (int **)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "export_fold_arrays_par" "', argument " "4"" of type '" "int **""'");
+ }
+ arg4 = (int **)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "export_fold_arrays_par" "', argument " "5"" of type '" "int **""'");
+ }
+ arg5 = (int **)(argp5);
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(5)))
+ croak("Argument 6 is not a reference.");
+ if (SvTYPE(SvRV(ST(5))) != SVt_PVAV)
+ croak("Argument 6 is not an array.");
+ tempav = (AV*)SvRV(ST(5));
+ len = av_len(tempav);
+ arg6 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg6[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg6[i] = NULL;
+ }
+ res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "export_fold_arrays_par" "', argument " "7"" of type '" "paramT **""'");
+ }
+ arg7 = (paramT **)(argp7);
+ export_fold_arrays_par(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ ST(argvi) = sv_newmortal();
+
+
+
+
+
+ {
+ free(arg6);
+ }
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+ {
+ free(arg6);
+ }
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_circfold_arrays) {
+ {
+ int *arg1 = (int *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ int **arg5 = (int **) 0 ;
+ int **arg6 = (int **) 0 ;
+ int **arg7 = (int **) 0 ;
+ int **arg8 = (int **) 0 ;
+ int **arg9 = (int **) 0 ;
+ int **arg10 = (int **) 0 ;
+ char **arg11 = (char **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 11) || (items > 11)) {
+ SWIG_croak("Usage: export_circfold_arrays(Fc_p,FcH_p,FcI_p,FcM_p,fM2_p,f5_p,c_p,fML_p,fM1_p,indx_p,ptype_p);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "export_circfold_arrays" "', argument " "1"" of type '" "int *""'");
+ }
+ arg1 = (int *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "export_circfold_arrays" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "export_circfold_arrays" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "export_circfold_arrays" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "export_circfold_arrays" "', argument " "5"" of type '" "int **""'");
+ }
+ arg5 = (int **)(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "export_circfold_arrays" "', argument " "6"" of type '" "int **""'");
+ }
+ arg6 = (int **)(argp6);
+ res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "export_circfold_arrays" "', argument " "7"" of type '" "int **""'");
+ }
+ arg7 = (int **)(argp7);
+ res8 = SWIG_ConvertPtr(ST(7), &argp8,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "export_circfold_arrays" "', argument " "8"" of type '" "int **""'");
+ }
+ arg8 = (int **)(argp8);
+ res9 = SWIG_ConvertPtr(ST(8), &argp9,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "export_circfold_arrays" "', argument " "9"" of type '" "int **""'");
+ }
+ arg9 = (int **)(argp9);
+ res10 = SWIG_ConvertPtr(ST(9), &argp10,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "export_circfold_arrays" "', argument " "10"" of type '" "int **""'");
+ }
+ arg10 = (int **)(argp10);
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(10)))
+ croak("Argument 11 is not a reference.");
+ if (SvTYPE(SvRV(ST(10))) != SVt_PVAV)
+ croak("Argument 11 is not an array.");
+ tempav = (AV*)SvRV(ST(10));
+ len = av_len(tempav);
+ arg11 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg11[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg11[i] = NULL;
+ }
+ export_circfold_arrays(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+ ST(argvi) = sv_newmortal();
+
+
+
+
+
+
+
+
+
+
+ {
+ free(arg11);
+ }
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+
+
+
+
+ {
+ free(arg11);
+ }
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_circfold_arrays_par) {
+ {
+ int *arg1 = (int *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ int **arg5 = (int **) 0 ;
+ int **arg6 = (int **) 0 ;
+ int **arg7 = (int **) 0 ;
+ int **arg8 = (int **) 0 ;
+ int **arg9 = (int **) 0 ;
+ int **arg10 = (int **) 0 ;
+ char **arg11 = (char **) 0 ;
+ paramT **arg12 = (paramT **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ void *argp12 = 0 ;
+ int res12 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 12) || (items > 12)) {
+ SWIG_croak("Usage: export_circfold_arrays_par(Fc_p,FcH_p,FcI_p,FcM_p,fM2_p,f5_p,c_p,fML_p,fM1_p,indx_p,ptype_p,P_p);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "export_circfold_arrays_par" "', argument " "1"" of type '" "int *""'");
+ }
+ arg1 = (int *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "export_circfold_arrays_par" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "export_circfold_arrays_par" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "export_circfold_arrays_par" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "export_circfold_arrays_par" "', argument " "5"" of type '" "int **""'");
+ }
+ arg5 = (int **)(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "export_circfold_arrays_par" "', argument " "6"" of type '" "int **""'");
+ }
+ arg6 = (int **)(argp6);
+ res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "export_circfold_arrays_par" "', argument " "7"" of type '" "int **""'");
+ }
+ arg7 = (int **)(argp7);
+ res8 = SWIG_ConvertPtr(ST(7), &argp8,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "export_circfold_arrays_par" "', argument " "8"" of type '" "int **""'");
+ }
+ arg8 = (int **)(argp8);
+ res9 = SWIG_ConvertPtr(ST(8), &argp9,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "export_circfold_arrays_par" "', argument " "9"" of type '" "int **""'");
+ }
+ arg9 = (int **)(argp9);
+ res10 = SWIG_ConvertPtr(ST(9), &argp10,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "export_circfold_arrays_par" "', argument " "10"" of type '" "int **""'");
+ }
+ arg10 = (int **)(argp10);
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(10)))
+ croak("Argument 11 is not a reference.");
+ if (SvTYPE(SvRV(ST(10))) != SVt_PVAV)
+ croak("Argument 11 is not an array.");
+ tempav = (AV*)SvRV(ST(10));
+ len = av_len(tempav);
+ arg11 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg11[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg11[i] = NULL;
+ }
+ res12 = SWIG_ConvertPtr(ST(11), &argp12,SWIGTYPE_p_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res12)) {
+ SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "export_circfold_arrays_par" "', argument " "12"" of type '" "paramT **""'");
+ }
+ arg12 = (paramT **)(argp12);
+ export_circfold_arrays_par(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+ ST(argvi) = sv_newmortal();
+
+
+
+
+
+
+
+
+
+
+ {
+ free(arg11);
+ }
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+
+
+
+
+ {
+ free(arg11);
+ }
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_assign_plist_from_db) {
+ {
+ plist **arg1 = (plist **) 0 ;
+ char *arg2 = (char *) 0 ;
+ float arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ float val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: assign_plist_from_db(pl,struc,pr);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "assign_plist_from_db" "', argument " "1"" of type '" "plist **""'");
+ }
+ arg1 = (plist **)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "assign_plist_from_db" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "assign_plist_from_db" "', argument " "3"" of type '" "float""'");
+ }
+ arg3 = (float)(val3);
+ assign_plist_from_db(arg1,(char const *)arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_LoopEnergy) {
+ {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int arg5 ;
+ int arg6 ;
+ int arg7 ;
+ int arg8 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ int val8 ;
+ int ecode8 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 8) || (items > 8)) {
+ SWIG_croak("Usage: LoopEnergy(n1,n2,type,type_2,si1,sj1,sp1,sq1);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LoopEnergy" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopEnergy" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopEnergy" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LoopEnergy" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LoopEnergy" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ ecode6 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LoopEnergy" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ ecode7 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LoopEnergy" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ ecode8 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LoopEnergy" "', argument " "8"" of type '" "int""'");
+ }
+ arg8 = (int)(val8);
+ result = (int)LoopEnergy(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_HairpinE) {
+ {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ char *arg5 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: HairpinE(size,type,si1,sj1,string);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "HairpinE" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HairpinE" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HairpinE" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HairpinE" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HairpinE" "', argument " "5"" of type '" "char const *""'");
+ }
+ arg5 = (char *)(buf5);
+ result = (int)HairpinE(arg1,arg2,arg3,arg4,(char const *)arg5);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+
+
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_initialize_fold) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: initialize_fold(length);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "initialize_fold" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ initialize_fold(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_struct) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: energy_of_struct(string,structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_struct" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_struct" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (float)energy_of_struct((char const *)arg1,(char const *)arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_struct_pt) {
+ {
+ char *arg1 = (char *) 0 ;
+ short *arg2 = (short *) 0 ;
+ short *arg3 = (short *) 0 ;
+ short *arg4 = (short *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: energy_of_struct_pt(string,ptable,s,s1);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_struct_pt" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_struct_pt" "', argument " "2"" of type '" "short *""'");
+ }
+ arg2 = (short *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_struct_pt" "', argument " "3"" of type '" "short *""'");
+ }
+ arg3 = (short *)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "energy_of_struct_pt" "', argument " "4"" of type '" "short *""'");
+ }
+ arg4 = (short *)(argp4);
+ result = (int)energy_of_struct_pt((char const *)arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_circ_struct) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: energy_of_circ_struct(string,structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_circ_struct" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_circ_struct" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (float)energy_of_circ_struct((char const *)arg1,(char const *)arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_cofold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) NULL ;
+ float *arg3 = (float *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ float temp3 ;
+ int res3 = SWIG_TMPOBJ ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ arg3 = &temp3;
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: cofold(string,constraints);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cofold" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ if (items > 1) {
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cofold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ }
+ result = (char *)my_cofold(arg1,arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (SWIG_IsTmpObj(res3)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg3)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_cofold_par) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ paramT *arg3 = (paramT *) 0 ;
+ int arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: cofold_par(string,structure,parameters,is_constrained);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cofold_par" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cofold_par" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cofold_par" "', argument " "3"" of type '" "paramT *""'");
+ }
+ arg3 = (paramT *)(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cofold_par" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (float)cofold_par((char const *)arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_co_arrays) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: free_co_arrays();");
+ }
+ free_co_arrays();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_cofold_params) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: update_cofold_params();");
+ }
+ update_cofold_params();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_cofold_params_par) {
+ {
+ paramT *arg1 = (paramT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: update_cofold_params_par(parameters);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "update_cofold_params_par" "', argument " "1"" of type '" "paramT *""'");
+ }
+ arg1 = (paramT *)(argp1);
+ update_cofold_params_par(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_cofold_arrays_gq) {
+ {
+ int **arg1 = (int **) 0 ;
+ int **arg2 = (int **) 0 ;
+ int **arg3 = (int **) 0 ;
+ int **arg4 = (int **) 0 ;
+ int **arg5 = (int **) 0 ;
+ int **arg6 = (int **) 0 ;
+ int **arg7 = (int **) 0 ;
+ char **arg8 = (char **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 8) || (items > 8)) {
+ SWIG_croak("Usage: export_cofold_arrays_gq(f5_p,c_p,fML_p,fM1_p,fc_p,ggg_p,indx_p,ptype_p);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "export_cofold_arrays_gq" "', argument " "1"" of type '" "int **""'");
+ }
+ arg1 = (int **)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "export_cofold_arrays_gq" "', argument " "2"" of type '" "int **""'");
+ }
+ arg2 = (int **)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "export_cofold_arrays_gq" "', argument " "3"" of type '" "int **""'");
+ }
+ arg3 = (int **)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "export_cofold_arrays_gq" "', argument " "4"" of type '" "int **""'");
+ }
+ arg4 = (int **)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "export_cofold_arrays_gq" "', argument " "5"" of type '" "int **""'");
+ }
+ arg5 = (int **)(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "export_cofold_arrays_gq" "', argument " "6"" of type '" "int **""'");
+ }
+ arg6 = (int **)(argp6);
+ res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "export_cofold_arrays_gq" "', argument " "7"" of type '" "int **""'");
+ }
+ arg7 = (int **)(argp7);
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(7)))
+ croak("Argument 8 is not a reference.");
+ if (SvTYPE(SvRV(ST(7))) != SVt_PVAV)
+ croak("Argument 8 is not an array.");
+ tempav = (AV*)SvRV(ST(7));
+ len = av_len(tempav);
+ arg8 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg8[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg8[i] = NULL;
+ }
+ export_cofold_arrays_gq(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+ ST(argvi) = sv_newmortal();
+
+
+
+
+
+
+
+ {
+ free(arg8);
+ }
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+
+ {
+ free(arg8);
+ }
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_cofold_arrays) {
+ {
+ int **arg1 = (int **) 0 ;
+ int **arg2 = (int **) 0 ;
+ int **arg3 = (int **) 0 ;
+ int **arg4 = (int **) 0 ;
+ int **arg5 = (int **) 0 ;
+ int **arg6 = (int **) 0 ;
+ char **arg7 = (char **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 7) || (items > 7)) {
+ SWIG_croak("Usage: export_cofold_arrays(f5_p,c_p,fML_p,fM1_p,fc_p,indx_p,ptype_p);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "export_cofold_arrays" "', argument " "1"" of type '" "int **""'");
+ }
+ arg1 = (int **)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "export_cofold_arrays" "', argument " "2"" of type '" "int **""'");
+ }
+ arg2 = (int **)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "export_cofold_arrays" "', argument " "3"" of type '" "int **""'");
+ }
+ arg3 = (int **)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "export_cofold_arrays" "', argument " "4"" of type '" "int **""'");
+ }
+ arg4 = (int **)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "export_cofold_arrays" "', argument " "5"" of type '" "int **""'");
+ }
+ arg5 = (int **)(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "export_cofold_arrays" "', argument " "6"" of type '" "int **""'");
+ }
+ arg6 = (int **)(argp6);
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(6)))
+ croak("Argument 7 is not a reference.");
+ if (SvTYPE(SvRV(ST(6))) != SVt_PVAV)
+ croak("Argument 7 is not an array.");
+ tempav = (AV*)SvRV(ST(6));
+ len = av_len(tempav);
+ arg7 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg7[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg7[i] = NULL;
+ }
+ export_cofold_arrays(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ ST(argvi) = sv_newmortal();
+
+
+
+
+
+
+ {
+ free(arg7);
+ }
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+ {
+ free(arg7);
+ }
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_zukersubopt) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ SOLUTION *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: zukersubopt(string);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zukersubopt" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (SOLUTION *)zukersubopt((char const *)arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 | SWIG_SHADOW); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_zukersubopt_par) {
+ {
+ char *arg1 = (char *) 0 ;
+ paramT *arg2 = (paramT *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ SOLUTION *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: zukersubopt_par(string,parameters);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zukersubopt_par" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zukersubopt_par" "', argument " "2"" of type '" "paramT *""'");
+ }
+ arg2 = (paramT *)(argp2);
+ result = (SOLUTION *)zukersubopt_par((char const *)arg1,arg2);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 | SWIG_SHADOW); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_monomere_mfes) {
+ {
+ float *arg1 = (float *) 0 ;
+ float *arg2 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: get_monomere_mfes(e1,e2);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_monomere_mfes" "', argument " "1"" of type '" "float *""'");
+ }
+ arg1 = (float *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_monomere_mfes" "', argument " "2"" of type '" "float *""'");
+ }
+ arg2 = (float *)(argp2);
+ get_monomere_mfes(arg1,arg2);
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_initialize_cofold) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: initialize_cofold(length);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "initialize_cofold" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ initialize_cofold(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_pf_fold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) NULL ;
+ float *arg3 = (float *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ float temp3 ;
+ int res3 = SWIG_TMPOBJ ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ arg3 = &temp3;
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: pf_fold(string,constraints);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pf_fold" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ if (items > 1) {
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pf_fold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ }
+ result = (char *)my_pf_fold(arg1,arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (SWIG_IsTmpObj(res3)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg3)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_pf_fold_par) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ pf_paramT *arg3 = (pf_paramT *) 0 ;
+ int arg4 ;
+ int arg5 ;
+ int arg6 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: pf_fold_par(sequence,structure,parameters,calculate_bppm,is_constrained,is_circular);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pf_fold_par" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pf_fold_par" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_pf_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pf_fold_par" "', argument " "3"" of type '" "pf_paramT *""'");
+ }
+ arg3 = (pf_paramT *)(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pf_fold_par" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pf_fold_par" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ ecode6 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pf_fold_par" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ result = (float)pf_fold_par((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_pf_circ_fold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: pf_circ_fold(sequence,structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pf_circ_fold" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pf_circ_fold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (float)pf_circ_fold((char const *)arg1,arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_pbacktrack) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: pbacktrack(sequence);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pbacktrack" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)pbacktrack(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_pbacktrack_circ) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: pbacktrack_circ(sequence);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pbacktrack_circ" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)pbacktrack_circ(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_pf_arrays) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: free_pf_arrays();");
+ }
+ free_pf_arrays();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_pf_params) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: update_pf_params(length);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "update_pf_params" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ update_pf_params(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_pf_params_par) {
+ {
+ int arg1 ;
+ pf_paramT *arg2 = (pf_paramT *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: update_pf_params_par(length,parameters);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "update_pf_params_par" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_pf_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "update_pf_params_par" "', argument " "2"" of type '" "pf_paramT *""'");
+ }
+ arg2 = (pf_paramT *)(argp2);
+ update_pf_params_par(arg1,arg2);
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_bppm) {
+ {
+ int argvi = 0;
+ double *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: export_bppm();");
+ }
+ result = (double *)export_bppm();
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_assign_plist_from_pr) {
+ {
+ plist **arg1 = (plist **) 0 ;
+ double *arg2 = (double *) 0 ;
+ int arg3 ;
+ double arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: assign_plist_from_pr(pl,probs,length,cutoff);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "assign_plist_from_pr" "', argument " "1"" of type '" "plist **""'");
+ }
+ arg1 = (plist **)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "assign_plist_from_pr" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "assign_plist_from_pr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "assign_plist_from_pr" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ assign_plist_from_pr(arg1,arg2,arg3,arg4);
+ ST(argvi) = sv_newmortal();
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_assign_plist_gquad_from_pr) {
+ {
+ plist **arg1 = (plist **) 0 ;
+ int arg2 ;
+ double arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: assign_plist_gquad_from_pr(pl,length,cut_off);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "assign_plist_gquad_from_pr" "', argument " "1"" of type '" "plist **""'");
+ }
+ arg1 = (plist **)(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "assign_plist_gquad_from_pr" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "assign_plist_gquad_from_pr" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ assign_plist_gquad_from_pr(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_centroid_struct_gquad_pr) {
+ {
+ int arg1 ;
+ double *arg2 = (double *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: get_centroid_struct_gquad_pr(length,dist);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_centroid_struct_gquad_pr" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_centroid_struct_gquad_pr" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ result = (char *)get_centroid_struct_gquad_pr(arg1,arg2);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_pf_arrays) {
+ {
+ short **arg1 = (short **) 0 ;
+ short **arg2 = (short **) 0 ;
+ char **arg3 = (char **) 0 ;
+ double **arg4 = (double **) 0 ;
+ double **arg5 = (double **) 0 ;
+ double **arg6 = (double **) 0 ;
+ double **arg7 = (double **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 7) || (items > 7)) {
+ SWIG_croak("Usage: get_pf_arrays(S_p,S1_p,ptype_p,qb_p,qm_p,q1k_p,qln_p);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_pf_arrays" "', argument " "1"" of type '" "short **""'");
+ }
+ arg1 = (short **)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_pf_arrays" "', argument " "2"" of type '" "short **""'");
+ }
+ arg2 = (short **)(argp2);
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(2)))
+ croak("Argument 3 is not a reference.");
+ if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
+ croak("Argument 3 is not an array.");
+ tempav = (AV*)SvRV(ST(2));
+ len = av_len(tempav);
+ arg3 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg3[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg3[i] = NULL;
+ }
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_pf_arrays" "', argument " "4"" of type '" "double **""'");
+ }
+ arg4 = (double **)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "get_pf_arrays" "', argument " "5"" of type '" "double **""'");
+ }
+ arg5 = (double **)(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "get_pf_arrays" "', argument " "6"" of type '" "double **""'");
+ }
+ arg6 = (double **)(argp6);
+ res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "get_pf_arrays" "', argument " "7"" of type '" "double **""'");
+ }
+ arg7 = (double **)(argp7);
+ result = (int)get_pf_arrays(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+ {
+ free(arg3);
+ }
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ {
+ free(arg3);
+ }
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_subseq_F) {
+ {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: get_subseq_F(i,j);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_subseq_F" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_subseq_F" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (double)get_subseq_F(arg1,arg2);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_centroid_struct_pl) {
+ {
+ int arg1 ;
+ double *arg2 = (double *) 0 ;
+ plist *arg3 = (plist *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: get_centroid_struct_pl(length,dist,pl);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_centroid_struct_pl" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_centroid_struct_pl" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_centroid_struct_pl" "', argument " "3"" of type '" "plist *""'");
+ }
+ arg3 = (plist *)(argp3);
+ result = (char *)get_centroid_struct_pl(arg1,arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_centroid_struct_pr) {
+ {
+ int arg1 ;
+ double *arg2 = (double *) 0 ;
+ double *arg3 = (double *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: get_centroid_struct_pr(length,dist,pr);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_centroid_struct_pr" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_centroid_struct_pr" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_centroid_struct_pr" "', argument " "3"" of type '" "double *""'");
+ }
+ arg3 = (double *)(argp3);
+ result = (char *)get_centroid_struct_pr(arg1,arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_mean_bp_distance) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: mean_bp_distance(length);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mean_bp_distance" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (double)mean_bp_distance(arg1);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_mean_bp_distance_pr) {
+ {
+ int arg1 ;
+ double *arg2 = (double *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: mean_bp_distance_pr(length,pr);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mean_bp_distance_pr" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mean_bp_distance_pr" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ result = (double)mean_bp_distance_pr(arg1,arg2);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_bppm_to_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ double *arg2 = (double *) 0 ;
+ unsigned int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: bppm_to_structure(structure,pr,length);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bppm_to_structure" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bppm_to_structure" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bppm_to_structure" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = (unsigned int)(val3);
+ bppm_to_structure(arg1,arg2,arg3);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_stackProb) {
+ {
+ double arg1 ;
+ double val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ plist *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: stackProb(cutoff);");
+ }
+ ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "stackProb" "', argument " "1"" of type '" "double""'");
+ }
+ arg1 = (double)(val1);
+ result = (plist *)stackProb(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_plist, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_bppm_symbol) {
+ {
+ float *arg1 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ char result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: bppm_symbol(x);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bppm_symbol" "', argument " "1"" of type '" "float const *""'");
+ }
+ arg1 = (float *)(argp1);
+ result = (char)bppm_symbol((float const *)arg1);
+ ST(argvi) = SWIG_From_char SWIG_PERL_CALL_ARGS_1((char)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_init_pf_fold) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: init_pf_fold(length);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "init_pf_fold" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ init_pf_fold(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_centroid) {
+ {
+ int arg1 ;
+ double *arg2 = (double *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: centroid(length,dist);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "centroid" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "centroid" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ result = (char *)centroid(arg1,arg2);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_mean_bp_dist) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: mean_bp_dist(length);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mean_bp_dist" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (double)mean_bp_dist(arg1);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_expLoopEnergy) {
+ {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ short arg5 ;
+ short arg6 ;
+ short arg7 ;
+ short arg8 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ short val5 ;
+ int ecode5 = 0 ;
+ short val6 ;
+ int ecode6 = 0 ;
+ short val7 ;
+ int ecode7 = 0 ;
+ short val8 ;
+ int ecode8 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 8) || (items > 8)) {
+ SWIG_croak("Usage: expLoopEnergy(u1,u2,type,type2,si1,sj1,sp1,sq1);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "expLoopEnergy" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "expLoopEnergy" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "expLoopEnergy" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "expLoopEnergy" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "expLoopEnergy" "', argument " "5"" of type '" "short""'");
+ }
+ arg5 = (short)(val5);
+ ecode6 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "expLoopEnergy" "', argument " "6"" of type '" "short""'");
+ }
+ arg6 = (short)(val6);
+ ecode7 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "expLoopEnergy" "', argument " "7"" of type '" "short""'");
+ }
+ arg7 = (short)(val7);
+ ecode8 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "expLoopEnergy" "', argument " "8"" of type '" "short""'");
+ }
+ arg8 = (short)(val8);
+ result = (double)expLoopEnergy(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+
+
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_expHairpinEnergy) {
+ {
+ int arg1 ;
+ int arg2 ;
+ short arg3 ;
+ short arg4 ;
+ char *arg5 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ short val4 ;
+ int ecode4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: expHairpinEnergy(u,type,si1,sj1,string);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "expHairpinEnergy" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "expHairpinEnergy" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "expHairpinEnergy" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = (short)(val3);
+ ecode4 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "expHairpinEnergy" "', argument " "4"" of type '" "short""'");
+ }
+ arg4 = (short)(val4);
+ res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "expHairpinEnergy" "', argument " "5"" of type '" "char const *""'");
+ }
+ arg5 = (char *)(buf5);
+ result = (double)expHairpinEnergy(arg1,arg2,arg3,arg4,(char const *)arg5);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+
+
+
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_co_pf_fold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) NULL ;
+ float *arg3 = (float *) 0 ;
+ float *arg4 = (float *) 0 ;
+ float *arg5 = (float *) 0 ;
+ float *arg6 = (float *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ float temp3 ;
+ int res3 = SWIG_TMPOBJ ;
+ float temp4 ;
+ int res4 = SWIG_TMPOBJ ;
+ float temp5 ;
+ int res5 = SWIG_TMPOBJ ;
+ float temp6 ;
+ int res6 = SWIG_TMPOBJ ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ arg3 = &temp3;
+ arg4 = &temp4;
+ arg5 = &temp5;
+ arg6 = &temp6;
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: co_pf_fold(string,constraints);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "co_pf_fold" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ if (items > 1) {
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "co_pf_fold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ }
+ result = (char *)my_co_pf_fold(arg1,arg2,arg3,arg4,arg5,arg6);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (SWIG_IsTmpObj(res3)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg3)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (SWIG_IsTmpObj(res4)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg4)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (SWIG_IsTmpObj(res5)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg5)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (SWIG_IsTmpObj(res6)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg6)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_co_pf_fold_par) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ pf_paramT *arg3 = (pf_paramT *) 0 ;
+ int arg4 ;
+ int arg5 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ cofoldF result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: co_pf_fold_par(sequence,structure,parameters,calculate_bppm,is_constrained);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "co_pf_fold_par" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "co_pf_fold_par" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_pf_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "co_pf_fold_par" "', argument " "3"" of type '" "pf_paramT *""'");
+ }
+ arg3 = (pf_paramT *)(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "co_pf_fold_par" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "co_pf_fold_par" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ result = co_pf_fold_par(arg1,arg2,arg3,arg4,arg5);
+ ST(argvi) = SWIG_NewPointerObj((cofoldF *)memcpy((cofoldF *)malloc(sizeof(cofoldF)),&result,sizeof(cofoldF)), SWIGTYPE_p_cofoldF, SWIG_POINTER_OWN | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_co_bppm) {
+ {
+ int argvi = 0;
+ double *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: export_co_bppm();");
+ }
+ result = (double *)export_co_bppm();
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_co_pf_arrays) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: free_co_pf_arrays();");
+ }
+ free_co_pf_arrays();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_co_pf_params) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: update_co_pf_params(length);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "update_co_pf_params" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ update_co_pf_params(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_co_pf_params_par) {
+ {
+ int arg1 ;
+ pf_paramT *arg2 = (pf_paramT *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: update_co_pf_params_par(length,parameters);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "update_co_pf_params_par" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_pf_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "update_co_pf_params_par" "', argument " "2"" of type '" "pf_paramT *""'");
+ }
+ arg2 = (pf_paramT *)(argp2);
+ update_co_pf_params_par(arg1,arg2);
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_concentrations__SWIG_0) {
+ {
+ double arg1 ;
+ double arg2 ;
+ double arg3 ;
+ double arg4 ;
+ double arg5 ;
+ double *arg6 = (double *) 0 ;
+ double val1 ;
+ int ecode1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int argvi = 0;
+ ConcEnt *result = 0 ;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: get_concentrations(FEAB,FEAA,FEBB,FEA,FEB,startconc);");
+ }
+ ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_concentrations" "', argument " "1"" of type '" "double""'");
+ }
+ arg1 = (double)(val1);
+ ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_concentrations" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_concentrations" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "get_concentrations" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ ecode5 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "get_concentrations" "', argument " "5"" of type '" "double""'");
+ }
+ arg5 = (double)(val5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "get_concentrations" "', argument " "6"" of type '" "double *""'");
+ }
+ arg6 = (double *)(argp6);
+ result = (ConcEnt *)get_concentrations(arg1,arg2,arg3,arg4,arg5,arg6);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConcEnt, 0 | 0); argvi++ ;
+
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_concentrations__SWIG_1) {
+ {
+ double arg1 ;
+ double arg2 ;
+ double arg3 ;
+ double arg4 ;
+ double arg5 ;
+ double arg6 ;
+ double arg7 ;
+ double *arg8 = (double *) 0 ;
+ double *arg9 = (double *) 0 ;
+ double *arg10 = (double *) 0 ;
+ double *arg11 = (double *) 0 ;
+ double *arg12 = (double *) 0 ;
+ double val1 ;
+ int ecode1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ double val6 ;
+ int ecode6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ double temp8 ;
+ int res8 = SWIG_TMPOBJ ;
+ double temp9 ;
+ int res9 = SWIG_TMPOBJ ;
+ double temp10 ;
+ int res10 = SWIG_TMPOBJ ;
+ double temp11 ;
+ int res11 = SWIG_TMPOBJ ;
+ double temp12 ;
+ int res12 = SWIG_TMPOBJ ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg8 = &temp8;
+ arg9 = &temp9;
+ arg10 = &temp10;
+ arg11 = &temp11;
+ arg12 = &temp12;
+ if ((items < 7) || (items > 7)) {
+ SWIG_croak("Usage: get_concentrations(FcAB,FcAA,FcBB,FEA,FEB,A0,BO);");
+ }
+ ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_concentrations" "', argument " "1"" of type '" "double""'");
+ }
+ arg1 = (double)(val1);
+ ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_concentrations" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_concentrations" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "get_concentrations" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ ecode5 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "get_concentrations" "', argument " "5"" of type '" "double""'");
+ }
+ arg5 = (double)(val5);
+ ecode6 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "get_concentrations" "', argument " "6"" of type '" "double""'");
+ }
+ arg6 = (double)(val6);
+ ecode7 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "get_concentrations" "', argument " "7"" of type '" "double""'");
+ }
+ arg7 = (double)(val7);
+ my_get_concentrations(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+ ST(argvi) = sv_newmortal();
+ if (SWIG_IsTmpObj(res8)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg8)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags); argvi++ ;
+ }
+ if (SWIG_IsTmpObj(res9)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg9)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags); argvi++ ;
+ }
+ if (SWIG_IsTmpObj(res10)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg10)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags); argvi++ ;
+ }
+ if (SWIG_IsTmpObj(res11)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg11)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_double, new_flags); argvi++ ;
+ }
+ if (SWIG_IsTmpObj(res12)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg12)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res12) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg12), SWIGTYPE_p_double, new_flags); argvi++ ;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_concentrations) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 6) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(4), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(5), &vptr, SWIGTYPE_p_double, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 7) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(4), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(5), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(6), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ PUSHMARK(MARK); SWIG_CALLXS(_wrap_get_concentrations__SWIG_0); return;
+ case 2:
+ PUSHMARK(MARK); SWIG_CALLXS(_wrap_get_concentrations__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'get_concentrations'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_inverse_fold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ float *arg3 = (float *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ float temp3 ;
+ int res3 = SWIG_TMPOBJ ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ arg3 = &temp3;
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: inverse_fold(start,target);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inverse_fold" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "inverse_fold" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (char *)my_inverse_fold(arg1,(char const *)arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (SWIG_IsTmpObj(res3)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg3)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_inverse_pf_fold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ float *arg3 = (float *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ float temp3 ;
+ int res3 = SWIG_TMPOBJ ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ arg3 = &temp3;
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: inverse_pf_fold(start,target);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inverse_pf_fold" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "inverse_pf_fold" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (char *)my_inverse_pf_fold(arg1,(char const *)arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (SWIG_IsTmpObj(res3)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg3)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_option_string) {
+ {
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: option_string();");
+ }
+ result = (char *)option_string();
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_set_model_details) {
+ {
+ model_detailsT *arg1 = (model_detailsT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: set_model_details(md);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_model_detailsT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_model_details" "', argument " "1"" of type '" "model_detailsT *""'");
+ }
+ arg1 = (model_detailsT *)(argp1);
+ set_model_details(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_update_alifold_params) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: update_alifold_params();");
+ }
+ update_alifold_params();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_circalifold) {
+ {
+ char **arg1 = (char **) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: circalifold(strings,structure);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "circalifold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (float)circalifold((char const **)arg1,arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_alifold_arrays) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: free_alifold_arrays();");
+ }
+ free_alifold_arrays();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_mpi) {
+ {
+ char **arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int *arg4 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: get_mpi(Alseq,n_seq,length,mini);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_mpi" "', argument " "1"" of type '" "char *[]""'");
+ }
+ arg1 = (char **)(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_mpi" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_mpi" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_mpi" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ result = (int)get_mpi(arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_readribosum) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ float **result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: readribosum(name);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readribosum" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (float **)readribosum(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_float, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_alistruct) {
+ {
+ char **arg1 = (char **) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ float *arg4 = (float *) 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: energy_of_alistruct(sequences,structure,n_seq,energy);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_alistruct" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_alistruct" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "energy_of_alistruct" "', argument " "4"" of type '" "float *""'");
+ }
+ arg4 = (float *)(argp4);
+ result = (float)energy_of_alistruct((char const **)arg1,(char const *)arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_energy_of_ali_gquad_structure) {
+ {
+ char **arg1 = (char **) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ float *arg4 = (float *) 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: energy_of_ali_gquad_structure(sequences,structure,n_seq,energy);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_ali_gquad_structure" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_ali_gquad_structure" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "energy_of_ali_gquad_structure" "', argument " "4"" of type '" "float *""'");
+ }
+ arg4 = (float *)(argp4);
+ result = (float)energy_of_ali_gquad_structure((char const **)arg1,(char const *)arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_encode_ali_sequence) {
+ {
+ char *arg1 = (char *) 0 ;
+ short *arg2 = (short *) 0 ;
+ short *arg3 = (short *) 0 ;
+ short *arg4 = (short *) 0 ;
+ char *arg5 = (char *) 0 ;
+ unsigned short *arg6 = (unsigned short *) 0 ;
+ int arg7 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 7) || (items > 7)) {
+ SWIG_croak("Usage: encode_ali_sequence(sequence,S,s5,s3,ss,as,circ);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encode_ali_sequence" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "encode_ali_sequence" "', argument " "2"" of type '" "short *""'");
+ }
+ arg2 = (short *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "encode_ali_sequence" "', argument " "3"" of type '" "short *""'");
+ }
+ arg3 = (short *)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "encode_ali_sequence" "', argument " "4"" of type '" "short *""'");
+ }
+ arg4 = (short *)(argp4);
+ res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "encode_ali_sequence" "', argument " "5"" of type '" "char *""'");
+ }
+ arg5 = (char *)(buf5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_unsigned_short, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "encode_ali_sequence" "', argument " "6"" of type '" "unsigned short *""'");
+ }
+ arg6 = (unsigned short *)(argp6);
+ ecode7 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "encode_ali_sequence" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ encode_ali_sequence((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+
+
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_alloc_sequence_arrays) {
+ {
+ char **arg1 = (char **) 0 ;
+ short ***arg2 = (short ***) 0 ;
+ short ***arg3 = (short ***) 0 ;
+ short ***arg4 = (short ***) 0 ;
+ unsigned short ***arg5 = (unsigned short ***) 0 ;
+ char ***arg6 = (char ***) 0 ;
+ int arg7 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 7) || (items > 7)) {
+ SWIG_croak("Usage: alloc_sequence_arrays(sequences,S,S5,S3,a2s,Ss,circ);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "alloc_sequence_arrays" "', argument " "2"" of type '" "short ***""'");
+ }
+ arg2 = (short ***)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "alloc_sequence_arrays" "', argument " "3"" of type '" "short ***""'");
+ }
+ arg3 = (short ***)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "alloc_sequence_arrays" "', argument " "4"" of type '" "short ***""'");
+ }
+ arg4 = (short ***)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_p_unsigned_short, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "alloc_sequence_arrays" "', argument " "5"" of type '" "unsigned short ***""'");
+ }
+ arg5 = (unsigned short ***)(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "alloc_sequence_arrays" "', argument " "6"" of type '" "char ***""'");
+ }
+ arg6 = (char ***)(argp6);
+ ecode7 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "alloc_sequence_arrays" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ alloc_sequence_arrays((char const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ ST(argvi) = sv_newmortal();
+ {
+ free(arg1);
+ }
+
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_sequence_arrays) {
+ {
+ unsigned int arg1 ;
+ short ***arg2 = (short ***) 0 ;
+ short ***arg3 = (short ***) 0 ;
+ short ***arg4 = (short ***) 0 ;
+ unsigned short ***arg5 = (unsigned short ***) 0 ;
+ char ***arg6 = (char ***) 0 ;
+ unsigned int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: free_sequence_arrays(n_seq,S,S5,S3,a2s,Ss);");
+ }
+ ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "free_sequence_arrays" "', argument " "1"" of type '" "unsigned int""'");
+ }
+ arg1 = (unsigned int)(val1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "free_sequence_arrays" "', argument " "2"" of type '" "short ***""'");
+ }
+ arg2 = (short ***)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "free_sequence_arrays" "', argument " "3"" of type '" "short ***""'");
+ }
+ arg3 = (short ***)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "free_sequence_arrays" "', argument " "4"" of type '" "short ***""'");
+ }
+ arg4 = (short ***)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_p_unsigned_short, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "free_sequence_arrays" "', argument " "5"" of type '" "unsigned short ***""'");
+ }
+ arg5 = (unsigned short ***)(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "free_sequence_arrays" "', argument " "6"" of type '" "char ***""'");
+ }
+ arg6 = (char ***)(argp6);
+ free_sequence_arrays(arg1,arg2,arg3,arg4,arg5,arg6);
+ ST(argvi) = sv_newmortal();
+
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_alipf_fold_par) {
+ {
+ char **arg1 = (char **) 0 ;
+ char *arg2 = (char *) 0 ;
+ plist **arg3 = (plist **) 0 ;
+ pf_paramT *arg4 = (pf_paramT *) 0 ;
+ int arg5 ;
+ int arg6 ;
+ int arg7 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 7) || (items > 7)) {
+ SWIG_croak("Usage: alipf_fold_par(sequences,structure,pl,parameters,calculate_bppm,is_constrained,is_circular);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "alipf_fold_par" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "alipf_fold_par" "', argument " "3"" of type '" "plist **""'");
+ }
+ arg3 = (plist **)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_pf_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "alipf_fold_par" "', argument " "4"" of type '" "pf_paramT *""'");
+ }
+ arg4 = (pf_paramT *)(argp4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "alipf_fold_par" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ ecode6 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "alipf_fold_par" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ ecode7 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "alipf_fold_par" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ result = (float)alipf_fold_par((char const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_alipf_fold) {
+ {
+ char **arg1 = (char **) 0 ;
+ char *arg2 = (char *) 0 ;
+ plist **arg3 = (plist **) 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: alipf_fold(sequences,structure,pl);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "alipf_fold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "alipf_fold" "', argument " "3"" of type '" "plist **""'");
+ }
+ arg3 = (plist **)(argp3);
+ result = (float)alipf_fold((char const **)arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_alipf_circ_fold) {
+ {
+ char **arg1 = (char **) 0 ;
+ char *arg2 = (char *) 0 ;
+ plist **arg3 = (plist **) 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: alipf_circ_fold(sequences,structure,pl);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "alipf_circ_fold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "alipf_circ_fold" "', argument " "3"" of type '" "plist **""'");
+ }
+ arg3 = (plist **)(argp3);
+ result = (float)alipf_circ_fold((char const **)arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_export_ali_bppm) {
+ {
+ int argvi = 0;
+ double *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: export_ali_bppm();");
+ }
+ result = (double *)export_ali_bppm();
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_alipf_arrays) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: free_alipf_arrays();");
+ }
+ free_alipf_arrays();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_alipbacktrack) {
+ {
+ double *arg1 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: alipbacktrack(prob);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "alipbacktrack" "', argument " "1"" of type '" "double *""'");
+ }
+ arg1 = (double *)(argp1);
+ result = (char *)alipbacktrack(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_alipf_arrays) {
+ {
+ short ***arg1 = (short ***) 0 ;
+ short ***arg2 = (short ***) 0 ;
+ short ***arg3 = (short ***) 0 ;
+ unsigned short ***arg4 = (unsigned short ***) 0 ;
+ char ***arg5 = (char ***) 0 ;
+ double **arg6 = (double **) 0 ;
+ double **arg7 = (double **) 0 ;
+ double **arg8 = (double **) 0 ;
+ double **arg9 = (double **) 0 ;
+ short **arg10 = (short **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 10) || (items > 10)) {
+ SWIG_croak("Usage: get_alipf_arrays(S_p,S5_p,S3_p,a2s_p,Ss_p,qb_p,qm_p,q1k_p,qln_p,pscore);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_alipf_arrays" "', argument " "1"" of type '" "short ***""'");
+ }
+ arg1 = (short ***)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_alipf_arrays" "', argument " "2"" of type '" "short ***""'");
+ }
+ arg2 = (short ***)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_alipf_arrays" "', argument " "3"" of type '" "short ***""'");
+ }
+ arg3 = (short ***)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_p_unsigned_short, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_alipf_arrays" "', argument " "4"" of type '" "unsigned short ***""'");
+ }
+ arg4 = (unsigned short ***)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "get_alipf_arrays" "', argument " "5"" of type '" "char ***""'");
+ }
+ arg5 = (char ***)(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "get_alipf_arrays" "', argument " "6"" of type '" "double **""'");
+ }
+ arg6 = (double **)(argp6);
+ res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "get_alipf_arrays" "', argument " "7"" of type '" "double **""'");
+ }
+ arg7 = (double **)(argp7);
+ res8 = SWIG_ConvertPtr(ST(7), &argp8,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "get_alipf_arrays" "', argument " "8"" of type '" "double **""'");
+ }
+ arg8 = (double **)(argp8);
+ res9 = SWIG_ConvertPtr(ST(8), &argp9,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "get_alipf_arrays" "', argument " "9"" of type '" "double **""'");
+ }
+ arg9 = (double **)(argp9);
+ res10 = SWIG_ConvertPtr(ST(9), &argp10,SWIGTYPE_p_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "get_alipf_arrays" "', argument " "10"" of type '" "short **""'");
+ }
+ arg10 = (short **)(argp10);
+ result = (int)get_alipf_arrays(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+
+
+
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_alifold) {
+ {
+ char **arg1 = (char **) 0 ;
+ char *arg2 = (char *) NULL ;
+ float *arg3 = (float *) 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ float temp3 ;
+ int res3 = SWIG_TMPOBJ ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ arg3 = &temp3;
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: alifold(strings,constraints);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ if (items > 1) {
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "alifold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ }
+ result = (char *)my_alifold(arg1,arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (SWIG_IsTmpObj(res3)) {
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((*arg3)); argvi++ ;
+ } else {
+ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
+ if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags); argvi++ ;
+ }
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_consensus) {
+ {
+ char **arg1 = (char **) 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: consensus(AS);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ result = (char *)consensus((char const **)arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ {
+ free(arg1);
+ }
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_consens_mis) {
+ {
+ char **arg1 = (char **) 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: consens_mis(AS);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ result = (char *)consens_mis((char const **)arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ {
+ free(arg1);
+ }
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_COORDINATE_X_set) {
+ {
+ COORDINATE *arg1 = (COORDINATE *) 0 ;
+ float arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ float val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: COORDINATE_X_set(self,X);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_COORDINATE, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_X_set" "', argument " "1"" of type '" "COORDINATE *""'");
+ }
+ arg1 = (COORDINATE *)(argp1);
+ ecode2 = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "COORDINATE_X_set" "', argument " "2"" of type '" "float""'");
+ }
+ arg2 = (float)(val2);
+ if (arg1) (arg1)->X = arg2;
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_COORDINATE_X_get) {
+ {
+ COORDINATE *arg1 = (COORDINATE *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: COORDINATE_X_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_COORDINATE, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_X_get" "', argument " "1"" of type '" "COORDINATE *""'");
+ }
+ arg1 = (COORDINATE *)(argp1);
+ result = (float) ((arg1)->X);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_COORDINATE_Y_set) {
+ {
+ COORDINATE *arg1 = (COORDINATE *) 0 ;
+ float arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ float val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: COORDINATE_Y_set(self,Y);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_COORDINATE, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_Y_set" "', argument " "1"" of type '" "COORDINATE *""'");
+ }
+ arg1 = (COORDINATE *)(argp1);
+ ecode2 = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "COORDINATE_Y_set" "', argument " "2"" of type '" "float""'");
+ }
+ arg2 = (float)(val2);
+ if (arg1) (arg1)->Y = arg2;
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_COORDINATE_Y_get) {
+ {
+ COORDINATE *arg1 = (COORDINATE *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: COORDINATE_Y_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_COORDINATE, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_Y_get" "', argument " "1"" of type '" "COORDINATE *""'");
+ }
+ arg1 = (COORDINATE *)(argp1);
+ result = (float) ((arg1)->Y);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_COORDINATE_get) {
+ {
+ COORDINATE *arg1 = (COORDINATE *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ COORDINATE *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: COORDINATE_get(self,i);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_COORDINATE, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_get" "', argument " "1"" of type '" "COORDINATE *""'");
+ }
+ arg1 = (COORDINATE *)(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "COORDINATE_get" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (COORDINATE *)COORDINATE_get(arg1,arg2);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_COORDINATE) {
+ {
+ int argvi = 0;
+ COORDINATE *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_COORDINATE();");
+ }
+ result = (COORDINATE *)calloc(1, sizeof(COORDINATE));
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_COORDINATE) {
+ {
+ COORDINATE *arg1 = (COORDINATE *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_COORDINATE(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_COORDINATE, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_COORDINATE" "', argument " "1"" of type '" "COORDINATE *""'");
+ }
+ arg1 = (COORDINATE *)(argp1);
+ free((char *) arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_xy_coordinates) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ COORDINATE *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: get_xy_coordinates(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_xy_coordinates" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (COORDINATE *)get_xy_coordinates((char const *)arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, 0 | SWIG_SHADOW); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SOLUTION_energy_set) {
+ {
+ SOLUTION *arg1 = (SOLUTION *) 0 ;
+ float arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ float val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SOLUTION_energy_set(self,energy);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_SOLUTION, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_energy_set" "', argument " "1"" of type '" "SOLUTION *""'");
+ }
+ arg1 = (SOLUTION *)(argp1);
+ ecode2 = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTION_energy_set" "', argument " "2"" of type '" "float""'");
+ }
+ arg2 = (float)(val2);
+ if (arg1) (arg1)->energy = arg2;
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SOLUTION_energy_get) {
+ {
+ SOLUTION *arg1 = (SOLUTION *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SOLUTION_energy_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_SOLUTION, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_energy_get" "', argument " "1"" of type '" "SOLUTION *""'");
+ }
+ arg1 = (SOLUTION *)(argp1);
+ result = (float) ((arg1)->energy);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SOLUTION_structure_set) {
+ {
+ SOLUTION *arg1 = (SOLUTION *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SOLUTION_structure_set(self,structure);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_SOLUTION, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_structure_set" "', argument " "1"" of type '" "SOLUTION *""'");
+ }
+ arg1 = (SOLUTION *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SOLUTION_structure_set" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ if (arg1->structure) free((char*)arg1->structure);
+ if (arg2) {
+ size_t size = strlen((const char *)(arg2)) + 1;
+ arg1->structure = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
+ } else {
+ arg1->structure = 0;
+ }
+ ST(argvi) = sv_newmortal();
+
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SOLUTION_structure_get) {
+ {
+ SOLUTION *arg1 = (SOLUTION *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SOLUTION_structure_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_SOLUTION, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_structure_get" "', argument " "1"" of type '" "SOLUTION *""'");
+ }
+ arg1 = (SOLUTION *)(argp1);
+ result = (char *) ((arg1)->structure);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SOLUTION_get) {
+ {
+ SOLUTION *arg1 = (SOLUTION *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ SOLUTION *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SOLUTION_get(self,i);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_SOLUTION, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_get" "', argument " "1"" of type '" "SOLUTION *""'");
+ }
+ arg1 = (SOLUTION *)(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTION_get" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (SOLUTION *)SOLUTION_get(arg1,arg2);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SOLUTION_size) {
+ {
+ SOLUTION *arg1 = (SOLUTION *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SOLUTION_size(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_SOLUTION, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_size" "', argument " "1"" of type '" "SOLUTION *""'");
+ }
+ arg1 = (SOLUTION *)(argp1);
+ result = (int)SOLUTION_size(arg1);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_SOLUTION) {
+ {
+ SOLUTION *arg1 = (SOLUTION *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_SOLUTION(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_SOLUTION, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SOLUTION" "', argument " "1"" of type '" "SOLUTION *""'");
+ }
+ arg1 = (SOLUTION *)(argp1);
+ delete_SOLUTION(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_SOLUTION) {
+ {
+ int argvi = 0;
+ SOLUTION *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_SOLUTION();");
+ }
+ result = (SOLUTION *)calloc(1, sizeof(SOLUTION));
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_subopt) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ FILE *arg4 = (FILE *) NULL ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ SOLUTION *result = 0 ;
+ dXSARGS;
+
+ if ((items < 3) || (items > 4)) {
+ SWIG_croak("Usage: subopt(seq,constraint,delta,fp);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subopt" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "subopt" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "subopt" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ if (items > 3) {
+ {
+ if (SvOK(ST(3))) /* check for undef */
+ arg4 = PerlIO_findFILE(IoIFP(sv_2io(ST(3))));
+ else arg4 = NULL;
+ }
+ }
+ result = (SOLUTION *)subopt(arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_pr) {
+ {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: get_pr(i,j);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_pr" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_pr" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (double)get_pr(arg1,arg2);
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_b2HIT) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: b2HIT(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "b2HIT" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)b2HIT(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_b2C) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: b2C(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "b2C" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)b2C(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_b2Shapiro) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: b2Shapiro(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "b2Shapiro" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)b2Shapiro(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_add_root) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: add_root(char *);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_root" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)add_root(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_expand_Shapiro) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: expand_Shapiro(coarse);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "expand_Shapiro" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)expand_Shapiro(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_expand_Full) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: expand_Full(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "expand_Full" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)expand_Full(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_unexpand_Full) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: unexpand_Full(ffull);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unexpand_Full" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)unexpand_Full(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_unweight) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: unweight(wcoarse);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unweight" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)unweight(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_unexpand_aligned_F) {
+ {
+ char **arg1 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: unexpand_aligned_F(align);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unexpand_aligned_F" "', argument " "1"" of type '" "char *[2]""'");
+ }
+ arg1 = (char **)(argp1);
+ unexpand_aligned_F(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_parse_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: parse_structure(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_structure" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ parse_structure(arg1);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_make_tree) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ Tree *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: make_tree(struc);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_tree" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (Tree *)make_tree(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Tree, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_tree_edit_distance) {
+ {
+ Tree *arg1 = (Tree *) 0 ;
+ Tree *arg2 = (Tree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: tree_edit_distance(T1,T2);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Tree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tree_edit_distance" "', argument " "1"" of type '" "Tree *""'");
+ }
+ arg1 = (Tree *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Tree, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tree_edit_distance" "', argument " "2"" of type '" "Tree *""'");
+ }
+ arg2 = (Tree *)(argp2);
+ result = (float)tree_edit_distance(arg1,arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_print_tree) {
+ {
+ Tree *arg1 = (Tree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: print_tree(t);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Tree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_tree" "', argument " "1"" of type '" "Tree *""'");
+ }
+ arg1 = (Tree *)(argp1);
+ print_tree(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_tree) {
+ {
+ Tree *arg1 = (Tree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: free_tree(t);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Tree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_tree" "', argument " "1"" of type '" "Tree *""'");
+ }
+ arg1 = (Tree *)(argp1);
+ free_tree(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Make_swString) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ swString *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Make_swString(string);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Make_swString" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (swString *)Make_swString(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swString, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_string_edit_distance) {
+ {
+ swString *arg1 = (swString *) 0 ;
+ swString *arg2 = (swString *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: string_edit_distance(T1,T2);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_swString, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_edit_distance" "', argument " "1"" of type '" "swString *""'");
+ }
+ arg1 = (swString *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_swString, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_edit_distance" "', argument " "2"" of type '" "swString *""'");
+ }
+ arg2 = (swString *)(argp2);
+ result = (float)string_edit_distance(arg1,arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_profile_edit_distance) {
+ {
+ float *arg1 = (float *) 0 ;
+ float *arg2 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: profile_edit_distance(T1,T2);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profile_edit_distance" "', argument " "1"" of type '" "float const *""'");
+ }
+ arg1 = (float *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profile_edit_distance" "', argument " "2"" of type '" "float const *""'");
+ }
+ arg2 = (float *)(argp2);
+ result = (float)profile_edit_distance((float const *)arg1,(float const *)arg2);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Make_bp_profile_bppm) {
+ {
+ double *arg1 = (double *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ float *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Make_bp_profile_bppm(bppm,length);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Make_bp_profile_bppm" "', argument " "1"" of type '" "double *""'");
+ }
+ arg1 = (double *)(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Make_bp_profile_bppm" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (float *)Make_bp_profile_bppm(arg1,arg2);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_print_bppm) {
+ {
+ float *arg1 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: print_bppm(T);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_bppm" "', argument " "1"" of type '" "float const *""'");
+ }
+ arg1 = (float *)(argp1);
+ print_bppm((float const *)arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_profile) {
+ {
+ float *arg1 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: free_profile(T);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_profile" "', argument " "1"" of type '" "float *""'");
+ }
+ arg1 = (float *)(argp1);
+ free_profile(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Make_bp_profile) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ float *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Make_bp_profile(length);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Make_bp_profile" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (float *)Make_bp_profile(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, SWIG_OWNER | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_space) {
+ {
+ unsigned int arg1 ;
+ unsigned int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ void *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: space(size);");
+ }
+ ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "space" "', argument " "1"" of type '" "unsigned int""'");
+ }
+ arg1 = (unsigned int)(val1);
+ result = (void *)space(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, SWIG_OWNER | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_xrealloc) {
+ {
+ void *arg1 = (void *) 0 ;
+ unsigned int arg2 ;
+ int res1 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ void *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: xrealloc(p,size);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0),SWIG_as_voidptrptr(&arg1), 0, 0);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xrealloc" "', argument " "1"" of type '" "void *""'");
+ }
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xrealloc" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = (unsigned int)(val2);
+ result = (void *)xrealloc(arg1,arg2);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_nrerror) {
+ {
+ char *arg1 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: nrerror(message);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nrerror" "', argument " "1"" of type '" "char const []""'");
+ }
+ arg1 = (char *)(buf1);
+ nrerror((char const (*))arg1);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_warn_user) {
+ {
+ char *arg1 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: warn_user(message);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "warn_user" "', argument " "1"" of type '" "char const []""'");
+ }
+ arg1 = (char *)(buf1);
+ warn_user((char const (*))arg1);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_init_rand) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: init_rand();");
+ }
+ init_rand();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_urn) {
+ {
+ int argvi = 0;
+ double result;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: urn();");
+ }
+ result = (double)urn();
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_int_urn) {
+ {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: int_urn(from,to);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "int_urn" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "int_urn" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)int_urn(arg1,arg2);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_filecopy) {
+ {
+ FILE *arg1 = (FILE *) 0 ;
+ FILE *arg2 = (FILE *) 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: filecopy(from,to);");
+ }
+ {
+ if (SvOK(ST(0))) /* check for undef */
+ arg1 = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
+ else arg1 = NULL;
+ }
+ {
+ if (SvOK(ST(1))) /* check for undef */
+ arg2 = PerlIO_findFILE(IoIFP(sv_2io(ST(1))));
+ else arg2 = NULL;
+ }
+ filecopy(arg1,arg2);
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_time_stamp) {
+ {
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: time_stamp();");
+ }
+ result = (char *)time_stamp();
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_random_string) {
+ {
+ int arg1 ;
+ char *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: random_string(l,symbols);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_string" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_string" "', argument " "2"" of type '" "char const []""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (char *)random_string(arg1,(char const (*))arg2);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_hamming) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: hamming(s1,s2);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hamming" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hamming" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (int)hamming((char const *)arg1,(char const *)arg2);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_hamming_bound) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: hamming_bound(s1,s2,n);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hamming_bound" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hamming_bound" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "hamming_bound" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (int)hamming_bound((char const *)arg1,(char const *)arg2,arg3);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_line) {
+ {
+ FILE *arg1 = (FILE *) 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: get_line(fp);");
+ }
+ {
+ if (SvOK(ST(0))) /* check for undef */
+ arg1 = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
+ else arg1 = NULL;
+ }
+ result = (char *)get_line(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_skip_comment_lines) {
+ {
+ char **arg1 = (char **) 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: skip_comment_lines(line);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ result = (int)skip_comment_lines(arg1);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_input_line) {
+ {
+ char **arg1 = (char **) 0 ;
+ unsigned int arg2 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ unsigned int result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: get_input_line(string,options);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_input_line" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = (unsigned int)(val2);
+ result = (unsigned int)get_input_line(arg1,arg2);
+ ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_multi_input_line) {
+ {
+ char **arg1 = (char **) 0 ;
+ unsigned int arg2 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ unsigned int result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: get_multi_input_line(string,options);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_multi_input_line" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = (unsigned int)(val2);
+ result = (unsigned int)get_multi_input_line(arg1,arg2);
+ ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_read_record) {
+ {
+ char **arg1 = (char **) 0 ;
+ char **arg2 = (char **) 0 ;
+ char ***arg3 = (char ***) 0 ;
+ unsigned int arg4 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ unsigned int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ unsigned int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: read_record(header,sequence,rest,options);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(1)))
+ croak("Argument 2 is not a reference.");
+ if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
+ croak("Argument 2 is not an array.");
+ tempav = (AV*)SvRV(ST(1));
+ len = av_len(tempav);
+ arg2 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg2[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg2[i] = NULL;
+ }
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "read_record" "', argument " "3"" of type '" "char ***""'");
+ }
+ arg3 = (char ***)(argp3);
+ ecode4 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "read_record" "', argument " "4"" of type '" "unsigned int""'");
+ }
+ arg4 = (unsigned int)(val4);
+ result = (unsigned int)read_record(arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ {
+ free(arg2);
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ {
+ free(arg2);
+ }
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_extract_record_rest_structure) {
+ {
+ char **arg1 = (char **) 0 ;
+ unsigned int arg2 ;
+ unsigned int arg3 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: extract_record_rest_structure(lines,length,option);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "extract_record_rest_structure" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = (unsigned int)(val2);
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "extract_record_rest_structure" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = (unsigned int)(val3);
+ result = (char *)extract_record_rest_structure((char const **)arg1,arg2,arg3);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ {
+ free(arg1);
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_pack_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: pack_structure(struc);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pack_structure" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)pack_structure((char const *)arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_unpack_structure) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: unpack_structure(packed);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unpack_structure" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (char *)unpack_structure((char const *)arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ free((char*)result);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_make_pair_table) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: make_pair_table(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_pair_table" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (short *)make_pair_table((char const *)arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, SWIG_OWNER | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_make_pair_table_pk) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: make_pair_table_pk(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_pair_table_pk" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (short *)make_pair_table_pk((char const *)arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_copy_pair_table) {
+ {
+ short *arg1 = (short *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: copy_pair_table(pt);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_pair_table" "', argument " "1"" of type '" "short const *""'");
+ }
+ arg1 = (short *)(argp1);
+ result = (short *)copy_pair_table((short const *)arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_alimake_pair_table) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: alimake_pair_table(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "alimake_pair_table" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (short *)alimake_pair_table((char const *)arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_make_pair_table_snoop) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: make_pair_table_snoop(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_pair_table_snoop" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (short *)make_pair_table_snoop((char const *)arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_make_loop_index_pt) {
+ {
+ short *arg1 = (short *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ int *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: make_loop_index_pt(pt);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_loop_index_pt" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ result = (int *)make_loop_index_pt(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_bp_distance) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: bp_distance(str1,str2);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bp_distance" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bp_distance" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (int)bp_distance((char const *)arg1,(char const *)arg2);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_print_tty_input_seq) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: print_tty_input_seq();");
+ }
+ print_tty_input_seq();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_print_tty_input_seq_str) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: print_tty_input_seq_str(s);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_tty_input_seq_str" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ print_tty_input_seq_str((char const *)arg1);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_print_tty_constraint_full) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: print_tty_constraint_full();");
+ }
+ print_tty_constraint_full();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_print_tty_constraint) {
+ {
+ unsigned int arg1 ;
+ unsigned int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: print_tty_constraint(option);");
+ }
+ ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "print_tty_constraint" "', argument " "1"" of type '" "unsigned int""'");
+ }
+ arg1 = (unsigned int)(val1);
+ print_tty_constraint(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_str_DNA2RNA) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: str_DNA2RNA(sequence);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str_DNA2RNA" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ str_DNA2RNA(arg1);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_str_uppercase) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: str_uppercase(sequence);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str_uppercase" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ str_uppercase(arg1);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_iindx) {
+ {
+ unsigned int arg1 ;
+ unsigned int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ int *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: get_iindx(length);");
+ }
+ ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_iindx" "', argument " "1"" of type '" "unsigned int""'");
+ }
+ arg1 = (unsigned int)(val1);
+ result = (int *)get_iindx(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_indx) {
+ {
+ unsigned int arg1 ;
+ unsigned int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ int *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: get_indx(length);");
+ }
+ ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_indx" "', argument " "1"" of type '" "unsigned int""'");
+ }
+ arg1 = (unsigned int)(val1);
+ result = (int *)get_indx(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_getConstraint) {
+ {
+ char **arg1 = (char **) 0 ;
+ char **arg2 = (char **) 0 ;
+ unsigned int arg3 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: getConstraint(cstruc,lines,option);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(1)))
+ croak("Argument 2 is not a reference.");
+ if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
+ croak("Argument 2 is not an array.");
+ tempav = (AV*)SvRV(ST(1));
+ len = av_len(tempav);
+ arg2 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg2[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg2[i] = NULL;
+ }
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getConstraint" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = (unsigned int)(val3);
+ getConstraint(arg1,(char const **)arg2,arg3);
+ ST(argvi) = sv_newmortal();
+ {
+ free(arg1);
+ }
+ {
+ free(arg2);
+ }
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ {
+ free(arg2);
+ }
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_constrain_ptypes) {
+ {
+ char *arg1 = (char *) 0 ;
+ unsigned int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int *arg4 = (int *) 0 ;
+ int arg5 ;
+ unsigned int arg6 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ unsigned int val6 ;
+ int ecode6 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: constrain_ptypes(constraint,length,ptype,BP,min_loop_size,idx_type);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "constrain_ptypes" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "constrain_ptypes" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = (unsigned int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "constrain_ptypes" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "constrain_ptypes" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "constrain_ptypes" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "constrain_ptypes" "', argument " "6"" of type '" "unsigned int""'");
+ }
+ arg6 = (unsigned int)(val6);
+ constrain_ptypes((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_make_referenceBP_array) {
+ {
+ short *arg1 = (short *) 0 ;
+ unsigned int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ unsigned int *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: make_referenceBP_array(reference_pt,turn);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_referenceBP_array" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "make_referenceBP_array" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = (unsigned int)(val2);
+ result = (unsigned int *)make_referenceBP_array(arg1,arg2);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 | 0); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_compute_BPdifferences) {
+ {
+ short *arg1 = (short *) 0 ;
+ short *arg2 = (short *) 0 ;
+ unsigned int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ unsigned int *result = 0 ;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: compute_BPdifferences(pt1,pt2,turn);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "compute_BPdifferences" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compute_BPdifferences" "', argument " "2"" of type '" "short *""'");
+ }
+ arg2 = (short *)(argp2);
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compute_BPdifferences" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = (unsigned int)(val3);
+ result = (unsigned int *)compute_BPdifferences(arg1,arg2,arg3);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 | 0); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_read_parameter_file) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: read_parameter_file(fname);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_parameter_file" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ read_parameter_file(arg1);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_write_parameter_file) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: write_parameter_file(fname);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "write_parameter_file" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ write_parameter_file(arg1);
+ ST(argvi) = sv_newmortal();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_deref_any) {
+ {
+ void **arg1 = (void **) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ void *result = 0 ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: deref_any(ptr,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_void, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deref_any" "', argument " "1"" of type '" "void **""'");
+ }
+ arg1 = (void **)(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "deref_any" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (void *)deref_any(arg1,arg2);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_scale_parameters) {
+ {
+ int argvi = 0;
+ paramT *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: scale_parameters();");
+ }
+ result = (paramT *)scale_parameters();
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_paramT, 0 | 0); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_copy_parameters) {
+ {
+ int argvi = 0;
+ paramT *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: copy_parameters();");
+ }
+ result = (paramT *)copy_parameters();
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_paramT, 0 | 0); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_set_parameters) {
+ {
+ paramT *arg1 = (paramT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ paramT *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: set_parameters(dest);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_paramT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_parameters" "', argument " "1"" of type '" "paramT *""'");
+ }
+ arg1 = (paramT *)(argp1);
+ result = (paramT *)set_parameters(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_paramT, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_aligned_line) {
+ {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: get_aligned_line(int);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_aligned_line" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (char *)get_aligned_line(arg1);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_make_loop_index) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: make_loop_index(structure);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_loop_index" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (short *)make_loop_index((char const *)arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexT_i_set) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: duplexT_i_set(self,i);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_i_set" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_i_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->i = arg2;
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexT_i_get) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: duplexT_i_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_i_get" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ result = (int) ((arg1)->i);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexT_j_set) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: duplexT_j_set(self,j);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_j_set" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_j_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->j = arg2;
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexT_j_get) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: duplexT_j_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_j_get" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ result = (int) ((arg1)->j);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexT_structure_set) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: duplexT_structure_set(self,structure);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_structure_set" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "duplexT_structure_set" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ if (arg1->structure) free((char*)arg1->structure);
+ if (arg2) {
+ size_t size = strlen((const char *)(arg2)) + 1;
+ arg1->structure = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
+ } else {
+ arg1->structure = 0;
+ }
+ ST(argvi) = sv_newmortal();
+
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexT_structure_get) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ char *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: duplexT_structure_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_structure_get" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ result = (char *) ((arg1)->structure);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexT_energy_set) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ float arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ float val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: duplexT_energy_set(self,energy);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_energy_set" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ ecode2 = SWIG_AsVal_float SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_energy_set" "', argument " "2"" of type '" "float""'");
+ }
+ arg2 = (float)(val2);
+ if (arg1) (arg1)->energy = arg2;
+ ST(argvi) = sv_newmortal();
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexT_energy_get) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: duplexT_energy_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_energy_get" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ result = (float) ((arg1)->energy);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_duplexT) {
+ {
+ int argvi = 0;
+ duplexT *result = 0 ;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_duplexT();");
+ }
+ result = (duplexT *)calloc(1, sizeof(duplexT));
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_duplexT, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_duplexT) {
+ {
+ duplexT *arg1 = (duplexT *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_duplexT(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_duplexT, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_duplexT" "', argument " "1"" of type '" "duplexT *""'");
+ }
+ arg1 = (duplexT *)(argp1);
+ free((char *) arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_duplexfold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ duplexT result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: duplexfold(s1,s2);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexfold" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "duplexfold" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = duplexfold((char const *)arg1,(char const *)arg2);
+ ST(argvi) = SWIG_NewPointerObj((duplexT *)memcpy((duplexT *)malloc(sizeof(duplexT)),&result,sizeof(duplexT)), SWIGTYPE_p_duplexT, SWIG_POINTER_OWN | SWIG_SHADOW); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_aliduplexfold) {
+ {
+ char **arg1 = (char **) 0 ;
+ char **arg2 = (char **) 0 ;
+ int argvi = 0;
+ duplexT result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: aliduplexfold(s1,s2);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(1)))
+ croak("Argument 2 is not a reference.");
+ if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
+ croak("Argument 2 is not an array.");
+ tempav = (AV*)SvRV(ST(1));
+ len = av_len(tempav);
+ arg2 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg2[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg2[i] = NULL;
+ }
+ result = aliduplexfold((char const **)arg1,(char const **)arg2);
+ ST(argvi) = SWIG_NewPointerObj((duplexT *)memcpy((duplexT *)malloc(sizeof(duplexT)),&result,sizeof(duplexT)), SWIGTYPE_p_duplexT, SWIG_POINTER_OWN | SWIG_SHADOW); argvi++ ;
+ {
+ free(arg1);
+ }
+ {
+ free(arg2);
+ }
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ {
+ free(arg2);
+ }
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_encode_seq) {
+ {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int argvi = 0;
+ short *result = 0 ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: encode_seq(sequence);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encode_seq" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (short *)encode_seq(arg1);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Lfold) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: Lfold(string,structure,maxdist);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lfold" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Lfold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Lfold" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (float)Lfold((char const *)arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Lfoldz) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ int arg4 ;
+ double arg5 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: Lfoldz(string,structure,maxdist,zsc,min_z);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lfoldz" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Lfoldz" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Lfoldz" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Lfoldz" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Lfoldz" "', argument " "5"" of type '" "double""'");
+ }
+ arg5 = (double)(val5);
+ result = (float)Lfoldz((char const *)arg1,arg2,arg3,arg4,arg5);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_aliLfold) {
+ {
+ char **arg1 = (char **) 0 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ float result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: aliLfold(strings,structure,maxdist);");
+ }
+ {
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK(ST(0)))
+ croak("Argument 1 is not a reference.");
+ if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
+ croak("Argument 1 is not an array.");
+ tempav = (AV*)SvRV(ST(0));
+ len = av_len(tempav);
+ arg1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ arg1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ arg1[i] = NULL;
+ }
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aliLfold" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aliLfold" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (float)aliLfold((char const **)arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_float SWIG_PERL_CALL_ARGS_1((float)(result)); argvi++ ;
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ XSRETURN(argvi);
+ fail:
+ {
+ free(arg1);
+ }
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_simple_xy_coordinates) {
+ {
+ short *arg1 = (short *) 0 ;
+ float *arg2 = (float *) 0 ;
+ float *arg3 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: simple_xy_coordinates(pair_table,X,Y);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simple_xy_coordinates" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "simple_xy_coordinates" "', argument " "2"" of type '" "float *""'");
+ }
+ arg2 = (float *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "simple_xy_coordinates" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ result = (int)simple_xy_coordinates(arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_simple_circplot_coordinates) {
+ {
+ short *arg1 = (short *) 0 ;
+ float *arg2 = (float *) 0 ;
+ float *arg3 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: simple_circplot_coordinates(pair_table,x,y);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_short, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simple_circplot_coordinates" "', argument " "1"" of type '" "short *""'");
+ }
+ arg1 = (short *)(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "simple_circplot_coordinates" "', argument " "2"" of type '" "float *""'");
+ }
+ arg2 = (float *)(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "simple_circplot_coordinates" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ result = (int)simple_circplot_coordinates(arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_rna_plot_snoop_a) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int *arg4 = (int *) 0 ;
+ char **arg5 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: PS_rna_plot_snoop_a(string,structure,ssfile,relative_access,seqs);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_rna_plot_snoop_a" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_rna_plot_snoop_a" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_rna_plot_snoop_a" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PS_rna_plot_snoop_a" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PS_rna_plot_snoop_a" "', argument " "5"" of type '" "char const *[]""'");
+ }
+ arg5 = (char **)(argp5);
+ result = (int)PS_rna_plot_snoop_a(arg1,arg2,arg3,arg4,(char const *(*))arg5);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_rna_plot) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: PS_rna_plot(string,structure,file);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_rna_plot" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_rna_plot" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_rna_plot" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (int)PS_rna_plot(arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_rna_plot_a) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ char *arg4 = (char *) 0 ;
+ char *arg5 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: PS_rna_plot_a(string,structure,file,pre,post);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_rna_plot_a" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_rna_plot_a" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_rna_plot_a" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PS_rna_plot_a" "', argument " "4"" of type '" "char *""'");
+ }
+ arg4 = (char *)(buf4);
+ res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PS_rna_plot_a" "', argument " "5"" of type '" "char *""'");
+ }
+ arg5 = (char *)(buf5);
+ result = (int)PS_rna_plot_a(arg1,arg2,arg3,arg4,arg5);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_rna_plot_a_gquad) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ char *arg4 = (char *) 0 ;
+ char *arg5 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: PS_rna_plot_a_gquad(string,structure,ssfile,pre,post);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_rna_plot_a_gquad" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_rna_plot_a_gquad" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_rna_plot_a_gquad" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PS_rna_plot_a_gquad" "', argument " "4"" of type '" "char *""'");
+ }
+ arg4 = (char *)(buf4);
+ res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PS_rna_plot_a_gquad" "', argument " "5"" of type '" "char *""'");
+ }
+ arg5 = (char *)(buf5);
+ result = (int)PS_rna_plot_a_gquad(arg1,arg2,arg3,arg4,arg5);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_gmlRNA) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ char arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ char val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: gmlRNA(string,structure,ssfile,option);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gmlRNA" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gmlRNA" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gmlRNA" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_char SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gmlRNA" "', argument " "4"" of type '" "char""'");
+ }
+ arg4 = (char)(val4);
+ result = (int)gmlRNA(arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_ssv_rna_plot) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: ssv_rna_plot(string,structure,ssfile);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ssv_rna_plot" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ssv_rna_plot" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ssv_rna_plot" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (int)ssv_rna_plot(arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_svg_rna_plot) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: svg_rna_plot(string,structure,ssfile);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svg_rna_plot" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svg_rna_plot" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svg_rna_plot" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (int)svg_rna_plot(arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_xrna_plot) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: xrna_plot(string,structure,ssfile);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xrna_plot" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xrna_plot" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xrna_plot" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (int)xrna_plot(arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_color_dot_plot) {
+ {
+ char *arg1 = (char *) 0 ;
+ cpair *arg2 = (cpair *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: PS_color_dot_plot(string,pi,filename);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_color_dot_plot" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_cpair, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_color_dot_plot" "', argument " "2"" of type '" "cpair *""'");
+ }
+ arg2 = (cpair *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_color_dot_plot" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (int)PS_color_dot_plot(arg1,arg2,arg3);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_color_dot_plot_turn) {
+ {
+ char *arg1 = (char *) 0 ;
+ cpair *arg2 = (cpair *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: PS_color_dot_plot_turn(seq,pi,filename,winSize);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_color_dot_plot_turn" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_cpair, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_color_dot_plot_turn" "', argument " "2"" of type '" "cpair *""'");
+ }
+ arg2 = (cpair *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_color_dot_plot_turn" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PS_color_dot_plot_turn" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (int)PS_color_dot_plot_turn(arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_dot_plot_list) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ plist *arg3 = (plist *) 0 ;
+ plist *arg4 = (plist *) 0 ;
+ char *arg5 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: PS_dot_plot_list(seq,filename,pl,mf,comment);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_dot_plot_list" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_dot_plot_list" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_dot_plot_list" "', argument " "3"" of type '" "plist *""'");
+ }
+ arg3 = (plist *)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PS_dot_plot_list" "', argument " "4"" of type '" "plist *""'");
+ }
+ arg4 = (plist *)(argp4);
+ res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PS_dot_plot_list" "', argument " "5"" of type '" "char *""'");
+ }
+ arg5 = (char *)(buf5);
+ result = (int)PS_dot_plot_list(arg1,arg2,arg3,arg4,arg5);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_dot_plot_turn) {
+ {
+ char *arg1 = (char *) 0 ;
+ struct plist *arg2 = (struct plist *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: PS_dot_plot_turn(seq,pl,filename,winSize);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_dot_plot_turn" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_plist, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_dot_plot_turn" "', argument " "2"" of type '" "struct plist *""'");
+ }
+ arg2 = (struct plist *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_dot_plot_turn" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PS_dot_plot_turn" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (int)PS_dot_plot_turn(arg1,arg2,arg3,arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_color_aln) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char **arg3 ;
+ char **arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: PS_color_aln(structure,filename,seqs,names);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_color_aln" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_color_aln" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_color_aln" "', argument " "3"" of type '" "char const *[]""'");
+ }
+ arg3 = (char **)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PS_color_aln" "', argument " "4"" of type '" "char const *[]""'");
+ }
+ arg4 = (char **)(argp4);
+ result = (int)PS_color_aln((char const *)arg1,(char const *)arg2,(char const *(*))arg3,(char const *(*))arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_aliPS_color_aln) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char **arg3 ;
+ char **arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: aliPS_color_aln(structure,filename,seqs,names);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliPS_color_aln" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aliPS_color_aln" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aliPS_color_aln" "', argument " "3"" of type '" "char const *[]""'");
+ }
+ arg3 = (char **)(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "aliPS_color_aln" "', argument " "4"" of type '" "char const *[]""'");
+ }
+ arg4 = (char **)(argp4);
+ result = (int)aliPS_color_aln((char const *)arg1,(char const *)arg2,(char const *(*))arg3,(char const *(*))arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PS_dot_plot) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: PS_dot_plot(string,file);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_dot_plot" "', argument " "1"" of type '" "char *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_dot_plot" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (int)PS_dot_plot(arg1,arg2);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_find_saddle) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ int result;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: find_saddle(seq,struc1,struc2,max);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "find_saddle" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "find_saddle" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "find_saddle" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "find_saddle" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (int)find_saddle((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_get_path) {
+ {
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ path_t *result = 0 ;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: get_path(seq,s1,s2,maxkeep);");
+ }
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_path" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_path" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_path" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "get_path" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (path_t *)get_path((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_path_t, 0 | 0); argvi++ ;
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ XSRETURN(argvi);
+ fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_free_path) {
+ {
+ path_t *arg1 = (path_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: free_path(path);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_path_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_path" "', argument " "1"" of type '" "path_t *""'");
+ }
+ arg1 = (path_t *)(argp1);
+ free_path(arg1);
+ ST(argvi) = sv_newmortal();
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_p_floatArrayTo_p_p_float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((float **) ((floatArray **) x));
+}
+static void *_p_floatArrayTo_p_float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((float *) ((floatArray *) x));
+}
+static void *_p_intArrayTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((int *) ((intArray *) x));
+}
+static void *_p_doubleArrayTo_p_double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((double *) ((doubleArray *) x));
+}
+static void *_p_p_doubleArrayTo_p_p_double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((double **) ((doubleArray **) x));
+}
+static void *_p_p_intArrayTo_p_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((int **) ((intArray **) x));
+}
+static swig_type_info _swigt__p_COORDINATE = {"_p_COORDINATE", "COORDINATE *", 0, 0, (void*)"RNA::COORDINATE", 0};
+static swig_type_info _swigt__p_ConcEnt = {"_p_ConcEnt", "ConcEnt *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SOLUTION = {"_p_SOLUTION", "SOLUTION *", 0, 0, (void*)"RNA::SOLUTION", 0};
+static swig_type_info _swigt__p_Tree = {"_p_Tree", "Tree *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_bondT = {"_p_bondT", "bondT *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_cofoldF = {"_p_cofoldF", "cofoldF *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_cpair = {"_p_cpair", "cpair *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_doubleArray = {"_p_doubleArray", "doubleArray *", 0, 0, (void*)"RNA::doubleArray", 0};
+static swig_type_info _swigt__p_duplexT = {"_p_duplexT", "duplexT *", 0, 0, (void*)"RNA::duplexT", 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_floatArray = {"_p_floatArray", "floatArray *", 0, 0, (void*)"RNA::floatArray", 0};
+static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_intArray = {"_p_intArray", "intArray *", 0, 0, (void*)"RNA::intArray", 0};
+static swig_type_info _swigt__p_model_detailsT = {"_p_model_detailsT", "model_detailsT *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_doubleArray = {"_p_p_doubleArray", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_float = {"_p_p_float", "float **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_floatArray = {"_p_p_floatArray", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_intArray = {"_p_p_intArray", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_p_short = {"_p_p_p_short", "short ***", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_p_unsigned_short = {"_p_p_p_unsigned_short", "unsigned short ***", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_paramT = {"_p_p_paramT", "paramT **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_plist = {"_p_p_plist", "plist **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_short = {"_p_p_short", "short **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_paramT = {"_p_paramT", "paramT *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_path_t = {"_p_path_t", "path_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_pf_paramT = {"_p_pf_paramT", "pf_paramT *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_plist = {"_p_plist", "plist *|struct plist *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_swString = {"_p_swString", "swString *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+ &_swigt__p_COORDINATE,
+ &_swigt__p_ConcEnt,
+ &_swigt__p_FILE,
+ &_swigt__p_SOLUTION,
+ &_swigt__p_Tree,
+ &_swigt__p_bondT,
+ &_swigt__p_char,
+ &_swigt__p_cofoldF,
+ &_swigt__p_cpair,
+ &_swigt__p_double,
+ &_swigt__p_doubleArray,
+ &_swigt__p_duplexT,
+ &_swigt__p_float,
+ &_swigt__p_floatArray,
+ &_swigt__p_int,
+ &_swigt__p_intArray,
+ &_swigt__p_model_detailsT,
+ &_swigt__p_p_char,
+ &_swigt__p_p_double,
+ &_swigt__p_p_doubleArray,
+ &_swigt__p_p_float,
+ &_swigt__p_p_floatArray,
+ &_swigt__p_p_int,
+ &_swigt__p_p_intArray,
+ &_swigt__p_p_p_char,
+ &_swigt__p_p_p_short,
+ &_swigt__p_p_p_unsigned_short,
+ &_swigt__p_p_paramT,
+ &_swigt__p_p_plist,
+ &_swigt__p_p_short,
+ &_swigt__p_p_void,
+ &_swigt__p_paramT,
+ &_swigt__p_path_t,
+ &_swigt__p_pf_paramT,
+ &_swigt__p_plist,
+ &_swigt__p_short,
+ &_swigt__p_swString,
+ &_swigt__p_unsigned_int,
+ &_swigt__p_unsigned_short,
+ &_swigt__p_void,
+};
+
+static swig_cast_info _swigc__p_COORDINATE[] = { {&_swigt__p_COORDINATE, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ConcEnt[] = { {&_swigt__p_ConcEnt, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SOLUTION[] = { {&_swigt__p_SOLUTION, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Tree[] = { {&_swigt__p_Tree, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_bondT[] = { {&_swigt__p_bondT, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_cofoldF[] = { {&_swigt__p_cofoldF, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_cpair[] = { {&_swigt__p_cpair, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = { {&_swigt__p_doubleArray, _p_doubleArrayTo_p_double, 0, 0}, {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_doubleArray[] = { {&_swigt__p_doubleArray, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_duplexT[] = { {&_swigt__p_duplexT, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0}, {&_swigt__p_floatArray, _p_floatArrayTo_p_float, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_floatArray[] = { {&_swigt__p_floatArray, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = { {&_swigt__p_intArray, _p_intArrayTo_p_int, 0, 0}, {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_intArray[] = { {&_swigt__p_intArray, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_model_detailsT[] = { {&_swigt__p_model_detailsT, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_doubleArray[] = {{&_swigt__p_p_doubleArray, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_doubleArray, _p_p_doubleArrayTo_p_p_double, 0, 0}, {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_floatArray[] = {{&_swigt__p_p_floatArray, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_float[] = { {&_swigt__p_p_float, 0, 0, 0}, {&_swigt__p_p_floatArray, _p_p_floatArrayTo_p_p_float, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_intArray[] = {{&_swigt__p_p_intArray, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_int[] = { {&_swigt__p_p_intArray, _p_p_intArrayTo_p_p_int, 0, 0}, {&_swigt__p_p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_p_char[] = { {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_p_short[] = { {&_swigt__p_p_p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_p_unsigned_short[] = { {&_swigt__p_p_p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_paramT[] = { {&_swigt__p_p_paramT, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_plist[] = { {&_swigt__p_p_plist, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_short[] = { {&_swigt__p_p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_paramT[] = { {&_swigt__p_paramT, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_path_t[] = { {&_swigt__p_path_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_pf_paramT[] = { {&_swigt__p_pf_paramT, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_plist[] = { {&_swigt__p_plist, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_swString[] = { {&_swigt__p_swString, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+ _swigc__p_COORDINATE,
+ _swigc__p_ConcEnt,
+ _swigc__p_FILE,
+ _swigc__p_SOLUTION,
+ _swigc__p_Tree,
+ _swigc__p_bondT,
+ _swigc__p_char,
+ _swigc__p_cofoldF,
+ _swigc__p_cpair,
+ _swigc__p_double,
+ _swigc__p_doubleArray,
+ _swigc__p_duplexT,
+ _swigc__p_float,
+ _swigc__p_floatArray,
+ _swigc__p_int,
+ _swigc__p_intArray,
+ _swigc__p_model_detailsT,
+ _swigc__p_p_char,
+ _swigc__p_p_double,
+ _swigc__p_p_doubleArray,
+ _swigc__p_p_float,
+ _swigc__p_p_floatArray,
+ _swigc__p_p_int,
+ _swigc__p_p_intArray,
+ _swigc__p_p_p_char,
+ _swigc__p_p_p_short,
+ _swigc__p_p_p_unsigned_short,
+ _swigc__p_p_paramT,
+ _swigc__p_p_plist,
+ _swigc__p_p_short,
+ _swigc__p_p_void,
+ _swigc__p_paramT,
+ _swigc__p_path_t,
+ _swigc__p_pf_paramT,
+ _swigc__p_plist,
+ _swigc__p_short,
+ _swigc__p_swString,
+ _swigc__p_unsigned_int,
+ _swigc__p_unsigned_short,
+ _swigc__p_void,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+static swig_constant_info swig_constants[] = {
+{0,0,0,0,0,0}
+};
+#ifdef __cplusplus
+}
+#endif
+static swig_variable_info swig_variables[] = {
+ { "RNAc::logML", MAGIC_CLASS _wrap_logML_set, MAGIC_CLASS _wrap_logML_get,0 },
+ { "RNAc::uniq_ML", MAGIC_CLASS _wrap_uniq_ML_set, MAGIC_CLASS _wrap_uniq_ML_get,0 },
+ { "RNAc::cut_point", MAGIC_CLASS _wrap_cut_point_set, MAGIC_CLASS _wrap_cut_point_get,0 },
+ { "RNAc::eos_debug", MAGIC_CLASS _wrap_eos_debug_set, MAGIC_CLASS _wrap_eos_debug_get,0 },
+ { "RNAc::st_back", MAGIC_CLASS _wrap_st_back_set, MAGIC_CLASS _wrap_st_back_get,0 },
+ { "RNAc::mirnatog", MAGIC_CLASS _wrap_mirnatog_set, MAGIC_CLASS _wrap_mirnatog_get,0 },
+ { "RNAc::F_monomer", MAGIC_CLASS _wrap_F_monomer_set, MAGIC_CLASS _wrap_F_monomer_get,&SWIGTYPE_p_double },
+ { "RNAc::symbolset", MAGIC_CLASS _wrap_symbolset_set, MAGIC_CLASS _wrap_symbolset_get,0 },
+ { "RNAc::final_cost", MAGIC_CLASS _wrap_final_cost_set, MAGIC_CLASS _wrap_final_cost_get,0 },
+ { "RNAc::give_up", MAGIC_CLASS _wrap_give_up_set, MAGIC_CLASS _wrap_give_up_get,0 },
+ { "RNAc::inv_verbose", MAGIC_CLASS _wrap_inv_verbose_set, MAGIC_CLASS _wrap_inv_verbose_get,0 },
+ { "RNAc::fold_constrained", MAGIC_CLASS _wrap_fold_constrained_set, MAGIC_CLASS _wrap_fold_constrained_get,0 },
+ { "RNAc::noLonelyPairs", MAGIC_CLASS _wrap_noLonelyPairs_set, MAGIC_CLASS _wrap_noLonelyPairs_get,0 },
+ { "RNAc::dangles", MAGIC_CLASS _wrap_dangles_set, MAGIC_CLASS _wrap_dangles_get,0 },
+ { "RNAc::noGU", MAGIC_CLASS _wrap_noGU_set, MAGIC_CLASS _wrap_noGU_get,0 },
+ { "RNAc::no_closingGU", MAGIC_CLASS _wrap_no_closingGU_set, MAGIC_CLASS _wrap_no_closingGU_get,0 },
+ { "RNAc::tetra_loop", MAGIC_CLASS _wrap_tetra_loop_set, MAGIC_CLASS _wrap_tetra_loop_get,0 },
+ { "RNAc::energy_set", MAGIC_CLASS _wrap_energy_set_set, MAGIC_CLASS _wrap_energy_set_get,0 },
+ { "RNAc::circ", MAGIC_CLASS _wrap_circ_set, MAGIC_CLASS _wrap_circ_get,0 },
+ { "RNAc::csv", MAGIC_CLASS _wrap_csv_set, MAGIC_CLASS _wrap_csv_get,0 },
+ { "RNAc::oldAliEn", MAGIC_CLASS _wrap_oldAliEn_set, MAGIC_CLASS _wrap_oldAliEn_get,0 },
+ { "RNAc::ribo", MAGIC_CLASS _wrap_ribo_set, MAGIC_CLASS _wrap_ribo_get,0 },
+ { "RNAc::RibosumFile", MAGIC_CLASS _wrap_RibosumFile_set, MAGIC_CLASS _wrap_RibosumFile_get,0 },
+ { "RNAc::nonstandards", MAGIC_CLASS _wrap_nonstandards_set, MAGIC_CLASS _wrap_nonstandards_get,0 },
+ { "RNAc::temperature", MAGIC_CLASS _wrap_temperature_set, MAGIC_CLASS _wrap_temperature_get,0 },
+ { "RNAc::james_rule", MAGIC_CLASS _wrap_james_rule_set, MAGIC_CLASS _wrap_james_rule_get,0 },
+ { "RNAc::base_pair", MAGIC_CLASS _wrap_base_pair_set, MAGIC_CLASS _wrap_base_pair_get,&SWIGTYPE_p_bondT },
+ { "RNAc::pr", MAGIC_CLASS _wrap_pr_set, MAGIC_CLASS _wrap_pr_get,&SWIGTYPE_p_double },
+ { "RNAc::iindx", MAGIC_CLASS _wrap_iindx_set, MAGIC_CLASS _wrap_iindx_get,&SWIGTYPE_p_int },
+ { "RNAc::pf_scale", MAGIC_CLASS _wrap_pf_scale_set, MAGIC_CLASS _wrap_pf_scale_get,0 },
+ { "RNAc::do_backtrack", MAGIC_CLASS _wrap_do_backtrack_set, MAGIC_CLASS _wrap_do_backtrack_get,0 },
+ { "RNAc::backtrack_type", MAGIC_CLASS _wrap_backtrack_type_set, MAGIC_CLASS _wrap_backtrack_type_get,0 },
+ { "RNAc::gquad", MAGIC_CLASS _wrap_gquad_set, MAGIC_CLASS _wrap_gquad_get,0 },
+ { "RNAc::cv_fact", MAGIC_CLASS _wrap_cv_fact_set, MAGIC_CLASS _wrap_cv_fact_get,0 },
+ { "RNAc::nc_fact", MAGIC_CLASS _wrap_nc_fact_set, MAGIC_CLASS _wrap_nc_fact_get,0 },
+ { "RNAc::subopt_sorted", MAGIC_CLASS _wrap_subopt_sorted_set, MAGIC_CLASS _wrap_subopt_sorted_get,0 },
+ { "RNAc::loop_size", MAGIC_CLASS _wrap_loop_size_set, MAGIC_CLASS _wrap_loop_size_get,&SWIGTYPE_p_int },
+ { "RNAc::helix_size", MAGIC_CLASS _wrap_helix_size_set, MAGIC_CLASS _wrap_helix_size_get,&SWIGTYPE_p_int },
+ { "RNAc::loop_degree", MAGIC_CLASS _wrap_loop_degree_set, MAGIC_CLASS _wrap_loop_degree_get,&SWIGTYPE_p_int },
+ { "RNAc::loops", MAGIC_CLASS _wrap_loops_set, MAGIC_CLASS _wrap_loops_get,0 },
+ { "RNAc::unpaired", MAGIC_CLASS _wrap_unpaired_set, MAGIC_CLASS _wrap_unpaired_get,0 },
+ { "RNAc::pairs", MAGIC_CLASS _wrap_pairs_set, MAGIC_CLASS _wrap_pairs_get,0 },
+ { "RNAc::edit_backtrack", MAGIC_CLASS _wrap_edit_backtrack_set, MAGIC_CLASS _wrap_edit_backtrack_get,0 },
+ { "RNAc::aligned_line", MAGIC_CLASS _wrap_aligned_line_set, MAGIC_CLASS _wrap_aligned_line_get,&SWIGTYPE_p_p_char },
+ { "RNAc::cost_matrix", MAGIC_CLASS _wrap_cost_matrix_set, MAGIC_CLASS _wrap_cost_matrix_get,0 },
+ { "RNAc::xsubi", MAGIC_CLASS _wrap_xsubi_set, MAGIC_CLASS _wrap_xsubi_get,&SWIGTYPE_p_unsigned_short },
+ { "RNAc::rna_plot_type", MAGIC_CLASS _wrap_rna_plot_type_set, MAGIC_CLASS _wrap_rna_plot_type_get,0 },
+{0,0,0,0}
+};
+static swig_command_info swig_commands[] = {
+{"RNAc::new_intP", _wrap_new_intP},
+{"RNAc::delete_intP", _wrap_delete_intP},
+{"RNAc::intP_getitem", _wrap_intP_getitem},
+{"RNAc::intP_setitem", _wrap_intP_setitem},
+{"RNAc::new_intArray", _wrap_new_intArray},
+{"RNAc::delete_intArray", _wrap_delete_intArray},
+{"RNAc::intArray_getitem", _wrap_intArray_getitem},
+{"RNAc::intArray_setitem", _wrap_intArray_setitem},
+{"RNAc::intArray_cast", _wrap_intArray_cast},
+{"RNAc::intArray_frompointer", _wrap_intArray_frompointer},
+{"RNAc::new_floatP", _wrap_new_floatP},
+{"RNAc::delete_floatP", _wrap_delete_floatP},
+{"RNAc::floatP_getitem", _wrap_floatP_getitem},
+{"RNAc::floatP_setitem", _wrap_floatP_setitem},
+{"RNAc::new_floatArray", _wrap_new_floatArray},
+{"RNAc::delete_floatArray", _wrap_delete_floatArray},
+{"RNAc::floatArray_getitem", _wrap_floatArray_getitem},
+{"RNAc::floatArray_setitem", _wrap_floatArray_setitem},
+{"RNAc::floatArray_cast", _wrap_floatArray_cast},
+{"RNAc::floatArray_frompointer", _wrap_floatArray_frompointer},
+{"RNAc::new_doubleP", _wrap_new_doubleP},
+{"RNAc::delete_doubleP", _wrap_delete_doubleP},
+{"RNAc::doubleP_getitem", _wrap_doubleP_getitem},
+{"RNAc::doubleP_setitem", _wrap_doubleP_setitem},
+{"RNAc::new_doubleArray", _wrap_new_doubleArray},
+{"RNAc::delete_doubleArray", _wrap_delete_doubleArray},
+{"RNAc::doubleArray_getitem", _wrap_doubleArray_getitem},
+{"RNAc::doubleArray_setitem", _wrap_doubleArray_setitem},
+{"RNAc::doubleArray_cast", _wrap_doubleArray_cast},
+{"RNAc::doubleArray_frompointer", _wrap_doubleArray_frompointer},
+{"RNAc::new_ushortP", _wrap_new_ushortP},
+{"RNAc::delete_ushortP", _wrap_delete_ushortP},
+{"RNAc::ushortP_getitem", _wrap_ushortP_getitem},
+{"RNAc::ushortP_setitem", _wrap_ushortP_setitem},
+{"RNAc::new_shortP", _wrap_new_shortP},
+{"RNAc::delete_shortP", _wrap_delete_shortP},
+{"RNAc::shortP_getitem", _wrap_shortP_getitem},
+{"RNAc::shortP_setitem", _wrap_shortP_setitem},
+{"RNAc::cdata", _wrap_cdata},
+{"RNAc::memmove", _wrap_memmove},
+{"RNAc::fold", _wrap_fold},
+{"RNAc::fold_par", _wrap_fold_par},
+{"RNAc::circfold", _wrap_circfold},
+{"RNAc::energy_of_structure", _wrap_energy_of_structure},
+{"RNAc::energy_of_struct_par", _wrap_energy_of_struct_par},
+{"RNAc::energy_of_circ_structure", _wrap_energy_of_circ_structure},
+{"RNAc::energy_of_circ_struct_par", _wrap_energy_of_circ_struct_par},
+{"RNAc::energy_of_gquad_structure", _wrap_energy_of_gquad_structure},
+{"RNAc::energy_of_structure_pt", _wrap_energy_of_structure_pt},
+{"RNAc::energy_of_struct_pt_par", _wrap_energy_of_struct_pt_par},
+{"RNAc::free_arrays", _wrap_free_arrays},
+{"RNAc::parenthesis_structure", _wrap_parenthesis_structure},
+{"RNAc::parenthesis_zuker", _wrap_parenthesis_zuker},
+{"RNAc::letter_structure", _wrap_letter_structure},
+{"RNAc::update_fold_params", _wrap_update_fold_params},
+{"RNAc::update_fold_params_par", _wrap_update_fold_params_par},
+{"RNAc::backtrack_fold_from_pair", _wrap_backtrack_fold_from_pair},
+{"RNAc::energy_of_move", _wrap_energy_of_move},
+{"RNAc::energy_of_move_pt", _wrap_energy_of_move_pt},
+{"RNAc::loop_energy", _wrap_loop_energy},
+{"RNAc::export_fold_arrays", _wrap_export_fold_arrays},
+{"RNAc::export_fold_arrays_par", _wrap_export_fold_arrays_par},
+{"RNAc::export_circfold_arrays", _wrap_export_circfold_arrays},
+{"RNAc::export_circfold_arrays_par", _wrap_export_circfold_arrays_par},
+{"RNAc::assign_plist_from_db", _wrap_assign_plist_from_db},
+{"RNAc::LoopEnergy", _wrap_LoopEnergy},
+{"RNAc::HairpinE", _wrap_HairpinE},
+{"RNAc::initialize_fold", _wrap_initialize_fold},
+{"RNAc::energy_of_struct", _wrap_energy_of_struct},
+{"RNAc::energy_of_struct_pt", _wrap_energy_of_struct_pt},
+{"RNAc::energy_of_circ_struct", _wrap_energy_of_circ_struct},
+{"RNAc::cofold", _wrap_cofold},
+{"RNAc::cofold_par", _wrap_cofold_par},
+{"RNAc::free_co_arrays", _wrap_free_co_arrays},
+{"RNAc::update_cofold_params", _wrap_update_cofold_params},
+{"RNAc::update_cofold_params_par", _wrap_update_cofold_params_par},
+{"RNAc::export_cofold_arrays_gq", _wrap_export_cofold_arrays_gq},
+{"RNAc::export_cofold_arrays", _wrap_export_cofold_arrays},
+{"RNAc::zukersubopt", _wrap_zukersubopt},
+{"RNAc::zukersubopt_par", _wrap_zukersubopt_par},
+{"RNAc::get_monomere_mfes", _wrap_get_monomere_mfes},
+{"RNAc::initialize_cofold", _wrap_initialize_cofold},
+{"RNAc::pf_fold", _wrap_pf_fold},
+{"RNAc::pf_fold_par", _wrap_pf_fold_par},
+{"RNAc::pf_circ_fold", _wrap_pf_circ_fold},
+{"RNAc::pbacktrack", _wrap_pbacktrack},
+{"RNAc::pbacktrack_circ", _wrap_pbacktrack_circ},
+{"RNAc::free_pf_arrays", _wrap_free_pf_arrays},
+{"RNAc::update_pf_params", _wrap_update_pf_params},
+{"RNAc::update_pf_params_par", _wrap_update_pf_params_par},
+{"RNAc::export_bppm", _wrap_export_bppm},
+{"RNAc::assign_plist_from_pr", _wrap_assign_plist_from_pr},
+{"RNAc::assign_plist_gquad_from_pr", _wrap_assign_plist_gquad_from_pr},
+{"RNAc::get_centroid_struct_gquad_pr", _wrap_get_centroid_struct_gquad_pr},
+{"RNAc::get_pf_arrays", _wrap_get_pf_arrays},
+{"RNAc::get_subseq_F", _wrap_get_subseq_F},
+{"RNAc::get_centroid_struct_pl", _wrap_get_centroid_struct_pl},
+{"RNAc::get_centroid_struct_pr", _wrap_get_centroid_struct_pr},
+{"RNAc::mean_bp_distance", _wrap_mean_bp_distance},
+{"RNAc::mean_bp_distance_pr", _wrap_mean_bp_distance_pr},
+{"RNAc::bppm_to_structure", _wrap_bppm_to_structure},
+{"RNAc::stackProb", _wrap_stackProb},
+{"RNAc::bppm_symbol", _wrap_bppm_symbol},
+{"RNAc::init_pf_fold", _wrap_init_pf_fold},
+{"RNAc::centroid", _wrap_centroid},
+{"RNAc::mean_bp_dist", _wrap_mean_bp_dist},
+{"RNAc::expLoopEnergy", _wrap_expLoopEnergy},
+{"RNAc::expHairpinEnergy", _wrap_expHairpinEnergy},
+{"RNAc::co_pf_fold", _wrap_co_pf_fold},
+{"RNAc::co_pf_fold_par", _wrap_co_pf_fold_par},
+{"RNAc::export_co_bppm", _wrap_export_co_bppm},
+{"RNAc::free_co_pf_arrays", _wrap_free_co_pf_arrays},
+{"RNAc::update_co_pf_params", _wrap_update_co_pf_params},
+{"RNAc::update_co_pf_params_par", _wrap_update_co_pf_params_par},
+{"RNAc::get_concentrations", _wrap_get_concentrations},
+{"RNAc::inverse_fold", _wrap_inverse_fold},
+{"RNAc::inverse_pf_fold", _wrap_inverse_pf_fold},
+{"RNAc::option_string", _wrap_option_string},
+{"RNAc::set_model_details", _wrap_set_model_details},
+{"RNAc::update_alifold_params", _wrap_update_alifold_params},
+{"RNAc::circalifold", _wrap_circalifold},
+{"RNAc::free_alifold_arrays", _wrap_free_alifold_arrays},
+{"RNAc::get_mpi", _wrap_get_mpi},
+{"RNAc::readribosum", _wrap_readribosum},
+{"RNAc::energy_of_alistruct", _wrap_energy_of_alistruct},
+{"RNAc::energy_of_ali_gquad_structure", _wrap_energy_of_ali_gquad_structure},
+{"RNAc::encode_ali_sequence", _wrap_encode_ali_sequence},
+{"RNAc::alloc_sequence_arrays", _wrap_alloc_sequence_arrays},
+{"RNAc::free_sequence_arrays", _wrap_free_sequence_arrays},
+{"RNAc::alipf_fold_par", _wrap_alipf_fold_par},
+{"RNAc::alipf_fold", _wrap_alipf_fold},
+{"RNAc::alipf_circ_fold", _wrap_alipf_circ_fold},
+{"RNAc::export_ali_bppm", _wrap_export_ali_bppm},
+{"RNAc::free_alipf_arrays", _wrap_free_alipf_arrays},
+{"RNAc::alipbacktrack", _wrap_alipbacktrack},
+{"RNAc::get_alipf_arrays", _wrap_get_alipf_arrays},
+{"RNAc::alifold", _wrap_alifold},
+{"RNAc::consensus", _wrap_consensus},
+{"RNAc::consens_mis", _wrap_consens_mis},
+{"RNAc::COORDINATE_X_set", _wrap_COORDINATE_X_set},
+{"RNAc::COORDINATE_X_get", _wrap_COORDINATE_X_get},
+{"RNAc::COORDINATE_Y_set", _wrap_COORDINATE_Y_set},
+{"RNAc::COORDINATE_Y_get", _wrap_COORDINATE_Y_get},
+{"RNAc::COORDINATE_get", _wrap_COORDINATE_get},
+{"RNAc::new_COORDINATE", _wrap_new_COORDINATE},
+{"RNAc::delete_COORDINATE", _wrap_delete_COORDINATE},
+{"RNAc::get_xy_coordinates", _wrap_get_xy_coordinates},
+{"RNAc::SOLUTION_energy_set", _wrap_SOLUTION_energy_set},
+{"RNAc::SOLUTION_energy_get", _wrap_SOLUTION_energy_get},
+{"RNAc::SOLUTION_structure_set", _wrap_SOLUTION_structure_set},
+{"RNAc::SOLUTION_structure_get", _wrap_SOLUTION_structure_get},
+{"RNAc::SOLUTION_get", _wrap_SOLUTION_get},
+{"RNAc::SOLUTION_size", _wrap_SOLUTION_size},
+{"RNAc::delete_SOLUTION", _wrap_delete_SOLUTION},
+{"RNAc::new_SOLUTION", _wrap_new_SOLUTION},
+{"RNAc::subopt", _wrap_subopt},
+{"RNAc::get_pr", _wrap_get_pr},
+{"RNAc::b2HIT", _wrap_b2HIT},
+{"RNAc::b2C", _wrap_b2C},
+{"RNAc::b2Shapiro", _wrap_b2Shapiro},
+{"RNAc::add_root", _wrap_add_root},
+{"RNAc::expand_Shapiro", _wrap_expand_Shapiro},
+{"RNAc::expand_Full", _wrap_expand_Full},
+{"RNAc::unexpand_Full", _wrap_unexpand_Full},
+{"RNAc::unweight", _wrap_unweight},
+{"RNAc::unexpand_aligned_F", _wrap_unexpand_aligned_F},
+{"RNAc::parse_structure", _wrap_parse_structure},
+{"RNAc::make_tree", _wrap_make_tree},
+{"RNAc::tree_edit_distance", _wrap_tree_edit_distance},
+{"RNAc::print_tree", _wrap_print_tree},
+{"RNAc::free_tree", _wrap_free_tree},
+{"RNAc::Make_swString", _wrap_Make_swString},
+{"RNAc::string_edit_distance", _wrap_string_edit_distance},
+{"RNAc::profile_edit_distance", _wrap_profile_edit_distance},
+{"RNAc::Make_bp_profile_bppm", _wrap_Make_bp_profile_bppm},
+{"RNAc::print_bppm", _wrap_print_bppm},
+{"RNAc::free_profile", _wrap_free_profile},
+{"RNAc::Make_bp_profile", _wrap_Make_bp_profile},
+{"RNAc::space", _wrap_space},
+{"RNAc::xrealloc", _wrap_xrealloc},
+{"RNAc::nrerror", _wrap_nrerror},
+{"RNAc::warn_user", _wrap_warn_user},
+{"RNAc::init_rand", _wrap_init_rand},
+{"RNAc::urn", _wrap_urn},
+{"RNAc::int_urn", _wrap_int_urn},
+{"RNAc::filecopy", _wrap_filecopy},
+{"RNAc::time_stamp", _wrap_time_stamp},
+{"RNAc::random_string", _wrap_random_string},
+{"RNAc::hamming", _wrap_hamming},
+{"RNAc::hamming_bound", _wrap_hamming_bound},
+{"RNAc::get_line", _wrap_get_line},
+{"RNAc::skip_comment_lines", _wrap_skip_comment_lines},
+{"RNAc::get_input_line", _wrap_get_input_line},
+{"RNAc::get_multi_input_line", _wrap_get_multi_input_line},
+{"RNAc::read_record", _wrap_read_record},
+{"RNAc::extract_record_rest_structure", _wrap_extract_record_rest_structure},
+{"RNAc::pack_structure", _wrap_pack_structure},
+{"RNAc::unpack_structure", _wrap_unpack_structure},
+{"RNAc::make_pair_table", _wrap_make_pair_table},
+{"RNAc::make_pair_table_pk", _wrap_make_pair_table_pk},
+{"RNAc::copy_pair_table", _wrap_copy_pair_table},
+{"RNAc::alimake_pair_table", _wrap_alimake_pair_table},
+{"RNAc::make_pair_table_snoop", _wrap_make_pair_table_snoop},
+{"RNAc::make_loop_index_pt", _wrap_make_loop_index_pt},
+{"RNAc::bp_distance", _wrap_bp_distance},
+{"RNAc::print_tty_input_seq", _wrap_print_tty_input_seq},
+{"RNAc::print_tty_input_seq_str", _wrap_print_tty_input_seq_str},
+{"RNAc::print_tty_constraint_full", _wrap_print_tty_constraint_full},
+{"RNAc::print_tty_constraint", _wrap_print_tty_constraint},
+{"RNAc::str_DNA2RNA", _wrap_str_DNA2RNA},
+{"RNAc::str_uppercase", _wrap_str_uppercase},
+{"RNAc::get_iindx", _wrap_get_iindx},
+{"RNAc::get_indx", _wrap_get_indx},
+{"RNAc::getConstraint", _wrap_getConstraint},
+{"RNAc::constrain_ptypes", _wrap_constrain_ptypes},
+{"RNAc::make_referenceBP_array", _wrap_make_referenceBP_array},
+{"RNAc::compute_BPdifferences", _wrap_compute_BPdifferences},
+{"RNAc::read_parameter_file", _wrap_read_parameter_file},
+{"RNAc::write_parameter_file", _wrap_write_parameter_file},
+{"RNAc::deref_any", _wrap_deref_any},
+{"RNAc::scale_parameters", _wrap_scale_parameters},
+{"RNAc::copy_parameters", _wrap_copy_parameters},
+{"RNAc::set_parameters", _wrap_set_parameters},
+{"RNAc::get_aligned_line", _wrap_get_aligned_line},
+{"RNAc::make_loop_index", _wrap_make_loop_index},
+{"RNAc::duplexT_i_set", _wrap_duplexT_i_set},
+{"RNAc::duplexT_i_get", _wrap_duplexT_i_get},
+{"RNAc::duplexT_j_set", _wrap_duplexT_j_set},
+{"RNAc::duplexT_j_get", _wrap_duplexT_j_get},
+{"RNAc::duplexT_structure_set", _wrap_duplexT_structure_set},
+{"RNAc::duplexT_structure_get", _wrap_duplexT_structure_get},
+{"RNAc::duplexT_energy_set", _wrap_duplexT_energy_set},
+{"RNAc::duplexT_energy_get", _wrap_duplexT_energy_get},
+{"RNAc::new_duplexT", _wrap_new_duplexT},
+{"RNAc::delete_duplexT", _wrap_delete_duplexT},
+{"RNAc::duplexfold", _wrap_duplexfold},
+{"RNAc::aliduplexfold", _wrap_aliduplexfold},
+{"RNAc::encode_seq", _wrap_encode_seq},
+{"RNAc::Lfold", _wrap_Lfold},
+{"RNAc::Lfoldz", _wrap_Lfoldz},
+{"RNAc::aliLfold", _wrap_aliLfold},
+{"RNAc::simple_xy_coordinates", _wrap_simple_xy_coordinates},
+{"RNAc::simple_circplot_coordinates", _wrap_simple_circplot_coordinates},
+{"RNAc::PS_rna_plot_snoop_a", _wrap_PS_rna_plot_snoop_a},
+{"RNAc::PS_rna_plot", _wrap_PS_rna_plot},
+{"RNAc::PS_rna_plot_a", _wrap_PS_rna_plot_a},
+{"RNAc::PS_rna_plot_a_gquad", _wrap_PS_rna_plot_a_gquad},
+{"RNAc::gmlRNA", _wrap_gmlRNA},
+{"RNAc::ssv_rna_plot", _wrap_ssv_rna_plot},
+{"RNAc::svg_rna_plot", _wrap_svg_rna_plot},
+{"RNAc::xrna_plot", _wrap_xrna_plot},
+{"RNAc::PS_color_dot_plot", _wrap_PS_color_dot_plot},
+{"RNAc::PS_color_dot_plot_turn", _wrap_PS_color_dot_plot_turn},
+{"RNAc::PS_dot_plot_list", _wrap_PS_dot_plot_list},
+{"RNAc::PS_dot_plot_turn", _wrap_PS_dot_plot_turn},
+{"RNAc::PS_color_aln", _wrap_PS_color_aln},
+{"RNAc::aliPS_color_aln", _wrap_aliPS_color_aln},
+{"RNAc::PS_dot_plot", _wrap_PS_dot_plot},
+{"RNAc::find_saddle", _wrap_find_saddle},
+{"RNAc::get_path", _wrap_get_path},
+{"RNAc::free_path", _wrap_free_path},
+{0,0}
+};
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned staticly to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ * 1) If the cast->type has already been loaded AND the type we are adding
+ * casting info to has not been loaded (it is in this module), THEN we
+ * replace the cast->type pointer with the type pointer that has already
+ * been loaded.
+ * 2) If BOTH types (the one we are adding casting info to, and the
+ * cast->type) are loaded, THEN the cast info has already been loaded by
+ * the previous module so we just ignore it.
+ * 3) Finally, if cast->type has not already been loaded, then we add that
+ * swig_cast_info to the linked list (because the cast->type) pointer will
+ * be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+ size_t i;
+ swig_module_info *module_head, *iter;
+ int found, init;
+ (void *)clientdata;
+
+ /* check to see if the circular list has been setup, if not, set it up */
+ if (swig_module.next==0) {
+ /* Initialize the swig_module */
+ swig_module.type_initial = swig_type_initial;
+ swig_module.cast_initial = swig_cast_initial;
+ swig_module.next = &swig_module;
+ init = 1;
+ } else {
+ init = 0;
+ }
+
+ /* Try and load any already created modules */
+ module_head = SWIG_GetModule(clientdata);
+ if (!module_head) {
+ /* This is the first module loaded for this interpreter */
+ /* so set the swig module into the interpreter */
+ SWIG_SetModule(clientdata, &swig_module);
+ module_head = &swig_module;
+ } else {
+ /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+ found=0;
+ iter=module_head;
+ do {
+ if (iter==&swig_module) {
+ found=1;
+ break;
+ }
+ iter=iter->next;
+ } while (iter!= module_head);
+
+ /* if the is found in the list, then all is done and we may leave */
+ if (found) return;
+ /* otherwise we must add out module into the list */
+ swig_module.next = module_head->next;
+ module_head->next = &swig_module;
+ }
+
+ /* When multiple interpeters are used, a module could have already been initialized in
+ a different interpreter, but not yet have a pointer in this interpreter.
+ In this case, we do not want to continue adding types... everything should be
+ set up already */
+ if (init == 0) return;
+
+ /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+ for (i = 0; i < swig_module.size; ++i) {
+ swig_type_info *type = 0;
+ swig_type_info *ret;
+ swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+ /* if there is another module already loaded */
+ if (swig_module.next != &swig_module) {
+ type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+ }
+ if (type) {
+ /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+ if (swig_module.type_initial[i]->clientdata) {
+ type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+ }
+ } else {
+ type = swig_module.type_initial[i];
+ }
+
+ /* Insert casting types */
+ cast = swig_module.cast_initial[i];
+ while (cast->type) {
+ /* Don't need to add information already in the list */
+ ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+ if (swig_module.next != &swig_module) {
+ ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+ if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+ }
+ if (ret) {
+ if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+ cast->type = ret;
+ ret = 0;
+ } else {
+ /* Check for casting already in the list */
+ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+ if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+ if (!ocast) ret = 0;
+ }
+ }
+
+ if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+ if (type->cast) {
+ type->cast->prev = cast;
+ cast->next = type->cast;
+ }
+ type->cast = cast;
+ }
+ cast++;
+ }
+ /* Set entry in modules->types array equal to the type */
+ swig_module.types[i] = type;
+ }
+ swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
+ for (i = 0; i < swig_module.size; ++i) {
+ int j = 0;
+ swig_cast_info *cast = swig_module.cast_initial[i];
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+ while (cast->type) {
+ printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+ cast++;
+ ++j;
+ }
+ printf("---- Total casts: %d\n",j);
+ }
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types. It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+ size_t i;
+ swig_cast_info *equiv;
+ static int init_run = 0;
+
+ if (init_run) return;
+ init_run = 1;
+
+ for (i = 0; i < swig_module.size; i++) {
+ if (swig_module.types[i]->clientdata) {
+ equiv = swig_module.types[i]->cast;
+ while (equiv) {
+ if (!equiv->converter) {
+ if (equiv->type && !equiv->type->clientdata)
+ SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+ }
+ equiv = equiv->next;
+ }
+ }
+ }
+}
+
+#ifdef __cplusplus
+#if 0
+{
+ /* c-mode */
+#endif
+}
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+
+XS(SWIG_init) {
+ dXSARGS;
+ int i;
+
+ SWIG_InitializeModule(0);
+
+ /* Install commands */
+ for (i = 0; swig_commands[i].name; i++) {
+ // Casts only needed for Perl < 5.10.
+#ifdef __cplusplus
+ newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
+#else
+ newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
+#endif
+ }
+
+ /* Install variables */
+ for (i = 0; swig_variables[i].name; i++) {
+ SV *sv;
+ sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
+ if (swig_variables[i].type) {
+ SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
+ } else {
+ sv_setiv(sv,(IV) 0);
+ }
+ swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
+ }
+
+ /* Install constant */
+ for (i = 0; swig_constants[i].type; i++) {
+ SV *sv;
+ sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
+ switch(swig_constants[i].type) {
+ case SWIG_INT:
+ sv_setiv(sv, (IV) swig_constants[i].lvalue);
+ break;
+ case SWIG_FLOAT:
+ sv_setnv(sv, (double) swig_constants[i].dvalue);
+ break;
+ case SWIG_STRING:
+ sv_setpv(sv, (const char *) swig_constants[i].pvalue);
+ break;
+ case SWIG_POINTER:
+ SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
+ break;
+ case SWIG_BINARY:
+ SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
+ break;
+ default:
+ break;
+ }
+ SvREADONLY_on(sv);
+ }
+
+ SWIG_TypeClientData(SWIGTYPE_p_intArray, (void*) "RNA::intArray");
+ SWIG_TypeClientData(SWIGTYPE_p_floatArray, (void*) "RNA::floatArray");
+ SWIG_TypeClientData(SWIGTYPE_p_doubleArray, (void*) "RNA::doubleArray");
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VERSION", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(0.3)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_COORDINATE, (void*) "RNA::COORDINATE");
+ SWIG_TypeClientData(SWIGTYPE_p_SOLUTION, (void*) "RNA::SOLUTION");
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_ERROR", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(1U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_QUIT", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(2U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_MISC", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(4U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_FASTA_HEADER", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(8U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_SEQUENCE", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(16U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_CONSTRAINT", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(32U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_NO_TRUNCATION", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(256U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_NO_REST", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(512U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_NO_SPAN", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(1024U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_NOSKIP_BLANK_LINES", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(2048U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_BLANK_LINE", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(4096U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_NOSKIP_COMMENTS", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(128U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_INPUT_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(8192U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_PIPE", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(1U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_DOT", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(2U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_X", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(4U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_ANG_BRACK", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(8U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_RND_BRACK", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(16U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_MULTILINE", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(32U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_NO_HEADER", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(64U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_ALL", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(128U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_CONSTRAINT_G", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(256U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_OPTION_MULTILINE", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(32U)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "FILENAME_MAX_LENGTH", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(80)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "FILENAME_ID_LENGTH", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(42)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+
+ /* work around segfault when script tries to free symbolset */
+
+ symbolset = (char *) space(21);
+ strcpy(symbolset, "AUGC");
+
+
+ SWIG_TypeClientData(SWIGTYPE_p_duplexT, (void*) "RNA::duplexT");
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "PI", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(3.141592654)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "PIHALF", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(3.141592654/2.)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_PLOT_TYPE_SIMPLE", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(0)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_PLOT_TYPE_NAVIEW", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(1)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:/usr/share/swig/2.0.8/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "VRNA_PLOT_TYPE_CIRCULAR", TRUE | 0x2 | GV_ADDMULTI);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(2)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ ST(0) = &PL_sv_yes;
+ XSRETURN(1);
+}
+
git://source.jalview.org / jabaws.git / blobdiff