/* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). * Version 1.3.24 *  * 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.  * ----------------------------------------------------------------------------- */#ifdef __cplusplustemplate<class T> class SwigValueWrapper {    T *tt;public:    SwigValueWrapper() : tt(0) { }    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }    SwigValueWrapper(const T& t) : tt(new T(t)) { }    ~SwigValueWrapper() { delete tt; }     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }    operator T&() const { return *tt; }    T *operator&() { return tt; }private:    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);};#endif#ifndef SWIG_TEMPLATE_DISAMBIGUATOR#  if defined(__SUNPRO_CC) #    define SWIG_TEMPLATE_DISAMBIGUATOR template#  else#    define SWIG_TEMPLATE_DISAMBIGUATOR #  endif#endif/*********************************************************************** * swigrun.swg * *     This file contains generic CAPI 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 "1"/* 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#include <string.h>#ifndef SWIGINLINE#if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))#  define SWIGINLINE inline#else#  define SWIGINLINE#endif#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 is strictly necessary, ie, if you have problems  with your compiler or so.*/#ifndef SWIGRUNTIME#define SWIGRUNTIME static#endif#ifndef SWIGRUNTIMEINLINE#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE#endif#ifdef __cplusplusextern "C" {#endiftypedef void *(*swig_converter_func)(void *);typedef struct swig_type_info *(*swig_dycast_func)(void **);typedef struct swig_type_info {  const char             *name;  swig_converter_func     converter;  const char             *str;  void                   *clientdata;  swig_dycast_func        dcast;  struct swig_type_info  *next;  struct swig_type_info  *prev;} swig_type_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 intSWIG_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;  }  return (l1 - f1) - (l2 - f2);}/*  Check type equivalence in a name list like <name1>|<name2>|...*/SWIGRUNTIME intSWIG_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;    if (*ne) ++ne;  }  return equiv;}/*  Register a type mapping with the type-checking*/SWIGRUNTIME swig_type_info *SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {  swig_type_info *tc, *head, *ret, *next;  /* Check to see if this type has already been registered */  tc = *tl;  while (tc) {    /* check simple type equivalence */    int typeequiv = (strcmp(tc->name, ti->name) == 0);       /* check full type equivalence, resolving typedefs */    if (!typeequiv) {      /* only if tc is not a typedef (no '|' on it) */      if (tc->str && ti->str && !strstr(tc->str,"|")) {	typeequiv = SWIG_TypeEquiv(ti->str,tc->str);      }    }    if (typeequiv) {      /* Already exists in the table.  Just add additional types to the list */      if (ti->clientdata) tc->clientdata = ti->clientdata;      head = tc;      next = tc->next;      goto l1;    }    tc = tc->prev;  }  head = ti;  next = 0;  /* Place in list */  ti->prev = *tl;  *tl = ti;  /* Build linked lists */  l1:  ret = head;  tc = ti + 1;  /* Patch up the rest of the links */  while (tc->name) {    head->next = tc;    tc->prev = head;    head = tc;    tc++;  }  if (next) next->prev = head;  head->next = next;  return ret;}/*  Check the typename*/SWIGRUNTIME swig_type_info *SWIG_TypeCheck(const char *c, swig_type_info *ty) {  swig_type_info *s;  if (!ty) return 0;        /* Void pointer */  s = ty->next;             /* First element always just a name */  do {    if (strcmp(s->name,c) == 0) {      if (s == ty->next) return s;      /* Move s to the top of the linked list */      s->prev->next = s->next;      if (s->next) {        s->next->prev = s->prev;      }      /* Insert s as second element in the list */      s->next = ty->next;      if (ty->next) ty->next->prev = s;      ty->next = s;      s->prev = ty;      return s;    }    s = s->next;  } while (s && (s != ty->next));  return 0;}/*  Cast a pointer up an inheritance hierarchy*/SWIGRUNTIMEINLINE void *SWIG_TypeCast(swig_type_info *ty, void *ptr) {  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);}/*    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->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;}/*  Search for a swig_type_info structure*/SWIGRUNTIME swig_type_info *SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {  swig_type_info *ty = tl;  while (ty) {    if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;    ty = ty->prev;  }  return 0;}/*    Set the clientdata field for a type*/SWIGRUNTIME voidSWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {  swig_type_info *tc, *equiv;  if (ti->clientdata) return;  /* if (ti->clientdata == clientdata) return; */  ti->clientdata = clientdata;  equiv = ti->next;  while (equiv) {    if (!equiv->converter) {      tc = tl;      while (tc) {        if ((strcmp(tc->name, equiv->name) == 0))          SWIG_TypeClientDataTL(tl,tc,clientdata);        tc = tc->prev;      }    }    equiv = equiv->next;  }}/*    Pack binary data into a string*/SWIGRUNTIME char *SWIG_PackData(char *c, void *ptr, size_t sz) {  static char hex[17] = "0123456789abcdef";  unsigned char *u = (unsigned char *) ptr;  const unsigned char *eu =  u + sz;  register unsigned char uu;  for (; u != eu; ++u) {    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 int d = *(c++);    register unsigned char uu = 0;    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;}/*  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 voidSWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {  swig_type_info *equiv = type->next;  swig_type_info *tc;  if (!type->clientdata) return;  while (equiv) {    if (!equiv->converter) {      tc = tl;      while (tc) {        if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)          SWIG_TypeClientDataTL(tl,tc, type->clientdata);        tc = tc->prev;      }    }    equiv = equiv->next;  }}/*    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);}