/* ----------------------------------------------------------------------------

 * 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. 

 * ----------------------------------------------------------------------------- */

#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 __cplusplus

extern "C" {

#endif

typedef 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 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;

  }

  return (l1 - f1) - (l2 - f2);

}

/*

  Check type equivalence in a name list like <name1>|<name2>|...

*/

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;

    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 void

SWIG_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 void

SWIG_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);

}

#ifdef __cplusplus

}

#endif

/***********************************************************************

 * common.swg

 *

 *     This file contains generic SWIG runtime support for pointer

 *     type checking as well as a few commonly used macros to control

 *     external linkage.

 *

 * Author : David Beazley (beazley@cs.uchicago.edu)

 *

 * Copyright (c) 1999-2000, The University of Chicago

 * 

 * This file may be freely redistributed without license or fee provided

 * this copyright message remains intact.

 ************************************************************************/

#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

#  if !defined(STATIC_LINKED)

#    define SWIGEXPORT(a) __declspec(dllexport) a

#  else

#    define SWIGEXPORT(a) a

#  endif

#else

#  define SWIGEXPORT(a) a

#endif

#ifdef __cplusplus

extern "C" {

#endif

/*************************************************************************/

/* The static type info list */

static swig_type_info *swig_type_list = 0;

static swig_type_info **swig_type_list_handle = &swig_type_list;

/* Register a type mapping with the type-checking */

static swig_type_info *

SWIG_TypeRegister(swig_type_info *ti) {

  return SWIG_TypeRegisterTL(swig_type_list_handle, ti);

}

/* Search for a swig_type_info structure */

static swig_type_info *

SWIG_TypeQuery(const char *name) {

  return SWIG_TypeQueryTL(*swig_type_list_handle, name);

}

/* Set the clientdata field for a type */

static void

SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {

  SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);

}

/* 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.

*/

static void

SWIG_PropagateClientData(swig_type_info *type) {

  SWIG_PropagateClientDataTL(*swig_type_list_handle, type);

}

#ifdef __cplusplus

}

#endif

/* ---------------------------------------------------------------------- -*- c -*-

 * perl5.swg

 *

 * Perl5 runtime library

 * $Header: /cvsroot/swig/SWIG/Lib/perl5/perlrun.swg,v 1.20 2004/11/29 23:13:57 wuzzeb Exp $

 * ----------------------------------------------------------------------------- */

#define SWIGPERL

#define SWIGPERL5

#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"

/* Get rid of free and malloc defined by perl */

#undef free

#undef malloc

#ifndef pTHX_

#define pTHX_

#endif

#include <string.h>

#ifdef __cplusplus

}

#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