~ubuntu-branches/ubuntu/vivid/znc/vivid

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

 * This file was automatically generated by SWIG (http://www.swig.org).

 * coding conventions designed to improve portability and efficiency. Do not make

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

 

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

#ifndef SWIGUNUSED

# if defined(__GNUC__)

#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))

#   else

#     define SWIGUNUSED

#   endif

# elif defined(__ICC)

# else

# endif

#endif

 

#ifndef SWIG_MSC_UNSUPPRESS_4505

# if defined(_MSC_VER)

#   pragma warning(disable : 4505) /* unreferenced local function has been removed */

#endif

 

#ifndef SWIGUNUSEDPARM

# ifdef __cplusplus

#   define SWIGUNUSEDPARM(p)

# else

# endif

#endif

 

#   define SWIGSTDCALL __stdcall

# else

#   define SWIGSTDCALL

#endif

 

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */

#endif

 

/*  Errors in SWIG */

#define  SWIG_SystemError          -10

#define  SWIG_AttributeError       -11

#define  SWIG_NullReferenceError   -13

 

 

  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.

*/

#define SWIG_POINTER_OWN           0x1

 

 

   Flags/methods for returning states.

   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) {

    } 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

 

      }

 

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be

       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_ERROR                 (-1)

#define SWIG_IsOK(r)               (r >= 0)

 

/* The CastRankLimit says how many bits are used for the cast rank */

#define SWIG_CASTRANKLIMIT         (1 << 8)

#  endif

#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)

#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)

  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;

}

}

#else /* no cast-rank mode */

#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)

#endif

 

  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.

 

 

/*

  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) {

 

/*

  Check the typename

  return 0;

}

 

  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison

*/

SWIGRUNTIME swig_cast_info *

  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);

}

 

   Dynamic pointer casting. Down an inheritance hierarchy

*/

SWIGRUNTIME swig_type_info *

    return type->name;

}

 

   Set the clientdata field for a type

*/

SWIGRUNTIME void

  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;

  }

}

  SWIG_TypeClientData(ti, clientdata);

  ti->owndata = 1;

}

/*

  Search for a swig_type_info structure only by mangled name

  Search is a O(log #types)

  Note: if start == end at the beginning of the function, we go all the way around

  the circular list.

*/

SWIGRUNTIME swig_type_info *

                            const char *name) {

  swig_module_info *iter = start;

  do {

    if (iter->size) {

      do {

        /* since l+r >= 0, we can (>> 1) instead (/ 2) */

        const char *iname = iter->types[i]->name;

        if (iname) {

            return iter->types[i];

          } else if (compare < 0) {

            if (i) {

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

  Note: if start == end at the beginning of the function, we go all the way around

  the circular list.

*/

SWIGRUNTIME swig_type_info *

                     const char *name) {

  /* STEP 1: Search the name field using binary search */

  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);

       of the str field (the human readable name) */

    swig_module_info *iter = start;

    do {

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

  for (; u != eu; ++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) {

  for (; u != eu; ++u) {

    if ((d >= '0') && (d <= '9'))

      uu = ((d - '0') << 4);

    else if ((d >= 'a') && (d <= 'f'))

      uu = ((d - ('a'-10)) << 4);

      return (char *) 0;

    d = *(c++);

    if ((d >= '0') && (d <= '9'))

      uu |= (d - '0');

    else if ((d >= 'a') && (d <= 'f'))

      uu |= (d - ('a'-10));

      return (char *) 0;

    *u = uu;

  }

  return c;

}

 

   Pack 'void *' into a string buffer.

*/

SWIGRUNTIME char *

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

    /* Now see if the types match */

    char *_c = HvNAME(SvSTASH(SvRV(sv)));

    tc = SWIG_TypeProxyCheck(_c,_t);

    if (!tc) {

      return SWIG_ERROR;

    }

    {